Comments and cleanup

README.md

@@ -12,9 +12,12 @@ $ pip install -r requirements.txt
 
 # Usage
 
+Isle requires that `./data` does not exist as a file, and may overwrite 
+particular file names in `./data/`.
+
 ## Simulation 
 
-Execute the simulation with this command
+Execute a single simulation run with the command:
 
 ```
 $ python3 start.py
@@ -25,28 +28,21 @@ $ python3 start.py
 The ```start.py``` script accepts a number of options. 
 
 ```
-usage: start.py [-h] [--abce] [--oneriskmodel] [--riskmodels {1,2,3,4}]
-                [--replicid REPLICID] [--replicating]
-                [--randomseed RANDOMSEED] [--foreground] [-p] [-v]
+usage: start.py [-h] [-f FILE] [-r] [-o] [-p] [-v] [--resume] [--oneriskmodel]
+                [--riskmodels {1,2,3,4}] [--randomseed RANDOMSEED]
+                [--foreground] [--shownetwork]
+                [--save_iterations SAVE_ITERATIONS]
 ```
 
 See the help for more details
 
 ```
-python3 start.py --help
-```
-
-## Graphical simulation runs
-
-abce can be used to run simulations with a graphical interface:
-
-```
-python3 start.py --abce
+$ python3 start.py --help
 ```
 
 ## Ensemble simulations
 
-The bash scripts ```starter_*.sh``` can be used to run ensembles of a large number of simulations for settings with 1-4 different riskmodels. ```starter_two.sh``` is set up to generate random seeds and risk event schedules that are - for consistency and comparability - also used by the other scripts (i.e. ```starter_two.sh``` needs to be run first).
+The bash scripts ```starter_*.sh``` can be used to run ensembles of a large number of simulations for settings with 1-4 different risk models. ```starter_two.sh``` is set up to generate random seeds and risk event schedules that are - for consistency and comparability - also used by the other scripts (i.e. ```starter_two.sh``` needs to be run first).
 
 ```
 bash starter_two.sh
