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 snow_distribution(xml): for snow_dist_pk in asearch.findall_path(xml, ["PKs", "snow distribution"]): snow_dist_pk.append( parameter.DoubleParameter("distribution time", 86400.0)) if snow_dist_pk.isElement("primary variable key") and \ asearch.child_by_name(snow_dist_pk,"primary variable key").getValue() == "surface-precipitation_snow" and \ snow_dist_pk.isElement("conserved quantity key") and \ asearch.child_by_name(snow_dist_pk,"conserved quantity key").getValue() == "precipitation-snow": asearch.child_by_name(snow_dist_pk, "conserved quantity key").set( "value", "surface-precipitation-snow") for ssk in asearch.findall_path( xml, ["state", "field evaluators", "surface-snow_skin_potential"]): if not ssk.isElement("dt factor"): ssk.append(parameter.DoubleParameter("dt factor", 86400.0)) else: asearch.child_by_name(ssk, "dt factor").set("value", "86400.0") for ssc in asearch.findall_path( xml, ["state", "field evaluators", "surface-snow_conductivity"]): if not ssc.isElement("include dt factor"): ssc.append(parameter.BoolParameter("include dt factor", True)) else: asearch.child_by_name(ssc, "include dt factor").set("value", "true") if not ssc.isElement("dt factor"): ssc.append(parameter.DoubleParameter("dt factor", 86400.0)) else: asearch.child_by_name(ssc, "dt factor").set("value", "86400.0")
def snow_depth(xml): for seb_pk in asearch.gen_by_path(xml, ["PKs", "SEB"]): if seb_pk.isElement("primary variable key") and \ asearch.child_by_name(seb_pk,"primary variable key").getValue() == "surface-snow_depth" and \ seb_pk.isElement("conserved quantity key") and \ asearch.child_by_name(seb_pk,"conserved quantity key").getValue() == "snow_depth": asearch.child_by_name(seb_pk, "conserved quantity key").set( "value", "surface-snow_depth")
def seb_threecomponent(xml, eval_name): """This changes the old, 'Arctic' SEB model into more robust variant that crashes less often.""" # area fractions try: frac_area = asearch.find_path( xml, ["state", "field evaluators", "snow-fractional_areas"]) except aerrors.MissingXMLError: pass else: frac_area.setName("surface-fractional_areas") for name in [ 'surface-fractional_areas', 'surface_column:*-fractional_areas' ]: try: frac_area = asearch.find_path(xml, ["state", "field evaluators", name]) except aerrors.MissingXMLError: pass else: domain = frac_area.getName().split('-')[0] frac_area.setName(domain + "-area_fractions") frac_area_type = asearch.child_by_name(frac_area, "field evaluator type") if frac_area_type.getValue() == "surface balance area fractions": frac_area_type.setValue("area fractions, three components") # water source try: water_source = asearch.find_path( xml, ['state', 'field evaluators', eval_name]) except aerrors.MissingXMLError: pass else: water_source_type = asearch.child_by_name(water_source, "field evaluator type") if water_source_type.getValue() == "surface balance": water_source_type.setValue( "surface energy balance, three components") # subgrid albedos for name in [ 'surface-subgrid_albedos', 'surface_column:*-subgrid_albedos' ]: try: albedo = asearch.find_path(xml, ['state', 'field evaluators', name]) except aerrors.MissingXMLError: pass else: dname = name.split('-')[0] albedo.setName(dname + '-albedos') albedo_type = asearch.child_by_name(albedo, "field evaluator type") if albedo_type.getValue() == "albedo": albedo_type.setValue("three-component subgrid albedos")
def alias_mesh_target(xml): mesh_list = asearch.child_by_name(xml, "mesh") for mesh in mesh_list: mtype = asearch.child_by_name(mesh, "mesh type") if mtype.getValue() == "aliased": try: alias = asearch.find_path(mesh, ["aliased parameters", "alias"]) except aerrors.MissingXMLError: pass else: alias.setName("target")
def linear_operator(xml): """Changes any instances of "linear operator" to "linear solver", which is now standard across all PKs.""" pks = asearch.child_by_name(xml, "PKs") for pk in pks: try: lin_op = asearch.child_by_name(pk, "linear operator") except aerrors.MissingXMLError: pass else: lin_op.setName("linear solver")
def flatten_pks(xml): try: cycle_driver = asearch.child_by_name(xml, "cycle driver") except aerrors.MissingXMLError: pass else: return pks = asearch.child_by_name(xml, "PKs") cd_pks = coordinator_to_cycle_driver(xml) flat_pks = ParameterList("PKs") flatten(pks, flat_pks, cd_pks) pks.extend(flat_pks)
def max_valid_change(xml): """Adds options for max valid change, which aren't required, but are strongly suggested.""" pks = asearch.child_by_name(xml, "PKs") for pk in pks: pk_type = asearch.child_by_name(pk, "PK type") if pk_type.get('value') == 'permafrost flow': try: pk.getElement("max valid change in saturation in a time step [-]") except aerrors.MissingXMLError: pk.append(parameter.DoubleParameter("max valid change in saturation in a time step [-]", 0.1)) try: pk.getElement("max valid change in ice saturation in a time step [-]") except aerrors.MissingXMLError: pk.append(parameter.DoubleParameter("max valid change in ice saturation in a time step [-]", 0.1))
def add_to_lc(eval_name, param_name, param_default, lc, param_name_new=None): if param_name_new is None: param_name_new = param_name # add the dessicated zone thickness try: evaluator = asearch.find_path( xml, ['state', 'field evaluators', eval_name]) except aerrors.MissingXMLError: pval = None else: try: param = asearch.child_by_name(evaluator, param_name) except aerrors.MissingXMLError: pval = None else: pval = param.getValue() evaluator.remove(param) if pval is None: pval = param_default lc.append(parameter.DoubleParameter(param_name_new, pval))
def coordinator_to_cycle_driver(xml): cycle_driver = asearch.child_by_name(xml, "coordinator") cycle_driver.set("name", "cycle driver") cycle_driver_pks = ParameterList("PK tree") cycle_driver.append(cycle_driver_pks) return cycle_driver_pks
def sources(xml): """Can turn off derivative of source terms""" pks = asearch.child_by_name(xml, "PKs") for pk in pks: try: source_term = pk.getElement("mass source key") except aerrors.MissingXMLError: pass else: source_term.setName('source key') try: source_term = pk.getElement("energy source key") except aerrors.MissingXMLError: pass else: source_term.setName('source key') try: source_term = pk.getElement("source term") except aerrors.MissingXMLError: pass else: if source_term.getValue(): try: source_is_diff = pk.getElement( "source term is differentiable") except aerrors.MissingXMLError: pk.append( parameter.BoolParameter( "source term is differentiable", True))
def update(xml): linear_operator(xml) max_valid_change(xml) bad_spinup_longwave(xml) sources(xml) pks = asearch.child_by_name(xml, "PKs") for pk in pks: pk_type = asearch.child_by_name(pk, "PK type") if pk_type.get('value') == 'surface balance implicit': print('updating seb monolitic') import seb_monolithic_to_evals seb_monolithic_to_evals.update_seb(xml) fixEvaluator(xml, "surface-snow_skin_potential", "snow-skin_potential") fixEvaluator(xml, "surface-snow_conductivity", "snow-conductivity") snow_distribution(xml) end_time_units(xml) import verbose_object verbose_object.fixVerboseObject(xml)
def create_landcover(xml, eval_name='water_source', water_transition_depth=0.02): """Adds a default land-cover section that will be the same as the Arctic defaults.""" ic_list = asearch.find_path(xml, ['state', 'initial conditions']) try: lc = asearch.child_by_name(ic_list, "land cover types") except aerrors.MissingXMLError: pass else: return # already exists # create a single land-cover type on the entire surface domain def add_to_lc(eval_name, param_name, param_default, lc, param_name_new=None): if param_name_new is None: param_name_new = param_name # add the dessicated zone thickness try: evaluator = asearch.find_path( xml, ['state', 'field evaluators', eval_name]) except aerrors.MissingXMLError: pval = None else: try: param = asearch.child_by_name(evaluator, param_name) except aerrors.MissingXMLError: pval = None else: pval = param.getValue() evaluator.remove(param) if pval is None: pval = param_default lc.append(parameter.DoubleParameter(param_name_new, pval)) lc = ic_list.sublist('land cover types').sublist('surface domain') add_to_lc('water_source', 'dessicated zone thickness [m]', 0.1, lc) add_to_lc('water_source', 'roughness length of bare ground [m]', 0.04, lc) add_to_lc('water_source', 'roughness length of snow-covered ground [m]', 0.004, lc, 'roughness length of snow [m]') add_to_lc('water_source', 'snow-ground transitional depth [m]', 0.02, lc, 'snow transition depth [m]') add_to_lc('water_source', 'water-ground transitional depth [m]', water_transition_depth, lc, 'water transition depth [m]') add_to_lc('surface-subgrid_albedos', 'albedo ground surface [-]', 0.135, lc, 'albedo of bare ground [-]') add_to_lc('surface-subgrid_albedos', 'emissivity tundra [-]', 0.92, lc, 'emissivity of bare ground [-]')
def getCoordinateFromList(self, one_list): well_name = one_list.getElement("Region").value region = search.child_by_name( search.find_path(self.xml, [ "amanzi_input", "regions", ], False), well_name) try: coordinate = region.get("coordinate") except KeyError: raise RuntimeError("Region is not of type point") return coordinate
def lower_case(xml): """Converts an xml object, in-place""" try: regions = asearch.child_by_name(xml, "Regions") except aerrors.MissingXMLError: pass else: for label in changes_regions: asearch.change_name(regions, label, label.lower(), allow_multiple=True) asearch.change_name(xml, ["Region: Plane", "location"], "point", allow_multiple=True) asearch.change_name(xml, ["Region: Plane", "direction"], "normal", allow_multiple=True) regions.setName("regions") try: mesh = asearch.child_by_name(xml, "Mesh") except aerrors.MissingXMLError: pass else: for label in changes_mesh: asearch.change_name(mesh, label, label.lower(), True) mesh.setName("mesh") try: domain = asearch.child_by_name(xml, "Domain") except aerrors.MissingXMLError: pass else: xml.remove(domain)
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.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 vis(xml): if xml.isElement("visualization") and not asearch.child_by_name( xml, "visualization").isElement("domain"): vis_domain = xml.pop("visualization") vis_domain.setName("domain") vis_list = xml.sublist("visualization") vis_list.append(vis_domain) if xml.isElement("visualization surface"): vis_surf = xml.pop("visualization surface") vis_surf.setName("surface") vis_list.append(vis_surf) if xml.isElement("visualization columns"): vis_col = xml.pop("visualization columns") vis_col.setName("column_*") vis_list.append(vis_col)
def seb(xml): pk_list = asearch.findall_name(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.child_by_name( pk, "PK type").getValue() == "surface balance implicit": if seb_pk is not None: raise RuntimeError("Cannot deal with SEB changes!") seb_pk = pk elif asearch.child_by_name(pk, "PK type").getValue() == "permafrost flow": if flow_sub_pk is not None: raise RuntimeError("Cannot deal with SEB changes!") flow_sub_pk = pk elif asearch.child_by_name( pk, "PK type").getValue() == "overland flow with ice": if flow_surf_pk is not None: raise RuntimeError("Cannot deal with SEB changes!") flow_surf_pk = pk elif asearch.child_by_name( pk, "PK type").getValue() == "three-phase energy": if energy_sub_pk is not None: raise RuntimeError("Cannot deal with SEB changes!") energy_sub_pk = pk elif asearch.child_by_name(pk, "PK type").getValue() == "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.child_by_name(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 = asearch.find_path(xml, ["state", "field evaluators"]) 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.child_by_name(eval_list, "surface-source_molar_density") if molar_dens.isElement("temperature key"): asearch.child_by_name(molar_dens, "temperature key").set("value", "surface-temperature") else: molar_dens.append( parameter.StringParameter("temperature key", "surface-temperature"))
def snow_distribution(xml): for snow_dist_pk in asearch.gen_path(xml, ["PKs", "snow distribution"]): if snow_dist_pk.isElement("primary variable key") and \ asearch.child_by_name(snow_dist_pk,"primary variable key").getValue() == "surface-precipitation_snow": asearch.child_by_name( snow_dist_pk, "primary variable key").setValue("snow-precipitation") if snow_dist_pk.isElement("conserved quantity key") and \ asearch.child_by_name(snow_dist_pk,"conserved quantity key").getValue() == "surface-precipitation_snow": asearch.child_by_name( snow_dist_pk, "conserved quantity key").setValue("snow-precipitation") if snow_dist_pk.isElement("domain name") and \ asearch.child_by_name(snow_dist_pk,"domain name").getValue() == "surface": asearch.child_by_name(snow_dist_pk, "domain name").setValue("snow") for ssk in asearch.find_path( xml, ["state", "field evaluators", "snow-conductivity"]): if ssk.isElement("height key"): asearch.child_by_name(ssk, "height key").setValue("snow-precipitation")
def seb_twocomponent(xml, eval_name): """This changes the old, 'Arctic' SEB model into a test-reproducing, same answer input file.""" # area fractions try: frac_area = asearch.find_path( xml, ["state", "field evaluators", "snow-fractional_areas"]) except aerrors.MissingXMLError: pass else: frac_area.setName("surface-fractional_areas") for name in [ 'surface-fractional_areas', 'surface_column:*-fractional_areas' ]: try: frac_area = asearch.find_path(xml, ["state", "field evaluators", name]) except aerrors.MissingXMLError: pass else: domain = frac_area.getName().split('-')[0] frac_area.setName(domain + "-area_fractions") frac_area_type = asearch.child_by_name(frac_area, "field evaluator type") if frac_area_type.getValue() == "surface balance area fractions": frac_area_type.setValue("area fractions, two components") # water source try: water_source = asearch.find_path( xml, ['state', 'field evaluators', eval_name]) except aerrors.MissingXMLError: pass else: water_source_type = asearch.child_by_name(water_source, "field evaluator type") if water_source_type.getValue() == "surface balance": water_source_type.setValue( "surface energy balance, two components") try: asearch.child_by_name(water_source, "use model from ATS 1.1") except aerrors.MissingXMLError: water_source.append( parameter.BoolParameter("use model from ATS 1.1", True)) # subgrid albedos for name in [ 'surface-subgrid_albedos', 'surface_column:*-subgrid_albedos' ]: try: albedo = asearch.find_path(xml, ['state', 'field evaluators', name]) except aerrors.MissingXMLError: pass else: dname = name.split('-')[0] albedo.setName(dname + '-albedos') albedo_type = asearch.child_by_name(albedo, "field evaluator type") if albedo_type.getValue() == "albedo": albedo_type.setValue("two-component subgrid albedos")
def getElement(self, name): """Get Parameter/sublist from the ParameterList""" return search.child_by_name(self, name)
def mesh_list(xml): try: xml.pop("Native Unstructured Input") except aerrors.MissingXMLError: pass try: xml.pop("grid_option") except aerrors.MissingXMLError: pass # move domain mesh parameters to a sublist mesh = asearch.child_by_name(xml, "mesh") domain = mesh.sublist("domain") to_pop = [] for el in mesh: if el.get("name") == "surface mesh": el.setName("surface") elif el.get("name") == "column meshes": el.setName("column") elif el.get("name") == "column surface meshes": el.setName("column surface") elif el.get("name") in [ "surface", "column", "column surface", "domain", "subgrid" ]: pass elif el.get("name") in ["framework"]: to_pop.append(el) else: domain.append(el) if domain.isElement("framework"): domain.pop("framework") for el in domain: if mesh.isElement(el.get("name")): mesh.pop(el.get("name")) for el in to_pop: mesh.pop(el.get("name")) # move surface mesh parameters to a sublist if mesh.isElement("surface"): surf_list = mesh.sublist("surface") surf_p_list = surf_list.sublist("surface") if surf_list.isElement("surface sideset name"): surf_p_list.append(surf_list.pop("surface sideset name")) if surf_list.isElement("surface sideset names"): surf_p_list.append(surf_list.pop("surface sideset names")) # make sure all left are mesh sublists, add a mesh type parameter valid_types = [ "read mesh file", "generate mesh", "logical mesh", "aliased", "surface", "column", "column surface", "subgrid" ] for el in mesh: if not el.isElement("mesh type"): print(el) found = False for valid_type in valid_types: if el.isElement(valid_type): print("setting type: ", valid_type) el.setParameter("mesh type", "string", valid_type) asearch.child_by_name( el, valid_type).setName(valid_type + " parameters") found = True break assert (found) return
def set_source_term(pk): if not pk.isElement("source term"): pk.append(parameter.BoolParameter("source term", True)) else: asearch.child_by_name(pk, "source term").set("value", "true")
def snow_distribution(xml): try: snow_dist_pk = asearch.find_path(xml, ["PKs","snow distribution"]) except aerrors.MissingXMLError: pass else: if snow_dist_pk.isElement("primary variable key") and \ asearch.child_by_name(snow_dist_pk,"primary variable key").getValue() == "surface-precipitation_snow": asearch.child_by_name(snow_dist_pk,"primary variable key").setValue("snow-precipitation") if snow_dist_pk.isElement("conserved quantity key") and \ asearch.child_by_name(snow_dist_pk,"conserved quantity key").getValue() == "surface-precipitation_snow": asearch.child_by_name(snow_dist_pk,"conserved quantity key").setValue("snow-precipitation") if snow_dist_pk.isElement("domain name") and \ asearch.child_by_name(snow_dist_pk,"domain name").getValue() == "surface": asearch.child_by_name(snow_dist_pk,"domain name").setValue("snow") try: ssk = asearch.find_path(xml, ["state","field evaluators","snow-conductivity"]) except aerrors.MissingXMLError: pass else: if ssk.isElement("height key"): asearch.child_by_name(ssk, "height key").setValue("snow-precipitation")