diff --git a/Project.toml b/Project.toml index 701d820..ddcd50c 100644 --- a/Project.toml +++ b/Project.toml @@ -1,7 +1,8 @@ name = "ClimateMARGO" uuid = "d3f62095-a717-45bf-aadc-ac9dfc258fa6" repo = "https://github.com/ClimateMARGO/ClimateMARGO.jl" -version = "0.2.2" +version = "0.3.0" + [deps] CompilerSupportLibraries_jll = "e66e0078-7015-5450-92f7-15fbd957f2ae" @@ -13,6 +14,7 @@ Ipopt_jll = "9cc047cb-c261-5740-88fc-0cf96f7bdcc7" JSON2 = "2535ab7d-5cd8-5a07-80ac-9b1792aadce3" JuMP = "4076af6c-e467-56ae-b986-b466b2749572" PyPlot = "d330b81b-6aea-500a-939a-2ce795aea3ee" +Revise = "295af30f-e4ad-537b-8983-00126c2a3abe" [compat] DiffResults = "= 1.0.2" diff --git a/configurations/default_params.json b/configurations/default_params.json index d854f3b..dce495b 100644 --- a/configurations/default_params.json +++ b/configurations/default_params.json @@ -1 +1,112 @@ -{"name":"default","domain":{"dt":5.0,"present_year":2020.0,"initial_year":2020.0,"final_year":2200.0},"economics":{"E0":100.0,"γ":0.02,"β":0.0022222222222222222,"ρ":0.02,"Finf":8.5,"mitigate_cost":0.034,"remove_cost":13.0,"geoeng_cost":0.126,"adapt_cost":0.18,"mitigate_init":0.0,"remove_init":0.0,"geoeng_init":0.0,"adapt_init":null,"baseline_emissions":[7.5,8.4375,9.375,10.3125,11.25,12.1875,13.125,14.0625,15.0,15.9375,16.875,17.8125,18.75,19.6875,20.625,21.5625,22.5,20.25,18.0,15.75,13.5,11.25,9.0,6.75,4.5,2.25,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0],"epsilon_cost":0.0,"extra_CO₂":[0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0]},"physics":{"c0":460.0,"T0":1.1,"a":4.977297891066924,"B":1.13,"Cd":106.0,"κ":0.73,"r":0.5}} \ No newline at end of file +{ + "name": "default", + "domain": { + "dt": 5.0, + "present_year": 2020.0, + "initial_year": 2020.0, + "final_year": 2200.0 + }, + "economics": { + "E0": 100.0, + "γ": 0.02, + "β": 0.01, + "ρ": 0.02, + "Finf": 8.5, + "mitigate_cost": 0.055489419901509705, + "remove_cost": 36.97631285953187, + "geoeng_cost": 0.5658234787375677, + "adapt_cost": 0.115, + "mitigate_init": 0.0, + "remove_init": 0.0, + "geoeng_init": 0.0, + "adapt_init": 0.0, + "baseline_emissions": [ + 7.5, + 8.4375, + 9.375, + 10.3125, + 11.25, + 12.1875, + 13.125, + 14.0625, + 15.0, + 15.9375, + 16.875, + 17.8125, + 18.75, + 19.6875, + 20.625, + 21.5625, + 22.5, + 20.25, + 18.0, + 15.75, + 13.5, + 11.25, + 9.0, + 6.75, + 4.5, + 2.25, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ], + "epsilon_cost": 0.0, + "extra_CO₂": [ + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0 + ] + }, + "physics": { + "c0": 460.0, + "T0": 1.1, + "a": 4.977297891066924, + "B": 1.13, + "Cd": 106.0, + "κ": 0.73, + "r": 0.5 + } +} \ No newline at end of file diff --git a/examples/default_configuration.jl b/examples/default_configuration.jl new file mode 100644 index 0000000..0f423cc --- /dev/null +++ b/examples/default_configuration.jl @@ -0,0 +1,351 @@ +# # ClimateMARGO.jl tutorial + +# The following schematic shows the full formulation of the MARGO model, which is described in detail in the accompanying (but not yet peer-reviewed) manuscript, available for free at [EarthArXiv.org/5bgyc](https://eartharxiv.org/5bgyc). No-policy baseline emissions $q(t)$ are prescribed, leading to changing greenhouse gas (CO$_{2e}$) concentrations, radiative forcing, temperatures, and climate damages. Emissions can be decreased by **M**itigation; concentrations can be decreased by carbon dioxide **R**emoval; forcing can be decreased by solar **G**eo-engineering; and the "adapted" temperature that leads to climate damages can be reduced by **A**dapting to the changed climate. +# drawing + +# ### Import software + +# The MARGO model has been implemented and registered as the Julia package `ClimateMARGO.jl`, which can be installed with the command `Pkg.add("ClimateMARGO")`. + +# If you are running this tutorial via Binder, there is no need to install the package; just import it using the command below. + +using ClimateMARGO # Julia implementation of the MARGO model +using PyPlot # A basic plotting package + +# + +using ClimateMARGO.Models +using ClimateMARGO.Utils +using ClimateMARGO.Diagnostics + +# ## Model configuration + +# An instance of MARGO `ClimateModelParameters` requires specifying a `name` and the parameters for three model subcomponents: +# 1. `Domain`: determines the time period of interest, as well as the timestep and– in the policy response mode– the "present" decision-making year. +# 2. `Economics`: determines exogenous economic growth, the cliamte damage cost function, and the cost function for each of the four controls, and the discount rate. +# 3. `Physics`: determines the parameters that govern the aiborn fraction of emissions that remain in the atmosphere, the strength of climate feedbacks, and the rate of ocean heat uptake. + +# An instance of the MARGO `ClimateModel` is determined by combining the prescribed set of `ClimateModelParameters` with timeseries of the four `Controls`, which will act as the control variables in the optimization framework: +# 1. **M**itigation of baseline emissions +# 2. **R**emoval of carbon dioxide from the atmopshere +# 3. **G**eongineering by solar radiation management, and +# 4. **A**daptating to the changed climate to reduce the damages of climate change impacts. + +# Here, we run through the full construction of the model with its "default" parameter values. + +name = "default"; + +# #### 1. Setting up the temporal grid +# First, we need to set up a time-frame for our experiment. Let's begin our simulation in the year 2020– present day– and consider out to 2200, with a 5-year timestep for computational efficiency. + +initial_year = 2020. # [yr] +final_year = 2200. # [yr] +dt = 5. # [yr] +t_arr = t(initial_year, final_year, dt); + +# While the model allows for shifting the "present" year forward or backward in time to simulate past and future policy decision-making processes, we will only consider the simplest case in which we take the perspective of a policy decision maker in the year 2020, which is also the initial year of our simulation. + +present_year = initial_year +dom = Domain(dt, initial_year, initial_year, final_year); + +#### 2. Configuring the carbon cycle and energy balance models + +# CO$_{2e}$ concentrations are given by: +# \begin{equation} +# c_{M,R}(t) = c_{0} + \int_{t_{0}}^{t} rq(t')(1-M(t')) \text{ d}t' - q_{0} \int_{t_{0}}^{t} R(t')\text{ d}t'. +# \end{equation} +# where $q(t)$ is a specific timeseries of no-climate-policy baseline emissions (with $q(t_{0}) = q_{0}$), $c_{0}$ is the initial CO$_{2e}$ concentration, and $r$ is the fraction of emitted CO$_{2e}$ that remains in the atmosphere net of short-term uptake by the ocean and biosphere. $M(t')$ and $R(t')$ represent the effects emissions mitigation and carbon dioxide removal, respectively, on CO$_{2e}$ concentrations relative to the baseline; they will be initially set to zero and later determined by solving an optimization problem. + +# The default no-policy scenario is one of rapid, fossil-fueled growth which leads to an accumulation of $c(t) = 1400$ ppm of CO$_{2e}$ in the atmosphere by 2150, when emissions are assumed to finally reach net-zero. + +c0 = 460. # [ppm] +r = 0.5; # [1] fraction of emissions remaining after biosphere and ocean uptake (Solomon 2009) + +q0 = 7.5 +q0mult = 3. +t_peak = 2100. +t_zero = 2150. +q = ramp_emissions(t_arr, q0, q0mult, t_peak, t_zero); + +# + +figure(figsize=(9,3.5)) + +subplot(1,2,1) +plot(t_arr, ppm_to_GtCO2(q)) +xlabel("year") +ylabel(L"baseline emissions $q(t)$ [GtCO2 / year]") +xlim([2020, 2200]) +grid(true) + +subplot(1,2,2) +q_effective = effective_emissions(r, q, 0., 0.) # No mitigation, no carbon removal +c_baseline = c(c0, q_effective, dt) +plot(t_arr, c_baseline) +xlabel("year") +ylabel(L"baseline concentrations $c(t)$ [ppm]") +xlim([2020, 2200]) +tight_layout(); +grid(true) +gcf() + +# These CO$_{2e}$ concentrations drive an anomalous greenhouse effect, which is represented by the radiative forcing +# \begin{equation} +# F_{M,R,G} = a \ln\left(\frac{c_{M,R}(t)}{c_{0}}\right) - G(t)F_{\infty}, +# \end{equation} +# where $a$ is an empirically determined coefficient, $G(t)$ represents the effects of geoengineering, and $F_{\infty} = 8.5$ W/m$^2$ is a scaling factor for the effects of geoengineering by Solar Radiation Modification (SRM). + +a = (6.9/2.)/log(2.); # F4xCO2/2 / log(2) [W m^-2] +Finf = 8.5; + +# + +figure(figsize=(4.5,3.2)) +F0 = 3.0 +F_baseline = F(a, c0, Finf, c_baseline, 0.) +plot(t_arr, F_baseline .+ F0) +xlabel("year") +ylabel(L"baseline radiative forcing $F(t)$ [W/m$^2$]") +xlim([2020, 2200]) +grid(true) +ylim([0,10.]); +gcf() + +# Next, we configure MARGO's energy balance model, which is forced by the controlled forcing $F_{M,R,G}$. The two-layer energy balance model can be solved, approximately, as: +# \begin{equation} +# T_{M,R,G}(t) - T_{0} = \frac{F_{M,R,G}(t)}{B + \kappa} + \frac{\kappa}{B} \int_{t_{0}}^{t} \frac{e^{\frac{t'-t}{\tau_{D}}}}{\tau_{D}} \frac{F_{M,R,G}(t')}{B+\kappa} \, \text{d}t', +# \end{equation} +# where $T_{0}$ is the initial temperature change relative to preindustrial, $B$ is the feedback parameter, $\kappa$ is , and the timescale $\tau_{D} = \dfrac{C_{D}}{B} \dfrac{B + \kappa}{\kappa}$ is a more convenient expression for the deep ocean heat capacity $C_{D}$. + +# Default parameter values are taken from [Geoffroy et al. 2013](https://journals.ametsoc.org/doi/full/10.1175/JCLI-D-12-00195.1)'s physically-based calibration of the two-layer model to CMIP5. + +# Two-layer EBM parameters +B = 1.13; # Feedback parameter [J yr^-1 m^-2 K^-1] +Cd = 106.; # Deep ocean heat capacity [J m^-2 K^-1] +κ = 0.73; # Heat exchange coefficient [J yr^-1 m^2 K^-1] + +# Initial condition: present-day temperature, relative to pre-industrial +T0 = 1.1; # [degC] Berkeley Earth Surface Temperature (Rohde 2013) + +print("τD = ", Int64(round(τd(Cd, B, κ))), " years") + +# These physical parameters can be used to diagnose the climate sensitivity to a doubling of CO$_{2}$ ($ECS$). + +print("ECS = ", round(ECS(a, B),digits=1) ,"ºC") + +# Combined, these parameters define the physical model, which is instantiated by the calling the `Physics` constructor method: + +Phys = Physics(c0, T0, a, B, Cd, κ, r); + +# #### 3. Configuring the simple economic model +# Economic growth in MARGO (in terms of Gross World Product, GWP) is exogenous $E(t) = E_{0} (1 + \gamma)^{(t-t_{0})}$ and is entirely determined by the growth rate $\gamma$. By default, we set $\gamma = 2\%$. + +E0 = 100. # Gross World Product at t0 [10^12$ yr^-1] +γ = 0.02 # economic growth rate + +E_arr = E(t_arr, E0, γ) + +figure(figsize=(4, 2.5)) +plot(t_arr, E_arr) +xlabel("year") +ylabel("GWP [trillion USD]") +xlim([2020, 2200]) +ylim([0, 3000]); +grid(true) +gcf() + +# Economic damages $D_{M,R,G,A} = \tilde{\beta}E(t) (\Delta T_{M,R,G})^{2} (1 - A(t))$, expressed as a fraction $\tilde{\beta}(\Delta T_{M,R,G})^{2}$ of the instantaneous Gross World Product, increase quadratically with temperature change relative to preindustrial. They can be decrease by adaptation controls $A(t)$. The default value of the damage parameter $\tilde{\beta}$ corresponds to damages of 2\% of GWP at 3ºC of warming. + +βtilde = 0.01; # damages [%GWP / celsius^2] + +# The total cost of climate controls is simply the sum of their individual costs, each of which follows a parabolic cost function: +# \begin{equation} +# \mathcal{C}_{M,R,G,A} = \mathcal{C}_{M}M^2 + \mathcal{C}_{R}R^2 + \mathcal{C}_{G}G^2 + \mathcal{C}_{A}A^2 +# \end{equation} + +# The calculation of the reference control costs $\mathcal{C}_{M}, \mathcal{C}_{R}, \mathcal{C}_{G}, \mathcal{C}_{A}$ are somewhat more complicated; see our Methods in [the preprint](https://eartharxiv.org/5bgyc/) and `defaults.jl` for details. Here, we simply provide their default numerical values, where the costs of mitigation $\mathcal{C}_{M} = \tilde{\mathcal{C}}_{M} E(t)$ and geoengineering $\mathcal{C}_{G} = \tilde{\mathcal{C}}_{G} E(t)$ grow with the size of the global economy and are thus specified as a fraction of GWP, while adaptaiton and removal costs are in trillions of USD per year. + +ti = findall(x->x==2100, t_arr)[1] +mitigate_cost_percentGWP = 0.02 +mitigate_cost = mitigate_cost_percentGWP*E_arr[ti]/ppm_to_GtCO2(q[ti]); # [trillion USD / year / GtCO2] + +# Costs of negative emissions technologies [US$/tCO2] +costs = Dict( + "BECCS" => 150., + "DACCS" => 200., + "Forests" => 27.5, + "Weathering" => 125., + "Biochar" => 70., + "Soils" => 50. +) + +# Upper-bound potential for sequestration (GtCO2/year) +potentials = Dict( + "BECCS" => 5., + "DACCS" => 5., + "Forests" => 3.6, + "Weathering" => 4., + "Biochar" => 2., + "Soils" => 5. +) + +mean_cost = sum(values(potentials) .* values(costs)) / sum(values(potentials)) # [$ tCO2^-1] weighted average +CDR_potential = sum(values(potentials)) +CDR_potential_fraction = CDR_potential / ppm_to_GtCO2(q0) + +# Estimate cost from Fuss 2018 (see synthesis Figure 14 and Table 2) +remove_cost = (mean_cost * CDR_potential*1.e9) / (CDR_potential_fraction^3) * 1.e-12; # [trillion USD / year] + +adapt_cost = 0.115; # [%GWP / year] directly from de Bruin, Dellink, and Tol (2009) + +geoeng_cost = βtilde*(Finf/B)^2; # [% GWP] + +# Climate damages and control costs are discounted at the relatively low rate of $\rho = 2\%$, such that future damages and costs are reduced by a multiplicative discount factor $(1 - \rho)^{(t-t_{0})}$. + +ρ = 0.02; + +figure(figsize=(4, 2.5)) +plot(t_arr, discount(t_arr, ρ, present_year)*100) +xlabel("year") +ylabel("discount factor (%)") +xlim([2020, 2200]) +ylim([0, 100]); +grid(true) +gcf() + +# These parameters, in addition to a no-policy baseline emissions time-series and present-day control values, define the economic model. + +Econ = Economics( + E0, γ, βtilde, ρ, Finf, + mitigate_cost, remove_cost, geoeng_cost, adapt_cost, + 0., 0., 0., 0., # Initial condition on control deployments at t[1] + q +); + +# #### A MARGO model configuration is uniquely determined by the parameters defined above + +params = ClimateModelParameters( + name, + dom, + Econ, + Phys +); + +# ## Instanciating the MARGO climate model + +# Along with economic and physical model components, the timeseries for each of the four controls must be specified. By default, we simply set these to zero. + +Cont = Controls( + zeros(size(t_arr)), # mitigate + zeros(size(t_arr)), # remove + zeros(size(t_arr)), # geoeng + zeros(size(t_arr)) # adapt +); + +# The above parameters determine the full configuration of the MARGO model, which is instanced using the `ClimateModel` constructor method: + +m = ClimateModel( + params, + Cont +); + +# ## Model optimization + +# #### Formulating the optimization problem +# By default, the optimization problem we solve is for the most cost-effective combination of controls, as determined by minimization of the discounted net present value, + +# \begin{equation} +# \min\left\{\int_{t_{0}}^{t_{f}} \mathcal{C}_{M,R,G,A} (1 + \rho)^{-(t-t_{0})} \text{ d}t\right\} +# \end{equation} + +# which keep controlled damages below the level corresponding to a chosen temperature threshold $T^{\star}$, + +# \begin{equation} +# \tilde{\beta} E(t) (T_{M,R,G})^{2} (1 - A(t)) < \tilde{\beta} E(t) (T^{\star})^{2}. +# \end{equation} + +temp_goal = 2.0; + +# #### Additional policy / inertia constraints +# The optimization is also subject to the constraints described below. + +# First, we set a upper bounds on the maximum plausible deployment of each control. + +max_deployment = Dict("mitigate"=>1., "remove"=>1., "geoeng"=>1., "adapt"=>0.4); + +# Second, we set upper limits on how quickly each control can be ramped up or down. + +# (Adaptation is treated differently since we it interpret it as buying insurance against future climate damages, although the financing is spread evenly over the entire period.) + +max_slope = Dict("mitigate"=>1. /40., "remove"=>1. /40., "geoeng"=>1. /40., "adapt"=> 1. /40.); + +# Third, we impose restrictions on when controls can be first deployed. In particular, since carbon dioxide removal and solar radiation modification do not yet exist at scale, we delay these until 2030 and 2050, respectively, at the earliest. + +delay_deployment = Dict( + "mitigate"=>0., + "remove"=>0., + "geoeng"=>0., + "adapt"=>0. +); + +# #### Running the optimization +# The optimization takes about ~40 seconds the first time it is run as the code compiles, but runs virtually instantly afterwards, even if model parameter values are changed. + +using ClimateMARGO.Optimization + +@time msolve = optimize_controls!( + m, + obj_option = "adaptive_temp", temp_goal = temp_goal, + max_deployment = max_deployment, max_slope = max_slope, delay_deployment = delay_deployment +); + +# ## Plotting MARGO results + +# We provide some convenient functions for plotting basic model results. + +using ClimateMARGO.Plotting +plot_state(m, temp_goal=temp_goal) +gcf() + +# ## Customizing MARGO + +# Try changing some of the parameters above and re-running the model! + +# For example, in the simulation below we set a more stringent temperature goal of $T^{\star} = 1.5$ and omit solar geoengineering and adaptation completely (by setting their maximum deployment to zero). + +temp_goal = 1.5 +max_deployment["geoeng"] = 0. +max_deployment["adapt"] = 0. + +@time optimize_controls!( + m, + obj_option = "adaptive_temp", temp_goal = temp_goal, + max_deployment = max_deployment, max_slope = max_slope, delay_deployment = delay_deployment +); + +plot_state(m, temp_goal=temp_goal) +gcf() + +# ## Saving (and loading) MARGO simulations (or parameter configurations) + +using ClimateMARGO.IO +export_path = tempname() * ".json" + +# + +export_parameters(export_path, params); + +# + +new_params = import_parameters(export_path) + +# Let's say we want to see what happens if climate feedbacks $B$ are twice as strong as they are now (which means a lower feedback parameter). + +new_params.name = "stronger_feedbacks" +new_params.physics.B /= 2.; + +new_m = ClimateModel(new_params, Cont) + +# The new equilibrium climate sensitivity (recall $ECS = F_{2x}/B$) is now: + +print("ECS ≈ $(round(ECS(new_m), digits=1))°C") diff --git a/examples/default_optimization.jl b/examples/default_optimization.jl index 498894c..1f4bcc8 100644 --- a/examples/default_optimization.jl +++ b/examples/default_optimization.jl @@ -1,5 +1,9 @@ # # Optimization of the default MARGO configuration +using Revise + +## + # ## Using `ClimateMARGO.jl` using ClimateMARGO using ClimateMARGO.Models @@ -19,16 +23,16 @@ m.controls # ## Real-time climate optimization # Let's optimize the controls with the default settings, which finds the cheapest combination of the control timeseries that keeps adapted temperatures below 2°C. -@time optimize_controls!(m); +@time optimize_controls!(m, temp_goal=1.5); # The optimization can be slow the first time since it has to compile. # Let's re-initialize the model and see how fast it runs now that the the optimization routine has been precompiled. m = ClimateModel(params); -@time optimize_controls!(m); +@time optimize_controls!(m, temp_goal=1.5); # ## Visualizing the results # Finally, let's plot the resulting temperature timeseries using PyPlot -fig, axes = ClimateMARGO.Plotting.plot_state(m); +fig, axes = ClimateMARGO.Plotting.plot_state(m, temp_goal=1.5); gcf() \ No newline at end of file diff --git a/examples/one-two_dimensional_optimization.jl b/examples/one-two_dimensional_optimization.jl index 3187c59..3e96419 100644 --- a/examples/one-two_dimensional_optimization.jl +++ b/examples/one-two_dimensional_optimization.jl @@ -13,8 +13,8 @@ using ClimateMARGO.Optimization # ## Loading the default MARGO configuration params = deepcopy(ClimateMARGO.IO.included_configurations["default"]) -# Slightly increasing the discount rate to 3% to be more comparable with other models -params.economics.ρ = 0.03 +# Slightly increasing the discount rate to 4% to be more comparable with other models +params.economics.ρ = 0.04 # ## Reducing the default problem's dimensionality from ``4N`` to ``2``. @@ -146,6 +146,8 @@ ylabel("Net present benefits, relative to baseline [trillion USD]") legend(loc="upper left") gcf() +## + # ### Visualizing the two-dimensional optimization problem fig = figure(figsize=(14, 5)) @@ -155,7 +157,7 @@ subplot(1,2,o) pcolor(Ms, Rs, control_cost, cmap="Greys", vmin=0., vmax=150.) cbar = colorbar(label="Net present cost of controls [trillion USD]") control_cost[(min_temp .<= 0.)] .= NaN -contour(Ms, Rs, control_cost, levels=[25, 50, 75], colors="k", linewidths=0.85, alpha=0.4) +contour(Ms, Rs, control_cost, levels=[10, 50], colors="k", linewidths=0.5, alpha=0.4) grid(true, color="k", alpha=0.25) temp_mask = ones(size(max_temp)) @@ -180,15 +182,15 @@ xlabel("Emissions mitigation level [% reduction]") xticks(0.:0.2:1.0, ["0%", "20%", "40%", "60%", "80%", "100%"]) ylabel(L"CO$_{2e}$ removal rate [% of present-day emissions]") yticks(0.:0.2:1.0, ["0%", "20%", "40%", "60%", "80%", "100%"]) -annotate(L"$T > 4\degree$C", (0.02, 0.04), xycoords="axes fraction", color="darkred", fontsize=13) -annotate(L"$T < 0\degree$C", (0.74, 0.66), xycoords="axes fraction", color="darkblue", fontsize=13) +annotate(L"$\max(T) > 4\degree$C", (0.015, 0.03), xycoords="axes fraction", color="darkred", fontsize=9) +annotate(L"$\min(T) < 0\degree$C", (0.72, 0.725), xycoords="axes fraction", color="darkblue", fontsize=9) title("Cost-effectiveness analysis") o = 2 subplot(1,2,o) -q = pcolor(Ms, Rs, net_benefit, cmap="Greys_r", vmin=-75, vmax=75) +q = pcolor(Ms, Rs, net_benefit, cmap="Greys_r", vmin=0, vmax=250) cbar = colorbar(label="Net present benefits, relative to baseline [trillion USD]", extend="both") -contour(Ms, Rs, net_benefit, levels=[0, 25, 50], colors="k", linewidths=0.85, alpha=0.4) +contour(Ms, Rs, net_benefit, levels=[100, 200], colors="k", linewidths=0.5, alpha=0.4) grid(true, color="k", alpha=0.25) temp_mask = ones(size(min_temp)) @@ -207,6 +209,6 @@ xlabel("Emissions mitigation level [% reduction]") xticks(0.:0.2:1.0, ["0%", "20%", "40%", "60%", "80%", "100%"]) ylabel(L"CO$_{2e}$ removal rate [% of present-day emissions]") yticks(0.:0.2:1.0, ["0%", "20%", "40%", "60%", "80%", "100%"]) -annotate(L"$T < 0\degree$C", (0.74, 0.66), xycoords="axes fraction", color="darkblue", fontsize=13) +annotate(L"$\min(T) < 0\degree$C", (0.72, 0.725), xycoords="axes fraction", color="darkblue", fontsize=9) title("Cost-benefit analysis") gcf() \ No newline at end of file diff --git a/notebooks/tutorial.ipynb b/notebooks/tutorial.ipynb deleted file mode 100644 index 6d85683..0000000 --- a/notebooks/tutorial.ipynb +++ /dev/null @@ -1,932 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# ClimateMARGO.jl tutorial\n", - "\n", - "The following schematic shows the full formulation of the MARGO model, which is described in detail in the accompanying (but not yet peer-reviewed) manuscript, available for free at [EarthArXiv.org/5bgyc](https://eartharxiv.org/5bgyc). No-policy baseline emissions $q(t)$ are prescribed, leading to changing greenhouse gas (CO$_{2e}$) concentrations, radiative forcing, temperatures, and climate damages. Emissions can be decreased by **M**itigation; concentrations can be decreased by carbon dioxide **R**emoval; forcing can be decreased by solar **G**eo-engineering; and the \"adapted\" temperature that leads to climate damages can be reduced by **A**dapting to the changed climate.\n", - "\"drawing\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Import software\n", - "\n", - "The MARGO model has been implemented and registered as the Julia package `ClimateMARGO.jl`, which can be installed with the command `Pkg.add(\"ClimateMARGO\")`.\n", - "\n", - "If you are running this tutorial via Binder, there is no need to install the package; just import it using the command below." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "using Revise" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "┌ Info: Precompiling ClimateMARGO [d3f62095-a717-45bf-aadc-ac9dfc258fa6]\n", - "└ @ Base loading.jl:1260\n" - ] - } - ], - "source": [ - "using ClimateMARGO # Julia implementation of the MARGO model\n", - "using PyPlot # A basic plotting package" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "using ClimateMARGO.Models\n", - "using ClimateMARGO.Utils\n", - "using ClimateMARGO.Diagnostics" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Model configuration\n", - "\n", - "An instance of MARGO `ClimateModelParameters` requires specifying a `name` and the parameters for three model subcomponents:\n", - "1. `Domain`: determines the time period of interest, as well as the timestep and– in the policy response mode– the \"present\" decision-making year.\n", - "2. `Economics`: determines exogenous economic growth, the cliamte damage cost function, and the cost function for each of the four controls, and the discount rate.\n", - "3. `Physics`: determines the parameters that govern the aiborn fraction of emissions that remain in the atmosphere, the strength of climate feedbacks, and the rate of ocean heat uptake.\n", - "\n", - "An instance of the MARGO `ClimateModel` is determined by combining the prescribed set of `ClimateModelParameters` with timeseries of the four `Controls`, which will act as the control variables in the optimization framework:\n", - "1. **M**itigation of baseline emissions\n", - "2. **R**emoval of carbon dioxide from the atmopshere\n", - "3. **G**eongineering by solar radiation management, and\n", - "4. **A**daptating to the changed climate to reduce the damages of climate change impacts.\n", - "\n", - "Here, we run through the full construction of the model with its \"default\" parameter values." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "name = \"default\";" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 1. Setting up the temporal grid\n", - "First, we need to set up a time-frame for our experiment. Let's begin our simulation in the year 2020– present day– and consider out to 2200, with a 5-year timestep for computational efficiency." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "initial_year = 2020. # [yr]\n", - "final_year = 2200. # [yr]\n", - "dt = 5. # [yr]\n", - "t_arr = t(initial_year, final_year, dt);" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "While the model allows for shifting the \"present\" year forward or backward in time to simulate past and future policy decision-making processes, we will only consider the simplest case in which we take the perspective of a policy decision maker in the year 2020, which is also the initial year of our simulation." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "present_year = initial_year\n", - "dom = Domain(dt, initial_year, initial_year, final_year);" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 2. Configuring the carbon cycle and energy balance models\n", - "\n", - "CO$_{2e}$ concentrations are given by:\n", - "\\begin{equation}\n", - "c_{M,R}(t) = c_{0} + \\int_{t_{0}}^{t} rq(t')(1-M(t')) \\text{ d}t' - q_{0} \\int_{t_{0}}^{t} R(t')\\text{ d}t'.\n", - "\\end{equation}\n", - "where $q(t)$ is a specific timeseries of no-climate-policy baseline emissions (with $q(t_{0}) = q_{0}$), $c_{0}$ is the initial CO$_{2e}$ concentration, and $r$ is the fraction of emitted CO$_{2e}$ that remains in the atmosphere net of short-term uptake by the ocean and biosphere. $M(t')$ and $R(t')$ represent the effects emissions mitigation and carbon dioxide removal, respectively, on CO$_{2e}$ concentrations relative to the baseline; they will be initially set to zero and later determined by solving an optimization problem.\n", - "\n", - "The default no-policy scenario is one of rapid, fossil-fueled growth which leads to an accumulation of $c(t) = 1400$ ppm of CO$_{2e}$ in the atmosphere by 2150, when emissions are assumed to finally reach net-zero." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "c0 = 460. # [ppm]\n", - "r = 0.5; # [1] fraction of emissions remaining after biosphere and ocean uptake (Solomon 2009)\n", - "\n", - "q0 = 7.5\n", - "q0mult = 3.\n", - "t_peak = 2100.\n", - "t_zero = 2150.\n", - "q = ramp_emissions(t_arr, q0, q0mult, t_peak, t_zero);" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "Figure(PyObject
)" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "figure(figsize=(9,3.5))\n", - "\n", - "subplot(1,2,1)\n", - "plot(t_arr, ppm_to_GtCO2(q))\n", - "xlabel(\"year\")\n", - "ylabel(L\"baseline emissions $q(t)$ [GtCO2 / year]\")\n", - "xlim([2020, 2200])\n", - "grid(true)\n", - "\n", - "subplot(1,2,2)\n", - "q_effective = effective_emissions(r, q, 0., 0.) # No mitigation, no carbon removal\n", - "c_baseline = c(c0, q_effective, dt)\n", - "plot(t_arr, c_baseline)\n", - "xlabel(\"year\")\n", - "ylabel(L\"baseline concentrations $c(t)$ [ppm]\")\n", - "xlim([2020, 2200])\n", - "tight_layout();\n", - "grid(true)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "These CO$_{2e}$ concentrations drive an anomalous greenhouse effect, which is represented by the radiative forcing\n", - "\\begin{equation}\n", - "F_{M,R,G} = a \\ln\\left(\\frac{c_{M,R}(t)}{c_{0}}\\right) - G(t)F_{\\infty},\n", - "\\end{equation}\n", - "where $a$ is an empirically determined coefficient, $G(t)$ represents the effects of geoengineering, and $F_{\\infty} = 8.5$ W/m$^2$ is a scaling factor for the effects of geoengineering by Solar Radiation Modification (SRM)." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "a = (6.9/2.)/log(2.); # F4xCO2/2 / log(2) [W m^-2]\n", - "Finf = 8.5;" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "Figure(PyObject
)" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "figure(figsize=(4.5,3.2))\n", - "F0 = 3.0\n", - "F_baseline = F(a, c0, Finf, c_baseline, 0.)\n", - "plot(t_arr, F_baseline .+ F0)\n", - "xlabel(\"year\")\n", - "ylabel(L\"baseline radiative forcing $F(t)$ [W/m$^2$]\")\n", - "xlim([2020, 2200])\n", - "grid(true)\n", - "ylim([0,10.]);" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Next, we configure MARGO's energy balance model, which is forced by the controlled forcing $F_{M,R,G}$. The two-layer energy balance model can be solved, approximately, as:\n", - "\\begin{equation}\n", - " T_{M,R,G}(t) - T_{0} = \\frac{F_{M,R,G}(t)}{B + \\kappa} + \\frac{\\kappa}{B} \\int_{t_{0}}^{t} \\frac{e^{\\frac{t'-t}{\\tau_{D}}}}{\\tau_{D}} \\frac{F_{M,R,G}(t')}{B+\\kappa} \\, \\text{d}t',\n", - "\\end{equation}\n", - "where $T_{0}$ is the initial temperature change relative to preindustrial, $B$ is the feedback parameter, $\\kappa$ is , and the timescale $\\tau_{D} = \\dfrac{C_{D}}{B} \\dfrac{B + \\kappa}{\\kappa}$ is a more convenient expression for the deep ocean heat capacity $C_{D}$.\n", - "\n", - "Default parameter values are taken from [Geoffroy et al. 2013](https://journals.ametsoc.org/doi/full/10.1175/JCLI-D-12-00195.1)'s physically-based calibration of the two-layer model to CMIP5." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "τD = 239 years" - ] - } - ], - "source": [ - "# Two-layer EBM parameters\n", - "B = 1.13; # Feedback parameter [J yr^-1 m^-2 K^-1]\n", - "Cd = 106.; # Deep ocean heat capacity [J m^-2 K^-1]\n", - "κ = 0.73; # Heat exchange coefficient [J yr^-1 m^2 K^-1]\n", - "\n", - "# Initial condition: present-day temperature, relative to pre-industrial\n", - "T0 = 1.1; # [degC] Berkeley Earth Surface Temperature (Rohde 2013)\n", - "\n", - "print(\"τD = \", Int64(round(τd(Cd, B, κ))), \" years\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "These physical parameters can be used to diagnose the climate sensitivity to a doubling of CO$_{2}$ ($ECS$)." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ECS = 3.1ºC" - ] - } - ], - "source": [ - "print(\"ECS = \", round(ECS(a, B),digits=1) ,\"ºC\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "These parameters define the physical model, which is instantiated by the calling the `Physics` constructor method:" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "Phys = Physics(c0, T0, a, B, Cd, κ, r);" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### 3. Configuring the simple economic model" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Economic growth in MARGO (in terms of Gross World Product, GWP) is exogenous $E(t) = E_{0} (1 + \\gamma)^{(t-t_{0})}$ and is entirely determined by the growth rate $\\gamma$. By default, we set $\\gamma = 2\\%$." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "Figure(PyObject
)" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "E0 = 100. # Gross World Product at t0 [10^12$ yr^-1]\n", - "γ = 0.02 # economic growth rate\n", - "\n", - "figure(figsize=(4, 2.5))\n", - "plot(t_arr, E(t_arr, E0, γ))\n", - "xlabel(\"year\")\n", - "ylabel(\"GWP [trillion USD]\")\n", - "xlim([2020, 2200])\n", - "ylim([0, 3000]);\n", - "grid(true)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Economic damages $D_{M,R,G,A} = \\tilde{\\beta}E(t) (\\Delta T_{M,R,G})^{2} (1 - A(t))$, expressed as a fraction $\\tilde{\\beta}(\\Delta T_{M,R,G})^{2}$ of the instantaneous Gross World Product, increase quadratically with temperature change relative to preindustrial. They can be decrease by adaptation controls $A(t)$. The default value of the damage parameter $\\tilde{\\beta}$ corresponds to damages of 2\\% of GWP at 3ºC of warming." - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [], - "source": [ - "βtilde = 0.02/(3.0)^2; # damages [%GWP / celsius^2]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The total cost of climate controls is simply the sum of their individual costs, each of which follows a parabolic cost function:\n", - "\\begin{equation}\n", - " \\mathcal{C}_{M,R,G,A} = \\mathcal{C}_{M}M^2 + \\mathcal{C}_{R}R^2 + \\mathcal{C}_{G}G^2 + \\mathcal{C}_{A}A^2\n", - "\\end{equation}\n", - "\n", - "The calculation of the reference control costs $\\mathcal{C}_{M}, \\mathcal{C}_{R}, \\mathcal{C}_{G}, \\mathcal{C}_{A}$ are somewhat more complicated; see our Methods in [the preprint](https://eartharxiv.org/5bgyc/) and `defaults.jl` for details. Here, we simply provide their default numerical values, where the costs of mitigation $\\mathcal{C}_{M} = \\tilde{\\mathcal{C}}_{M} E(t)$ and geoengineering $\\mathcal{C}_{G} = \\tilde{\\mathcal{C}}_{G} E(t)$ grow with the size of the global economy and are thus specified as a fraction of GWP, while adaptaiton and removal costs are in trillions of USD per year." - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [], - "source": [ - "mitigate_cost = 0.034; # [trillion USD / year / GtCO2]\n", - "\n", - "remove_cost = 13.; # [trillion USD / year]\n", - "adapt_cost = 4.5; # [trillion USD / year]\n", - "\n", - "#mitigate_cost = 0.02; # [% GWP]\n", - "geoeng_cost = 0.046; # [% GWP]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Climate damages and control costs are discounted at the relatively low rate of $\\rho = 1\\%$, such that future damages and costs are reduced by a multiplicative discount factor $(1 - \\rho)^{(t-t_{0})}$." - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "Figure(PyObject
)" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "ρ = 0.01;\n", - "\n", - "figure(figsize=(4, 2.5))\n", - "plot(t_arr, discount(t_arr, ρ, present_year)*100)\n", - "xlabel(\"year\")\n", - "ylabel(\"discount factor (%)\")\n", - "xlim([2020, 2200])\n", - "ylim([0, 100]);\n", - "grid(true)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "These parameters, in addition to a no-policy baseline emissions time-series and present-day control values, define the economic model." - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [], - "source": [ - "Econ = Economics(\n", - " E0, γ, βtilde, ρ, Finf,\n", - " mitigate_cost, remove_cost, geoeng_cost, adapt_cost,\n", - " 0.1, 0., 0., nothing, # Initial condition on control deployments at t[1]\n", - " q\n", - ");" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### A MARGO model configuration is uniquely determined by the parameters defined above" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [], - "source": [ - "params = ClimateModelParameters(\n", - " name,\n", - " dom,\n", - " Econ,\n", - " Phys\n", - ");" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Instanciating the MARGO climate model" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "\n", - "Along with economic and physical model components, the timeseries for each of the four controls must be specified. By default, we simply set these to zero." - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [], - "source": [ - "Cont = Controls(\n", - " zeros(size(t_arr)), # mitigate\n", - " zeros(size(t_arr)), # remove\n", - " zeros(size(t_arr)), # geoeng\n", - " zeros(size(t_arr)) # adapt\n", - ");" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The above parameters determine the full configuration of the MARGO model, which is instanced using the `ClimateModel` constructor method:" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [], - "source": [ - "m = ClimateModel(\n", - " params,\n", - " Cont\n", - ");" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Model optimization\n", - "\n", - "#### Formulating the optimization problem\n", - "By default, the optimization problem we solve is for the most cost-effective combination of controls, as determined by minimization of the discounted net present value,\n", - "\n", - "\\begin{equation}\n", - " \\min\\left\\{\\int_{t_{0}}^{t_{f}} \\mathcal{C}_{M,R,G,A} (1 + \\rho)^{-(t-t_{0})} \\text{ d}t\\right\\}\n", - "\\end{equation}\n", - "\n", - "which keep controlled damages below the level corresponding to a chosen temperature threshold $T^{\\star}$,\n", - "\n", - "\\begin{equation}\n", - " \\tilde{\\beta} E(t) (T_{M,R,G})^{2} (1 - A(t)) < \\tilde{\\beta} E(t) (T^{\\star})^{2}.\n", - "\\end{equation}" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [], - "source": [ - "temp_goal = 2.0;" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Additional policy / inertia constraints\n", - "The optimization is also subject to the constraints described below.\n", - "\n", - "First, we set a upper bounds on the maximum plausible deployment of each control." - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [], - "source": [ - "max_deployment = Dict(\"mitigate\"=>1., \"remove\"=>1., \"geoeng\"=>1., \"adapt\"=>0.4);" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Second, we set upper limits on how quickly each control can be ramped up or down.\n", - "\n", - "(Adaptation is treated differently since we it interpret it as buying insurance against future climate damages, although the financing is spread evenly over the entire period.)" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [], - "source": [ - "max_slope = Dict(\"mitigate\"=>1. /40., \"remove\"=>1. /40., \"geoeng\"=>1. /30., \"adapt\"=>0.);" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Third, we impose restrictions on when controls can be first deployed. In particular, since carbon dioxide removal and solar radiation modification do not yet exist at scale, we delay these until 2030 and 2050, respectively, at the earliest." - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [], - "source": [ - "delay_deployment = Dict(\n", - " \"mitigate\"=>0.,\n", - " \"remove\"=>10.,\n", - " \"geoeng\"=>30.,\n", - " \"adapt\"=>0.\n", - ");" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Running the optimization" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The optimization takes about ~40 seconds the first time it is run as the code compiles, but runs virtually instantly afterwards, even if model parameter values are changed." - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [], - "source": [ - "using ClimateMARGO.Optimization" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "******************************************************************************\n", - "This program contains Ipopt, a library for large-scale nonlinear optimization.\n", - " Ipopt is released as open source code under the Eclipse Public License (EPL).\n", - " For more information visit http://projects.coin-or.org/Ipopt\n", - "******************************************************************************\n", - "\n", - "Solve_Succeeded\n", - " 42.754889 seconds (122.36 M allocations: 6.838 GiB, 5.84% gc time)\n" - ] - } - ], - "source": [ - "@time msolve = optimize_controls!(\n", - " m,\n", - " obj_option = \"temp\", temp_goal = temp_goal,\n", - " max_deployment = max_deployment, max_slope = max_slope, delay_deployment = delay_deployment\n", - ");" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "It is always good to check that the solver actually converged on a valid solution!" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Plotting MARGO results\n", - "\n", - "We provide some convenient functions for plotting basic model results." - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [], - "source": [ - "using ClimateMARGO.Plotting" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "Figure(PyObject
)" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_state(m)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Customizing MARGO\n", - "\n", - "Try changing some of the parameters above and re-running the model!\n", - "\n", - "For example, in the simulation below we set a more stringent temperature goal of $T^{\\star} = 1.5$ and omit solar geoengineering and adaptation completely (by setting their maximum deployment to zero)." - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Solve_Succeeded\n", - " 0.065928 seconds (95.70 k allocations: 4.138 MiB)\n" - ] - } - ], - "source": [ - "temp_goal = 1.5\n", - "max_deployment[\"geoeng\"] = 0.\n", - "max_deployment[\"adapt\"] = 0.\n", - "\n", - "@time optimize_controls!(\n", - " m,\n", - " obj_option = \"temp\", temp_goal = temp_goal,\n", - " max_deployment = max_deployment, max_slope = max_slope, delay_deployment = delay_deployment\n", - ");" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "Figure(PyObject
)" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_state(m)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Saving (and loading) MARGO simulations (or parameter configurations)" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "\"/var/folders/dr/t79w5jxj7xs_l_mklgcl1xt40000gn/T/jl_odZ3ea.json\"" - ] - }, - "execution_count": 32, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "using ClimateMARGO.IO\n", - "export_path = tempname() * \".json\"" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": {}, - "outputs": [], - "source": [ - "export_parameters(export_path, params);" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "ClimateModelParameters(\"default\", Domain(5.0, 2020.0, 2020.0, 2200.0), Economics(100.0, 0.02, 0.0022222222222222222, 0.01, 8.5, 0.034, 13.0, 0.046, 4.5, 0.1, 0, 0, nothing, [7.5, 8.4375, 9.375, 10.3125, 11.25, 12.1875, 13.125, 14.0625, 15.0, 15.9375 … 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 … 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]), Physics(460.0, 1.1, 4.977297891066924, 1.13, 106.0, 0.73, 0.5))" - ] - }, - "execution_count": 34, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "new_params = import_parameters(export_path)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's say we want to see what happens if climate feedbacks $B$ are twice as strong as they are now (which means a lower feedback parameter)." - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": {}, - "outputs": [], - "source": [ - "new_params.name = \"stronger_feedbacks\"\n", - "new_params.physics.B /= 2.;" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "ClimateModel(\"stronger_feedbacks\", Domain(5.0, 2020.0, 2020.0, 2200.0), Economics(100.0, 0.02, 0.0022222222222222222, 0.01, 8.5, 0.034, 13.0, 0.046, 4.5, 0.1, 0, 0, nothing, [7.5, 8.4375, 9.375, 10.3125, 11.25, 12.1875, 13.125, 14.0625, 15.0, 15.9375 … 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 … 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]), Physics(460.0, 1.1, 4.977297891066924, 0.565, 106.0, 0.73, 0.5), Controls([0.1, 0.22500004999104373, 0.350000099979977, 0.47500014996564954, 0.6000001999457527, 0.7250002499144974, 0.850000299848677, 0.9477994934106518, 0.9500529028429148, 0.9520860716881722 … 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.1250000498613665, 0.18812839182026328, 0.19581990939457214, 0.2037938618329738, 0.21204567993938628, 0.14519923744826585, 0.1455444508241079, 0.14585592447748327 … 0.02323950104723206, 0.022436294233423786, 0.021661454988364037, 0.02091394120850451, 0.02019275167609972, 0.01949692432666522, 0.018825534558218938, 0.018177693618293595, 0.017552548132442072, 0.016949238880767884], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 … 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 … 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]))" - ] - }, - "execution_count": 36, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "new_m = ClimateModel(new_params, Cont)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The new equilibrium climate sensitivity (recall $ECS = F_{2x}/B$) is now:" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ECS ≈ 6.1°C" - ] - } - ], - "source": [ - "print(\"ECS ≈ $(round(ECS(new_m), digits=1))°C\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Julia 1.4.2", - "language": "julia", - "name": "julia-1.4" - }, - "language_info": { - "file_extension": ".jl", - "mimetype": "application/julia", - "name": "julia", - "version": "1.4.2" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/src/Constants/.jl b/src/Constants/units.jl similarity index 100% rename from src/Constants/.jl rename to src/Constants/units.jl diff --git a/src/Diagnostics/cost_benefit.jl b/src/Diagnostics/cost_benefit.jl index 3568562..3dbc582 100644 --- a/src/Diagnostics/cost_benefit.jl +++ b/src/Diagnostics/cost_benefit.jl @@ -1,4 +1,4 @@ -f(α::Array; p=2.) = α.^p # shape of individual cost functions +f(α::Array; p=3.) = α.^p # shape of individual cost functions E(t, E0, γ) = E0 * (1. .+ γ).^(t .- t[1]) E(m) = E(t(m), m.economics.E0, m.economics.γ) @@ -6,6 +6,13 @@ E(m) = E(t(m), m.economics.E0, m.economics.γ) discount(t, ρ, tp) = .~past_mask(t, tp) .* (1. .+ ρ) .^ (- (t .- tp)) discount(m::ClimateModel) = discount(t(m), m.economics.ρ, m.domain.present_year) +T_adapt(T, A) = T .* sqrt.(1 .- A) + +T_adapt(m::ClimateModel; M=false, R=false, G=false, A=false) = T_adapt( + T(m, M=M, R=R, G=G), + m.controls.adapt .* (1. .- .~past_mask(m) * ~A), +) + damage(β, E, Ta; discount=1.) = (β .* E .* Ta.^2) .* discount damage(m; discounting=false, M=false, R=false, G=false, A=false) = damage( @@ -15,14 +22,14 @@ damage(m; discounting=false, M=false, R=false, G=false, A=false) = damage( discount=1. .+ discounting * (discount(m) .- 1.) ) -cost(CM, CR, CG, CA, ϵCG, E, q, M, R, G, A; discount=1., p=2.) = ( +cost(CM, CR, CG, CA, ϵCG, E, q, M, R, G, A; discount=1., p=3.) = ( ( ppm_to_GtCO2(q).*CM.*f(M, p=p) + E.*(CG.*f(G, p=p) .+ ϵCG*(G.>1.e-3)) + CR*f(R, p=p) + - E[1]*CA.*f(A, p=p) + E.*CA.*f(A, p=p) ) .* discount ) -cost(m::ClimateModel; discounting=false, p=2., M=false, R=false, G=false, A=false) = cost( +cost(m::ClimateModel; discounting=false, p=3., M=false, R=false, G=false, A=false) = cost( m.economics.mitigate_cost, m.economics.remove_cost, m.economics.geoeng_cost, diff --git a/src/Diagnostics/energy_balance.jl b/src/Diagnostics/energy_balance.jl index 21a1f2a..4034e92 100644 --- a/src/Diagnostics/energy_balance.jl +++ b/src/Diagnostics/energy_balance.jl @@ -106,12 +106,4 @@ T(m::ClimateModel; M=false, R=false, G=false) = T( m.physics.B, t(m), m.domain.dt -) - -T_adapt(Tc, Tb, A) = Tc .- A.*Tb - -T_adapt(m::ClimateModel; M=false, R=false, G=false, A=false) = T_adapt( - T(m, M=M, R=R, G=G), - T(m), - m.controls.adapt .* (1. .- .~past_mask(m) * ~A), ) \ No newline at end of file diff --git a/src/Models/economics.jl b/src/Models/economics.jl index b332f3a..ce0a50f 100644 --- a/src/Models/economics.jl +++ b/src/Models/economics.jl @@ -30,7 +30,7 @@ mutable struct Economics β::Float64 ρ::Float64 Finf::Float64 - + mitigate_cost::Float64 remove_cost::Float64 geoeng_cost::Float64 diff --git a/src/Optimization/deterministic_optimization.jl b/src/Optimization/deterministic_optimization.jl index 9b65732..dcdf9a4 100644 --- a/src/Optimization/deterministic_optimization.jl +++ b/src/Optimization/deterministic_optimization.jl @@ -1,9 +1,9 @@ function optimize_controls!( m::ClimateModel; - obj_option = "adaptive_temp", temp_goal = 1.1, budget=10., expenditure = 0.5, - max_deployment = Dict("mitigate"=>1., "remove"=>1., "geoeng"=>1., "adapt"=>0.4), - max_slope = Dict("mitigate"=>1. /40., "remove"=>1. /40., "geoeng"=>1. /80., "adapt"=> 0.), + obj_option = "adaptive_temp", temp_goal = 1.5, budget=10., expenditure = 0.5, + max_deployment = Dict("mitigate"=>1., "remove"=>1., "geoeng"=>1., "adapt"=>1.), + max_slope = Dict("mitigate"=>1. /40., "remove"=>1. /40., "geoeng"=>1. /40., "adapt"=> 1. /40.), temp_overshoot = nothing, overshoot_year = 2100, delay_deployment = Dict( @@ -12,7 +12,7 @@ function optimize_controls!( "geoeng"=>0, "adapt"=>0 ), - cost_exponent = 2., + cost_exponent = 3., print_status = false, print_statistics = false, print_raw_status = true, ) @@ -38,7 +38,6 @@ function optimize_controls!( tp = m.domain.present_year q = m.economics.baseline_emissions qGtCO2 = ppm_to_GtCO2(q) - Tb = T(m) N = length(tarr) # Set default temperature goal for end year @@ -146,6 +145,11 @@ function optimize_controls!( register(model_optimizer, :discounting_JuMP, 1, discounting_JuMP, autodiff=true) # constraints on control variables + for (key, item) in max_deployment + if item==0. + max_deployment[key] = item+1.e-8 + end + end @variables(model_optimizer, begin 0. <= M[1:N] <= max_deployment["mitigate"] # emissions reductions 0. <= R[1:N] <= max_deployment["remove"] # negative emissions @@ -247,17 +251,12 @@ function optimize_controls!( # Add constraint of rate of changes present_idx = argmin(abs.(tarr .- tp)) - if m.domain.present_year == t0 - allow_adapt_changes = 0; - else - allow_adapt_changes = 1; - end @variables(model_optimizer, begin -max_slope["mitigate"] <= dMdt[present_idx:N-1] <= max_slope["mitigate"] -max_slope["remove"] <= dRdt[present_idx:N-1] <= max_slope["remove"] -max_slope["geoeng"] <= dGdt[present_idx:N-1] <= max_slope["geoeng"] - -max_slope["adapt"] <= dAdt[present_idx+allow_adapt_changes:N-1] <= max_slope["adapt"] + -max_slope["adapt"] <= dAdt[present_idx:N-1] <= max_slope["adapt"] end); for i in present_idx:N-1 @constraint(model_optimizer, dMdt[i] == (M[i+1] - M[i]) / dt) @@ -268,13 +267,14 @@ function optimize_controls!( for i in present_idx:N-1 @constraint(model_optimizer, dGdt[i] == (G[i+1] - G[i]) / dt) end - for i in present_idx+allow_adapt_changes:N-1 + for i in present_idx:N-1 @constraint(model_optimizer, dAdt[i] == (A[i+1] - A[i]) / dt) end ## Optimization options + + # maximize net benefits if obj_option == "net_benefit" - # maximize net benefits # (in practice we solve the equivalent problem of minimizing the net cost, i.e. minus the net benefit) @NLobjective(model_optimizer, Min, sum( @@ -282,7 +282,7 @@ function optimize_controls!( m.economics.β * Earr[i] * ( - ((m.physics.T0 + + (m.physics.T0 + ( (m.physics.a * log_JuMP( (m.physics.c0 + cumsum_qMR[i]) / @@ -294,11 +294,11 @@ function optimize_controls!( exp( - (tarr[i] - (t0 - dt)) / τ ) * cumsum_KFdt[i] ) / (m.physics.B + m.physics.κ) - ) - A[i]*Tb[i])^2 - ) + + )^2 + ) * ( (1 - A[i]) ) + + Earr[i] * m.economics.adapt_cost * fA_JuMP(A[i]) + m.economics.mitigate_cost * qGtCO2[i] * fM_JuMP(M[i]) + - Earr[1] * m.economics.adapt_cost * fA_JuMP(A[i]) + m.economics.remove_cost * fR_JuMP(R[i]) + Earr[i] * ( m.economics.geoeng_cost * fG_JuMP(G[i]) + @@ -311,36 +311,19 @@ function optimize_controls!( for i=1:N) ) + # maximize net benefits subject to a temperature goal elseif obj_option == "temp" - @NLobjective(model_optimizer, Min, + @NLobjective(model_optimizer, Min, sum( ( - m.economics.β * - Earr[i] * - ( - ((m.physics.T0 + - ( - (m.physics.a * log_JuMP( - (m.physics.c0 + cumsum_qMR[i]) / - (m.physics.c0) - ) - m.economics.Finf*G[i] - ) + - m.physics.κ / - (τ * m.physics.B) * - exp( - (tarr[i] - (t0 - dt)) / τ ) * - cumsum_KFdt[i] - ) / (m.physics.B + m.physics.κ) - ) - A[i]*Tb[i])^2 - ) + + Earr[i] * m.economics.adapt_cost * fA_JuMP(A[i]) + m.economics.mitigate_cost * qGtCO2[i] * fM_JuMP(M[i]) + - Earr[1] * m.economics.adapt_cost * fA_JuMP(A[i]) + m.economics.remove_cost * fR_JuMP(R[i]) + Earr[i] * ( m.economics.geoeng_cost * fG_JuMP(G[i]) + m.economics.epsilon_cost * Hstep(G[i]) ) - ) * discounting_JuMP(tarr[i]) * dt @@ -384,14 +367,16 @@ function optimize_controls!( ) end + # minimize control costs subject to adaptative-temperature constraint elseif obj_option == "adaptive_temp" - # minimize control costs subject to adaptative-temperature constraint + + # minimize control costs @NLobjective(model_optimizer, Min, sum( ( + Earr[i] * m.economics.adapt_cost * fA_JuMP(A[i]) + m.economics.mitigate_cost * qGtCO2[i] * fM_JuMP(M[i]) + - Earr[1] * m.economics.adapt_cost * fA_JuMP(A[i]) + m.economics.remove_cost * fR_JuMP(R[i]) + Earr[i] * ( m.economics.geoeng_cost * fG_JuMP(G[i]) + @@ -403,7 +388,7 @@ function optimize_controls!( for i=1:N) ) - # Subject to temperature goal (during overshoot period) + # Subject to adaptive temperature goal (during overshoot period) for i in 1:odx-1 @NLconstraint(model_optimizer, ((m.physics.T0 + @@ -419,11 +404,11 @@ function optimize_controls!( cumsum_KFdt[i] ) / (m.physics.B + m.physics.κ) ) - - A[i]*Tb[i]) <= + * sqrt(1. - A[i]) ) <= temp_overshoot ) end - # Subject to temperature goal (after temporary overshoot period) + # Subject to adaptive temperature goal (after temporary overshoot period) for i in odx:N @NLconstraint(model_optimizer, ((m.physics.T0 + @@ -439,8 +424,8 @@ function optimize_controls!( cumsum_KFdt[i] ) / (m.physics.B + m.physics.κ) ) - - A[i]*Tb[i]) <= - temp_goal + * sqrt(1. - A[i]) ) <= + temp_goal ) end @@ -450,7 +435,8 @@ function optimize_controls!( sum( m.economics.β * Earr[i] * - (((m.physics.T0 + + ( + m.physics.T0 + ( (m.physics.a * log_JuMP( (m.physics.c0 + cumsum_qMR[i]) / @@ -462,8 +448,7 @@ function optimize_controls!( exp( - (tarr[i] - (t0 - dt)) / τ ) * cumsum_KFdt[i] ) / (m.physics.B + m.physics.κ) - ) - - A[i]*Tb[i])^2) * + )^2 * (1. - A[i]) * discounting_JuMP(t[i]) * dt for i=1:N) @@ -472,16 +457,16 @@ function optimize_controls!( @NLconstraint(model_optimizer, sum( ( + Earr[i] * m.economics.adapt_cost * fA_JuMP(A[i]) + m.economics.mitigate_cost * qGtCO2[i] * fM_JuMP(M[i]) + - Earr[1] * m.economics.adapt_cost * fA_JuMP(A[i]) + m.economics.remove_cost * fR_JuMP(R[i]) + Earr[i] * ( m.economics.geoeng_cost * fG_JuMP(G[i]) + m.economics.epsilon_cost * Hstep(G[i]) ) ) * - discounting_JuMP(t[i]) * + discounting_JuMP(tarr[i]) * dt for i=1:N) <= budget ) @@ -492,7 +477,7 @@ function optimize_controls!( sum( m.economics.β * Earr[i] * - (((m.physics.T0 + + (m.physics.T0 + ( (m.physics.a * log_JuMP( (m.physics.c0 + cumsum_qMR[i]) / @@ -504,8 +489,7 @@ function optimize_controls!( exp( - (tarr[i] - (t0 - dt)) / τ ) * cumsum_KFdt[i] ) / (m.physics.B + m.physics.κ) - ) - - A[i]*Tb[i])^2) * + )^2 * (1-A[i]) * discounting_JuMP(t[i]) * dt for i=1:N) @@ -514,9 +498,9 @@ function optimize_controls!( for i in 1:N @NLconstraint(model_optimizer, ( + Earr[i] * m.economics.adapt_cost * fA_JuMP(A[i]) + m.economics.mitigate_cost * qGtCO2[i] * fM_JuMP(M[i]) + - Earr[1] * m.economics.adapt_cost * fA_JuMP(A[i]) + m.economics.remove_cost * fR_JuMP(R[i]) + Earr[i] * ( m.economics.geoeng_cost * fG_JuMP(G[i]) + diff --git a/src/Plotting/line_plots.jl b/src/Plotting/line_plots.jl index 22e24f4..beeab90 100644 --- a/src/Plotting/line_plots.jl +++ b/src/Plotting/line_plots.jl @@ -19,9 +19,9 @@ function plot_emissions(m::ClimateModel) fill_between(t(m), effective_emissions(m), effective_emissions(m, M=true), facecolor="C0", alpha=0.3, label="Mitigation") fill_between(t(m), effective_emissions(m, M=true), effective_emissions(m, M=true, R=true), facecolor="C1", alpha=0.3, label="CDR") - plot(t(m), effective_emissions(m), "-", color="grey", lw=2.25, label=L"$rq$ (no-policy baseline)") + plot(t(m), effective_emissions(m), "-", color="grey", lw=2.0, label=L"$rq$ (no-policy baseline)") plot(t(m), effective_emissions(m, M=true), "k-", lw=1, alpha=0.4) - plot(t(m), effective_emissions(m, M=true, R=true), "k-", lw=2.25, label=L"$rq(1-M) - rq_{0}R$ (controlled)") + plot(t(m), effective_emissions(m, M=true, R=true), "k-", lw=2., label=L"$rq(1-M) - rq_{0}R$ (controlled)") plot(t(m), zeros(size(t(m))), dashes=(2.5, 1.75), color="grey", alpha=0.5) ylimit = maximum(effective_emissions(m)) * 1.1 @@ -41,9 +41,9 @@ function plot_concentrations(m::ClimateModel) fill_between(t(m), c(m), c(m, M=true), facecolor="C0", alpha=0.3, label="Mitigation") fill_between(t(m), c(m, M=true), c(m, M=true, R=true), facecolor="C1", alpha=0.3, label="CDR") - plot(t(m), c(m), "-", color="grey", lw=2.25, label=L"$c$ (no-policy baseline)") + plot(t(m), c(m), "-", color="grey", lw=2.0, label=L"$c$ (no-policy baseline)") plot(t(m), c(m, M=true), "k-", lw=1, alpha=0.4) - plot(t(m), c(m, M=true, R=true), "k-", lw=2.25, label=L"$c_{M,R}$ (controlled)") + plot(t(m), c(m, M=true, R=true), "k-", lw=2.0, label=L"$c_{M,R}$ (controlled)") ylims = [0., maximum(c(m))*1.05] ylabel(L"CO$_{2e}$ concentration [ppm]") xlabel("year") @@ -61,10 +61,10 @@ function plot_forcings(m::ClimateModel; F0=3.) fill_between(t(m), F(m, F0=F0), F(m, M=true, F0=F0), facecolor="C0", alpha=0.3, label="Mitigation") fill_between(t(m), F(m, M=true, F0=F0), F(m, M=true, R=true, F0=F0), facecolor="C1", alpha=0.3, label="CDR") fill_between(t(m), F(m, M=true, R=true, F0=F0), F(m, M=true, R=true, G=true, F0=F0), facecolor="C3", alpha=0.3, label="SRM") - plot(t(m), F(m, F0=F0), "-", color="grey", lw=2.25, label=L"$F$ (no-policy baseline)") + plot(t(m), F(m, F0=F0), "-", color="grey", lw=2.0, label=L"$F$ (no-policy baseline)") plot(t(m), F(m, M=true, F0=F0), "k-", lw=1, alpha=0.4) plot(t(m), F(m, M=true, R=true, F0=F0), "k-", lw=1, alpha=0.4) - plot(t(m), F(m, M=true, R=true, G=true, F0=F0), "k-", lw=2.25, label=L"$F_{M,R,G}$ (controlled)") + plot(t(m), F(m, M=true, R=true, G=true, F0=F0), "k-", lw=2.0, label=L"$F_{M,R,G}$ (controlled)") ylims = [0., maximum(F(m, F0=F0))*1.05] ylabel(L"radiative forcing [W/m$^{2}$]") xlabel("year") @@ -75,7 +75,7 @@ function plot_forcings(m::ClimateModel; F0=3.) return end -function plot_temperatures(m::ClimateModel; temp_goal=1.1) +function plot_temperatures(m::ClimateModel; temp_goal=1.2) title("adaptive temperature change") #fill_past(m, ylims) @@ -83,12 +83,12 @@ function plot_temperatures(m::ClimateModel; temp_goal=1.1) fill_between(t(m), T_adapt(m, M=true), T_adapt(m, M=true, R=true), facecolor="C1", alpha=0.3, label="CDR") fill_between(t(m), T_adapt(m, M=true, R=true), T_adapt(m, M=true, R=true, G=true), facecolor="C3", alpha=0.3, label="SRM") fill_between(t(m), T_adapt(m, M=true, R=true, G=true), T_adapt(m, M=true, R=true, G=true, A=true), facecolor="C2", alpha=0.3, label="Adaptation") - plot(t(m), T_adapt(m), "-", color="grey", lw=2.25, label=L"$T$ (no-policy baseline)") + plot(t(m), T_adapt(m), "-", color="grey", lw=2.0, label=L"$T$ (no-policy baseline)") plot(t(m), T_adapt(m, M=true), "k-", lw=1, alpha=0.4) plot(t(m), T_adapt(m, M=true, R=true), "k-", lw=1, alpha=0.4) plot(t(m), T_adapt(m, M=true, R=true, G=true), "k-", lw=1., alpha=0.4) - plot(t(m), T_adapt(m, M=true, R=true, G=true, A=true), "k-", lw=2.25, label=L"$T_{M,R,G,A}$ (adaptive)") - plot(t(m),temp_goal .* ones(size(t(m))).+0.06, dashes=(2.5, 1.75), color="grey", alpha=0.75, lw=2.5) + plot(t(m), T_adapt(m, M=true, R=true, G=true, A=true), "k-", lw=2.0, label=L"$T_{M,R,G,A}$ (adaptive)") + plot(t(m),temp_goal .* ones(size(t(m))), dashes=(2.5, 1.75), color="grey", alpha=0.75, lw=2.5) ylims = [0., maximum(T_adapt(m)) * 1.05] ylabel("temperature anomaly [°C]") xlabel("year") @@ -139,7 +139,7 @@ function plot_benefits(m::ClimateModel; discounting=true) return end -function plot_damages(m::ClimateModel; discounting=true, percent_GWP=false, temp_goal=1.1) +function plot_damages(m::ClimateModel; discounting=true, percent_GWP=false, temp_goal=1.2) Enorm = deepcopy(E(m))/100. if ~percent_GWP; Enorm=1.; end; @@ -152,18 +152,18 @@ function plot_damages(m::ClimateModel; discounting=true, percent_GWP=false, temp ) damages = damage(m, discounting=discounting, M=true, R=true, G=true, A=true) costs = cost(m, discounting=discounting, M=true, R=true, G=true, A=true) - plot(t(m)[domain_idx], (damage(m, discounting=discounting) ./ Enorm)[domain_idx], color="gray", lw=2.25, label="uncontrolled damages") - plot(t(m)[domain_idx], ((damages .+ costs)./ Enorm)[domain_idx], color="k", lw=2.25, label="net costs (controlled damages + controls)") - plot(t(m)[domain_idx], (damages ./ Enorm)[domain_idx], color="C8", lw=2.25, label="controlled damages") - plot(t(m)[domain_idx], (costs ./ Enorm)[domain_idx], color="C4", lw=2.25, label="cost of controls") + plot(t(m)[domain_idx], (damage(m, discounting=discounting) ./ Enorm)[domain_idx], color="gray", lw=2.0, label="uncontrolled damages") + plot(t(m)[domain_idx], ((damages .+ costs)./ Enorm)[domain_idx], color="k", lw=2.0, label="net costs (controlled damages + controls)") + plot(t(m)[domain_idx], (damages ./ Enorm)[domain_idx], color="C8", lw=2.0, label="controlled damages") + plot(t(m)[domain_idx], (costs ./ Enorm)[domain_idx], color="C4", lw=2.0, label="cost of controls") ylim([0, maximum((damage(m, discounting=discounting) ./ Enorm)[domain_idx]) * 0.75]) dmg_label = string("damage threshold at ",round(temp_goal, digits=2),L"°C with $A=0$") plot( t(m)[domain_idx], - (damage(m.economics.β, E(m), temp_goal + 0.075, discount=discount(m)) ./ Enorm)[domain_idx], - dashes=(2.5,1.75), color="grey", alpha=0.75, lw=2.25, label=dmg_label + (damage(m.economics.β, E(m), temp_goal, discount=discount(m)) ./ Enorm)[domain_idx], + dashes=(2.5,1.75), color="grey", alpha=0.75, lw=2.0, label=dmg_label ) if ~percent_GWP; @@ -190,7 +190,7 @@ function plot_damages(m::ClimateModel; discounting=true, percent_GWP=false, temp return end -function plot_state(m::ClimateModel; new_figure=true, plot_legends=true) +function plot_state(m::ClimateModel; new_figure=true, plot_legends=true, temp_goal=1.2) if new_figure fig, axs = subplots(2, 3, figsize=(14,8)) axs = vcat(axs...) @@ -203,7 +203,7 @@ function plot_state(m::ClimateModel; new_figure=true, plot_legends=true) plot_concentrations(m) title("b)", loc="left") sca(axs[3]) - plot_temperatures(m) + plot_temperatures(m, temp_goal=temp_goal) title("c)", loc="left") sca(axs[4]) @@ -213,7 +213,7 @@ function plot_state(m::ClimateModel; new_figure=true, plot_legends=true) plot_benefits(m) title("e)", loc="left") sca(axs[6]) - plot_damages(m) + plot_damages(m, temp_goal=temp_goal) title("f)", loc="left") if plot_legends; diff --git a/test/runtests.jl b/test/runtests.jl index 48a5129..1606b38 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -52,7 +52,7 @@ end result_T = T_adapt(model; M=true, R=true, G=true, A=true) - @test result_T ≈ [1.0682193356535885, 1.297612780324065, 1.453526247004754, 1.5062585038724643, 1.4285517554348575, 1.2572703815973132, 1.1794105896558098, 1.1028828321322799, 1.0328298013342352, 0.9703332767635697] rtol=1e-5 + @test result_T ≈ [1.2767663110173484, 1.608852123606971, 1.8978258561722958, 2.108526090432568, 2.211931788367322, 2.1713210884072347, 2.158586858753497, 2.1224302958426446, 2.0894535810555555, 2.0607413902621032] rtol=1e-5 end @testset "Optimization" begin @@ -60,10 +60,10 @@ end optimize_controls!(model, temp_goal=2.2) - @test model.controls.mitigate ≈ [0.0, 0.2622327257259913, 0.3756069054925597, 0.5383017458771391, 0.7309812393611623, 0.904183223823383, 0.999999991007597, 0.0, 0.0, 0.0] rtol=1e-3 - @test model.controls.remove ≈ [0.0, 0.04017304516129229, 0.05754153344586193, 0.08246575725211311, 0.11198351460708776, 0.1385173926652173, 0.16224795528492542, 0.17802096041962337, 0.17336250309642975, 0.1274237589588297] rtol=1e-3 - @test model.controls.geoeng ≈ [0.0, 0.014090929105437192, 0.01532077112122306, 0.03991571838270348, 0.07566973390226892, 0.07983310361284779, 0.07662382450378728, 0.07333361345178593, 0.06934631662083496, 0.06706612802139787] rtol=1e-3 - @test model.controls.adapt ≈ [0.09378983273810226, 0.09378983273810226, 0.09378983273810226, 0.09378983273810226, 0.09378983273810226, 0.09378983273810226, 0.09378983273810226, 0.09378983273810226, 0.09378983273810226, 0.09378983273810226] rtol=1e-3 + @test model.controls.mitigate ≈ [0.0, 0.3670584821282429, 0.4393272792260638, 0.5257940783265341, 0.6245380250211872, 0.7074912042403808, 0.7676867396677578, 0.0, 0.0, 0.0] rtol=1e-3 + @test model.controls.remove ≈ [0.0, 0.10882651060773696, 0.13025296274983308, 0.15588887768405002, 0.18516475517861308, 0.20975894242613452, 0.22760588089905764, 0.2367501073337253, 0.23175978166812158, 0.19659824324032557] rtol=1e-3 + @test model.controls.geoeng ≈ [0.0, 0.05049106345373785, 0.05264838036542512, 0.06460796652594906, 0.10819144740515446, 0.12584271884062354, 0.12767445817227918, 0.12318301615805025, 0.11794556458720538, 0.1132343245663971] rtol=1e-3 + @test model.controls.adapt ≈ [0.0, 0.0001537202313707738, 0.00015374376329529388, 0.03816957588616602, 0.10942294994448329, 0.13786594819465353, 0.14363875559967432, 0.14044599067883523, 0.1365010682189578, 0.13366455981096753] rtol=1e-3 end end