Merge pull request #174 from spjuhel/develop

v0.6.3 release (VA tracking and Arbitrary events)

Author: spjuhel

.github/release.yml

@@ -0,0 +1,5 @@
+changelog:
+  exclude:
+    authors:
+      - dependabot
+      - pre-commit-ci

AUTHORS.md

@@ -0,0 +1,3 @@
+# BoARIO authors
+
+* Samuel Juhel

boario/__init__.py

@@ -43,10 +43,10 @@
 
     try:
         __git_branch__ = pygit2.Repository(__file__).head.name
-        logger.info("You are using boario from branch %s", __git_branch__)
+        logger.debug("You are using boario from branch %s", __git_branch__)
     except pygit2.GitError:
-        logger.info(
+        logger.debug(
             "Could not find git branch, this is normal if you installed boario from pip/conda."
         )
 except ModuleNotFoundError:
-    logger.info("Unable to tell git branch as pygit2 was not found.")
+    logger.debug("Unable to tell git branch as pygit2 was not found.")

boario/event.py

@@ -287,7 +287,16 @@ def from_scalar_industries(
             recovery_function=recovery_function,
         )
     elif event_type == "arbitrary":
-        raise NotImplementedError("This method does not yet accept this type of event.")
+        return EventArbitraryProd._from_scalar_industries(
+            impact=impact,
+            affected_industries=affected_industries,
+            impact_distrib=impact_distrib,
+            occurrence=occurrence,
+            duration=duration,
+            name=name,
+            recovery_tau=recovery_tau,
+            recovery_function=recovery_function,
+        )
     else:
         raise ValueError(f"Wrong event type: {event_type}")
 
@@ -389,7 +398,18 @@ def from_scalar_regions_sectors(
             recovery_function=recovery_function,
         )
     elif event_type == "arbitrary":
-        raise NotImplementedError("This type of event is not implemented yet.")
+        return EventArbitraryProd._from_scalar_regions_sectors(
+            impact=impact,
+            affected_regions=affected_regions,
+            affected_sectors=affected_sectors,
+            impact_regional_distrib=impact_regional_distrib,
+            impact_sectoral_distrib=impact_sectoral_distrib,
+            occurrence=occurrence,
+            duration=duration,
+            name=name,
+            recovery_tau=recovery_tau,
+            recovery_function=recovery_function,
+        )
     else:
         raise ValueError(f"Wrong event type: {event_type}")
 
@@ -609,7 +629,6 @@ def from_scalar_regions_sectors(
         impact_sectoral_distrib : Optional[Union[str, npt.ArrayLike]], optional
             Either:
 
-            * ``\"gdp\"``, the impact is then distributed using the gross value added of each sector as a weight.
             * A vector of equal size to the list of sectors affected, stating the share of the impact each industry should receive. Defaults to None.
 
         occurrence : int, optional

boario/model_base.py

@@ -1066,6 +1066,8 @@ def distribute_production(
                 raise RuntimeError(
                     "matrix_stock contains negative values, this should not happen"
                 )
+            if (np.isnan(self.inputs_stock)).any():
+                raise RuntimeError("matrix_stock contains NaNs, this should not happen")
 
         # 6. Compute final demand not met due to rationing
         final_demand_not_met = (

boario/simulation.py

@@ -76,6 +76,7 @@ class Simulation:
         "inputs_stocks",
         "limiting_inputs",
         "productive_capital_to_recover",
+        "value_added",
     ]
 
     __file_save_array_specs = {
@@ -91,6 +92,12 @@ class Simulation:
             "industries",
             np.nan,
         ),
+        "value_added": (
+            "float64",
+            "_value_added_evolution",
+            "industries",
+            np.nan,
+        ),
         "final_demand": ("float64", "_final_demand_evolution", "industries", np.nan),
         "intermediate_demand": (
             "float64",
@@ -209,6 +216,7 @@ def __init__(
         self._io_demand_evolution = np.array([])
         self._rebuild_demand_evolution = np.array([])
         self._overproduction_evolution = np.array([])
+        self._value_added_evolution = np.array([])
         self._final_demand_unmet_evolution = np.array([])
         self._rebuild_production_evolution = np.array([])
         self._inputs_evolution = np.array([])
@@ -508,6 +516,10 @@ def next_step(
                 "_io_demand_evolution" in self._vars_to_record
             ):
                 self._write_io_demand()
+            if ("_value_added_evolution" in self._files_to_record) or (
+                "_value_added_evolution" in self._vars_to_record
+            ):
+                self._write_value_added()
 
             # 1)
             constraints = self.model.calc_production(self.current_temporal_unit)
@@ -912,6 +924,8 @@ def update_rebuild_demand(self):
                             * (evnt_trck._rebuild_id + 1),
                         ] = evnt_trck.distributed_reb_dem_house_tau
 
+            if np.isnan(_rebuilding_demand).any():
+                raise ValueError("NaNs found when creating the rebuilding demand.")
             self.model.rebuild_demand = _rebuilding_demand
 
     def update_productive_capital_lost(self):
@@ -1007,6 +1021,22 @@ def production_capacity(self) -> pd.DataFrame:
             copy=True,
         ).rename_axis("step")
 
+    @property
+    def value_added(self) -> pd.DataFrame:
+        """Returns the evolution of the production capacity of each industry (region,sector) as a DataFrame.
+
+        Returns
+        -------
+            pd.DataFrame: A pandas DataFrame where the value is the production capacity, the columns are the industries
+            and the index is the step considered.
+
+        """
+        return pd.DataFrame(
+            self._value_added_evolution,
+            columns=self.model.industries,
+            copy=True,
+        ).rename_axis("step")
+
     @property
     def final_demand(self) -> pd.DataFrame:
         """Return the evolution of final demand asked of each industry as a DataFrame.
@@ -1237,6 +1267,12 @@ def _write_production_max(self) -> None:
             self.model.production_cap
         )
 
+    def _write_value_added(self) -> None:
+        """Saves the current production capacity vector to the memmap."""
+        self._value_added_evolution[self.current_temporal_unit] = (
+            self.model.production - self.model.intermediate_demand_tot
+        )
+
     def _write_io_demand(self) -> None:
         """Saves the current (total per industry) intermediate demand vector to the memmap."""
         self._io_demand_evolution[self.current_temporal_unit] = (
@@ -1508,16 +1544,20 @@ def _normalize_distribution(
         ret.loc[addressed_to, :] = (
             dist_sq.loc[addressed_to]
             .groupby(level=1)
-            .transform(lambda x: x / sum(x))
+            .transform(lambda x: x / sum(x) if sum(x) != 0 else 0)
             .values[:, None]
         )
+        if np.isnan(ret).any(axis=None):
+            raise ValueError("The distribution contains NaNs")
         return ret
     elif isinstance(dist_sq, pd.DataFrame):
         ret.loc[addressed_to, affected] = (
             dist_sq.loc[addressed_to, affected]
             .groupby(level=1)
-            .transform(lambda x: x / sum(x))
+            .transform(lambda x: x / sum(x) if sum(x) != 0 else 0)
         )
+        if np.isnan(ret).any(axis=None):
+            raise ValueError("The distribution contains NaNs")
         return ret
     else:
         raise ValueError("given distribution should be a Series or a DataFrame.")

docs/source/tutorials/boario-events.rst

@@ -204,8 +204,7 @@ Otherwise, production capacity is restored instantaneously after the duration of
 Defining events from a scalar
 ================================
 
-You can also define an event from a scalar impact
-(except for :class:`~boario.event.EventArbitraryProd`).
+You can also define an event from a scalar impact.
 This requires to define which industries are affected and
 how the impact is distributed among the industries.
 
@@ -236,25 +235,16 @@ Otherwise, there are multiple ways to setup a custom distribution:
    of per affected industry share of the impact (although in this case you should
    probably directly give the impact vector).
 2. Give a vector of the share per region, and the share per sector.
-3. Give a vector of the share per region, and specify ``"gdp"`` for the per sector
-   distribution. This will distribute each regional impact toward each affected sector
-   proportionally to their share of the regional GDP among the affected sectors.
-   For example: Suppose we look at the impact in region ``"reg2"``, and suppose
-   ``"manufactoring"`` and ``"mining"`` are both affected. Now suppose
-   ``"manufactoring"`` account for 40% of ``"reg2"``'s GDP and ``"mining"``
-   for 10%. The ``"manufactoring"`` sector will receive :math:`(40 * 100) / (40 + 10) = 80\%`
-   of the impact and ``"mining"`` the remaining :math:`(10 * 100) / (40 + 10) = 20\%`.
 
 .. note::
 
-  The GDP shares are estimated from the MRIO table used, based on the Value Added,
-  which itself is computed as the gross output minus the intermediate demand:
+  Users often use the GVA shares to distribute the impact, which can be computed as the gross output minus the intermediate demand:
 
   :math:`\textrm{GVA} = \iox - \ioz`
 
 .. warning::
 
-  You should not assume the default impact distribution setting is a good representation
+  You should not assume the default impact distribution (impact equaly distributed) setting is a good representation
   of the general case, as different regions and sectors are most probably differently
   impacted by an event. It is strongly advised to setup your own distribution in accordance
   with your study.