def eval_snow_source_sink(dc=None):
ss = parameter_list.ParameterList("snow-source_sink")
ss.append(
parameter.StringParameter("field evaluator type", "surface balance"))
ss.append(parameter.BoolParameter("save diagnostic data", True))
if dc is not None:
ss.append(dc)
vo = ss.sublist("verbose object")
vo.append(parameter.StringParameter("verbosity level", "high"))
return ss
def add_snow_mesh(xml):
meshes = asearch.childByName(xml, "mesh")
snow = meshes.sublist("snow")
snow.append(parameter.StringParameter("mesh type", "aliased"))
aliased = snow.sublist("aliased parameters")
aliased.append(parameter.StringParameter("alias", "surface"))
vis = asearch.childByName(xml, "visualization")
surf_vis = asearch.childByName(vis, "surface")
snow_vis = vis.sublist("snow")
snow_vis.append(parameter.StringParameter("file name base",
"visdump_snow"))
for p in surf_vis:
if p.get('name') != "file name base":
snow_vis.append(copy.copy(p))
def priestley_taylor(xml):
eval_list = asearch.find_path(xml, ['state', 'field evaluators'])
for ev in eval_list:
ev_type = asearch.child_by_name(ev, 'field evaluator type')
if ev_type.getValue() == 'potential evapotranspiration':
ev_type.setValue('potential evapotranspiration, Priestley-Taylor')
# net radiation is the new key, old used shortwave by default
default = True
try:
sw_key = asearch.child_by_name(ev, 'shortwave radiation key')
except aerrors.MissingXMLError:
pass
else:
sw_key.setName('net radiation key')
default = False
try:
sw_suffix = asearch.child_by_name(
ev, 'shortwave radiation key suffix')
except aerrors.MissingXMLError:
pass
else:
sw_key.setName('net radiation key suffix')
default = False
if default:
ev.append(
parameter.StringParameter('net radiation key suffix',
'shortwave_radiation'))
if ev.getName() == 'surface-air_temperature_inter':
# this name is dead, now just surface-temperature (which is what it was intended to be physically)
ev.setName('surface-temperature')
def createFunctionSpec(spec_name, region, component, func):
"""Create a Function spec on a 'region' and 'component'"""
if type(region) is str:
region_p = parameter.StringParameter("region", region)
else:
region_p = parameter.ArrayStringParameter("regions", region)
if type(component) is str:
component_p = parameter.StringParameter("component", component)
else:
component_p = parameter.ArrayStringParameter("components", component)
pl = parameter_list.ParameterList(spec_name)
pl.append(region_p)
pl.append(entity_p)
pl.sublist("function").append(func)
return pl
def eval_snow_swe():
swe = parameter_list.ParameterList("snow-swe")
swe.append(
parameter.StringParameter("field evaluator type",
"multiplicative evaluator"))
swe.append(
parameter.ArrayStringParameter(
"evaluator dependencies",
["snow-depth", "snow-density", "snow-cell_volume"]))
swe.append(parameter.DoubleParameter("coefficient", 1.e-3))
return swe
def flatten(pks, flat_pks, cd_pks):
while len(pks) > 0:
pk = pks.getchildren().pop(0)
flat_pks.append(pk)
new_cd = ParameterList(pk.get("name"))
new_cd.append(
parameter.StringParameter(
"PK type",
asearch.childByName(pk, "PK type").get("value")))
cd_pks.append(new_cd)
try:
subpks = pk.pop("PKs")
except aerrors.MissingXMLError:
pass
else:
flatten(subpks, flat_pks, new_cd)
def flatten(pks, flat_pks, cd_pks):
while len(pks) > 0:
pk_name = pks.getchildren()[0].get("name")
new_cd = ParameterList(pk_name)
pk = pks.pop(pk_name)
flat_pks.append(pk)
print(f'Flattened PK: {pk_name}')
new_cd.append(
parameter.StringParameter(
"PK type",
asearch.child_by_name(pk, "PK type").get("value")))
cd_pks.append(new_cd)
try:
subpks = pk.pop("PKs")
except aerrors.MissingXMLError:
pass
else:
flatten(subpks, flat_pks, new_cd)
def createIndependentVariableEvaluator(eval_name, func_list):
pl = plist.ParameterList(eval_name)
pl.append(parameter.StringParameter("field evaluator type", "independent variable"))
pl.sublist("function").extend(func_list)
return pl
def seb(xml):
pk_list = [pk for pk in asearch.generateElementByNamePath(xml, "PKs")]
assert (len(pk_list) == 1)
pk_list = pk_list[0]
seb_pk = None
flow_sub_pk = None
flow_surf_pk = None
energy_sub_pk = None
energy_surf_pk = None
# make sure we can find all of them!
for pk in pk_list:
if asearch.childByName(
pk, "PK type").get("value") == "surface balance implicit":
if seb_pk is not None:
raise RuntimeError("Cannot deal with SEB changes!")
seb_pk = pk
elif asearch.childByName(pk,
"PK type").get("value") == "permafrost flow":
if flow_sub_pk is not None:
raise RuntimeError("Cannot deal with SEB changes!")
flow_sub_pk = pk
elif asearch.childByName(
pk, "PK type").get("value") == "overland flow with ice":
if flow_surf_pk is not None:
raise RuntimeError("Cannot deal with SEB changes!")
flow_surf_pk = pk
elif asearch.childByName(
pk, "PK type").get("value") == "three-phase energy":
if energy_sub_pk is not None:
raise RuntimeError("Cannot deal with SEB changes!")
energy_sub_pk = pk
elif asearch.childByName(pk,
"PK type").get("value") == "surface energy":
if energy_surf_pk is not None:
raise RuntimeError("Cannot deal with SEB changes!")
energy_surf_pk = pk
if seb_pk is None or flow_sub_pk is None or flow_surf_pk is None or energy_sub_pk is None or energy_surf_pk is None:
return
# check the source terms for all
def set_source_term(pk):
if not pk.isElement("source term"):
pk.append(parameter.BoolParameter("source term", True))
else:
asearch.childByName(pk, "source term").set("value", "true")
set_source_term(flow_sub_pk)
set_source_term(flow_surf_pk)
set_source_term(energy_sub_pk)
set_source_term(energy_surf_pk)
if not flow_sub_pk.isElement("mass source key"):
flow_sub_pk.append(
parameter.StringParameter("mass source key", "mass_source"))
if not flow_surf_pk.isElement("source key"):
flow_surf_pk.append(
parameter.StringParameter("source key", "surface-mass_source"))
if not flow_surf_pk.isElement("mass source in meters"):
flow_surf_pk.append(
parameter.BoolParameter("mass source in meters", True))
if not energy_sub_pk.isElement("energy source"):
energy_sub_pk.append(
parameter.StringParameter("energy source", "total_energy_source"))
if not energy_surf_pk.isElement("energy source"):
energy_surf_pk.append(
parameter.StringParameter("energy source",
"surface-total_energy_source"))
eval_list = [
ev for ev in asearch.generateElementByNamePath(
xml, "state/field evaluators")
]
assert (len(eval_list) == 1)
eval_list = eval_list[0]
try:
eval_list.pop("surface-total_energy_source")
except aerrors.MissingXMLError:
pass
try:
eval_list.pop("surface-mass_source_enthalpy")
except aerrors.MissingXMLError:
pass
try:
eval_list.pop("surface-source_internal_energy")
except aerrors.MissingXMLError:
pass
molar_dens = asearch.childByName(eval_list, "surface-source_molar_density")
if molar_dens.isElement("temperature key"):
asearch.childByName(molar_dens,
"temperature key").set("value",
"surface-temperature")
else:
molar_dens.append(
parameter.StringParameter("temperature key",
"surface-temperature"))
def eval_albedo():
al = parameter_list.ParameterList("surface-subgrid_albedos")
al.append(parameter.StringParameter("field evaluator type", "albedo"))
return al
def eval_longwave():
lw = parameter_list.ParameterList("surface-incoming_longwave_radiation")
lw.append(
parameter.StringParameter("field evaluator type",
"incoming longwave radiation"))
return lw
def eval_snow_frac_areas():
fa = parameter_list.ParameterList("surface-fractional_areas")
fa.append(
parameter.StringParameter("field evaluator type",
"surface balance area fractions"))
return fa
def pks(xml):
pk_tree = asearch.childByNamePath(xml, "cycle driver/PK tree")
for pk_type in asearch.generateElementByNamePath(pk_tree, "PK type"):
if pk_type.getValue() == 'surface balance implicit':
pk_type.setValue('surface balance implicit subgrid')
pks = asearch.childByName(xml, "PKs")
for pk in pks:
pk_type = asearch.childByName(pk, "PK type")
if pk_type.get('value') == 'permafrost flow':
try:
source_term = asearch.childByName(pk, "source term")
except aerrors.MissingXMLError:
pass
else:
source_term.setValue(False)
elif pk_type.get('value') == 'overland flow with ice':
try:
source_term = asearch.childByName(pk, "source term")
except aerrors.MissingXMLError:
pk.append(parameter.BoolParameter("source term", True))
else:
source_term.setValue(True)
try:
source_is_diff = asearch.childByName(
pk, "source term is differentiable")
except aerrors.MissingXMLError:
pk.append(
parameter.BoolParameter("source term is differentiable",
False))
else:
source_is_diff.setValue(False)
elif pk_type.get('value') == 'three-phase energy':
try:
source_term = asearch.childByName(pk, "source term")
except aerrors.MissingXMLError:
pass
else:
source_term.setValue(False)
elif pk_type.get('value') == 'surface energy':
try:
source_term = asearch.childByName(pk, "source term")
except aerrors.MissingXMLError:
pk.append(parameter.BoolParameter("source term", True))
else:
source_term.setValue(True)
try:
source_is_diff = asearch.childByName(
pk, "source term is differentiable")
except aerrors.MissingXMLError:
pk.append(
parameter.BoolParameter("source term is differentiable",
True))
else:
source_is_diff.setValue(True)
try:
source_fd = asearch.childByName(
pk, "source term finite difference")
except aerrors.MissingXMLError:
pk.append(
parameter.BoolParameter("source term finite difference",
True))
else:
source_fd.setValue(True)
elif pk_type.get('value') == 'surface balance implicit':
pk_seb = parameter_list.ParameterList(pk.get('name'))
pk_seb.append(
parameter.StringParameter('PK type',
'surface balance implicit subgrid'))
pk_seb.append(parameter.StringParameter('layer name', 'snow'))
pk_seb.append(parameter.StringParameter('domain name', 'snow'))
pk_seb.append(
parameter.StringParameter('primary variable key',
'snow-depth'))
pk_seb.append(
parameter.StringParameter('conserved quantity key',
'snow-swe'))
pk_seb.append(
parameter.StringParameter('source key', 'snow-source_sink'))
pk_seb.append(
parameter.BoolParameter('source term is differentiable',
False))
pk_seb.append(pk.pop('initial condition'))
try:
pk_seb.append(pk.pop('verbose object'))
except aerrors.MissingXMLError:
pass
try:
dc = pk.pop('debug cells')
except aerrors.MissingXMLError:
dc = None
else:
pk_seb.append(copy.copy(dc))
pc = pk_seb.sublist('preconditioner')
pc.append(
parameter.StringParameter('preconditioner type', 'identity'))
ls = pk_seb.sublist('linear solver')
ls.append(parameter.StringParameter('iterative method', 'nka'))
nka = ls.sublist('nka parameters')
nka.append(parameter.DoubleParameter('error tolerance', 1.e-6))
nka.append(
parameter.IntParameter('maximum number of iterations', 10))
pks.pop(pk.get('name'))
pks.append(pk_seb)
return dc