Skip to content

Economics

Back to general structure

Economic module and production function

Gross and net GDP

The core of the model is the economic module, detailing how GDP, investments and consumptions vary over time. We use a traditional Cobb-Douglas production function. This means that the gross GDP is calculated by:

GDPgross,t,r=TFPt,r⋅Lt,r1−α⋅Kt,rα, with TFP the total factor productivity (exogenously calibrated from the baseline SSP scenarios) L the labor (represented by the total population), K the capital stock and α the share of capital in the production function.

Source code in mimosa/common/economics.py 
41
42
43
44
45
46
47
48
def calc_GDP(TFP, L, K, alpha):
    """
    $$ \\text{GDP}_{\\text{gross},t,r} = \\text{TFP}\\_{t,r} \\cdot L^{1-\\alpha}\\_{t,r} \\cdot K^{\\alpha}\\_{t,r}, $$
    with $\\text{TFP}$ the total factor productivity (exogenously calibrated from the baseline SSP scenarios)
    $L$ the labor (represented by the total population), $K$ the capital stock and $\\alpha$ the share of capital in the production function.

    """
    return TFP * L ** (1 - alpha) * K**alpha

The net GDP is then calculated by subtracting the damages and mitigation costs from the gross GDP. (Note that in MIMOSA, the damages are expressed as a fraction of the gross GDP, whereas the mitigation costs are expressed in absolute terms.)

GDPnet,t,r= GDPgross,t,r⋅(1−damage costst,r)   −mitigation costst,r−financial transf.t,r

The last term represents optional financial transfers to compensate regions for damage costs. By default this term is always 0 (see Financial transfers).

Investments and consumption

This net GDP is then split in a part of investments (It) and a part of consumption (Ct), according to a fixed savings rate (sr):

It,r=sr⋅GDPnet,t,r,
Ct,r=(1−sr)⋅GDPnet,t,r.

Capital stock

The capital stock Kt grows over time according to the investments and the depreciation of the capital stock:

Kt,r=Kt−1,r+Δt⋅∂Kt,r∂t,

with the change in capital stock calculated by:

∂Kt,r∂t=1Δt⋅((1−dk)Δt−1)⋅Kt,r+It,r.
Source code in mimosa/common/economics.py 
34
35
36
37
38
def calc_dKdt(K, dk, I, dt):
    """
    $$ \\frac{\\partial K_{t,r}}{\\partial t} = \\frac{1}{\\Delta t} \\cdot ((1 - dk)^{\\Delta t}  - 1) \\cdot K_{t,r} + I_{t,r}.$$
    """
    return ((1 - dk) ** dt - 1) / dt * K + I

Since this only gives the change in capital stock, we need to add the initial capital stock to get the actual capital stock. This is calculated as a region-dependent multiple of the initial GDP:

Kt=0,r=init_capitalstock_factorr⋅GDPt=0,r.

The initial capital stock factor is a calibration factor to obtain the initial capital stock. TODO: Source (IMF)

Parameters defined in this module

  • init_capitalstock_factor
  • alpha: Output elasticity of capital. Type: float. Default: 0.3. Min: 0. Max: 1.
  • dk: Yearly depreciation rate of capital stock. Type: float. Default: 0.05. Min: 0. Max: inf.
  • sr: Fraction of GDP used for investments. Type: float. Default: 0.21. Min: 0. Max: 1.
  • ignore_damages: Flag to not take into account the damages in the GDP (but damages are calculated). Type: bool. Default: False.
