GDP loss and better variable names

mimosa/abstract_model.py

@@ -19,7 +19,6 @@
     welfare,
 )
 
-
 ######################
 # Create model
 ######################
@@ -85,7 +84,12 @@ def create_abstract_model(
         doc="timeandregional::GDP",
         units=quant.unit("currency_unit"),
     )
-    m.baseline_emissions = Param(
+    m.global_baseline_GDP = Param(
+        m.t,
+        initialize=lambda m, t: sum(m.baseline_GDP[t, r] for r in m.regions),
+        units=quant.unit("currency_unit"),
+    )
+    m.ssp_baseline_emissions = Param(
         m.t,
         m.regions,
         doc="timeandregional::emissions",

mimosa/common/pyomo_utils.py

@@ -126,11 +126,11 @@ def __init__(self, lhs, rhs, indices):
 
             RegionalEquation(
                 lhs=m.regional_emissions,
-                rhs=lambda m, t, r: (1 - m.relative_abatement[t, r]) * m.baseline[t, r]
+                rhs=lambda m, t, r: (1 - m.relative_abatement[t, r]) * m.baseline_emissions[t, r]
             )
 
             which will be evaluated as:
-            m.regional_emissions[t, r] == (1 - m.relative_abatement[t, r]) * m.baseline[t, r]
+            m.regional_emissions[t, r] == (1 - m.relative_abatement[t, r]) * m.baseline_emissions[t, r]
 
         """
 

mimosa/components/cobbdouglas.py

@@ -186,4 +186,33 @@ def get_constraints(m: AbstractModel) -> Sequence[GeneralConstraint]:
         ]
     )
 
+    # GDP loss: takes into account indirect effects of reduced GDP growth due to damages and mitigation costs
+    m.GDP_loss = Var(
+        m.t,
+        m.regions,
+        units=quant.unit("fraction_of_baseline_GDP"),
+        initialize=0,
+    )
+    m.global_GDP_loss = Var(
+        m.t, units=quant.unit("fraction_of_baseline_GDP"), initialize=0
+    )
+
+    constraints.extend(
+        [
+            RegionalEquation(
+                m.GDP_loss,
+                lambda m, t, r: (
+                    (m.baseline_GDP[t, r] - m.GDP_net[t, r]) / m.baseline_GDP[t, r]
+                ),
+            ),
+            GlobalEquation(
+                m.global_GDP_loss,
+                lambda m, t: (
+                    (m.global_baseline_GDP[t] - m.global_GDP_net[t])
+                    / m.global_baseline_GDP[t]
+                ),
+            ),
+        ]
+    )
+
     return constraints

mimosa/components/effortsharing/ability_to_pay.py

@@ -68,7 +68,10 @@ def get_constraints(m: AbstractModel) -> Sequence[GeneralConstraint]:
         GlobalEquation(
             m.effortsharing_AP_inv_correction_factor,
             lambda m, t: (
-                (sum(m.baseline[t, r] for r in m.regions) - m.global_emissions[t])
+                (
+                    sum(m.baseline_emissions[t, r] for r in m.regions)
+                    - m.global_emissions[t]
+                )
                 / soft_min(
                     sum(
                         m.effortsharing_AP_reductions_before_correction[t, r]
@@ -82,7 +85,7 @@ def get_constraints(m: AbstractModel) -> Sequence[GeneralConstraint]:
         RegionalEquation(
             m.effortsharing_AP_allowances,
             lambda m, t, r: (
-                m.baseline[t, r]
+                m.baseline_emissions[t, r]
                 - m.effortsharing_AP_reductions_before_correction[t, r]
                 * m.effortsharing_AP_inv_correction_factor[t]
             ),
@@ -119,13 +122,13 @@ def ability_to_pay_rule(m, t, r):
     gdp_var = m.baseline_GDP  # or: m.GDP_net
     per_cap_gdp = gdp_var[t, r] / m.population[t, r]
     global_per_cap_gdp = sum(gdp_var[t, s] for s in m.regions) / m.global_population[t]
-    global_baseline_emissions = sum(m.baseline[t, s] for s in m.regions)
+    global_baseline_emissions = sum(m.baseline_emissions[t, s] for s in m.regions)
 
     reductions_before_correction = (
         (per_cap_gdp / global_per_cap_gdp) ** (1 / 3)
         * (global_baseline_emissions - m.global_emissions[t])
         / global_baseline_emissions
-        * m.baseline[t, r]
+        * m.baseline_emissions[t, r]
     )
 
     return reductions_before_correction

mimosa/components/effortsharing/per_cap_convergence.py

@@ -75,8 +75,8 @@ def get_constraints(m: AbstractModel) -> Sequence[GeneralConstraint]:
     # )
     m.percapconv_share_init = Param(
         m.regions,
-        initialize=lambda m, r: m.baseline_emissions[0, r]
-        / sum(m.baseline_emissions[0, s] for s in m.regions),
+        initialize=lambda m, r: m.ssp_baseline_emissions[0, r]
+        / sum(m.ssp_baseline_emissions[0, s] for s in m.regions),
     )
     m.percapconv_year = Param(initialize=2050, doc="::effort sharing.percapconv_year")
     m.percapconv_share_pop = Param(

mimosa/components/emissions.py

@@ -58,7 +58,7 @@ def _set_baseline_emissions(m: AbstractModel) -> None:
     # Create a param for the regional cumulative baseline emissions
     def _calc_cum_baseline_emissions(m, t, r):
         values_t = range(t + 1)
-        values = [value(m.baseline_emissions[s, r]) for s in values_t]
+        values = [value(m.ssp_baseline_emissions[s, r]) for s in values_t]
         years = value(m.beginyear) + np.array(values_t) * value(m.dt)
         return trapezoid(values, years)
 
@@ -82,7 +82,7 @@ def _calc_cum_baseline_emissions(m, t, r):
         m.t,
         m.regions,
         initialize=lambda m, t, r: (
-            m.baseline_emissions[t, r] / m.baseline_GDP[t - 1 if t > 1 else t, r]
+            m.ssp_baseline_emissions[t, r] / m.baseline_GDP[t - 1 if t > 1 else t, r]
         ),
         units=quant.unit("emissionsrate_unit/currency_unit"),
     )
@@ -168,10 +168,10 @@ def _get_emissions_constraints(m: AbstractModel) -> Sequence[GeneralConstraint]:
     constraints = []
 
     m.regional_emissions = Var(m.t, m.regions, units=quant.unit("emissionsrate_unit"))
-    m.baseline = Var(
+    m.baseline_emissions = Var(
         m.t,
         m.regions,
-        initialize=lambda m, t, r: m.baseline_emissions[t, r],
+        initialize=lambda m, t, r: m.ssp_baseline_emissions[t, r],
         units=quant.unit("emissionsrate_unit"),
     )
     m.use_carbon_intensity_for_baseline = Param(
@@ -197,14 +197,14 @@ def _get_emissions_constraints(m: AbstractModel) -> Sequence[GeneralConstraint]:
         [
             # Baseline emissions based on emissions or carbon intensity
             RegionalEquation(
-                m.baseline,
+                m.baseline_emissions,
                 lambda m, t, r: (
                     (
                         m.baseline_carbon_intensity[t, r]
                         * (m.GDP_net[t - 1, r] if t > 1 else m.GDP_gross[t, r])
                     )
                     if value(m.use_carbon_intensity_for_baseline)
-                    else m.baseline_emissions[t, r]
+                    else m.ssp_baseline_emissions[t, r]
                 ),
             ),
             # Regional emissions from baseline and relative abatement
@@ -213,17 +213,17 @@ def _get_emissions_constraints(m: AbstractModel) -> Sequence[GeneralConstraint]:
                 lambda m, t, r: (
                     (1 - m.relative_abatement[t, r])
                     * (
-                        m.baseline[t, r]
+                        m.baseline_emissions[t, r]
                         if value(m.use_carbon_intensity_for_baseline)
-                        else m.baseline_emissions[t, r]
+                        else m.ssp_baseline_emissions[t, r]
                     )
                     if t > 0
-                    else m.baseline_emissions[0, r]
+                    else m.ssp_baseline_emissions[0, r]
                 ),
             ),
             RegionalEquation(
                 m.regional_emission_reduction,
-                lambda m, t, r: m.baseline[t, r] - m.regional_emissions[t, r],
+                lambda m, t, r: m.baseline_emissions[t, r] - m.regional_emissions[t, r],
             ),
             # Global emissions (sum from regional emissions)
             GlobalEquation(
@@ -527,7 +527,7 @@ def _get_inertia_and_budget_constraints(
                     m.global_emissions[t] - m.global_emissions[t - 1]
                     >= m.dt
                     * m.inertia_global
-                    * sum(m.baseline_emissions[0, r] for r in m.regions)
+                    * sum(m.ssp_baseline_emissions[0, r] for r in m.regions)
                     if value(m.inertia_global) is not False and t > 0
                     else Constraint.Skip
                 ),
@@ -536,7 +536,7 @@ def _get_inertia_and_budget_constraints(
             RegionalConstraint(
                 lambda m, t, r: (
                     m.regional_emissions[t, r] - m.regional_emissions[t - 1, r]
-                    >= m.dt * m.inertia_regional * m.baseline_emissions[0, r]
+                    >= m.dt * m.inertia_regional * m.ssp_baseline_emissions[0, r]
                     if value(m.inertia_regional) is not False and t > 0
                     else Constraint.Skip
                 ),

mimosa/components/emissiontrade/emissiontrade.py

@@ -74,43 +74,43 @@ def get_constraints(m: AbstractModel) -> Sequence[GeneralConstraint]:
 
     ## Extra reporting variables:
 
-    m.paid_for_emission_reductions = Var(
+    m.attributed_emission_reductions = Var(
         m.t, m.regions, units=quant.unit("emissionsrate_unit")
     )
     m.regional_emission_allowances = Var(
         m.t, m.regions, units=quant.unit("emissionsrate_unit")
     )
-    m.import_export_emission_reduction_balance = Var(
+    m.emission_reduction_trading_balance = Var(
         m.t, m.regions, units=quant.unit("emissionsrate_unit")
     )
-    m.import_export_mitigation_cost_balance = Var(
+    m.mitigation_cost_trading_balance = Var(
         m.t, m.regions, units=quant.unit("currency_unit")
     )
     constraints.extend(
         [
             GlobalConstraint(
                 lambda m, t: sum(
-                    m.import_export_mitigation_cost_balance[t, r] for r in m.regions
+                    m.mitigation_cost_trading_balance[t, r] for r in m.regions
                 )
                 == 0.0,
                 "sum_mitigation_equals_sum_area_under_mac",
             ),
             # Constraint: from import/export mitigation costs to import/export of emissions using the global carbon price
             RegionalEquation(
-                m.import_export_emission_reduction_balance,
+                m.emission_reduction_trading_balance,
                 lambda m, t, r: (
-                    m.import_export_mitigation_cost_balance[t, r]
+                    m.mitigation_cost_trading_balance[t, r]
                     / soft_min(m.global_carbonprice[t])
                     if t > 0
                     else 0
                 ),
             ),
             # Constraint: paid for emission reductions
             RegionalEquation(
-                m.paid_for_emission_reductions,
+                m.attributed_emission_reductions,
                 lambda m, t, r: (
                     m.regional_emission_reduction[t, r]
-                    + m.import_export_emission_reduction_balance[t, r]
+                    + m.emission_reduction_trading_balance[t, r]
                     if t > 0
                     else Constraint.Skip
                 ),
@@ -119,9 +119,9 @@ def get_constraints(m: AbstractModel) -> Sequence[GeneralConstraint]:
             RegionalEquation(
                 m.regional_emission_allowances,
                 lambda m, t, r: (
-                    m.baseline[t, r] - m.paid_for_emission_reductions[t, r]
+                    m.baseline_emissions[t, r] - m.attributed_emission_reductions[t, r]
                     if t > 0
-                    else m.baseline[t, r]
+                    else m.baseline_emissions[t, r]
                 ),
             ),
         ]

mimosa/components/emissiontrade/globalcostpool.py

@@ -37,7 +37,7 @@ def get_constraints(m: AbstractModel) -> Sequence[GeneralConstraint]:
     """
     constraints = []
 
-    m.area_under_MAC = Var(
+    m.domestic_mitigation_costs = Var(
         m.t,
         m.regions,
         within=NonNegativeReals,
@@ -49,34 +49,34 @@ def get_constraints(m: AbstractModel) -> Sequence[GeneralConstraint]:
     constraints.extend(
         [
             RegionalConstraint(
-                lambda m, t, r: m.area_under_MAC[t, r]
-                == AC(m.relative_abatement[t, r], m, t, r) * m.baseline[t, r],
+                lambda m, t, r: m.domestic_mitigation_costs[t, r]
+                == AC(m.relative_abatement[t, r], m, t, r) * m.baseline_emissions[t, r],
                 "mitigation_costs",
             ),
             GlobalConstraint(
                 lambda m, t: sum(m.mitigation_costs[t, r] for r in m.regions)
-                == sum(m.area_under_MAC[t, r] for r in m.regions),
-                "sum_abatement_equals_sum_area_under_mac",
+                == sum(m.domestic_mitigation_costs[t, r] for r in m.regions),
+                "sum_mitigation_costs_equals_sum_domestic_mitigation_costs",
             ),
         ]
     )
 
     ## Extra reporting variables:
 
-    m.paid_for_emission_reductions = Var(
+    m.attributed_emission_reductions = Var(
         m.t, m.regions, units=quant.unit("emissionsrate_unit")
     )
-    m.import_export_emission_reduction_balance = Var(
+    m.emission_reduction_trading_balance = Var(
         m.t, m.regions, units=quant.unit("emissionsrate_unit")
     )
-    m.import_export_mitigation_cost_balance = Var(
+    m.mitigation_cost_trading_balance = Var(
         m.t, m.regions, units=quant.unit("currency_unit")
     )
     constraints.extend(
         [
             RegionalConstraint(
                 lambda m, t, r: (
-                    m.paid_for_emission_reductions[t, r]
+                    m.attributed_emission_reductions[t, r]
                     == m.mitigation_costs[t, r]
                     * m.global_emission_reduction_per_cost_unit[t]
                     if t > 0
@@ -87,17 +87,17 @@ def get_constraints(m: AbstractModel) -> Sequence[GeneralConstraint]:
             # Import export of emission reduction balance: if positive: , if negative:
             RegionalConstraint(
                 lambda m, t, r: (
-                    m.import_export_emission_reduction_balance[t, r]
-                    == m.paid_for_emission_reductions[t, r]
+                    m.emission_reduction_trading_balance[t, r]
+                    == m.attributed_emission_reductions[t, r]
                     - m.regional_emission_reduction[t, r]
                     if t > 0
                     else Constraint.Skip
                 ),
                 "import_export_emission_reduction_balance",
             ),
             RegionalConstraint(
-                lambda m, t, r: m.import_export_mitigation_cost_balance[t, r]
-                == m.mitigation_costs[t, r] - m.area_under_MAC[t, r],
+                lambda m, t, r: m.mitigation_cost_trading_balance[t, r]
+                == m.mitigation_costs[t, r] - m.domestic_mitigation_costs[t, r],
                 "import_export_mitigation_cost_balance",
             ),
         ]

mimosa/components/emissiontrade/notrade.py

@@ -27,10 +27,10 @@ def get_constraints(m: AbstractModel) -> Sequence[GeneralConstraint]:
     """
     constraints = []  # No constraints here
 
-    m.import_export_emission_reduction_balance = Param(
+    m.emission_reduction_trading_balance = Param(
         m.t, m.regions, units=quant.unit("emissionsrate_unit"), initialize=0
     )
-    m.import_export_mitigation_cost_balance = Param(
+    m.mitigation_cost_trading_balance = Param(
         m.t, m.regions, units=quant.unit("currency_unit"), initialize=0
     )
     m.regional_emission_allowances = Var(

mimosa/components/mitigation.py

@@ -222,7 +222,7 @@ def _get_mac_constraints(m: AbstractModel) -> Sequence[GeneralConstraint]:
         initialize=0,
         units=quant.unit("currency_unit"),
     )
-    m.area_under_MAC = Var(
+    m.domestic_mitigation_costs = Var(
         m.t,
         m.regions,
         initialize=0,
@@ -234,20 +234,21 @@ def _get_mac_constraints(m: AbstractModel) -> Sequence[GeneralConstraint]:
     )
     constraints.extend(
         [
+            # Domestic mitigation costs: area under the MAC times baseline emissions,
+            # so the costs of mitigation in a region without taking into account emission trading
+            RegionalEquation(
+                m.domestic_mitigation_costs,
+                lambda m, t, r: AC(m.relative_abatement[t, r], m, t, r)
+                * m.baseline_emissions[t, r],
+            ),
+            # Total mitigation costs: domestic mitigation costs plus import/export of mitigation costs (if emission trading is enabled)
             RegionalEquation(
                 m.mitigation_costs,
                 lambda m, t, r: (
-                    AC(m.relative_abatement[t, r], m, t, r) * m.baseline[t, r]
-                    + m.import_export_mitigation_cost_balance[t, r]
+                    m.domestic_mitigation_costs[t, r]
+                    + m.mitigation_cost_trading_balance[t, r]
                 ),
             ),
-            # Extra (dummy) constraint for the variable area_under_MAC, which is the same as the mitigation costs
-            # when no emission trading is enabled
-            RegionalEquation(
-                m.area_under_MAC,
-                lambda m, t, r: AC(m.relative_abatement[t, r], m, t, r)
-                * m.baseline[t, r],
-            ),
             RegionalEquation(
                 m.rel_mitigation_costs,
                 lambda m, t, r: m.mitigation_costs[t, r] / m.GDP_gross[t, r],