Emission trading

Back to general structure

By default, every region has to pay for their own emission reductions. However, emission trading is a mechanism to allow regions to trade emission allowances with each other. This way, regions can pay for reductions in other regions if it is cheaper than reducing their own emissions or when following an effort-sharing regime.

The emission trading module can be chosen using the parameter emissiontrade module.

Note that emission trading is most often used in combination with an effort-sharing module.

Usage: 

params = load_params()
params["model"]["emissiontrade module"] = "notrade"
model = MIMOSA(params)

Without emission trading, the import/export of emission reductions and mitigation costs is always zero:

\[ \text{mitigation_cost_trading_balance}_{t,r} = 0 \]

This means that the mitigation costs and the area under the MAC are exactly the same for each region (see Mitigation costs).

Source code in mimosa/components/emissiontrade/notrade.py 
18
19
20
21
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
def get_constraints(m: AbstractModel) -> Sequence[GeneralConstraint]:
    """
    Without emission trading, the import/export of emission reductions and mitigation costs is always zero:

    $$
    \\text{mitigation_cost_trading_balance}_{t,r} = 0
    $$

    This means that the mitigation costs and the area under the MAC are exactly the same for each region (see [Mitigation costs](mitigation.md#mitigation-costs)).
    """
    constraints = []  # No constraints here

    m.emission_reduction_trading_balance = Param(
        m.t, m.regions, units=quant.unit("emissionsrate_unit"), initialize=0
    )
    m.mitigation_cost_trading_balance = Param(
        m.t, m.regions, units=quant.unit("currency_unit"), initialize=0
    )
    m.regional_emission_allowances = Var(
        m.t, m.regions, units=quant.unit("emissionsrate_unit")
    )

    constraints.append(
        # When there is no emission trading, emission allowances are simply equal to the emissions
        RegionalEquation(
            m.regional_emission_allowances, lambda m, t, r: m.regional_emissions[t, r]
        )
    )

    return constraints

Usage: 

params = load_params()
params["model"]["emissiontrade module"] = "emissiontrade"
model = MIMOSA(params)

In MIMOSA, every region can reduce its own emissions. The price for this is determined by the area under the MAC (see Mitigation). On top of that, regions can trade emission reductions with each other. Regions can pay other regions to reduce their emissions, or receive payments for reducing their own emissions.

The financial transfers for this are captured in the variable \(\text{mitigation cost trading balance}_{t,r}\). If it is positive, the region has to pay for emission reductions in other regions. If it is negative, the region receives payments for reducing its own emissions. For every timestep, the sum of these transfers should be zero:

\[ \sum_r \text{mitigation cost trading balance}_{t,r} = 0 \]

All emissions are traded at the global carbon price. Therefore, the financial flows (mitigation cost balance) is translated into emission flows (emission reduction trading balance) using the global carbon price:

\[ \text{emission reduction trading balance}_{t,r} = \frac{\text{mitigation cost trading balance}_{t,r}}{\text{global carbon price}_{t}}, \]

where the global carbon price is the population weighted average of the regional carbon prices:

\[ \text{global carbon price}_{t} = \frac{\sum_r \text{carbon price}_{t,r} \cdot \text{population}_{t,r}}{\sum_r \text{population}_{t,r}}. \]

Finally, the emission reductions paid for by a region are calculated as the physical reductions in the region plus the emission reduction trading balance:

\[ \text{paid for emission reductions}_{t,r} = \text{regional emission reduction}_{t,r} + \text{emission reduction trading balance}_{t,r}. \]
Source code in mimosa/components/emissiontrade/emissiontrade.py 
 19
 20
 21
 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
def get_constraints(m: AbstractModel) -> Sequence[GeneralConstraint]:
    """
    In MIMOSA, every region can reduce its own emissions. The price for this is determined
    by the area under the MAC (see [Mitigation](mitigation.md#mitigation-costs)). On top of that,
    regions can trade emission reductions with each other. Regions can pay other regions to reduce
    their emissions, or receive payments for reducing their own emissions.

    The financial transfers for
    this are captured in the variable $\\text{mitigation cost trading balance}_{t,r}$. If it is positive,
    the region has to pay for emission reductions in other regions. If it is negative,
    the region receives payments for reducing its own emissions. For every timestep,
    the sum of these transfers should be zero:

    $$
    \\sum_r \\text{mitigation cost trading balance}_{t,r} = 0
    $$

    All emissions are traded at the global carbon price. Therefore, the financial flows (mitigation cost balance) is
    translated into emission flows (emission reduction trading balance) using the global carbon price:

    $$
    \\text{emission reduction trading balance}_{t,r} = \\frac{\\text{mitigation cost trading balance}_{t,r}}{\\text{global carbon price}_{t}},
    $$

    where the global carbon price is the population weighted average of the regional carbon prices:

    $$
    \\text{global carbon price}_{t} = \\frac{\\sum_r \\text{carbon price}_{t,r} \\cdot \\text{population}_{t,r}}{\\sum_r \\text{population}_{t,r}}.
    $$

    Finally, the emission reductions paid for by a region are calculated as the physical reductions in the region plus the
    emission reduction trading balance:

    $$
    \\text{paid for emission reductions}_{t,r} = \\text{regional emission reduction}_{t,r} + \\text{emission reduction trading balance}_{t,r}.
    $$



    """
    constraints = []

    m.global_carbonprice = Var(m.t)

    # Emissions are traded at the global carbon price
    constraints.extend(
        [
            # Constraint that sets the global carbon price to the average of the regional carbon prices:
            GlobalEquation(
                m.global_carbonprice,
                lambda m, t: sum(
                    m.carbonprice[t, r] * m.population[t, r] for r in m.regions
                )
                / m.global_population[t],
            ),
        ]
    )

    ## Extra reporting variables:

    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.emission_reduction_trading_balance = Var(
        m.t, m.regions, units=quant.unit("emissionsrate_unit")
    )
    m.mitigation_cost_trading_balance = Var(
        m.t, m.regions, units=quant.unit("currency_unit")
    )
    constraints.extend(
        [
            GlobalConstraint(
                lambda m, t: sum(
                    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.emission_reduction_trading_balance,
                lambda m, 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.attributed_emission_reductions,
                lambda m, t, r: (
                    m.regional_emission_reduction[t, r]
                    + m.emission_reduction_trading_balance[t, r]
                    if t > 0
                    else Constraint.Skip
                ),
            ),
            # Constraint: regional emission allowances, equal to baseline minus paid for emission reductions
            RegionalEquation(
                m.regional_emission_allowances,
                lambda m, t, r: (
                    m.baseline_emissions[t, r] - m.attributed_emission_reductions[t, r]
                    if t > 0
                    else m.baseline_emissions[t, r]
                ),
            ),
        ]
    )

    return constraints