Source code in mimosa/components/cobbdouglas.py 
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
def get_constraints(m: AbstractModel) -> Sequence[GeneralConstraint]:
    """
    # Economic module and production function

    ## Gross and net GDP

    The core of the model is the economic module, detailing how GDP, investments and
    consumptions vary over time. We use a traditional Cobb-Douglas production function. This means
    that the gross GDP is calculated by:

    :::mimosa.common.economics.calc_GDP

    The net GDP is then calculated by subtracting the damages and
    mitigation costs from the gross GDP. *(Note that in MIMOSA, the damages are expressed as a fraction of the gross GDP,
    whereas the mitigation costs are expressed in absolute terms.)*

    $$
    \\begin{align}
    \\text{GDP}_{\\text{net},t,r} =\\ & \\text{GDP}_{\\text{gross},t,r} \\cdot (1 - \\text{damage costs}_{t,r}) \\\\
    &\\ \\ \\ - \\text{mitigation costs}_{t,r} - \\text{financial transf.}_{t,r}
    \\end{align}
    $$

    The last term represents optional financial transfers to compensate regions for damage
    costs. By default this term is always 0 (see [Financial transfers](financialtransfers.md)).

    ## Investments and consumption

    This net GDP is then split in a part of investments ($I_t$) and a part of consumption ($C_t$), according to a fixed savings rate ($\\text{sr}$):

    $$ I_{t,r} = \\text{sr} \\cdot \\text{GDP}_{\\text{net},t,r}, $$

    $$ C_{t,r} = (1 - \\text{sr}) \\cdot \\text{GDP}_{\\text{net},t,r}. $$

    ## Capital stock

    The capital stock $K_t$ grows over time according to the investments and the depreciation of the capital stock:

    $$ K_{t,r} = K_{t-1,r} + \\Delta t \\cdot \\frac{\\partial K_{t,r}}{\\partial t}, $$

    with the change in capital stock calculated by:

    :::mimosa.common.economics.calc_dKdt

    Since this only gives the change in capital stock, we need to add the initial capital stock to get the actual capital stock.
    This is calculated as a region-dependent multiple of the initial GDP:

    $$ K_{t=0,r} = \\text{init_capitalstock_factor}_r \\cdot \\text{GDP}_{t=0,r}. $$

    The initial capital stock factor is a calibration factor to obtain the initial capital stock. TODO: Source (IMF)
    ``` plotly
    {"file_path": "./assets/plots/economics_init_capital_factor.json"}
    ```

    ## Parameters defined in this module
    - init_capitalstock_factor
    - alpha: Output elasticity of capital. Type: float. Default: 0.3. Min: 0. Max: 1.
    - dk: Yearly depreciation rate of capital stock. Type: float. Default: 0.05. Min: 0. Max: inf.
    - sr: Fraction of GDP used for investments. Type: float. Default: 0.21. Min: 0. Max: 1.
    - ignore_damages: Flag to not take into account the damages in the GDP (but damages are calculated). Type: bool. Default: False.



    """
    constraints = []

    m.init_capitalstock_factor = Param(
        m.regions,
        units=quant.unit("dimensionless"),
        doc="regional::economics.init_capital_factor",
    )
    m.capital_stock = Var(
        m.t,
        m.regions,
        initialize=lambda m, t, r: m.init_capitalstock_factor[r] * m.baseline_GDP[t, r],
        units=quant.unit("currency_unit"),
    )

    # Parameters
    m.alpha = Param(doc="::economics.GDP.alpha")
    m.dk = Param(doc="::economics.GDP.depreciation of capital")
    m.sr = Param(doc="::economics.GDP.savings rate")

    m.GDP_gross = Var(
        m.t,
        m.regions,
        initialize=lambda m, t, r: m.baseline_GDP[0, r],
        units=quant.unit("currency_unit"),
    )
    m.GDP_net = Var(
        m.t,
        m.regions,
        units=quant.unit("currency_unit"),
        initialize=lambda m, t, r: m.baseline_GDP[0, r],
    )
    m.investments = Var(m.t, m.regions, units=quant.unit("currency_unit"))
    m.consumption = Var(m.t, m.regions, units=quant.unit("currency_unit"))

    m.ignore_damages = Param(doc="::economics.damages.ignore damages")

    m.TFP = Param(m.t, m.regions, initialize=economics.get_TFP_value)

    # Cobb-Douglas, GDP, investments, capital and consumption
    constraints.extend(
        [
            RegionalConstraint(
                lambda m, t, r: (
                    m.GDP_gross[t, r]
                    == economics.calc_GDP(
                        m.TFP[t, r],
                        m.population[t, r],
                        soft_min(m.capital_stock[t, r], scale=10),
                        m.alpha,
                    )
                    if t > 0
                    else Constraint.Skip
                ),
                "GDP_gross",
            ),
            RegionalInitConstraint(
                lambda m, r: m.GDP_gross[0, r] == m.baseline_GDP[0, r], "GDP_gross_init"
            ),
            RegionalConstraint(
                lambda m, t, r: m.GDP_net[t, r]
                == m.GDP_gross[t, r]
                * (1 - (m.damage_costs[t, r] if not value(m.ignore_damages) else 0))
                - m.mitigation_costs[t, r]
                - m.financial_transfer[t, r],
                "GDP_net",
            ),
            RegionalConstraint(
                lambda m, t, r: m.investments[t, r] == m.sr * m.GDP_net[t, r],
                "investments",
            ),
            RegionalConstraint(
                lambda m, t, r: m.consumption[t, r] == (1 - m.sr) * m.GDP_net[t, r],
                "consumption",
            ),
            RegionalConstraint(
                lambda m, t, r: (
                    (
                        m.capital_stock[t, r]
                        == m.capital_stock[t - 1, r]
                        + m.dt
                        * economics.calc_dKdt(
                            m.capital_stock[t, r], m.dk, m.investments[t, r], m.dt
                        )
                    )
                    if t > 0
                    else Constraint.Skip
                ),
                "capital_stock",
            ),
            RegionalInitConstraint(
                lambda m, r: m.capital_stock[0, r]
                == m.init_capitalstock_factor[r] * m.baseline_GDP[0, r]
            ),
        ]
    )

    return constraints