update_param! when originally set by default

[lrennels]

We need to revisit how we want set_param! vs. update_param! to work in the case of defaults being set. Current behavior is confusing to users:

1. If a parameter is set by a default and the model is then run, users expect to be able to call update_param! on the parameter in the model, but this errors because they need to call set_param!. At the very least we should throw a better error telling them to try calling set_param!, but we should also discuss this behavior.

• FUND user: https://forum.mimiframework.org/t/undefvarerror-update-param-not-defined/144
• PAGE user: Unable to update TCR anthofflab/MimiPAGE2009.jl#222

2. Also comes out in Monte Carlo...

Frank

I'm doing a Monte Carlo with SNEASY and there are a couple parameters with default values. When I try to do an update_param! on them, it throws the error: Cannot update parameter; CO₂_0 not found in composite's external parameters. So to do a Monte Carlo, I have to first do a set_param! with a fake value, and then I can carry out the Monte Carlo runs with the update_param! syntax. Am I misunderstanding how this should work? If so, it seems like default values should only be used for things you never plan to change?

Here's some code to show what I'm talking about.

This errors

using Mimi
using MimiSNEASY
m = MimiSNEASY.get_model()
co2_vals = [281.0, 282.5]
for i = 1:2
	update_param!(m, :CO₂_0, co2_vals[i])
	run(m)
end

This works

using Mimi
using MimiSNEASY
m = MimiSNEASY.get_model()
set_param!(m, :rfco2, :CO₂_0, 10000.0)
co2_vals = [281.0, 282.5]
for i = 1:2
	update_param!(m, :CO₂_0, co2_vals[i])
	run(m)
end

David

Actually, I think I remember now why we did it the way it is right now: the alternative design would be that if one adds a component to a model, and that component has a parameter with a default value, we add an external parameter to the model with that name, set it to the value from the component, and then connect things up. So far so good, but if one then adds another component that has a parameter with the same name that also has a default value, then it is unclear how we would handle that.

Maybe we need a function that "elevates" a default parameter from a component to the model level...

[lrennels]

Current behavior:

using Mimi
using MimiFUND
m = MimiFUND.get_model()

# cannot update_param! for one with a default
update_param!(m, :climatesensitivity, 2.0) 
ERROR: Cannot update parameter; climatesensitivity not found in composite's external parameters.

# can set_param!
set_param!(m, :climatesensitivity, 2.0) # works! 

while this may make sense, because the model has not been built yet, the same behavior remains even after we have called run(m), which strikes me as unexpected. Users expect that if a model has run, and thus all needed parameters were set, they should be to call update_param! on any parameter.

The reason here is that we call _set_defaults! on m.mi.md during build!, not on m.md. Thus if we later try to call update_param! on m, it delegates to m.md and cannot find the parameter name in m.md.external_params. Once a user calls set_param! once with the :climatesensitivity parameter, an external parameter is created in m.md and from then on they will call update_param! on it.

I see what the idea was here, but we should revisit to ensure this is what we want. Essentially what we are saying here is that defaults apply to model instances at run time, but do not ever get baked into the actual model definition. I'm not sure I agree with that, but haven't really made up my mind. Some change options could be ...

• leave it like it is
• call _set_defaults! on m.md so that the defaults all create external parameters on the first call of run, basically saying that if you haven't set your own parameter we will call set_param! for you for all defaults
• something else...

[lrennels]

The middle bullet above would be achieved by flipping the first two lines in this function, but that in some ways breaks other invariants so its worth a discussion.

function build(m::Model)  
  
    # Reference a copy in the ModelInstance to avoid changes underfoot
    md = deepcopy(m.md)
    _set_defaults!(md)  # apply defaults to unset parameters in the model instance's copy of the model definition
    
    mi = _build(md)
    return mi
end