from BPTK_Py import Model, bptk
from BPTK_Py import sd_functions as sd
Limits to Growth Archetype
Limits to Growth Archetype
Nothing can grow indefinitely, hence a reinforceing, growing loop will destroy any system that is part of unless it is kept in check by a balancing loop.
The following causal loop diagram shows the limits to growth archetype in its simplest form:
At is heart is a reinforcing loop that changes the state of the system according to a growth factor, just as in the reinforcing loop archetype. But in contrast to that archetype, the growth factor isn’t constant but is limit by the resource adequacy of the system.
The resource adequacy get’s smaller and smaller when the systems state approaches the carrying capacity.
If there are no delays in the system, then this limits to growth archetype while display S-shaped growth. If there are delays present, then the growth of the system will overshoot the carrying capacity and then will oscillate around that value.
A Stock and Flow Model of the Limits To Growth Archetype
Let’s take a look at a stock and flow diagram for this archetype. In this diagram, we’ve separated the fractional change into a constant, which is then multiplied by the resource adequacy. This leads to an adjusted fractional change
Given the diagram, we can build a model as shown below.
= Model(starttime=0.0,stoptime=260.0,dt=1.0,name='Limits_to_growth') model
# decleare elements
= model.stock("state")
state = model.biflow("change")
change = model.converter("adjusted_fractional_change")
adjusted_fractional_change = model.constant("fractional_change")
fractional_change = model.converter("resource_adequacy")
resource_adequacy = model.constant("carrying_capacity")
carrying_capacity = model.constant("delay_resource_adequacy") delay_resource_adequacy
# define elements
=1.0
state.initial_value=change
state.equation
= state*adjusted_fractional_change
change.equation = fractional_change*resource_adequacy
adjusted_fractional_change.equation= (carrying_capacity - sd.delay(model, state, delay_resource_adequacy,1.0))/carrying_capacity
resource_adequacy.equation =0.1
fractional_change.equation= 50.0
carrying_capacity.equation
= 0.0 delay_resource_adequacy.equation
= bptk() bptk
bptk.register_model(model)
The plot below shows that the Limits to Growth archetype leads to S-shaped growth if there are no delays present in the system.
bptk.plot_scenarios(="S-Shaped Growth",
title=["smLimits_to_growth"],
scenario_managers=["base"],
scenarios=["state","carrying_capacity"]) equations
Now let’s add a scenario that introduces a delay: in this case we assume that the adjustment of the resource adequacy lags behind the actual system state by 10 weeks - this leads to an oscillatory behavior as displayed in the plot below.
bptk.register_scenarios(="smLimits_to_growth",
scenario_manager={
scenarios"oscillations":{
"constants":{
"delay_resource_adequacy":10.0
}
}
} )
=["smLimits_to_growth"],scenarios=["oscillations"],equations=["state","carrying_capacity"]) bptk.plot_scenarios(scenario_managers
Experimenting with the Limits To Growth Archetype
from BPTK_Py.visualizations import SimpleDashboard
import ipywidgets as widgets
bptk.register_scenarios(="smLimits_to_growth",
scenario_manager={
scenarios"interactive":{}
}
)
= SimpleDashboard(bptk, scenario_manager="smLimits_to_growth", scenario="interactive") dashboard
= widgets.FloatSlider(
wdg_delay_slider min=0.0,
max=20.0,
=10.0,
value=1.0
step
)
=widgets.FloatSlider(
wdg_increase_rate_slidermin=0.0,
max=0.2,
=0.1,
value=0.01
step )
"delay_resource_adequacy")
dashboard.add_widget(wdg_delay_slider, "fractional_change")
dashboard.add_widget(wdg_increase_rate_slider,
= dashboard.add_plot(
plot =["state","carrying_capacity"],
equations=["State", "Carrying Capacity"],
names="System State",
title="Week",
x_label="State",
y_label
)
= widgets.HBox([
controls "Delay"),widgets.Label("Fractional Change Rate")]),
widgets.VBox([widgets.Label(
widgets.VBox([wdg_delay_slider,wdg_increase_rate_slider])
])
display(plot)
display(controls) dashboard.start()