def get_gmres(error_tolerance=1.e-6):
plist = parameter_list.ParameterList("gmres parameters")
plist.setParameter("preconditioning strategy", "string", "left")
plist.setParameter("error tolerance", "double", error_tolerance)
plist.setParameter("convergence criteria", "Array(string)",
["relative residual", "make one iteration"])
plist.setParameter("maximum number of iteration", "int", 80)
return plist
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 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 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 createRegionLabeledSet(setname, entity, label, mesh, format="Exodus II"):
"""Create a labeled set region.
setname | string, name of the region
entity | string, entity (see mesh_entity.py)
label | string, label id in mesh file (note this is usually a string containing an integer)
mesh | string, mesh filename
fomat | string, format of mesh (currently only 'Exodus II' supported)
returns the region xml
"""
e = extractDoxygenXML(
os.path.join(AMANZI_SRC_DIR, 'src', 'geometry', 'RegionLabeledSet.hh'))
search.replace_by_name(e, "label", label)
search.replace_by_name(e, "entity", mesh_entity.valid_mesh_entity(entity))
search.replace_by_name(e, "format", format)
search.replace_by_name(e, "mesh", mesh)
pl = parameter_list.ParameterList(setname)
pl.append(e)
return pl
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
dens = 997.0
g = 9.80665
permeabilities = hydraulic_conduct * visc / (dens * g)
res_wcs = np.array([
0.008, 0.022, 0.26, 0.26, 0.008, 0.12, 0.12, 0.12, 0.12, 0.16, 0.18, 0.18,
0.24, 0.32, 0.34, 0.34
])
res_sats = np.array([wc / phi for wc, phi in zip(res_wcs, porosities)])
vg_alphas = 6.e-4 * np.ones((16, )) # made up!
vg_ms = 0.2 * np.ones((16, )) # made up!
res_sats = .2 * np.random.rand(16)
# create the regions
region_list = plist.ParameterList("regions")
for i, s in enumerate(soils):
region_list.append(
aregions.createRegionLabeledSet(s, "cell", str(i + 1), "mesh.exo"))
print "Regions list:"
print "-------------"
region_list.indent(0)
print region_list
print ""
print ""
# create the porosity functions
poro_funcs = []
for s, poro in zip(soils, porosities):
func = afuncs.createConstantFunction(poro)
poro_funcs.append(afuncs.createFunctionSpec(s, s, "cell", func))
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
def fixPorosity(xml):
"""Fix the compressible porosity list"""
try:
search.getElementByNamePath(xml,
"/Main/Regions/computation domain moss")
except errors.MissingXMLError:
moss = False
else:
moss = True
try:
poro = search.getElementByNamePath(
xml, "/Main/state/field evaluators/porosity")
except errors.MissingXMLError:
print "no porosity evaluator"
return
try:
params = search.getElementByNamePath(
poro, "/compressible porosity model parameters")
except errors.MissingXMLError:
print "porosity is not compressible"
return
if params.getchildren()[0].get("type") == "ParameterList":
print "porosity has already been fixed"
return
comp_el = params.getchildren().pop()
assert len(params.getchildren()) == 0
if moss:
moss_list = parameter_list.ParameterList("moss")
moss_list.setParameter("region", "string", "computational domain moss")
moss_list.setParameter("pore compressibility", "double", XXX)
params.getchildren().append(moss_list)
peat_list = parameter_list.ParameterList("peat")
peat_list.setParameter("region", "string", "computational domain peat")
peat_list.setParameter("pore compressibility", "double", XXX)
params.getchildren().append(peat_list)
up_min_list = parameter_list.ParameterList("upper mineral")
up_min_list.setParameter("region", "string",
"computational domain upper mineral")
up_min_list.setParameter("pore compressibility", "double", XXX)
params.getchildren().append(up_min_list)
low_org_list = parameter_list.ParameterList("lower organic")
low_org_list.setParameter("region", "string",
"computational domain lower organic")
low_org_list.setParameter("pore compressibility", "double", XXX)
params.getchildren().append(low_org_list)
low_min_list = parameter_list.ParameterList("lower mineral")
low_min_list.setParameter("region", "string",
"computational domain lower mineral")
low_min_list.setParameter("pore compressibility", "double", XXX)
params.getchildren().append(low_min_list)
deep_min_list = parameter_list.ParameterList("deep mineral")
deep_min_list.setParameter("region", "string",
"computational domain deep mineral")
deep_min_list.setParameter("pore compressibility", "double", XXX)
params.getchildren().append(deep_min_list)
else:
cp_list = parameter_list.ParameterList("computational domain")
cp_list.setParameter("region", "string", "computational domain")
cp_list.setParameter("pore compressibility", "double",
comp_el.get("value"))
params.getchildren().append(cp_list)
def _fixTIList(ti_list):
if ti_list.isElement("solver type"):
# already new style
return
old_pars = parameter_list.ParameterList("time integrator")
while len(ti_list.getchildren()) > 0:
old_pars.getchildren().append(ti_list.getchildren().pop())
# ti
migrate(ti_list, old_pars, "max preconditioner lag iterations")
migrate(ti_list, old_pars, "extrapolate initial guess")
# nonlinear solver
nl_solver = old_pars.pop("nonlinear solver").get("value")
if nl_solver == "NKA":
ti_list.setParameter("solver type", "string", "nka")
nl_plist = ti_list.sublist("nka parameters")
migrate(nl_plist, old_pars, "max du growth factor")
migrate(nl_plist, old_pars, "max error growth factor")
migrate(nl_plist, old_pars, "max divergent iterations")
migrate(nl_plist, old_pars, "lag iterations")
nl_plist.setParameter("modify correction", "bool", True)
migrate(nl_plist, old_pars, "monitor")
migrate(nl_plist, old_pars, "monitor", "convergence monitor")
nl_plist.setParameter("monitor", "string", "monitor residual")
elif nl_solver == "NKA BT":
ti_list.setParameter("solver type", "string", "nka_bt_ats")
nl_plist = ti_list.sublist("nka_bt_ats parameters")
migrate(nl_plist, old_pars, "nka lag iterations")
migrate(nl_plist, old_pars, "max backtrack steps")
migrate(nl_plist, old_pars, "max total backtrack steps")
migrate(nl_plist, old_pars, "backtrack lag")
migrate(nl_plist, old_pars, "last backtrack iteration")
migrate(nl_plist, old_pars, "backtrack factor")
migrate(nl_plist, old_pars, "backtrack tolerance")
migrate(nl_plist, old_pars, "nonlinear tolerance")
migrate(nl_plist, old_pars, "diverged tolerance")
migrate(nl_plist, old_pars, "limit iterations")
nl_plist.sublist("VerboseObject").setParameter(
"Verbosity Level", "string",
old_pars.sublist("VerboseObject").getElement("Verbosity Level").get(
"value"))
migrate(ti_list, old_pars, "VerboseObject")
# timestep controller
ts_ctrl = old_pars.pop("timestep controller type").get("value")
assert ts_ctrl == "smarter"
ti_list.setParameter("timestep controller type", "string", ts_ctrl)
ts_list = ti_list.sublist("timestep controller smarter parameters")
migrate(ts_list, old_pars, "max iterations")
migrate(ts_list, old_pars, "min iterations")
migrate(ts_list, old_pars, "time step reduction factor")
migrate(ts_list, old_pars, "time step increase factor")
migrate(ts_list, old_pars, "max time step increase factor")
migrate(ts_list, old_pars, "max time step")
migrate(ts_list, old_pars, "min time step")
migrate(ts_list, old_pars, "growth wait after fail")
migrate(ts_list, old_pars, "count before increasing increase factor")
