def snow_distribution(xml): for snow_dist_pk in asearch.generateElementByNamePath( xml, "PKs/snow distribution"): snow_dist_pk.append( parameter.DoubleParameter("distribution time", 86400.0)) if snow_dist_pk.isElement("primary variable key") and \ asearch.childByName(snow_dist_pk,"primary variable key").get("value") == "surface-precipitation_snow" and \ snow_dist_pk.isElement("conserved quantity key") and \ asearch.childByName(snow_dist_pk,"conserved quantity key").get("value") == "precipitation-snow": asearch.childByName(snow_dist_pk, "conserved quantity key").set( "value", "surface-precipitation-snow") for ssk in asearch.generateElementByNamePath( xml, "state/field evaluators/surface-snow_skin_potential"): if not ssk.isElement("dt factor"): ssk.append(parameter.DoubleParameter("dt factor", 86400.0)) else: asearch.childByName(ssk, "dt factor").set("value", "86400.0") for ssc in asearch.generateElementByNamePath( xml, "state/field evaluators/surface-snow_conductivity"): if not ssc.isElement("include dt factor"): ssc.append(parameter.BoolParameter("include dt factor", True)) else: asearch.childByName(ssc, "include dt factor").set("value", "true") if not ssc.isElement("dt factor"): ssc.append(parameter.DoubleParameter("dt factor", 86400.0)) else: asearch.childByName(ssc, "dt factor").set("value", "86400.0")
def snow_distribution(xml): for snow_dist_pk in asearch.generateElementByNamePath(xml, "PKs/snow distribution"): snow_dist_pk.append(parameter.DoubleParameter("distribution time", 86400.0)) if snow_dist_pk.isElement("primary variable key") and \ asearch.childByName(snow_dist_pk,"primary variable key").get("value") == "surface-precipitation_snow" and \ snow_dist_pk.isElement("conserved quantity key") and \ asearch.childByName(snow_dist_pk,"conserved quantity key").get("value") == "precipitation-snow": asearch.childByName(snow_dist_pk,"conserved quantity key").set("value", "surface-precipitation-snow") for ssk in asearch.generateElementByNamePath(xml, "state/field evaluators/surface-snow_skin_potential"): if not ssk.isElement("dt factor"): ssk.append(parameter.DoubleParameter("dt factor", 86400.0)) else: asearch.childByName(ssk, "dt factor").set("value","86400.0") for ssc in asearch.generateElementByNamePath(xml, "state/field evaluators/surface-snow_conductivity"): if not ssc.isElement("include dt factor"): ssc.append(parameter.BoolParameter("include dt factor", True)) else: asearch.childByName(ssc, "include dt factor").set("value","true") if not ssc.isElement("dt factor"): ssc.append(parameter.DoubleParameter("dt factor", 86400.0)) else: asearch.childByName(ssc, "dt factor").set("value","86400.0")
def primary_variable(xml): for pv in asearch.generateElementByNamePath(xml, "primary variable"): pv.setName("primary variable key") for pv in asearch.generateElementByNamePath(xml, "primary variable key"): if pv.value == "ponded_depth": pv.setValue("surface-ponded_depth") if pv.value == "snow_depth": pv.setValue("surface-snow_depth")
def primary_variable(xml): for pv in asearch.generateElementByNamePath(xml, "primary variable"): pv.setName("primary variable key") for pv in asearch.generateElementByNamePath(xml, "primary variable key"): if pv.value == "ponded_depth": pv.setValue("surface-ponded_depth") if pv.value == "snow_depth": pv.setValue("surface-snow_depth")
def snow_distribution(xml): for snow_dist_pk in asearch.generateElementByNamePath(xml, "PKs/snow distribution"): if snow_dist_pk.isElement("primary variable key") and \ asearch.childByName(snow_dist_pk,"primary variable key").get("value") == "surface-precipitation_snow": asearch.childByName(snow_dist_pk,"primary variable key").set("value", "snow-precipitation") if snow_dist_pk.isElement("conserved quantity key") and \ asearch.childByName(snow_dist_pk,"conserved quantity key").get("value") == "surface-precipitation_snow": asearch.childByName(snow_dist_pk,"conserved quantity key").set("value", "snow-precipitation") if snow_dist_pk.isElement("domain name") and \ asearch.childByName(snow_dist_pk,"domain name").get("value") == "surface": asearch.childByName(snow_dist_pk,"domain name").set("value", "snow") for ssk in asearch.generateElementByNamePath(xml, "state/field evaluators/snow-conductivity"): if ssk.isElement("height key"): asearch.childByName(ssk, "height key").set("value", "snow-precipitation")
def snow_depth(xml): for seb_pk in asearch.generateElementByNamePath(xml, "PKs/SEB"): if seb_pk.isElement("primary variable key") and \ asearch.childByName(seb_pk,"primary variable key").get("value") == "surface-snow_depth" and \ seb_pk.isElement("conserved quantity key") and \ asearch.childByName(seb_pk,"conserved quantity key").get("value") == "snow_depth": asearch.childByName(seb_pk,"conserved quantity key").set("value", "surface-snow_depth")
def fixSolvers(xml): for diff in search.generateElementByNamePath(xml, "Diffusion"): _fixDiffusion(diff, False, True) need_pc = True for pk in search.generateElementByNamePath(xml, "PK type"): if pk.get("value") == "new permafrost model no SC" or \ pk.get("value") == "subsurface permafrost" or \ pk.get("value") == "coupled water": need_pc = False for diff in search.generateElementByNamePath(xml, "Diffusion PC"): _fixDiffusion(diff, need_pc, True) for solver in search.generateElementByNamePath(xml, "Coupled PC"): _fixPC(solver.sublist("preconditioner"), "boomer amg", True) for solver in search.generateElementByNamePath(xml, "Coupled Solver"): _fixLinOp(solver)
def update(xml, clobber=True): for lin_op_list in asearch.generateElementByNamePath(xml, "linear solver"): if asearch.childByNamePath(lin_op_list, "iterative method").get("value") == "nka": lin_op_list.setParameter("iterative method", "string", "gmres") lin_op_list.pop("nka parameters") lin_op_list.append(get_gmres()) elif clobber and asearch.childByNamePath(lin_op_list, "iterative method").get("value") == "gmres": lin_op_list.pop("gmres parameters") lin_op_list.append(get_gmres())
def fixVerboseObject(xml): for vo in asearch.generateElementByNamePath(xml, "VerboseObject"): vo.set("name", "verbose object") try: vlev = asearch.childByNamePath(vo, "Verbosity Level") except aerrors.MissingXMLError: pass else: vlev.set("name", "verbosity level")
def write_new_xml(testname, testlog): """Adds the needed magic to a new xml file.""" print("Renaming: {0}.xml to {0}_orig.xml".format(testname), file=testlog) os.rename(testname + ".xml", testname + "_orig.xml") xml = aio.fromFile(testname + "_orig.xml", True) # vis by list of cycles try: vis = asearch.getElementByNamePath(xml, "visualization") except aerrors.MissingXMLError: pass else: for i in range(len(vis)): vis.pop(vis[0].get('name')) vis.setParameter("cycles", "Array(int)", find_vis_cycles(testname)) vis.setParameter("file name base", "string", "visdump") try: viss = asearch.getElementByNamePath(xml, "visualization surface") except aerrors.MissingXMLError: pass else: for i in range(len(viss)): viss.pop(viss[0].get('name')) viss.setParameter("cycles", "Array(int)", find_vis_cycles(testname)) viss.setParameter("file name base", "string", "visdump_surface") # update timestep controller, nonlinear solvers for ti in asearch.generateElementByNamePath(xml, "time integrator"): asearch.generateElementByNamePath( ti, "limit iterations").next().setValue(100) asearch.generateElementByNamePath( ti, "diverged tolerance").next().setValue(1.e10) asearch.getElementByNamePath( ti, "timestep controller type").setValue("from file") ts_hist = ti.sublist("timestep controller from file parameters") ts_hist.setParameter("file name", "string", "../data/{0}_dts.h5".format(testname)) print("Writing: {0}.xml".format(testname), file=testlog) aio.toFile(xml, "{0}.xml".format(testname))
def seepage_face_bcs(xml): for bclist in asearch.generateElementByNamePath(xml, "boundary conditions"): if bclist.isElement("seepage face"): agroup = bclist.sublist("seepage face")[0] if agroup.isElement("boundary pressure"): bclist.sublist("seepage face").set("name", "seepage face pressure") elif agroup.isElement("boundary head"): bclist.sublist("seepage face").set("name", "seepage face head") else: raise RuntimeError("unknown seepage condition")
def update(xml, clobber=True): for lin_op_list in asearch.generateElementByNamePath(xml, "linear solver"): if asearch.childByNamePath(lin_op_list, "iterative method").get("value") == "nka": lin_op_list.setParameter("iterative method", "string", "gmres") lin_op_list.pop("nka parameters") lin_op_list.append(get_gmres()) elif clobber and asearch.childByNamePath( lin_op_list, "iterative method").get("value") == "gmres": lin_op_list.pop("gmres parameters") lin_op_list.append(get_gmres())
def snow_distribution(xml): for snow_dist_pk in asearch.generateElementByNamePath( xml, "PKs/snow distribution"): if snow_dist_pk.isElement("primary variable key") and \ asearch.childByName(snow_dist_pk,"primary variable key").get("value") == "surface-precipitation_snow": asearch.childByName(snow_dist_pk, "primary variable key").set( "value", "snow-precipitation") if snow_dist_pk.isElement("conserved quantity key") and \ asearch.childByName(snow_dist_pk,"conserved quantity key").get("value") == "surface-precipitation_snow": asearch.childByName(snow_dist_pk, "conserved quantity key").set( "value", "snow-precipitation") if snow_dist_pk.isElement("domain name") and \ asearch.childByName(snow_dist_pk,"domain name").get("value") == "surface": asearch.childByName(snow_dist_pk, "domain name").set("value", "snow") for ssk in asearch.generateElementByNamePath( xml, "state/field evaluators/snow-conductivity"): if ssk.isElement("height key"): asearch.childByName(ssk, "height key").set("value", "snow-precipitation")
def lower_case(xml): """Converts an xml object, in-place""" try: regions = xml_search.getElementByNamePath(xml, "Regions") except xml_errors.MissingXMLError: pass else: for label in changes_regions: for param in xml_search.generateElementByNamePath(regions, label): param.set('name', label.lower()) for param in xml_search.generateElementByNamePath( xml, "Region: Plane/location"): param.set('name', 'point') for param in xml_search.generateElementByNamePath( xml, "Region: Plane/direction"): param.set('name', 'normal') regions.set('name', "regions") try: mesh = xml_search.getElementByNamePath(xml, "Mesh") except xml_errors.MissingXMLError: pass else: for label in changes_mesh: for param in xml_search.generateElementByNamePath(mesh, label): param.set('name', label.lower()) mesh.set('name', "mesh") try: domain = xml_search.getElementByNamePath(xml, "Domain") except xml_errors.MissingXMLError: pass else: xml.remove(domain)
def lower_case(xml): """Converts an xml object, in-place""" try: regions = xml_search.getElementByNamePath(xml, "Regions") except xml_errors.MissingXMLError: pass else: for label in changes_regions: for param in xml_search.generateElementByNamePath(regions, label): param.set('name', label.lower()) for param in xml_search.generateElementByNamePath(xml, "Region: Plane/location"): param.set('name', 'point') for param in xml_search.generateElementByNamePath(xml, "Region: Plane/direction"): param.set('name', 'normal') regions.set('name', "regions") try: mesh = xml_search.getElementByNamePath(xml, "Mesh") except xml_errors.MissingXMLError: pass else: for label in changes_mesh: for param in xml_search.generateElementByNamePath(mesh, label): param.set('name', label.lower()) mesh.set('name', "mesh") try: domain = xml_search.getElementByNamePath(xml, "Domain") except xml_errors.MissingXMLError: pass else: xml.remove(domain)
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 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 fixTIList(xml): for ti_list in search.generateElementByNamePath(xml, "time integrator"): _fixTIList(ti_list)
def compressibility(xml): for c in asearch.generateElementByNamePath(xml, "pore compressibility"): c.set("name", "pore compressibility [Pa^-1]")
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 end_time_units(xml): for end_time in asearch.generateElementByNamePath(xml, "cycle driver/end time units"): if end_time.get("value") == "yr": end_time.set("value", "y")
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 end_time_units(xml): for end_time in asearch.generateElementByNamePath( xml, "cycle driver/end time units"): if end_time.get("value") == "yr": end_time.set("value", "y")
def compressibility(xml): for c in asearch.generateElementByNamePath(xml, "pore compressibility"): c.set("name", "pore compressibility [Pa^-1]")
def diffusion(xml): for diff in asearch.generateElementByNamePath(xml, "Diffusion"): diff.set("name", "diffusion") for diff in asearch.generateElementByNamePath(xml, "Diffusion PC"): diff.set("name", "diffusion preconditioner")
def diffusion(xml): for diff in asearch.generateElementByNamePath(xml, "Diffusion"): diff.set("name", "diffusion") for diff in asearch.generateElementByNamePath(xml, "Diffusion PC"): diff.set("name", "diffusion preconditioner")