@@ -55,7 +51,32 @@ bash starter_four.sh
 bash starter_three.sh
 ```
 
-## Plotting
+## Visualisation
+
+#### Single runs
+Use the script ```visualisation.py [--single]``` from the command line to plot data from a single run. It also takes the 
+arguments ```[--pie] [--timeseries]``` for which data representation is wanted. The argument ```[--config_compare_filex ]``` 
+where ```x``` can be 1,2 or 3 is used for comparing two sets of data (singular or with replications) with different conditions.
+
+If the necessary data has been saved a network animation can also be created by running ```visualization_network.py``` 
+which takes the arguments ```[--save] [--number_iterations]``` if you want the animation to be saved as an mp4, and how
+many time iterations you want in the animation.
+
+#### Ensemble runs
+Ensemble runs can be plotted if the correct data is available using ``visualisation.py`` which has a number of arguments.
+
+```
+visualiation.py [--timeseries_comparison] [--firmdistribution] 
+                [--bankruptcydistribution] [--compare_riskmodels]
+```
+
+See help for more information.
+
+# Contributing
 
-Use the scripts ```plotter_pl_timescale.py``` and  ```visualize.py``` for plotting/visualizing single simulation runs. Use  ```.py```,  ```metaplotter_pl_timescale.py```, or  ```metaplotter_pl_timescale_additional_measures.py``` to visualize ensemble runs.
+## Code style
 
+[PEP 8](https://www.python.org/dev/peps/pep-0008/) styling should be used where possible. 
+The Python code formatter [black](https://github.com/python/black) is a good way
+to automatically fix style problems - install it with `$ pip install black` and
+then run it with, say, `black *.py`. Additionally, it is good to run flake8 over your code.

calibration_conditions.py

@@ -1,7 +1,7 @@
 """Collection of calibration test conditions as functions to be imported by the CalibrationScore class.
    Each function accepts a Logger object as argument and runs the tests on this. Auxiliary functions are
    in calibration_aux.py.
-   
+
 Components of Logger log, that can used for validation/calibration are:
 
                 [0]: 'total_cash'
@@ -31,100 +31,162 @@
 import condition_aux
 import isleconfig
 
+
 def condition_stationary_state_cash(logobj):
     """Stationarity test for total cash"""
-    return condition_aux.condition_stationary_state(logobj.history_logs['total_cash'])
-
+    return condition_aux.condition_stationary_state(logobj.history_logs["total_cash"])
+
+
 def condition_stationary_state_excess_capital(logobj):
     """Stationarity test for total excess capital"""
-    return condition_aux.condition_stationary_state(logobj.history_logs['total_excess_capital'])
+    return condition_aux.condition_stationary_state(
+        logobj.history_logs["total_excess_capital"]
+    )
+
 
 def condition_stationary_state_profits_losses(logobj):
     """Stationarity test for total profits and losses"""
-    return condition_aux.condition_stationary_state(logobj.history_logs['total_profitslosses'])
+    return condition_aux.condition_stationary_state(
+        logobj.history_logs["total_profitslosses"]
+    )
+
 
 def condition_stationary_state_contracts(logobj):
     """Stationarity test for total number of contracts"""
-    return condition_aux.condition_stationary_state(logobj.history_logs['total_contracts'])
+    return condition_aux.condition_stationary_state(
+        logobj.history_logs["total_contracts"]
+    )
+
 
 def condition_stationary_state_rein_cash(logobj):
     """Stationarity test for total cash (reinsurers)"""
-    return condition_aux.condition_stationary_state(logobj.history_logs['total_reincash'])
+    return condition_aux.condition_stationary_state(
+        logobj.history_logs["total_reincash"]
+    )
+
 
 def condition_stationary_state_rein_excess_capital(logobj):
     """Stationarity test for total excess capital (reinsurers)"""
-    return condition_aux.condition_stationary_state(logobj.history_logs['total_reinexcess_capital'])
+    return condition_aux.condition_stationary_state(
+        logobj.history_logs["total_reinexcess_capital"]
+    )
+
 
 def condition_stationary_state_rein_profits_losses(logobj):
     """Stationarity test for total profits and losses (reinsurers)"""
-    return condition_aux.condition_stationary_state(logobj.history_logs['total_reinprofitslosses'])
+    return condition_aux.condition_stationary_state(
+        logobj.history_logs["total_reinprofitslosses"]
+    )
+
 
 def condition_stationary_state_rein_contracts(logobj):
     """Stationarity test for total number of reinsured contracts"""
-    return condition_aux.condition_stationary_state(logobj.history_logs['total_reincontracts'])
+    return condition_aux.condition_stationary_state(
+        logobj.history_logs["total_reincontracts"]
+    )
+
 
 def condition_stationary_state_market_premium(logobj):
     """Stationarity test for insurance market premium"""
-    return condition_aux.condition_stationary_state(logobj.history_logs['market_premium'])
+    return condition_aux.condition_stationary_state(
+        logobj.history_logs["market_premium"]
+    )
+
 
 def condition_stationary_state_rein_market_premium(logobj):
     """Stationarity test for reinsurance market premium"""
-    return condition_aux.condition_stationary_state(logobj.history_logs['market_reinpremium'])
+    return condition_aux.condition_stationary_state(
+        logobj.history_logs["market_reinpremium"]
+    )
 
-def condition_defaults_insurance(logobj):          # TODO: develop this into a non-binary measure
+
+def condition_defaults_insurance(
+    logobj
+):  # TODO: develop this into a non-binary measure
     """Test for number of insurance bankruptcies (non zero, not all insurers)"""
-    #series  = logobj.history_logs['total_operational']
-    #if series[-1] != 0 and any(series[i]-series[i-1] < 0 for i in range(1,len(series))):
-    opseries = [logobj.history_logs["insurance_firms_cash"][-1][i][2] for i in \
-                        range(len(logobj.history_logs["insurance_firms_cash"][-1]))]
+    # series  = logobj.history_logs['total_operational']
+    # if series[-1] != 0 and any(series[i]-series[i-1] < 0 for i in range(1,len(series))):
+    pass
+    opseries = [
+        logobj.history_logs["insurance_firms_cash"][-1][i][2]
+        for i in range(len(logobj.history_logs["insurance_firms_cash"][-1]))
+    ]
     if any(opseries) and not all(opseries):
         return 1
     else:
         return 0
 
-def condition_defaults_reinsurance(logobj):        # TODO: develop this into a non-binary measure
+
+def condition_defaults_reinsurance(
+    logobj
+):  # TODO: develop this into a non-binary measure
     """Test for number of reinsurance bankruptcies (non zero, not all reinsurers)"""
-    #series  = logobj.history_logs['total_reinoperational']
-    #if series[-1] != 0 and any(series[i]-series[i-1] < 0 for i in range(1,len(series))):
-    opseries = [logobj.history_logs["reinsurance_firms_cash"][-1][i][2] for i in \
-                        range(len(logobj.history_logs["reinsurance_firms_cash"][-1]))]
+    # series  = logobj.history_logs['total_reinoperational']
+    # if series[-1] != 0 and any(series[i]-series[i-1] < 0 for i in range(1,len(series))):
+    opseries = [
+        logobj.history_logs["reinsurance_firms_cash"][-1][i][2]
+        for i in range(len(logobj.history_logs["reinsurance_firms_cash"][-1]))
+    ]
     if any(opseries) and not all(opseries):
         return 1
     else:
         return 0
 
+
 def condition_insurance_coverage(logobj):
     """Test for insurance coverage close to 100%"""
-    return logobj.history_logs['total_contracts'][-1] * 1. / isleconfig.simulation_parameters["no_risks"]
+    return (
+        logobj.history_logs["total_contracts"][-1]
+        * 1.0
+        / isleconfig.simulation_parameters["no_risks"]
+    )
+
 
 def condition_reinsurance_coverage(logobj, minimum=0.6):
     """Test for reinsurance coverage close to some minimum that may be less than 100% (default 60%)"""
-    score = logobj.history_logs['total_reincontracts'][-1] * 1. / (minimum * logobj.history_logs['total_contracts'][-1])
-    score = 1 if score>1 else score
+    try:
+        score = (
+            logobj.history_logs["total_reincontracts"][-1]
+            * 1.0
+            / (minimum * logobj.history_logs["total_contracts"][-1])
+        )
+    except ZeroDivisionError:
+        score = 0
+    score = 1 if score > 1 else score
     return score
 
-def condition_insurance_firm_dist(logobj):                 
+
+def condition_insurance_firm_dist(logobj):
     """Empirical calibration test for insurance firm size (total assets; cash)"""
     """filter operational firms"""
-    #dist = [logobj.history_logs["insurance_firms_cash"][-1][i][0] for i in range(len(logobj.history_logs["insurance_firms_cash"])) if \
+    # dist = [logobj.history_logs["insurance_firms_cash"][-1][i][0] for i in range(len(logobj.history_logs["insurance_firms_cash"])) if \
     #           logobj.history_logs["insurance_firms_cash"][-1][i][0] > isleconfig.simulation_parameters["cash_permanency_limit"]]
-    dist = [logobj.history_logs["insurance_firms_cash"][-1][i][0] for i in \
-                range(len(logobj.history_logs["insurance_firms_cash"][-1])) if \
-                      logobj.history_logs["insurance_firms_cash"][-1][i][2]]
+    dist = [
+        logobj.history_logs["insurance_firms_cash"][-1][i][0]
+        for i in range(len(logobj.history_logs["insurance_firms_cash"][-1]))
+        if logobj.history_logs["insurance_firms_cash"][-1][i][2]
+    ]
     """run two-sided KS test"""
-    KS_statistic, p_value = stats.ks_2samp(condition_aux.scaler(condition_aux.insurance_firm_sizes_empirical_2017), 
-                                           condition_aux.scaler(dist))
+    KS_statistic, p_value = stats.ks_2samp(
+        condition_aux.scaler(condition_aux.insurance_firm_sizes_empirical_2017),
+        condition_aux.scaler(dist),
+    )
     return p_value
 
-def condition_reinsurance_firm_dist(logobj):                 
+
+def condition_reinsurance_firm_dist(logobj):
     """Empirical calibration test for reinsurance firm size (total assets; cash)"""
     """filter operational firms"""
-    #dist = [logobj.history_logs["reinsurance_firms_cash"][-1][i][0] for i in range(len(logobj.history_logs["reinsurance_firms_cash"])) if \
+    # dist = [logobj.history_logs["reinsurance_firms_cash"][-1][i][0] for i in range(len(logobj.history_logs["reinsurance_firms_cash"])) if \
     #           logobj.history_logs["reinsurance_firms_cash"][-1][i][0] > isleconfig.simulation_parameters["cash_permanency_limit"]]
-    dist = [logobj.history_logs["reinsurance_firms_cash"][-1][i][0] for i in \
-                    range(len(logobj.history_logs["reinsurance_firms_cash"][-1])) if 
-                    logobj.history_logs["reinsurance_firms_cash"][-1][i][2]]
+    dist = [
+        logobj.history_logs["reinsurance_firms_cash"][-1][i][0]
+        for i in range(len(logobj.history_logs["reinsurance_firms_cash"][-1]))
+        if logobj.history_logs["reinsurance_firms_cash"][-1][i][2]
+    ]
     """run two-sided KS test"""
-    KS_statistic, p_value = stats.ks_2samp(condition_aux.scaler(condition_aux.reinsurance_firm_sizes_empirical_2017), 
-                                           condition_aux.scaler(dist))
+    KS_statistic, p_value = stats.ks_2samp(
+        condition_aux.scaler(condition_aux.reinsurance_firm_sizes_empirical_2017),
+        condition_aux.scaler(dist),
+    )
     return p_value

calibrationscore.py

@@ -5,9 +5,10 @@
 from inspect import getmembers, isfunction
 import numpy as np
 
-import calibration_conditions   # Test functions
+import calibration_conditions  # Test functions
 
-class CalibrationScore():
+
+class CalibrationScore:
     def __init__(self, L):
         """Constructor method.
             Arguments:
@@ -17,31 +18,39 @@ def __init__(self, L):
         """Assert sanity of log and save log."""
         assert isinstance(L, logger.Logger)
         self.logger = L
-        
+
         """Prepare list of calibration tests from calibration_conditions.py"""
-        self.conditions = [f for f in getmembers(calibration_conditions) if isfunction(f[1])]
-
+        self.conditions = [
+            f for f in getmembers(calibration_conditions) if isfunction(f[1])
+        ]
+
         """Prepare calibration score variable."""
         self.calibration_score = None
-        
+
     def test_all(self):
         """Method to test all calibration tests.
             No arguments.
-            Returns combined calibration score as float \in [0,1]."""
-        
+            Returns combined calibration score as float in [0,1]."""
+
         """Compute score components"""
-        scores = {condition[0]: condition[1](self.logger) for condition in self.conditions}
+        scores = {
+            condition[0]: condition[1](self.logger) for condition in self.conditions
+        }
         """Print components"""
         print("\n")
         for cond_name, score in scores.items():
-            print("{0:47s}: {1:8f}".format(cond_name, score))
+            print(f"{cond_name:47s}: {score:8f}")
         """Compute combined score"""
-        self.calibration_score = self.combine_scores(np.array([*scores.values()], dtype=object))
+        self.calibration_score = self.combine_scores(
+            np.array([*scores.values()], dtype=object)
+        )
         """Print combined score"""
-        print("\n                        Total calibration score: {0:8f}".format(self.calibration_score))
+        print(
+            f"\n                        Total calibration score: {self.calibration_score:8f}"
+        )
         """Return"""
         return self.calibration_score
-    
+
     def combine_scores(self, slist):
         """Method to combine calibration score components. Combination is additive (mean). Change the function
            for other combination methods (multiplicative or minimum).