Index: /issm/branches/trunk-larour-SLPS2022/src/c/Makefile.am =================================================================== --- /issm/branches/trunk-larour-SLPS2022/src/c/Makefile.am (revision 27083) +++ /issm/branches/trunk-larour-SLPS2022/src/c/Makefile.am (revision 27084) @@ -278,4 +278,5 @@ ./cores/steadystate_core.cpp \ ./cores/masstransport_core.cpp \ + ./cores/mmemasstransport_core.cpp \ ./cores/oceantransport_core.cpp \ ./cores/depthaverage_core.cpp \ @@ -487,5 +488,6 @@ endif if MASSTRANSPORT -issm_sources += ./analyses/MasstransportAnalysis.cpp +issm_sources += ./analyses/MasstransportAnalysis.cpp \ + ./analyses/MmemasstransportAnalysis.cpp endif if OCEANTRANSPORT Index: /issm/branches/trunk-larour-SLPS2022/src/c/analyses/EnumToAnalysis.cpp =================================================================== --- /issm/branches/trunk-larour-SLPS2022/src/c/analyses/EnumToAnalysis.cpp (revision 27083) +++ /issm/branches/trunk-larour-SLPS2022/src/c/analyses/EnumToAnalysis.cpp (revision 27084) @@ -100,4 +100,5 @@ #ifdef _HAVE_MASSTRANSPORT_ case MasstransportAnalysisEnum : return new MasstransportAnalysis(); + case MmemasstransportAnalysisEnum : return new MmemasstransportAnalysis(); #endif #ifdef _HAVE_MELTING_ Index: /issm/branches/trunk-larour-SLPS2022/src/c/analyses/MmemasstransportAnalysis.cpp =================================================================== --- /issm/branches/trunk-larour-SLPS2022/src/c/analyses/MmemasstransportAnalysis.cpp (revision 27084) +++ /issm/branches/trunk-larour-SLPS2022/src/c/analyses/MmemasstransportAnalysis.cpp (revision 27084) @@ -0,0 +1,168 @@ +#include "./MmemasstransporttransportAnalysis.h" +#include +#include "../toolkits/toolkits.h" +#include "../classes/classes.h" +#include "../classes/Inputs/TransientInput.h" +#include "../shared/shared.h" +#include "../modules/modules.h" + +/*Model processing*/ +void MmemasstransporttransportAnalysis::CreateConstraints(Constraints* constraints,IoModel* iomodel){/*{{{*/ + /*No constraints*/ +}/*}}}*/ +void MmemasstransporttransportAnalysis::CreateLoads(Loads* loads, IoModel* iomodel){/*{{{*/ + /*No loads*/ +}/*}}}*/ +void MmemasstransporttransportAnalysis::CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr){/*{{{*/ + ::CreateNodes(nodes,iomodel,MmemasstransporttransportAnalysisEnum,P1Enum); +}/*}}}*/ +int MmemasstransporttransportAnalysis::DofsPerNode(int** doflist,int domaintype,int approximation){/*{{{*/ + return 3; +}/*}}}*/ +void MmemasstransporttransportAnalysis::UpdateElements(Elements* elements,Inputs* inputs,IoModel* iomodel,int analysis_counter,int analysis_type){/*{{{*/ + + int nature=0; + bool isdakota=0; + + /*Update elements: */ + int counter=0; + for(int i=0;inumberofelements;i++){ + if(iomodel->my_elements[i]){ + Element* element=(Element*)elements->GetObjectByOffset(counter); + element->Update(inputs,i,iomodel,analysis_counter,analysis_type,P1Enum); + counter++; + } + } + + /*Plug inputs into element:*/ + iomodel->FetchDataToInput(inputs,elements,"md.mmemasstransport.deltathickness", MmemasstransportDeltathicknessEnum); + + /*Initialize sea level cumulated sea level loads :*/ + iomodel->ConstantToInput(inputs,elements,0.,AccumulatedDeltaThicknessEnum,P0Enum); + iomodel->ConstantToInput(inputs,elements,0.,OldAccumulatedDeltaThicknessEnum,P0Enum); + +}/*}}}*/ +void MmemasstransporttransportAnalysis::UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum){/*{{{*/ + + int numoutputs; + char** requestedoutputs = NULL; + + /*Deal with multi-model ensembles: {{{*/ + + int nids,npart,nel; + IssmDouble* modelids=NULL; + IssmDouble* partition = NULL; + + iomodel->FetchData(&nel,"md.mesh.numberofelements"); + iomodel->FetchData(&modelids,&nids,NULL,"md.mmemasstransport.modelids"); + parameters->AddObject(new DoubleParam(MmemasstransportModelidsEnum,modelids,nids,1)); + iomodel->FetchData(&partition,&npart,NULL,"md.mmemasstransport.partition"); + if (npart!=nel)_error_("MmemasstransportAnalysis:UpdateParameters: partition vector should be distributed over elements, not vertices!"); + parameters->AddObject(new DoubleParam(MmemasstransportPartitionEnum,partition,nel,1)); + + xDelete(modelids); + xDelete(partition); + + } /*}}}*/ + /*Requested outputs {{{*/ + iomodel->FindConstant(&requestedoutputs,&numoutputs,"md.solidearth.requested_outputs"); + if(numoutputs)parameters->AddObject(new StringArrayParam(SealevelchangeRequestedOutputsEnum,requestedoutputs,numoutputs)); + iomodel->DeleteData(&requestedoutputs,numoutputs,"md.solidearth.requested_outputs"); + /*}}}*/ + +}/*}}}*/ + +/*Finite Element Analysis*/ +void MmemasstransporttransportAnalysis::Core(FemModel* femmodel){/*{{{*/ + _error_("not implemented"); +}/*}}}*/ +void MmemasstransporttransportAnalysis::PreCore(FemModel* femmodel){/*{{{*/ + _error_("not implemented"); +}/*}}}*/ +ElementVector* MmemasstransporttransportAnalysis::CreateDVector(Element* element){/*{{{*/ + /*Default, return NULL*/ + return NULL; +}/*}}}*/ +ElementMatrix* MmemasstransporttransportAnalysis::CreateJacobianMatrix(Element* element){/*{{{*/ +_error_("Not implemented"); +}/*}}}*/ +ElementMatrix* MmemasstransporttransportAnalysis::CreateKMatrix(Element* element){/*{{{*/ + _error_("not implemented yet"); +}/*}}}*/ +ElementVector* MmemasstransporttransportAnalysis::CreatePVector(Element* element){/*{{{*/ +_error_("not implemented yet"); +}/*}}}*/ +void MmemasstransporttransportAnalysis::GetSolutionFromInputs(Vector* solution,Element* element){/*{{{*/ + + /*retrieve thickness from MmemasstransporttransportAnalysis spcs in our element:*/ + + IssmDouble h; + int *doflist = NULL; + + /*Fetch number of nodes and initialize values*/ + int numnodes = element->GetNumberOfNodes(); + int numdof = numnodes; + IssmDouble* values = xNew(numdof); + + /*Get dof list and inputs */ + element->GetDofList(&doflist,NoneApproximationEnum,GsetEnum); + Input* dh_input=element->GetInput(MmemasstransportDeltathicknessEnum); _assert_(h_input); + + /*Ok, we have the thickness in inputs, fill in solution */ + Gauss* gauss=element->NewGauss(); + for(int i=0;iGaussVertex(i); + dh_input->GetInputValue(&dh,gauss); + values[i+0]=dh; + } + + /*Add value to global vector*/ + solution->SetValues(numdof,doflist,values,INS_VAL); + + /*Free ressources:*/ + delete gauss; + xDelete(doflist); + xDelete(values); +}/*}}}*/ +void MmemasstransporttransportAnalysis::GradientJ(Vector* gradient,Element* element,int control_type,int control_interp,int control_index){/*{{{*/ + _error_("Not implemented yet"); +}/*}}}*/ +void MmemasstransporttransportAnalysis::InputUpdateFromSolution(IssmDouble* solution,Element* element){/*{{{*/ + + int i,domaintype; + int* doflist=NULL; + + /*Fetch number of nodes and dof for this finite element*/ + int numnodes = element->GetNumberOfNodes(); + int numdof = numnodes; + + /*Fetch dof list and allocate solution vectors*/ + element->GetDofListLocal(&doflist,NoneApproximationEnum,GsetEnum); + IssmDouble* values = xNew(numdof); + IssmDouble* h = xNew(numnodes); + + /*Use the dof list to index into the solution vector: */ + for(i=0;i(h[i])) _error_("NaN found in bottom pressure solution vector"); + if(xIsInf(h[i])) _error_("Inf found in bottom pressure solution vector"); + } + + /*Add bp, dsl and str as inputs to the tria element: */ + element->AddInput(ThicknessEnum,h,P1Enum); + + /*Free ressources:*/ + xDelete(h); + xDelete(values); + xDelete(doflist); + +}/*}}}*/ +void MmemasstransporttransportAnalysis::UpdateConstraints(FemModel* femmodel){/*{{{*/ + /*Default, do nothing*/ + return; +}/*}}}*/ Index: /issm/branches/trunk-larour-SLPS2022/src/c/analyses/MmemasstransportAnalysis.h =================================================================== --- /issm/branches/trunk-larour-SLPS2022/src/c/analyses/MmemasstransportAnalysis.h (revision 27084) +++ /issm/branches/trunk-larour-SLPS2022/src/c/analyses/MmemasstransportAnalysis.h (revision 27084) @@ -0,0 +1,34 @@ +/*! \file MmemasstransportAnalysis.h + * \brief: header file for generic external result object + */ + +#ifndef _MmemasstransportAnalysis_ +#define _MmemasstransportAnalysis_ + +/*Headers*/ +#include "./Analysis.h" + +class MmemasstransportAnalysis: public Analysis{ + + public: + /*Model processing*/ + void CreateConstraints(Constraints* constraints,IoModel* iomodel); + void CreateLoads(Loads* loads, IoModel* iomodel); + void CreateNodes(Nodes* nodes,IoModel* iomodel,bool isamr=false); + int DofsPerNode(int** doflist,int domaintype,int approximation); + void UpdateElements(Elements* elements,Inputs* inputs,IoModel* iomodel,int analysis_counter,int analysis_type); + void UpdateParameters(Parameters* parameters,IoModel* iomodel,int solution_enum,int analysis_enum); + + /*Finite element Analysis*/ + void Core(FemModel* femmodel); + void PreCore(FemModel* femmodel); + ElementVector* CreateDVector(Element* element); + ElementMatrix* CreateJacobianMatrix(Element* element); + ElementMatrix* CreateKMatrix(Element* element); + ElementVector* CreatePVector(Element* element); + void GetSolutionFromInputs(Vector* solution,Element* element); + void GradientJ(Vector* gradient,Element* element,int control_type,int control_interp,int control_index); + void InputUpdateFromSolution(IssmDouble* solution,Element* element); + void UpdateConstraints(FemModel* femmodel); +}; +#endif Index: /issm/branches/trunk-larour-SLPS2022/src/c/analyses/SealevelchangeAnalysis.cpp =================================================================== --- /issm/branches/trunk-larour-SLPS2022/src/c/analyses/SealevelchangeAnalysis.cpp (revision 27083) +++ /issm/branches/trunk-larour-SLPS2022/src/c/analyses/SealevelchangeAnalysis.cpp (revision 27084) @@ -24,4 +24,5 @@ int isexternal=0; + int horiz=0; /*Update elements: */ @@ -43,7 +44,9 @@ iomodel->FetchData(&isexternal,"md.solidearth.isexternal"); if(isexternal){ - - iomodel->FetchDataToInput(inputs,elements,"md.solidearth.external.displacementeast",SolidearthExternalDisplacementEastRateEnum); - iomodel->FetchDataToInput(inputs,elements,"md.solidearth.external.displacementnorth",SolidearthExternalDisplacementNorthRateEnum); + iomodel->FetchData(&horiz,"md.solidearth.settings.horiz"); + if(horiz){ + iomodel->FetchDataToInput(inputs,elements,"md.solidearth.external.displacementeast",SolidearthExternalDisplacementEastRateEnum); + iomodel->FetchDataToInput(inputs,elements,"md.solidearth.external.displacementnorth",SolidearthExternalDisplacementNorthRateEnum); + } iomodel->FetchDataToInput(inputs,elements,"md.solidearth.external.displacementup",SolidearthExternalDisplacementUpRateEnum); iomodel->FetchDataToInput(inputs,elements,"md.solidearth.external.geoid",SolidearthExternalGeoidRateEnum); Index: /issm/branches/trunk-larour-SLPS2022/src/c/analyses/analyses.h =================================================================== --- /issm/branches/trunk-larour-SLPS2022/src/c/analyses/analyses.h (revision 27083) +++ /issm/branches/trunk-larour-SLPS2022/src/c/analyses/analyses.h (revision 27084) @@ -35,4 +35,5 @@ #include "./LevelsetAnalysis.h" #include "./MasstransportAnalysis.h" +#include "./MmemasstransportAnalysis.h" #include "./OceantransportAnalysis.h" #include "./SamplingAnalysis.h" Index: /issm/branches/trunk-larour-SLPS2022/src/c/classes/FemModel.cpp =================================================================== --- /issm/branches/trunk-larour-SLPS2022/src/c/classes/FemModel.cpp (revision 27083) +++ /issm/branches/trunk-larour-SLPS2022/src/c/classes/FemModel.cpp (revision 27084) @@ -851,8 +851,9 @@ case TransientSolutionEnum:{ /*We have multiple analyses here, process one by one*/ - bool isSIA,isFS,isthermal,isenthalpy,ismasstransport,isoceantransport,isgroundingline,isstressbalance,ismovingfront,ishydrology,isdamage,issmb,isslc,isesa,issampling; + bool isSIA,isFS,isthermal,isenthalpy,ismasstransport,ismmemasstransport,isoceantransport,isgroundingline,isstressbalance,ismovingfront,ishydrology,isdamage,issmb,isslc,isesa,issampling; iomodel->FindConstant(&isthermal,"md.transient.isthermal"); iomodel->FindConstant(&ismovingfront,"md.transient.ismovingfront"); iomodel->FindConstant(&ismasstransport,"md.transient.ismasstransport"); + iomodel->FindConstant(&ismmemasstransport,"md.transient.ismmemasstransport"); iomodel->FindConstant(&isoceantransport,"md.transient.isoceantransport"); iomodel->FindConstant(&isstressbalance,"md.transient.isstressbalance"); @@ -900,4 +901,7 @@ if(isdamage){ analyses_temp[numanalyses++]=DamageEvolutionAnalysisEnum; + } + if(ismmemasstransport){ + analyses_temp[numanalyses++]=MmemasstransportAnalysisEnum; } if(isoceantransport){ Index: /issm/branches/trunk-larour-SLPS2022/src/c/cores/CorePointerFromSolutionEnum.cpp =================================================================== --- /issm/branches/trunk-larour-SLPS2022/src/c/cores/CorePointerFromSolutionEnum.cpp (revision 27083) +++ /issm/branches/trunk-larour-SLPS2022/src/c/cores/CorePointerFromSolutionEnum.cpp (revision 27084) @@ -59,4 +59,7 @@ solutioncore=&masstransport_core; break; + case MmemasstransportSolutionEnum: + solutioncore=&mmemasstransport_core; + break; case OceantransportSolutionEnum: solutioncore=&oceantransport_core; Index: /issm/branches/trunk-larour-SLPS2022/src/c/cores/cores.h =================================================================== --- /issm/branches/trunk-larour-SLPS2022/src/c/cores/cores.h (revision 27083) +++ /issm/branches/trunk-larour-SLPS2022/src/c/cores/cores.h (revision 27084) @@ -35,4 +35,5 @@ void controlvalidation_core(FemModel* femmodel); void masstransport_core(FemModel* femmodel); +void mmemasstransport_core(FemModel* femmodel); void oceantransport_core(FemModel* femmodel); void depthaverage_core(FemModel* femmodel); Index: /issm/branches/trunk-larour-SLPS2022/src/c/cores/masstransport_core.cpp =================================================================== --- /issm/branches/trunk-larour-SLPS2022/src/c/cores/masstransport_core.cpp (revision 27083) +++ /issm/branches/trunk-larour-SLPS2022/src/c/cores/masstransport_core.cpp (revision 27084) @@ -125,5 +125,5 @@ /*for Ivins deformation model, keep history of ice thickness changes inside TransientAccumulatedDeltaIceThicknessEnum:*/ - if(grdmodel==IvinsEnum){ + if(grdmodel==IvinsEnum){ /*{{{*/ TransientInput* transientinput = femmodel->inputs->GetTransientInput(TransientAccumulatedDeltaIceThicknessEnum); @@ -153,5 +153,5 @@ xDelete(cumdeltathickness); } - } + } /*}}}*/ /*compute total ice thickness change between two sea-level solver time steps, ie. every frequency*dt:*/ Index: /issm/branches/trunk-larour-SLPS2022/src/c/cores/mmemasstransport_core.cpp =================================================================== --- /issm/branches/trunk-larour-SLPS2022/src/c/cores/mmemasstransport_core.cpp (revision 27084) +++ /issm/branches/trunk-larour-SLPS2022/src/c/cores/mmemasstransport_core.cpp (revision 27084) @@ -0,0 +1,69 @@ +/*!\file: mmemasstransport_core.cpp + * \brief: core of the mmemasstransport solution + */ + +#include "./cores.h" +#include "../toolkits/toolkits.h" +#include "../classes/classes.h" +#include "../shared/shared.h" +#include "../modules/modules.h" +#include "../solutionsequences/solutionsequences.h" + +void SolidEarthMmemasstransportUpdates(FemModel* femmodel); +void mmemasstransport_core(FemModel* femmodel){ /*{{{*/ + + /*Start profiler*/ + femmodel->profiler->Start(OCEANTRANSPORTCORE); + + /*parameters: */ + int numoutputs; + bool save_results; + bool dakota_analysis; + int solution_type; + Vector* ug = NULL; + + /*activate configuration*/ + femmodel->SetCurrentConfiguration(MmemasstransportAnalysisEnum); + + /*recover parameters: */ + femmodel->parameters->FindParam(&save_results,SaveResultsEnum); + femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum); + + if(VerboseSolution()) _printf0_(" computing MME mass transport\n"); + + /*grab delta thickness from MmemasstransportDeltathicknessEnum inputs in each element, assemble into a vector and feed to + * InputUpdateFromSolutionx which will deal with accumulating such inputs:*/ + GetSolutionFromInputsx(&ug,femmodel); + InputUpdateFromSolutionx(femmodel,ug); + + SolidEarthMmemasstransportUpdates(femmodel); + + if(solution_type==MmemasstransportSolutionEnum)femmodel->RequestedDependentsx(); + + /*profiler*/ + femmodel->profiler->Stop(MMEMASSTRANSPORTCORE); + + /*free ressources:*/ + delete ug; + +} /*}}}*/ +void SolidEarthMmemasstransportUpdates(FemModel* femmodel){ /*{{{*/ + + IssmDouble time; + int frequency,count; + + /*retrieve parameters:*/ + femmodel->parameters->FindParam(&time,TimeEnum); + femmodel->parameters->FindParam(&frequency,SolidearthSettingsRunFrequencyEnum); + femmodel->parameters->FindParam(&count,SealevelchangeRunCountEnum); + + /* Accumulate delta thikcness: */ + femmodel->inputs->AXPY(+1, DeltaThicknessEnum,AccumulatedDeltaThicknessEnum); + + /* Compute total thickness change between two sea-level solver time steps, ie. every frequency*dt. */ + if(count==frequency){ + femmodel->inputs->ZAXPY(-1, OldAccumulatedDeltaThicknessEnum,AccumulatedDeltaThicknessEnum,DeltaThicknessEnum); + femmodel->inputs->DuplicateInput(AccumulatedDeltaThicknessEnum,OldAccumulatedDeltaThicknessEnum); + } + return; +}/*}}}*/ Index: /issm/branches/trunk-larour-SLPS2022/src/c/cores/oceantransport_core.cpp =================================================================== --- /issm/branches/trunk-larour-SLPS2022/src/c/cores/oceantransport_core.cpp (revision 27083) +++ /issm/branches/trunk-larour-SLPS2022/src/c/cores/oceantransport_core.cpp (revision 27084) @@ -31,6 +31,4 @@ if(VerboseSolution()) _printf0_(" computing ocean mass transport\n"); - - femmodel->SetCurrentConfiguration(OceantransportAnalysisEnum); /*save current bottom pressures before updating:*/ @@ -71,5 +69,5 @@ /*early return?:*/ - if(!isgrd)return; + //if(!isgrd)return; //I don't think so, why should ocean transport worry about grd? /* From old and new bottom pressures, create delta bottom pressure, delta dsl and delta str. Index: /issm/branches/trunk-larour-SLPS2022/src/c/cores/transient_core.cpp =================================================================== --- /issm/branches/trunk-larour-SLPS2022/src/c/cores/transient_core.cpp (revision 27083) +++ /issm/branches/trunk-larour-SLPS2022/src/c/cores/transient_core.cpp (revision 27084) @@ -130,5 +130,5 @@ /*parameters: */ - bool isstressbalance,ismasstransport,isoceantransport,issmb,isthermal,isgroundingline,isesa,issampling;; + bool isstressbalance,ismasstransport,ismmemasstransport,isoceantransport,issmb,isthermal,isgroundingline,isesa,issampling;; bool isslc,ismovingfront,isdamageevolution,ishydrology,isoceancoupling,isstochasticforcing,save_results; int step,sb_coupling_frequency; @@ -142,4 +142,5 @@ femmodel->parameters->FindParam(&isstressbalance,TransientIsstressbalanceEnum); femmodel->parameters->FindParam(&ismasstransport,TransientIsmasstransportEnum); + femmodel->parameters->FindParam(&ismmemasstransport,TransientIsMmemasstransportEnum); femmodel->parameters->FindParam(&isoceantransport,TransientIsoceantransportEnum); femmodel->parameters->FindParam(&issmb,TransientIssmbEnum); @@ -214,4 +215,7 @@ femmodel->UpdateVertexPositionsx(); } + if(ismmemasstransport){ + mmemasstransport_core(femmodel); + } if(isoceantransport){ Index: /issm/branches/trunk-larour-SLPS2022/src/c/modules/UpdateMmesx/UpdateMmesx.cpp =================================================================== --- /issm/branches/trunk-larour-SLPS2022/src/c/modules/UpdateMmesx/UpdateMmesx.cpp (revision 27083) +++ /issm/branches/trunk-larour-SLPS2022/src/c/modules/UpdateMmesx/UpdateMmesx.cpp (revision 27084) @@ -10,10 +10,11 @@ if(VerboseModule()) _printf0_(" Updating Mmes\n"); - IssmDouble modelid=0; - /*Deal with solid earth: */ + /*Deal with solid earth external: {{{*/ if (femmodel->inputs->Exist(SolidearthExternalDisplacementEastRateEnum) && femmodel->inputs->GetInputObjectEnum(SolidearthExternalDisplacementEastRateEnum)==DatasetInputEnum){ + + IssmDouble modelid=0; femmodel->parameters->FindParam(&modelid,SolidearthExternalModelidEnum); - + /*replace dataset of forcings with only one, the modelid'th:*/ MmeToInputFromIdx(femmodel->inputs,femmodel->elements,femmodel->parameters,modelid-1,SolidearthExternalDisplacementNorthRateEnum, P1Enum); @@ -22,7 +23,9 @@ MmeToInputFromIdx(femmodel->inputs,femmodel->elements,femmodel->parameters,modelid-1,SolidearthExternalGeoidRateEnum, P1Enum); - } - /*Deal with ocean: */ + } /*}}}*/ + /*Deal with ocean: {{{*/ if (femmodel->inputs->Exist(OceantransportSpcbottompressureEnum) && femmodel->inputs->GetInputObjectEnum(OceantransportSpcbottompressureEnum)==DatasetInputEnum){ + + IssmDouble modelid=0; femmodel->parameters->FindParam(&modelid,DslModelidEnum); @@ -31,5 +34,31 @@ MmeToInputFromIdx(femmodel->inputs,femmodel->elements,femmodel->parameters,modelid-1,OceantransportSpcdslEnum, P1Enum); MmeToInputFromIdx(femmodel->inputs,femmodel->elements,femmodel->parameters,modelid-1,OceantransportSpcstrEnum, P0Enum); - } + } /*}}}*/ + if (femmodel->inputs->Exist(MmemasstransportThicknessEnum) && femmodel->inputs->GetInputObjectEnum(MmemasstransportThicknessEnum)==DatasetInputEnum){ /*{{{*/ + + /*Deal with solid earth ice loads: */ + + int nids; + IssmDouble* modelids=NULL; + IssmDouble* partition = NULL; + + /*retrieve partition vector and model ids necessary to resolve our thickness:*/ + femmodel->parameters->FindParam(&modelids,&nids,NULL,MmemasstransportModelidsEnum); + femmodel->parameters->FindParam(&partition,NULL,NULL,MmemasstransportPartitionEnum); + + MmeToInput(femmodel,modelids,partition,nids,MmemasstransportThicknessEnum, P0Enum); + + if (femmodel->inputs->GetInputObjectEnum(MaskIceLevelsetEnum)==DatasetInputEnum) + MmeToInput(femmodel,modelids,partition,nids,MaskIceLevelsetEnum, P1Enum); + + if (femmodel->inputs->GetInputObjectEnum(MaskOceanLevelsetEnum)==DatasetInputEnum) + MmeToInput(femmodel,modelids,partition,nids,MaskOceanLevelsetEnum, P1Enum); + + /*free ressources:*/ + xDelete(modelids); + xDelete(partition); + + + } /*}}}*/ } Index: /issm/branches/trunk-larour-SLPS2022/src/c/shared/Enum/Enum.vim =================================================================== --- /issm/branches/trunk-larour-SLPS2022/src/c/shared/Enum/Enum.vim (revision 27083) +++ /issm/branches/trunk-larour-SLPS2022/src/c/shared/Enum/Enum.vim (revision 27084) @@ -309,4 +309,6 @@ syn keyword cConstant MasstransportRequestedOutputsEnum syn keyword cConstant MasstransportStabilizationEnum +syn keyword cConstant MmemasstransportModelidsEnum +syn keyword cConstant MmemasstransportPartitionEnum syn keyword cConstant MaterialsBetaEnum syn keyword cConstant MaterialsEarthDensityEnum @@ -571,4 +573,5 @@ syn keyword cConstant TransientIshydrologyEnum syn keyword cConstant TransientIsmasstransportEnum +syn keyword cConstant TransientIsmmemasstransportEnum syn keyword cConstant TransientIsoceantransportEnum syn keyword cConstant TransientIsmovingfrontEnum @@ -805,4 +808,5 @@ syn keyword cConstant MaskIceRefLevelsetEnum syn keyword cConstant MasstransportSpcthicknessEnum +syn keyword cConstant MmemasstransportDeltathicknessEnum syn keyword cConstant MaterialsRheologyBEnum syn keyword cConstant MaterialsRheologyBbarEnum @@ -1419,4 +1423,6 @@ syn keyword cConstant MassfluxatgateEnum syn keyword cConstant MasstransportAnalysisEnum +syn keyword cConstant MmemasstransportAnalysisEnum +syn keyword cConstant MmemasstransportSolutionEnum syn keyword cConstant MasstransportSolutionEnum syn keyword cConstant MatdamageiceEnum @@ -1624,5 +1630,4 @@ syn keyword cType Cfsurfacesquare syn keyword cType Channel -syn keyword cType classes syn keyword cType Constraint syn keyword cType Constraints @@ -1631,6 +1636,6 @@ syn keyword cType ControlInput syn keyword cType Covertree +syn keyword cType DataSetParam syn keyword cType DatasetInput -syn keyword cType DataSetParam syn keyword cType Definition syn keyword cType DependentObject @@ -1645,6 +1650,6 @@ syn keyword cType ElementInput syn keyword cType ElementMatrix +syn keyword cType ElementVector syn keyword cType Elements -syn keyword cType ElementVector syn keyword cType ExponentialVariogram syn keyword cType ExternalResult @@ -1653,10 +1658,9 @@ syn keyword cType Friction syn keyword cType Gauss -syn keyword cType GaussianVariogram -syn keyword cType gaussobjects syn keyword cType GaussPenta syn keyword cType GaussSeg syn keyword cType GaussTetra syn keyword cType GaussTria +syn keyword cType GaussianVariogram syn keyword cType GenericExternalResult syn keyword cType GenericOption @@ -1674,5 +1678,4 @@ syn keyword cType IssmDirectApplicInterface syn keyword cType IssmParallelDirectApplicInterface -syn keyword cType krigingobjects syn keyword cType Load syn keyword cType Loads @@ -1685,5 +1688,4 @@ syn keyword cType Matice syn keyword cType Matlitho -syn keyword cType matrixobjects syn keyword cType MatrixParam syn keyword cType Misfit @@ -1698,6 +1700,6 @@ syn keyword cType Observations syn keyword cType Option +syn keyword cType OptionUtilities syn keyword cType Options -syn keyword cType OptionUtilities syn keyword cType Param syn keyword cType Parameters @@ -1713,11 +1715,11 @@ syn keyword cType Regionaloutput syn keyword cType Results +syn keyword cType RiftStruct syn keyword cType Riftfront -syn keyword cType RiftStruct syn keyword cType SealevelGeometry syn keyword cType Seg syn keyword cType SegInput +syn keyword cType SegRef syn keyword cType Segment -syn keyword cType SegRef syn keyword cType SpcDynamic syn keyword cType SpcStatic @@ -1738,4 +1740,8 @@ syn keyword cType Vertex syn keyword cType Vertices +syn keyword cType classes +syn keyword cType gaussobjects +syn keyword cType krigingobjects +syn keyword cType matrixobjects syn keyword cType AdjointBalancethickness2Analysis syn keyword cType AdjointBalancethicknessAnalysis Index: /issm/branches/trunk-larour-SLPS2022/src/c/shared/Enum/EnumDefinitions.h =================================================================== --- /issm/branches/trunk-larour-SLPS2022/src/c/shared/Enum/EnumDefinitions.h (revision 27083) +++ /issm/branches/trunk-larour-SLPS2022/src/c/shared/Enum/EnumDefinitions.h (revision 27084) @@ -303,4 +303,6 @@ MasstransportRequestedOutputsEnum, MasstransportStabilizationEnum, + MmemasstransportModelidsEnum, + MmemasstransportPartitionEnum, MaterialsBetaEnum, MaterialsEarthDensityEnum, @@ -565,4 +567,5 @@ TransientIshydrologyEnum, TransientIsmasstransportEnum, + TransientIsmmemasstransportEnum, TransientIsoceantransportEnum, TransientIsmovingfrontEnum, @@ -801,4 +804,5 @@ MaskIceRefLevelsetEnum, MasstransportSpcthicknessEnum, + MmemasstransportDeltathicknessEnum, MaterialsRheologyBEnum, MaterialsRheologyBbarEnum, @@ -1418,4 +1422,6 @@ MassfluxatgateEnum, MasstransportAnalysisEnum, + MmemasstransportAnalysisEnum, + MmemasstransportSolutionEnum, MasstransportSolutionEnum, MatdamageiceEnum, Index: /issm/branches/trunk-larour-SLPS2022/src/c/shared/Enum/EnumToStringx.cpp =================================================================== --- /issm/branches/trunk-larour-SLPS2022/src/c/shared/Enum/EnumToStringx.cpp (revision 27083) +++ /issm/branches/trunk-larour-SLPS2022/src/c/shared/Enum/EnumToStringx.cpp (revision 27084) @@ -311,4 +311,6 @@ case MasstransportRequestedOutputsEnum : return "MasstransportRequestedOutputs"; case MasstransportStabilizationEnum : return "MasstransportStabilization"; + case MmemasstransportModelidsEnum : return "MmemasstransportModelids"; + case MmemasstransportPartitionEnum : return "MmemasstransportPartition"; case MaterialsBetaEnum : return "MaterialsBeta"; case MaterialsEarthDensityEnum : return "MaterialsEarthDensity"; @@ -573,4 +575,5 @@ case TransientIshydrologyEnum : return "TransientIshydrology"; case TransientIsmasstransportEnum : return "TransientIsmasstransport"; + case TransientIsmmemasstransportEnum : return "TransientIsmmemasstransport"; case TransientIsoceantransportEnum : return "TransientIsoceantransport"; case TransientIsmovingfrontEnum : return "TransientIsmovingfront"; @@ -807,4 +810,5 @@ case MaskIceRefLevelsetEnum : return "MaskIceRefLevelset"; case MasstransportSpcthicknessEnum : return "MasstransportSpcthickness"; + case MmemasstransportDeltathicknessEnum : return "MmemasstransportDeltathickness"; case MaterialsRheologyBEnum : return "MaterialsRheologyB"; case MaterialsRheologyBbarEnum : return "MaterialsRheologyBbar"; @@ -1421,4 +1425,6 @@ case MassfluxatgateEnum : return "Massfluxatgate"; case MasstransportAnalysisEnum : return "MasstransportAnalysis"; + case MmemasstransportAnalysisEnum : return "MmemasstransportAnalysis"; + case MmemasstransportSolutionEnum : return "MmemasstransportSolution"; case MasstransportSolutionEnum : return "MasstransportSolution"; case MatdamageiceEnum : return "Matdamageice"; Index: /issm/branches/trunk-larour-SLPS2022/src/c/shared/Enum/Enumjl.vim =================================================================== --- /issm/branches/trunk-larour-SLPS2022/src/c/shared/Enum/Enumjl.vim (revision 27083) +++ /issm/branches/trunk-larour-SLPS2022/src/c/shared/Enum/Enumjl.vim (revision 27084) @@ -302,4 +302,6 @@ syn keyword juliaConstC MasstransportRequestedOutputsEnum syn keyword juliaConstC MasstransportStabilizationEnum +syn keyword juliaConstC MmemasstransportModelidsEnum +syn keyword juliaConstC MmemasstransportPartitionEnum syn keyword juliaConstC MaterialsBetaEnum syn keyword juliaConstC MaterialsEarthDensityEnum @@ -564,4 +566,5 @@ syn keyword juliaConstC TransientIshydrologyEnum syn keyword juliaConstC TransientIsmasstransportEnum +syn keyword juliaConstC TransientIsmmemasstransportEnum syn keyword juliaConstC TransientIsoceantransportEnum syn keyword juliaConstC TransientIsmovingfrontEnum @@ -798,4 +801,5 @@ syn keyword juliaConstC MaskIceRefLevelsetEnum syn keyword juliaConstC MasstransportSpcthicknessEnum +syn keyword juliaConstC MmemasstransportDeltathicknessEnum syn keyword juliaConstC MaterialsRheologyBEnum syn keyword juliaConstC MaterialsRheologyBbarEnum @@ -1412,4 +1416,6 @@ syn keyword juliaConstC MassfluxatgateEnum syn keyword juliaConstC MasstransportAnalysisEnum +syn keyword juliaConstC MmemasstransportAnalysisEnum +syn keyword juliaConstC MmemasstransportSolutionEnum syn keyword juliaConstC MasstransportSolutionEnum syn keyword juliaConstC MatdamageiceEnum Index: /issm/branches/trunk-larour-SLPS2022/src/c/shared/Enum/StringToEnumx.cpp =================================================================== --- /issm/branches/trunk-larour-SLPS2022/src/c/shared/Enum/StringToEnumx.cpp (revision 27083) +++ /issm/branches/trunk-larour-SLPS2022/src/c/shared/Enum/StringToEnumx.cpp (revision 27084) @@ -317,4 +317,6 @@ else if (strcmp(name,"MasstransportRequestedOutputs")==0) return MasstransportRequestedOutputsEnum; else if (strcmp(name,"MasstransportStabilization")==0) return MasstransportStabilizationEnum; + else if (strcmp(name,"MmemasstransportModelids")==0) return MmemasstransportModelidsEnum; + else if (strcmp(name,"MmemasstransportPartition")==0) return MmemasstransportPartitionEnum; else if (strcmp(name,"MaterialsBeta")==0) return MaterialsBetaEnum; else if (strcmp(name,"MaterialsEarthDensity")==0) return MaterialsEarthDensityEnum; @@ -381,10 +383,10 @@ else if (strcmp(name,"SamplingRobin")==0) return SamplingRobinEnum; else if (strcmp(name,"SamplingSeed")==0) return SamplingSeedEnum; - else if (strcmp(name,"SaveResults")==0) return SaveResultsEnum; - else if (strcmp(name,"SolidearthPartitionIce")==0) return SolidearthPartitionIceEnum; else stage=4; } if(stage==4){ - if (strcmp(name,"SolidearthPartitionHydro")==0) return SolidearthPartitionHydroEnum; + if (strcmp(name,"SaveResults")==0) return SaveResultsEnum; + else if (strcmp(name,"SolidearthPartitionIce")==0) return SolidearthPartitionIceEnum; + else if (strcmp(name,"SolidearthPartitionHydro")==0) return SolidearthPartitionHydroEnum; else if (strcmp(name,"SolidearthPartitionOcean")==0) return SolidearthPartitionOceanEnum; else if (strcmp(name,"SolidearthNpartIce")==0) return SolidearthNpartIceEnum; @@ -504,10 +506,10 @@ else if (strcmp(name,"SmbIsturbulentflux")==0) return SmbIsturbulentfluxEnum; else if (strcmp(name,"SmbK")==0) return SmbKEnum; - else if (strcmp(name,"SmbLapseRates")==0) return SmbLapseRatesEnum; - else if (strcmp(name,"SmbNumBasins")==0) return SmbNumBasinsEnum; else stage=5; } if(stage==5){ - if (strcmp(name,"SmbNumElevationBins")==0) return SmbNumElevationBinsEnum; + if (strcmp(name,"SmbLapseRates")==0) return SmbLapseRatesEnum; + else if (strcmp(name,"SmbNumBasins")==0) return SmbNumBasinsEnum; + else if (strcmp(name,"SmbNumElevationBins")==0) return SmbNumElevationBinsEnum; else if (strcmp(name,"SmbNumRequestedOutputs")==0) return SmbNumRequestedOutputsEnum; else if (strcmp(name,"SmbPfac")==0) return SmbPfacEnum; @@ -585,4 +587,5 @@ else if (strcmp(name,"TransientIshydrology")==0) return TransientIshydrologyEnum; else if (strcmp(name,"TransientIsmasstransport")==0) return TransientIsmasstransportEnum; + else if (strcmp(name,"TransientIsmmemasstransport")==0) return TransientIsmmemasstransportEnum; else if (strcmp(name,"TransientIsoceantransport")==0) return TransientIsoceantransportEnum; else if (strcmp(name,"TransientIsmovingfront")==0) return TransientIsmovingfrontEnum; @@ -626,11 +629,11 @@ else if (strcmp(name,"BasalforcingsDeepwaterMeltingRateNoise")==0) return BasalforcingsDeepwaterMeltingRateNoiseEnum; else if (strcmp(name,"BasalforcingsDeepwaterMeltingRateValuesAutoregression")==0) return BasalforcingsDeepwaterMeltingRateValuesAutoregressionEnum; - else if (strcmp(name,"BasalforcingsFloatingiceMeltingRate")==0) return BasalforcingsFloatingiceMeltingRateEnum; - else if (strcmp(name,"BasalforcingsGeothermalflux")==0) return BasalforcingsGeothermalfluxEnum; - else if (strcmp(name,"BasalforcingsGroundediceMeltingRate")==0) return BasalforcingsGroundediceMeltingRateEnum; else stage=6; } if(stage==6){ - if (strcmp(name,"BasalforcingsLinearBasinId")==0) return BasalforcingsLinearBasinIdEnum; + if (strcmp(name,"BasalforcingsFloatingiceMeltingRate")==0) return BasalforcingsFloatingiceMeltingRateEnum; + else if (strcmp(name,"BasalforcingsGeothermalflux")==0) return BasalforcingsGeothermalfluxEnum; + else if (strcmp(name,"BasalforcingsGroundediceMeltingRate")==0) return BasalforcingsGroundediceMeltingRateEnum; + else if (strcmp(name,"BasalforcingsLinearBasinId")==0) return BasalforcingsLinearBasinIdEnum; else if (strcmp(name,"BasalforcingsPerturbationMeltingRate")==0) return BasalforcingsPerturbationMeltingRateEnum; else if (strcmp(name,"BasalforcingsSpatialDeepwaterElevation")==0) return BasalforcingsSpatialDeepwaterElevationEnum; @@ -749,11 +752,11 @@ else if (strcmp(name,"FrictionCoefficientcoulomb")==0) return FrictionCoefficientcoulombEnum; else if (strcmp(name,"FrictionEffectivePressure")==0) return FrictionEffectivePressureEnum; - else if (strcmp(name,"FrictionM")==0) return FrictionMEnum; - else if (strcmp(name,"FrictionP")==0) return FrictionPEnum; - else if (strcmp(name,"FrictionPressureAdjustedTemperature")==0) return FrictionPressureAdjustedTemperatureEnum; else stage=7; } if(stage==7){ - if (strcmp(name,"FrictionQ")==0) return FrictionQEnum; + if (strcmp(name,"FrictionM")==0) return FrictionMEnum; + else if (strcmp(name,"FrictionP")==0) return FrictionPEnum; + else if (strcmp(name,"FrictionPressureAdjustedTemperature")==0) return FrictionPressureAdjustedTemperatureEnum; + else if (strcmp(name,"FrictionQ")==0) return FrictionQEnum; else if (strcmp(name,"FrictionSedimentCompressibilityCoefficient")==0) return FrictionSedimentCompressibilityCoefficientEnum; else if (strcmp(name,"FrictionTillFrictionAngle")==0) return FrictionTillFrictionAngleEnum; @@ -825,4 +828,5 @@ else if (strcmp(name,"MaskIceRefLevelset")==0) return MaskIceRefLevelsetEnum; else if (strcmp(name,"MasstransportSpcthickness")==0) return MasstransportSpcthicknessEnum; + else if (strcmp(name,"MmemasstransportDeltathickness")==0) return MmemasstransportDeltathicknessEnum; else if (strcmp(name,"MaterialsRheologyB")==0) return MaterialsRheologyBEnum; else if (strcmp(name,"MaterialsRheologyBbar")==0) return MaterialsRheologyBbarEnum; @@ -871,12 +875,12 @@ else if (strcmp(name,"Sealevel")==0) return SealevelEnum; else if (strcmp(name,"SealevelGRD")==0) return SealevelGRDEnum; - else if (strcmp(name,"SealevelBarystaticMask")==0) return SealevelBarystaticMaskEnum; + else stage=8; + } + if(stage==8){ + if (strcmp(name,"SealevelBarystaticMask")==0) return SealevelBarystaticMaskEnum; else if (strcmp(name,"SealevelBarystaticIceMask")==0) return SealevelBarystaticIceMaskEnum; else if (strcmp(name,"SealevelBarystaticIceWeights")==0) return SealevelBarystaticIceWeightsEnum; else if (strcmp(name,"SealevelBarystaticIceArea")==0) return SealevelBarystaticIceAreaEnum; - else stage=8; - } - if(stage==8){ - if (strcmp(name,"SealevelBarystaticIceLatbar")==0) return SealevelBarystaticIceLatbarEnum; + else if (strcmp(name,"SealevelBarystaticIceLatbar")==0) return SealevelBarystaticIceLatbarEnum; else if (strcmp(name,"SealevelBarystaticIceLongbar")==0) return SealevelBarystaticIceLongbarEnum; else if (strcmp(name,"SealevelBarystaticIceLoad")==0) return SealevelBarystaticIceLoadEnum; @@ -994,12 +998,12 @@ else if (strcmp(name,"SmbEla")==0) return SmbElaEnum; else if (strcmp(name,"SmbEvaporation")==0) return SmbEvaporationEnum; - else if (strcmp(name,"SmbFAC")==0) return SmbFACEnum; + else stage=9; + } + if(stage==9){ + if (strcmp(name,"SmbFAC")==0) return SmbFACEnum; else if (strcmp(name,"SmbGdn")==0) return SmbGdnEnum; else if (strcmp(name,"SmbGdnini")==0) return SmbGdniniEnum; else if (strcmp(name,"SmbGsp")==0) return SmbGspEnum; - else stage=9; - } - if(stage==9){ - if (strcmp(name,"SmbGspini")==0) return SmbGspiniEnum; + else if (strcmp(name,"SmbGspini")==0) return SmbGspiniEnum; else if (strcmp(name,"SmbHref")==0) return SmbHrefEnum; else if (strcmp(name,"SmbIsInitialized")==0) return SmbIsInitializedEnum; @@ -1117,12 +1121,12 @@ else if (strcmp(name,"Vx")==0) return VxEnum; else if (strcmp(name,"VxMesh")==0) return VxMeshEnum; - else if (strcmp(name,"VxObs")==0) return VxObsEnum; + else stage=10; + } + if(stage==10){ + if (strcmp(name,"VxObs")==0) return VxObsEnum; else if (strcmp(name,"VxShear")==0) return VxShearEnum; else if (strcmp(name,"VxSurface")==0) return VxSurfaceEnum; else if (strcmp(name,"VyAverage")==0) return VyAverageEnum; - else stage=10; - } - if(stage==10){ - if (strcmp(name,"VyBase")==0) return VyBaseEnum; + else if (strcmp(name,"VyBase")==0) return VyBaseEnum; else if (strcmp(name,"Vy")==0) return VyEnum; else if (strcmp(name,"VyMesh")==0) return VyMeshEnum; @@ -1240,12 +1244,12 @@ else if (strcmp(name,"Outputdefinition92")==0) return Outputdefinition92Enum; else if (strcmp(name,"Outputdefinition93")==0) return Outputdefinition93Enum; - else if (strcmp(name,"Outputdefinition94")==0) return Outputdefinition94Enum; + else stage=11; + } + if(stage==11){ + if (strcmp(name,"Outputdefinition94")==0) return Outputdefinition94Enum; else if (strcmp(name,"Outputdefinition95")==0) return Outputdefinition95Enum; else if (strcmp(name,"Outputdefinition96")==0) return Outputdefinition96Enum; else if (strcmp(name,"Outputdefinition97")==0) return Outputdefinition97Enum; - else stage=11; - } - if(stage==11){ - if (strcmp(name,"Outputdefinition98")==0) return Outputdefinition98Enum; + else if (strcmp(name,"Outputdefinition98")==0) return Outputdefinition98Enum; else if (strcmp(name,"Outputdefinition99")==0) return Outputdefinition99Enum; else if (strcmp(name,"Outputdefinition9")==0) return Outputdefinition9Enum; @@ -1363,12 +1367,12 @@ else if (strcmp(name,"FullMeltOnPartiallyFloating")==0) return FullMeltOnPartiallyFloatingEnum; else if (strcmp(name,"GLheightadvectionAnalysis")==0) return GLheightadvectionAnalysisEnum; - else if (strcmp(name,"GaussPenta")==0) return GaussPentaEnum; + else stage=12; + } + if(stage==12){ + if (strcmp(name,"GaussPenta")==0) return GaussPentaEnum; else if (strcmp(name,"GaussSeg")==0) return GaussSegEnum; else if (strcmp(name,"GaussTetra")==0) return GaussTetraEnum; else if (strcmp(name,"GaussTria")==0) return GaussTriaEnum; - else stage=12; - } - if(stage==12){ - if (strcmp(name,"GenericOption")==0) return GenericOptionEnum; + else if (strcmp(name,"GenericOption")==0) return GenericOptionEnum; else if (strcmp(name,"GenericParam")==0) return GenericParamEnum; else if (strcmp(name,"GenericExternalResult")==0) return GenericExternalResultEnum; @@ -1454,4 +1458,6 @@ else if (strcmp(name,"Massfluxatgate")==0) return MassfluxatgateEnum; else if (strcmp(name,"MasstransportAnalysis")==0) return MasstransportAnalysisEnum; + else if (strcmp(name,"MmemasstransportAnalysis")==0) return MmemasstransportAnalysisEnum; + else if (strcmp(name,"MmemasstransportSolution")==0) return MmemasstransportSolutionEnum; else if (strcmp(name,"MasstransportSolution")==0) return MasstransportSolutionEnum; else if (strcmp(name,"Matdamageice")==0) return MatdamageiceEnum; @@ -1484,5 +1490,8 @@ else if (strcmp(name,"MpiDense")==0) return MpiDenseEnum; else if (strcmp(name,"Mpi")==0) return MpiEnum; - else if (strcmp(name,"MpiSparse")==0) return MpiSparseEnum; + else stage=13; + } + if(stage==13){ + if (strcmp(name,"MpiSparse")==0) return MpiSparseEnum; else if (strcmp(name,"Mumps")==0) return MumpsEnum; else if (strcmp(name,"NoFrictionOnPartiallyFloating")==0) return NoFrictionOnPartiallyFloatingEnum; @@ -1490,8 +1499,5 @@ else if (strcmp(name,"Nodal")==0) return NodalEnum; else if (strcmp(name,"Nodalvalue")==0) return NodalvalueEnum; - else stage=13; - } - if(stage==13){ - if (strcmp(name,"NodeSId")==0) return NodeSIdEnum; + else if (strcmp(name,"NodeSId")==0) return NodeSIdEnum; else if (strcmp(name,"NoneApproximation")==0) return NoneApproximationEnum; else if (strcmp(name,"None")==0) return NoneEnum; @@ -1607,5 +1613,8 @@ else if (strcmp(name,"TotalCalvingMeltingFluxLevelset")==0) return TotalCalvingMeltingFluxLevelsetEnum; else if (strcmp(name,"TotalFloatingBmb")==0) return TotalFloatingBmbEnum; - else if (strcmp(name,"TotalFloatingBmbScaled")==0) return TotalFloatingBmbScaledEnum; + else stage=14; + } + if(stage==14){ + if (strcmp(name,"TotalFloatingBmbScaled")==0) return TotalFloatingBmbScaledEnum; else if (strcmp(name,"TotalGroundedBmb")==0) return TotalGroundedBmbEnum; else if (strcmp(name,"TotalGroundedBmbScaled")==0) return TotalGroundedBmbScaledEnum; @@ -1613,8 +1622,5 @@ else if (strcmp(name,"TotalSmbScaled")==0) return TotalSmbScaledEnum; else if (strcmp(name,"TransientArrayParam")==0) return TransientArrayParamEnum; - else stage=14; - } - if(stage==14){ - if (strcmp(name,"TransientInput")==0) return TransientInputEnum; + else if (strcmp(name,"TransientInput")==0) return TransientInputEnum; else if (strcmp(name,"TransientParam")==0) return TransientParamEnum; else if (strcmp(name,"TransientSolution")==0) return TransientSolutionEnum; Index: /issm/branches/trunk-larour-SLPS2022/src/c/shared/Enum/issmenums.jl =================================================================== --- /issm/branches/trunk-larour-SLPS2022/src/c/shared/Enum/issmenums.jl (revision 27084) +++ /issm/branches/trunk-larour-SLPS2022/src/c/shared/Enum/issmenums.jl (revision 27084) @@ -0,0 +1,3211 @@ +# WARNING: DO NOT MODIFY THIS FILE +# this file has been automatically generated by Synchronize.sh +# Please read README for more information + +@enum IssmEnum begin + ParametersSTARTEnum + AdolcParamEnum + AmrDeviatoricErrorGroupThresholdEnum + AmrDeviatoricErrorMaximumEnum + AmrDeviatoricErrorResolutionEnum + AmrDeviatoricErrorThresholdEnum + AmrErrEnum + AmrFieldEnum + AmrGradationEnum + AmrGroundingLineDistanceEnum + AmrGroundingLineResolutionEnum + AmrHmaxEnum + AmrHminEnum + AmrIceFrontDistanceEnum + AmrIceFrontResolutionEnum + AmrKeepMetricEnum + AmrLagEnum + AmrLevelMaxEnum + AmrRestartEnum + AmrThicknessErrorGroupThresholdEnum + AmrThicknessErrorMaximumEnum + AmrThicknessErrorResolutionEnum + AmrThicknessErrorThresholdEnum + AmrTypeEnum + AnalysisCounterEnum + AnalysisTypeEnum + AugmentedLagrangianREnum + AugmentedLagrangianRholambdaEnum + AugmentedLagrangianRhopEnum + AugmentedLagrangianRlambdaEnum + AugmentedLagrangianThetaEnum + AutodiffCbufsizeEnum + AutodiffDependentObjectsEnum + AutodiffDriverEnum + AutodiffFosForwardIndexEnum + AutodiffFosReverseIndexEnum + AutodiffFovForwardIndicesEnum + AutodiffGcTriggerMaxSizeEnum + AutodiffGcTriggerRatioEnum + AutodiffIsautodiffEnum + AutodiffLbufsizeEnum + AutodiffNumDependentsEnum + AutodiffNumIndependentsEnum + AutodiffObufsizeEnum + AutodiffTapeAllocEnum + AutodiffTbufsizeEnum + AutodiffXpEnum + BalancethicknessStabilizationEnum + BarystaticContributionsEnum + BasalforcingsAutoregressionInitialTimeEnum + BasalforcingsAutoregressionTimestepEnum + BasalforcingsAutoregressiveOrderEnum + BasalforcingsBeta0Enum + BasalforcingsBeta1Enum + BasalforcingsBottomplumedepthEnum + BasalforcingsCrustthicknessEnum + BasalforcingsDeepwaterElevationEnum + BasalforcingsDeepwaterMeltingRateEnum + BasalforcingsDtbgEnum + BasalforcingsEnum + BasalforcingsIsmip6AverageTfEnum + BasalforcingsIsmip6BasinAreaEnum + BasalforcingsIsmip6DeltaTEnum + BasalforcingsIsmip6Gamma0Enum + BasalforcingsIsmip6IsLocalEnum + BasalforcingsIsmip6NumBasinsEnum + BasalforcingsIsmip6TfDepthsEnum + BasalforcingsLinearNumBasinsEnum + BasalforcingsLowercrustheatEnum + BasalforcingsMantleconductivityEnum + BasalforcingsNusseltEnum + BasalforcingsPhiEnum + BasalforcingsPicoAverageOverturningEnum + BasalforcingsPicoAverageSalinityEnum + BasalforcingsPicoAverageTemperatureEnum + BasalforcingsPicoBoxAreaEnum + BasalforcingsPicoFarOceansalinityEnum + BasalforcingsPicoFarOceantemperatureEnum + BasalforcingsPicoGammaTEnum + BasalforcingsPicoIsplumeEnum + BasalforcingsPicoMaxboxcountEnum + BasalforcingsPicoNumBasinsEnum + BasalforcingsPlumeradiusEnum + BasalforcingsPlumexEnum + BasalforcingsPlumeyEnum + BasalforcingsThresholdThicknessEnum + BasalforcingsTopplumedepthEnum + BasalforcingsUppercrustheatEnum + BasalforcingsUppercrustthicknessEnum + BasalforcingsUpperdepthMeltEnum + BasalforcingsUpperwaterElevationEnum + BasalforcingsUpperwaterMeltingRateEnum + CalvingCrevasseDepthEnum + CalvingCrevasseThresholdEnum + CalvingHeightAboveFloatationEnum + CalvingLawEnum + CalvingMinthicknessEnum + CalvingTestSpeedfactorEnum + CalvingUseParamEnum + CalvingScaleThetaEnum + CalvingAmpAlphaEnum + CalvingMidpointEnum + CalvingNonlinearLawEnum + ConfigurationTypeEnum + ConstantsGEnum + ConstantsNewtonGravityEnum + ConstantsReferencetemperatureEnum + ConstantsYtsEnum + ControlInputSizeMEnum + ControlInputSizeNEnum + ControlInputInterpolationEnum + CumBslcEnum + CumBslcIceEnum + CumBslcHydroEnum + CumBslcOceanEnum + CumBslcIcePartitionEnum + CumBslcHydroPartitionEnum + CumBslcOceanPartitionEnum + CumGmtslcEnum + CumGmslcEnum + DamageC1Enum + DamageC2Enum + DamageC3Enum + DamageC4Enum + DamageEnum + DamageEquivStressEnum + DamageEvolutionNumRequestedOutputsEnum + DamageEvolutionRequestedOutputsEnum + DamageHealingEnum + DamageKappaEnum + DamageLawEnum + DamageMaxDamageEnum + DamageStabilizationEnum + DamageStressThresholdEnum + DamageStressUBoundEnum + DebugProfilingEnum + DomainDimensionEnum + DomainTypeEnum + DslModelEnum + DslModelidEnum + DslNummodelsEnum + SolidearthIsExternalEnum + SolidearthExternalNatureEnum + SolidearthExternalModelidEnum + SolidearthExternalNummodelsEnum + SolidearthSettingsComputeBpGrdEnum + EarthIdEnum + ElasticEnum + EplZigZagCounterEnum + EsaHElasticEnum + EsaHemisphereEnum + EsaRequestedOutputsEnum + EsaUElasticEnum + ExtrapolationVariableEnum + FemModelCommEnum + FieldsEnum + FlowequationFeFSEnum + FlowequationIsFSEnum + FlowequationIsHOEnum + FlowequationIsL1L2Enum + FlowequationIsMLHOEnum + FlowequationIsSIAEnum + FlowequationIsSSAEnum + FlowequationIsNitscheEnum + FeFSNitscheGammaEnum + FrictionCouplingEnum + FrictionDeltaEnum + FrictionEffectivePressureLimitEnum + FrictionFEnum + FrictionGammaEnum + FrictionLawEnum + FrictionPseudoplasticityExponentEnum + FrictionThresholdSpeedEnum + FrictionVoidRatioEnum + FrontalForcingsBasinIcefrontAreaEnum + FrontalForcingsAutoregressionInitialTimeEnum + FrontalForcingsAutoregressionTimestepEnum + FrontalForcingsAutoregressiveOrderEnum + FrontalForcingsBeta0Enum + FrontalForcingsBeta1Enum + FrontalForcingsNumberofBasinsEnum + FrontalForcingsParamEnum + FrontalForcingsPhiEnum + GrdModelEnum + GroundinglineFrictionInterpolationEnum + GroundinglineMeltInterpolationEnum + GroundinglineMigrationEnum + GroundinglineNumRequestedOutputsEnum + GroundinglineRequestedOutputsEnum + HydrologyAveragingEnum + HydrologyCavitySpacingEnum + HydrologyChannelConductivityEnum + HydrologyChannelSheetWidthEnum + HydrologyEnglacialVoidRatioEnum + HydrologyIschannelsEnum + HydrologyMeltFlagEnum + HydrologyModelEnum + HydrologyNumRequestedOutputsEnum + HydrologyPressureMeltCoefficientEnum + HydrologyRelaxationEnum + HydrologyRequestedOutputsEnum + HydrologySedimentKmaxEnum + HydrologyStepsPerStepEnum + HydrologyStorageEnum + HydrologydcEplColapseThicknessEnum + HydrologydcEplConductivityEnum + HydrologydcEplInitialThicknessEnum + HydrologydcEplLayerCompressibilityEnum + HydrologydcEplMaxThicknessEnum + HydrologydcEplPoreWaterMassEnum + HydrologydcEplThickCompEnum + HydrologydcEplflipLockEnum + HydrologydcIsefficientlayerEnum + HydrologydcLeakageFactorEnum + HydrologydcMaxIterEnum + HydrologydcPenaltyFactorEnum + HydrologydcPenaltyLockEnum + HydrologydcRelTolEnum + HydrologydcSedimentlimitEnum + HydrologydcSedimentlimitFlagEnum + HydrologydcSedimentLayerCompressibilityEnum + HydrologydcSedimentPoreWaterMassEnum + HydrologydcSedimentPorosityEnum + HydrologydcSedimentThicknessEnum + HydrologydcTransferFlagEnum + HydrologydcUnconfinedFlagEnum + HydrologyshreveStabilizationEnum + IcecapToEarthCommEnum + IndexEnum + InputFileNameEnum + DirectoryNameEnum + IndicesEnum + InputToDepthaverageInEnum + InputToDepthaverageOutEnum + InputToExtrudeEnum + InputToL2ProjectEnum + InputToSmoothEnum + InversionAlgorithmEnum + InversionControlParametersEnum + InversionControlScalingFactorsEnum + InversionCostFunctionsEnum + InversionDxminEnum + InversionGatolEnum + InversionGradientScalingEnum + InversionGrtolEnum + InversionGttolEnum + InversionIncompleteAdjointEnum + InversionIscontrolEnum + InversionMaxiterEnum + InversionMaxiterPerStepEnum + InversionMaxstepsEnum + InversionNstepsEnum + InversionNumControlParametersEnum + InversionNumCostFunctionsEnum + InversionStepThresholdEnum + InversionTypeEnum + IvinsEnum + IsSlcCouplingEnum + LevelsetKillIcebergsEnum + LevelsetReinitFrequencyEnum + LevelsetStabilizationEnum + LockFileNameEnum + LoveAllowLayerDeletionEnum + LoveChandlerWobbleEnum + LoveCoreMantleBoundaryEnum + LoveEarthMassEnum + LoveForcingTypeEnum + LoveFrequenciesEnum + LoveIsTemporalEnum + LoveG0Enum + LoveGravitationalConstantEnum + LoveInnerCoreBoundaryEnum + LoveComplexComputationEnum + LoveIntStepsPerLayerEnum + LoveKernelsEnum + LoveMu0Enum + LoveNfreqEnum + LoveNTemporalIterationsEnum + LoveNYiEquationsEnum + LoveR0Enum + LoveShNmaxEnum + LoveShNminEnum + LoveStartingLayerEnum + LoveUnderflowTolEnum + LovePostWidderThresholdEnum + MassFluxSegmentsEnum + MassFluxSegmentsPresentEnum + MasstransportHydrostaticAdjustmentEnum + MasstransportIsfreesurfaceEnum + MasstransportMinThicknessEnum + MasstransportNumRequestedOutputsEnum + MasstransportPenaltyFactorEnum + MasstransportRequestedOutputsEnum + MasstransportStabilizationEnum + MmemasstransportModelidsEnum + MmemasstransportPartitionEnum + MaterialsBetaEnum + MaterialsEarthDensityEnum + MaterialsEffectiveconductivityAveragingEnum + MaterialsHeatcapacityEnum + MaterialsLatentheatEnum + MaterialsMeltingpointEnum + MaterialsMixedLayerCapacityEnum + MaterialsMuWaterEnum + MaterialsRheologyLawEnum + MaterialsRhoFreshwaterEnum + MaterialsRhoIceEnum + MaterialsRhoSeawaterEnum + MaterialsTemperateiceconductivityEnum + MaterialsThermalExchangeVelocityEnum + MaterialsThermalconductivityEnum + MeltingOffsetEnum + MeshAverageVertexConnectivityEnum + MeshElementtypeEnum + MeshNumberoflayersEnum + MeshNumberofverticesEnum + MeshNumberofelementsEnum + MigrationMaxEnum + ModelIdEnum + NbinsEnum + NodesEnum + NumModelsEnum + OceanGridNxEnum + OceanGridNyEnum + OceanGridXEnum + OceanGridYEnum + OutputBufferPointerEnum + OutputBufferSizePointerEnum + OutputFileNameEnum + OutputFilePointerEnum + OutputdefinitionEnum + QmuErrNameEnum + QmuInNameEnum + QmuIsdakotaEnum + QmuOutNameEnum + QmuOutputEnum + QmuCurrEvalIdEnum + QmuNsampleEnum + QmuResponsedescriptorsEnum + QmuVariableDescriptorsEnum + QmuVariablePartitionsEnum + QmuVariablePartitionsNpartEnum + QmuVariablePartitionsNtEnum + QmuResponsePartitionsEnum + QmuResponsePartitionsNpartEnum + QmuStatisticsEnum + QmuNumstatisticsEnum + QmuNdirectoriesEnum + QmuNfilesPerDirectoryEnum + QmuStatisticsMethodEnum + QmuMethodsEnum + RestartFileNameEnum + ResultsEnum + RootPathEnum + ModelnameEnum + SamplingAlphaEnum + SamplingNumRequestedOutputsEnum + SamplingRequestedOutputsEnum + SamplingRobinEnum + SamplingSeedEnum + SaveResultsEnum + SolidearthPartitionIceEnum + SolidearthPartitionHydroEnum + SolidearthPartitionOceanEnum + SolidearthNpartIceEnum + SolidearthNpartOceanEnum + SolidearthNpartHydroEnum + SolidearthPlanetRadiusEnum + SolidearthPlanetAreaEnum + SolidearthSettingsAbstolEnum + SolidearthSettingsCrossSectionShapeEnum + SolidearthSettingsElasticEnum + SolidearthSettingsViscousEnum + SealevelchangeGeometryDoneEnum + SealevelchangeViscousNumStepsEnum + SealevelchangeViscousTimesEnum + SealevelchangeViscousIndexEnum + SealevelchangeViscousPolarMotionEnum + SealevelchangeRunCountEnum + SealevelchangeTransitionsEnum + SealevelchangeRequestedOutputsEnum + RotationalAngularVelocityEnum + RotationalEquatorialMoiEnum + RotationalPolarMoiEnum + LovePolarMotionTransferFunctionColinearEnum + LovePolarMotionTransferFunctionOrthogonalEnum + TidalLoveHEnum + TidalLoveKEnum + TidalLoveLEnum + TidalLoveK2SecularEnum + LoadLoveHEnum + LoadLoveKEnum + LoadLoveLEnum + LoveTimeFreqEnum + LoveIsTimeEnum + SealevelchangeGSelfAttractionEnum + SealevelchangeGViscoElasticEnum + SealevelchangeUViscoElasticEnum + SealevelchangeHViscoElasticEnum + SealevelchangePolarMotionTransferFunctionColinearEnum + SealevelchangePolarMotionTransferFunctionOrthogonalEnum + SealevelchangePolarMotionTransferFunctionZEnum + SealevelchangeTidalK2Enum + SealevelchangeTidalH2Enum + SealevelchangeTidalL2Enum + SolidearthSettingsSealevelLoadingEnum + SolidearthSettingsGRDEnum + SolidearthSettingsRunFrequencyEnum + SolidearthSettingsTimeAccEnum + SolidearthSettingsHorizEnum + SolidearthSettingsMaxiterEnum + SolidearthSettingsGrdOceanEnum + SolidearthSettingsOceanAreaScalingEnum + StochasticForcingCovarianceEnum + StochasticForcingDefaultDimensionEnum + StochasticForcingDimensionsEnum + StochasticForcingFieldsEnum + StochasticForcingIsEffectivePressureEnum + StochasticForcingIsStochasticForcingEnum + StochasticForcingIsWaterPressureEnum + StochasticForcingNoisetermsEnum + StochasticForcingNumFieldsEnum + StochasticForcingRandomflagEnum + StochasticForcingTimestepEnum + SolidearthSettingsReltolEnum + SolidearthSettingsSelfAttractionEnum + SolidearthSettingsRotationEnum + SolidearthSettingsMaxSHCoeffEnum + SettingsIoGatherEnum + SettingsNumResultsOnNodesEnum + SettingsOutputFrequencyEnum + SettingsCheckpointFrequencyEnum + SettingsResultsOnNodesEnum + SettingsSbCouplingFrequencyEnum + SettingsSolverResidueThresholdEnum + SettingsWaitonlockEnum + SmbAIceEnum + SmbAIdxEnum + SmbASnowEnum + SmbAccualtiEnum + SmbAccugradEnum + SmbAccurefEnum + SmbAdThreshEnum + SmbAutoregressionInitialTimeEnum + SmbAutoregressionTimestepEnum + SmbAutoregressiveOrderEnum + SmbAveragingEnum + SmbBeta0Enum + SmbBeta1Enum + SmbDesfacEnum + SmbDpermilEnum + SmbDsnowIdxEnum + SmbElevationBinsEnum + SmbCldFracEnum + SmbDelta18oEnum + SmbDelta18oSurfaceEnum + SmbDenIdxEnum + SmbDtEnum + SmbEnum + SmbEIdxEnum + SmbFEnum + SmbInitDensityScalingEnum + SmbIsaccumulationEnum + SmbIsalbedoEnum + SmbIsconstrainsurfaceTEnum + SmbIsd18opdEnum + SmbIsdelta18oEnum + SmbIsdensificationEnum + SmbIsdeltaLWupEnum + SmbIsfirnwarmingEnum + SmbIsgraingrowthEnum + SmbIsmeltEnum + SmbIsmungsmEnum + SmbIsprecipscaledEnum + SmbIssetpddfacEnum + SmbIsshortwaveEnum + SmbIstemperaturescaledEnum + SmbIsthermalEnum + SmbIsturbulentfluxEnum + SmbKEnum + SmbLapseRatesEnum + SmbNumBasinsEnum + SmbNumElevationBinsEnum + SmbNumRequestedOutputsEnum + SmbPfacEnum + SmbPhiEnum + SmbRdlEnum + SmbRefElevationEnum + SmbRequestedOutputsEnum + SmbRlapsEnum + SmbRlapslgmEnum + SmbRunoffaltiEnum + SmbRunoffgradEnum + SmbRunoffrefEnum + SmbSealevEnum + SmbStepsPerStepEnum + SmbSwIdxEnum + SmbT0dryEnum + SmbT0wetEnum + SmbTeThreshEnum + SmbTdiffEnum + SmbThermoDeltaTScalingEnum + SmbTemperaturesReconstructedYearsEnum + SmbPrecipitationsReconstructedYearsEnum + SmoothThicknessMultiplierEnum + SolutionTypeEnum + SteadystateMaxiterEnum + SteadystateNumRequestedOutputsEnum + SteadystateReltolEnum + SteadystateRequestedOutputsEnum + StepEnum + StepsEnum + StressbalanceAbstolEnum + StressbalanceFSreconditioningEnum + StressbalanceIsnewtonEnum + StressbalanceMaxiterEnum + StressbalanceNumRequestedOutputsEnum + StressbalancePenaltyFactorEnum + StressbalanceReltolEnum + StressbalanceRequestedOutputsEnum + StressbalanceRestolEnum + StressbalanceRiftPenaltyThresholdEnum + StressbalanceShelfDampeningEnum + ThermalIsdrainicecolumnEnum + ThermalIsdynamicbasalspcEnum + ThermalIsenthalpyEnum + ThermalMaxiterEnum + ThermalNumRequestedOutputsEnum + ThermalPenaltyFactorEnum + ThermalPenaltyLockEnum + ThermalPenaltyThresholdEnum + ThermalReltolEnum + ThermalRequestedOutputsEnum + ThermalStabilizationEnum + ThermalWatercolumnUpperlimitEnum + TimeEnum + TimesteppingCflCoefficientEnum + TimesteppingCouplingTimeEnum + TimesteppingFinalTimeEnum + TimesteppingInterpForcingEnum + TimesteppingCycleForcingEnum + TimesteppingStartTimeEnum + TimesteppingTimeStepEnum + TimesteppingTimeStepMaxEnum + TimesteppingTimeStepMinEnum + TimesteppingTypeEnum + ToMITgcmCommEnum + ToolkitsFileNameEnum + ToolkitsOptionsAnalysesEnum + ToolkitsOptionsStringsEnum + ToolkitsTypesEnum + TransientAmrFrequencyEnum + TransientIsdamageevolutionEnum + TransientIsesaEnum + TransientIsgiaEnum + TransientIsgroundinglineEnum + TransientIshydrologyEnum + TransientIsmasstransportEnum + TransientIsmmemasstransportEnum + TransientIsoceantransportEnum + TransientIsmovingfrontEnum + TransientIsoceancouplingEnum + TransientIssamplingEnum + TransientIsslcEnum + TransientIssmbEnum + TransientIsstressbalanceEnum + TransientIsthermalEnum + TransientNumRequestedOutputsEnum + TransientRequestedOutputsEnum + VelocityEnum + XxeEnum + YyeEnum + ZzeEnum + AreaeEnum + WorldCommEnum + ParametersENDEnum + InputsSTARTEnum + AccumulatedDeltaBottomPressureEnum + AccumulatedDeltaIceThicknessEnum + AccumulatedDeltaTwsEnum + AdjointEnum + AdjointpEnum + AdjointxEnum + AdjointxBaseEnum + AdjointxShearEnum + AdjointyEnum + AdjointyBaseEnum + AdjointyShearEnum + AdjointzEnum + AirEnum + ApproximationEnum + BalancethicknessMisfitEnum + BalancethicknessOmega0Enum + BalancethicknessOmegaEnum + BalancethicknessSpcthicknessEnum + BalancethicknessThickeningRateEnum + BasalCrevasseEnum + BasalforcingsDeepwaterMeltingRateAutoregressionEnum + BasalforcingsDeepwaterMeltingRateNoiseEnum + BasalforcingsDeepwaterMeltingRateValuesAutoregressionEnum + BasalforcingsFloatingiceMeltingRateEnum + BasalforcingsGeothermalfluxEnum + BasalforcingsGroundediceMeltingRateEnum + BasalforcingsLinearBasinIdEnum + BasalforcingsPerturbationMeltingRateEnum + BasalforcingsSpatialDeepwaterElevationEnum + BasalforcingsSpatialDeepwaterMeltingRateEnum + BasalforcingsSpatialUpperwaterElevationEnum + BasalforcingsSpatialUpperwaterMeltingRateEnum + BasalforcingsIsmip6BasinIdEnum + BasalforcingsIsmip6TfEnum + BasalforcingsIsmip6TfShelfEnum + BasalforcingsIsmip6MeltAnomalyEnum + BasalforcingsMeltrateFactorEnum + BasalforcingsOceanSalinityEnum + BasalforcingsOceanTempEnum + BasalforcingsPicoBasinIdEnum + BasalforcingsPicoBoxIdEnum + BasalforcingsPicoOverturningCoeffEnum + BasalforcingsPicoSubShelfOceanOverturningEnum + BasalforcingsPicoSubShelfOceanSalinityEnum + BasalforcingsPicoSubShelfOceanTempEnum + BasalStressxEnum + BasalStressyEnum + BasalStressEnum + BaseEnum + BaseOldEnum + BaseSlopeXEnum + BaseSlopeYEnum + BaselineBasalforcingsFloatingiceMeltingRateEnum + BaselineBasalforcingsSpatialDeepwaterMeltingRateEnum + BaselineCalvingCalvingrateEnum + BaselineFrictionEffectivePressureEnum + BaselineSmbMassBalanceEnum + BedEnum + BedGRDEnum + BedEastEnum + BedEastGRDEnum + BedNorthEnum + BedNorthGRDEnum + BedSlopeXEnum + BedSlopeYEnum + BottomPressureEnum + BottomPressureOldEnum + CalvingCalvingrateEnum + CalvingHabFractionEnum + CalvingMeltingrateEnum + CalvingStressThresholdFloatingiceEnum + CalvingStressThresholdGroundediceEnum + CalvinglevermannCoeffEnum + CalvingratexAverageEnum + CalvingratexEnum + CalvingrateyAverageEnum + CalvingrateyEnum + CalvingFluxLevelsetEnum + CalvingMeltingFluxLevelsetEnum + ConvergedEnum + CrevasseDepthEnum + DamageDEnum + DamageDOldEnum + DamageDbarEnum + DamageDbarOldEnum + DamageFEnum + DegreeOfChannelizationEnum + DepthBelowSurfaceEnum + DeltaIceThicknessEnum + DeltaTwsEnum + DeltaBottomPressureEnum + DeltaDslEnum + DslOldEnum + DslEnum + DeltaStrEnum + StrOldEnum + StrEnum + DeviatoricStresseffectiveEnum + DeviatoricStressxxEnum + DeviatoricStressxyEnum + DeviatoricStressxzEnum + DeviatoricStressyyEnum + DeviatoricStressyzEnum + DeviatoricStresszzEnum + DeviatoricStress1Enum + DeviatoricStress2Enum + DistanceToCalvingfrontEnum + DistanceToGroundinglineEnum + Domain2DhorizontalEnum + Domain2DverticalEnum + Domain3DEnum + DragCoefficientAbsGradientEnum + DrivingStressXEnum + DrivingStressYEnum + DummyEnum + EffectivePressureEnum + EffectivePressureSubstepEnum + EffectivePressureTransientEnum + EnthalpyEnum + EnthalpyPicardEnum + EplHeadEnum + EplHeadOldEnum + EplHeadSlopeXEnum + EplHeadSlopeYEnum + EplHeadSubstepEnum + EplHeadTransientEnum + EsaEmotionEnum + EsaNmotionEnum + EsaRotationrateEnum + EsaStrainratexxEnum + EsaStrainratexyEnum + EsaStrainrateyyEnum + EsaUmotionEnum + EsaXmotionEnum + EsaYmotionEnum + EtaDiffEnum + FlowequationBorderFSEnum + FrictionAsEnum + FrictionCEnum + FrictionCmaxEnum + FrictionCoefficientEnum + FrictionCoefficientcoulombEnum + FrictionEffectivePressureEnum + FrictionMEnum + FrictionPEnum + FrictionPressureAdjustedTemperatureEnum + FrictionQEnum + FrictionSedimentCompressibilityCoefficientEnum + FrictionTillFrictionAngleEnum + FrictionWaterLayerEnum + FrictionfEnum + FrontalForcingsBasinIdEnum + FrontalForcingsSubglacialDischargeEnum + FrontalForcingsThermalForcingEnum + GeometryHydrostaticRatioEnum + NGiaEnum + NGiaRateEnum + UGiaEnum + UGiaRateEnum + GradientEnum + GroundinglineHeightEnum + HydraulicPotentialEnum + HydraulicPotentialOldEnum + HydrologyBasalFluxEnum + HydrologyBumpHeightEnum + HydrologyBumpSpacingEnum + HydrologydcBasalMoulinInputEnum + HydrologydcEplThicknessEnum + HydrologydcEplThicknessOldEnum + HydrologydcEplThicknessSubstepEnum + HydrologydcEplThicknessTransientEnum + HydrologydcMaskEplactiveEltEnum + HydrologydcMaskEplactiveNodeEnum + HydrologydcMaskThawedEltEnum + HydrologydcMaskThawedNodeEnum + HydrologydcSedimentTransmitivityEnum + HydrologyDrainageRateEnum + HydrologyEnglacialInputEnum + HydrologyGapHeightEnum + HydrologyGapHeightXEnum + HydrologyGapHeightXXEnum + HydrologyGapHeightYEnum + HydrologyGapHeightYYEnum + HydrologyHeadEnum + HydrologyHeadOldEnum + HydrologyMoulinInputEnum + HydrologyNeumannfluxEnum + HydrologyReynoldsEnum + HydrologySheetConductivityEnum + HydrologySheetThicknessEnum + HydrologySheetThicknessOldEnum + HydrologyTwsEnum + HydrologyTwsSpcEnum + HydrologyTwsAnalysisEnum + HydrologyWatercolumnMaxEnum + HydrologyWaterVxEnum + HydrologyWaterVyEnum + IceEnum + IceMaskNodeActivationEnum + InputEnum + InversionCostFunctionsCoefficientsEnum + InversionSurfaceObsEnum + InversionThicknessObsEnum + InversionVelObsEnum + InversionVxObsEnum + InversionVyObsEnum + LevelsetfunctionSlopeXEnum + LevelsetfunctionSlopeYEnum + LevelsetObservationEnum + LoadingforceXEnum + LoadingforceYEnum + LoadingforceZEnum + MaskOceanLevelsetEnum + MaskIceLevelsetEnum + MaskIceRefLevelsetEnum + MasstransportSpcthicknessEnum + MmemasstransportDeltathicknessEnum + MaterialsRheologyBEnum + MaterialsRheologyBbarEnum + MaterialsRheologyEEnum + MaterialsRheologyEbarEnum + MaterialsRheologyEcEnum + MaterialsRheologyEcbarEnum + MaterialsRheologyEsEnum + MaterialsRheologyEsbarEnum + MaterialsRheologyNEnum + MeshScaleFactorEnum + MeshVertexonbaseEnum + MeshVertexonboundaryEnum + MeshVertexonsurfaceEnum + MisfitEnum + MovingFrontalVxEnum + MovingFrontalVyEnum + NeumannfluxEnum + NewDamageEnum + NodeEnum + OmegaAbsGradientEnum + OceantransportSpcbottompressureEnum + OceantransportSpcstrEnum + OceantransportSpcdslEnum + P0Enum + P1Enum + PartitioningEnum + PressureEnum + RadarEnum + RadarAttenuationMacGregorEnum + RadarAttenuationWolffEnum + RadarIcePeriodEnum + RadarPowerMacGregorEnum + RadarPowerWolffEnum + RheologyBAbsGradientEnum + RheologyBInitialguessEnum + RheologyBInitialguessMisfitEnum + RheologyBbarAbsGradientEnum + SampleEnum + SampleOldEnum + SampleNoiseEnum + SamplingBetaEnum + SamplingKappaEnum + SamplingPhiEnum + SamplingTauEnum + SealevelEnum + SealevelGRDEnum + SealevelBarystaticMaskEnum + SealevelBarystaticIceMaskEnum + SealevelBarystaticIceWeightsEnum + SealevelBarystaticIceAreaEnum + SealevelBarystaticIceLatbarEnum + SealevelBarystaticIceLongbarEnum + SealevelBarystaticIceLoadEnum + SealevelBarystaticHydroMaskEnum + SealevelBarystaticHydroWeightsEnum + SealevelBarystaticHydroAreaEnum + SealevelBarystaticHydroLatbarEnum + SealevelBarystaticHydroLongbarEnum + SealevelBarystaticHydroLoadEnum + SealevelBarystaticBpMaskEnum + SealevelBarystaticBpWeightsEnum + SealevelBarystaticBpAreaEnum + SealevelBarystaticBpLoadEnum + SealevelBarystaticOceanMaskEnum + SealevelBarystaticOceanWeightsEnum + SealevelBarystaticOceanAreaEnum + SealevelBarystaticOceanLatbarEnum + SealevelBarystaticOceanLongbarEnum + SealevelBarystaticOceanLoadEnum + SealevelNEsaEnum + SealevelNEsaRateEnum + SealevelRSLEnum + BslcEnum + BslcIceEnum + BslcHydroEnum + BslcOceanEnum + BslcRateEnum + GmtslcEnum + SealevelRSLBarystaticEnum + SealevelRSLRateEnum + SealevelUGrdEnum + SealevelNGrdEnum + SealevelUEastEsaEnum + SealevelUNorthEsaEnum + SealevelchangeIndicesEnum + SealevelchangeGEnum + SealevelchangeGUEnum + SealevelchangeGEEnum + SealevelchangeGNEnum + SealevelchangeGrotEnum + SealevelchangeGUrotEnum + SealevelchangeGNrotEnum + SealevelchangeGErotEnum + SealevelchangeGsubelOceanEnum + SealevelchangeGUsubelOceanEnum + SealevelchangeGEsubelOceanEnum + SealevelchangeGNsubelOceanEnum + SealevelchangeGsubelIceEnum + SealevelchangeGUsubelIceEnum + SealevelchangeGEsubelIceEnum + SealevelchangeGNsubelIceEnum + SealevelchangeGsubelHydroEnum + SealevelchangeGUsubelHydroEnum + SealevelchangeGEsubelHydroEnum + SealevelchangeGNsubelHydroEnum + SealevelchangeViscousRSLEnum + SealevelchangeViscousUEnum + SealevelchangeViscousNEnum + SealevelchangeViscousEEnum + SedimentHeadEnum + SedimentHeadOldEnum + SedimentHeadSubstepEnum + SedimentHeadTransientEnum + SedimentHeadResidualEnum + SedimentHeadStackedEnum + SigmaNNEnum + SigmaVMEnum + SmbAccumulatedECEnum + SmbAccumulatedMassBalanceEnum + SmbAccumulatedMeltEnum + SmbAccumulatedPrecipitationEnum + SmbAccumulatedRainEnum + SmbAccumulatedRefreezeEnum + SmbAccumulatedRunoffEnum + SmbAEnum + SmbAdiffEnum + SmbAValueEnum + SmbAccumulationEnum + SmbAdiffiniEnum + SmbAiniEnum + SmbAutoregressionNoiseEnum + SmbBasinsIdEnum + SmbBMaxEnum + SmbBMinEnum + SmbBNegEnum + SmbBPosEnum + SmbCEnum + SmbCcsnowValueEnum + SmbCciceValueEnum + SmbCotValueEnum + SmbDEnum + SmbDailyairdensityEnum + SmbDailyairhumidityEnum + SmbDailydlradiationEnum + SmbDailydsradiationEnum + SmbDailypressureEnum + SmbDailyrainfallEnum + SmbDailysnowfallEnum + SmbDailytemperatureEnum + SmbDailywindspeedEnum + SmbDiniEnum + SmbDlwrfEnum + SmbDulwrfValueEnum + SmbDswrfEnum + SmbDswdiffrfEnum + SmbDzAddEnum + SmbDzEnum + SmbDzMinEnum + SmbDzTopEnum + SmbDziniEnum + SmbEAirEnum + SmbECEnum + SmbECDtEnum + SmbECiniEnum + SmbElaEnum + SmbEvaporationEnum + SmbFACEnum + SmbGdnEnum + SmbGdniniEnum + SmbGspEnum + SmbGspiniEnum + SmbHrefEnum + SmbIsInitializedEnum + SmbMAddEnum + SmbMassBalanceEnum + SmbMassBalanceSubstepEnum + SmbMassBalanceTransientEnum + SmbMeanLHFEnum + SmbMeanSHFEnum + SmbMeanULWEnum + SmbMeltEnum + SmbMonthlytemperaturesEnum + SmbMSurfEnum + SmbNetLWEnum + SmbNetSWEnum + SmbPAirEnum + SmbPEnum + SmbPddfacIceEnum + SmbPddfacSnowEnum + SmbPrecipitationEnum + SmbPrecipitationsAnomalyEnum + SmbPrecipitationsLgmEnum + SmbPrecipitationsPresentdayEnum + SmbPrecipitationsReconstructedEnum + SmbRainEnum + SmbReEnum + SmbRefreezeEnum + SmbReiniEnum + SmbRunoffEnum + SmbRunoffSubstepEnum + SmbRunoffTransientEnum + SmbS0gcmEnum + SmbS0pEnum + SmbS0tEnum + SmbSizeiniEnum + SmbSmbCorrEnum + SmbSmbrefEnum + SmbSzaValueEnum + SmbTEnum + SmbTaEnum + SmbTeValueEnum + SmbTemperaturesAnomalyEnum + SmbTemperaturesLgmEnum + SmbTemperaturesPresentdayEnum + SmbTemperaturesReconstructedEnum + SmbTiniEnum + SmbTmeanEnum + SmbTzEnum + SmbValuesAutoregressionEnum + SmbVEnum + SmbVmeanEnum + SmbVzEnum + SmbWEnum + SmbWAddEnum + SmbWiniEnum + SmbZMaxEnum + SmbZMinEnum + SmbZTopEnum + SmbZYEnum + SolidearthExternalDisplacementEastRateEnum + SolidearthExternalDisplacementNorthRateEnum + SolidearthExternalDisplacementUpRateEnum + SolidearthExternalGeoidRateEnum + StochasticForcingDefaultIdEnum + StrainRateeffectiveEnum + StrainRateparallelEnum + StrainRateperpendicularEnum + StrainRatexxEnum + StrainRatexyEnum + StrainRatexzEnum + StrainRateyyEnum + StrainRateyzEnum + StrainRatezzEnum + StressMaxPrincipalEnum + StressTensorxxEnum + StressTensorxyEnum + StressTensorxzEnum + StressTensoryyEnum + StressTensoryzEnum + StressTensorzzEnum + SurfaceAbsMisfitEnum + SurfaceAbsVelMisfitEnum + AreaEnum + SealevelAreaEnum + SurfaceAreaEnum + SurfaceAverageVelMisfitEnum + SurfaceCrevasseEnum + SurfaceEnum + SurfaceOldEnum + SurfaceLogVelMisfitEnum + SurfaceLogVxVyMisfitEnum + SurfaceObservationEnum + SurfaceRelVelMisfitEnum + SurfaceSlopeXEnum + SurfaceSlopeYEnum + TemperatureEnum + TemperaturePDDEnum + TemperaturePicardEnum + TemperatureSEMICEnum + ThermalforcingAutoregressionNoiseEnum + ThermalforcingValuesAutoregressionEnum + ThermalSpctemperatureEnum + ThicknessAbsGradientEnum + ThicknessAbsMisfitEnum + ThicknessAcrossGradientEnum + ThicknessAlongGradientEnum + ThicknessEnum + ThicknessOldEnum + ThicknessPositiveEnum + ThicknessResidualEnum + TransientAccumulatedDeltaIceThicknessEnum + VelEnum + VxAverageEnum + VxBaseEnum + VxEnum + VxMeshEnum + VxObsEnum + VxShearEnum + VxSurfaceEnum + VyAverageEnum + VyBaseEnum + VyEnum + VyMeshEnum + VyObsEnum + VyShearEnum + VySurfaceEnum + VzEnum + VzFSEnum + VzHOEnum + VzMeshEnum + VzSSAEnum + WaterColumnOldEnum + WatercolumnEnum + WaterfractionDrainageEnum + WaterfractionDrainageIntegratedEnum + WaterfractionEnum + WaterheightEnum + FrictionWaterPressureEnum + FrictionWaterPressureNoiseEnum + WeightsLevelsetObservationEnum + WeightsSurfaceObservationEnum + OldAccumulatedDeltaBottomPressureEnum + OldAccumulatedDeltaIceThicknessEnum + OldAccumulatedDeltaTwsEnum + Outputdefinition1Enum + Outputdefinition10Enum + Outputdefinition11Enum + Outputdefinition12Enum + Outputdefinition13Enum + Outputdefinition14Enum + Outputdefinition15Enum + Outputdefinition16Enum + Outputdefinition17Enum + Outputdefinition18Enum + Outputdefinition19Enum + Outputdefinition20Enum + Outputdefinition21Enum + Outputdefinition22Enum + Outputdefinition23Enum + Outputdefinition24Enum + Outputdefinition25Enum + Outputdefinition26Enum + Outputdefinition27Enum + Outputdefinition28Enum + Outputdefinition29Enum + Outputdefinition2Enum + Outputdefinition30Enum + Outputdefinition31Enum + Outputdefinition32Enum + Outputdefinition33Enum + Outputdefinition34Enum + Outputdefinition35Enum + Outputdefinition36Enum + Outputdefinition37Enum + Outputdefinition38Enum + Outputdefinition39Enum + Outputdefinition3Enum + Outputdefinition40Enum + Outputdefinition41Enum + Outputdefinition42Enum + Outputdefinition43Enum + Outputdefinition44Enum + Outputdefinition45Enum + Outputdefinition46Enum + Outputdefinition47Enum + Outputdefinition48Enum + Outputdefinition49Enum + Outputdefinition4Enum + Outputdefinition50Enum + Outputdefinition51Enum + Outputdefinition52Enum + Outputdefinition53Enum + Outputdefinition54Enum + Outputdefinition55Enum + Outputdefinition56Enum + Outputdefinition57Enum + Outputdefinition58Enum + Outputdefinition59Enum + Outputdefinition5Enum + Outputdefinition60Enum + Outputdefinition61Enum + Outputdefinition62Enum + Outputdefinition63Enum + Outputdefinition64Enum + Outputdefinition65Enum + Outputdefinition66Enum + Outputdefinition67Enum + Outputdefinition68Enum + Outputdefinition69Enum + Outputdefinition6Enum + Outputdefinition70Enum + Outputdefinition71Enum + Outputdefinition72Enum + Outputdefinition73Enum + Outputdefinition74Enum + Outputdefinition75Enum + Outputdefinition76Enum + Outputdefinition77Enum + Outputdefinition78Enum + Outputdefinition79Enum + Outputdefinition7Enum + Outputdefinition80Enum + Outputdefinition81Enum + Outputdefinition82Enum + Outputdefinition83Enum + Outputdefinition84Enum + Outputdefinition85Enum + Outputdefinition86Enum + Outputdefinition87Enum + Outputdefinition88Enum + Outputdefinition89Enum + Outputdefinition8Enum + Outputdefinition90Enum + Outputdefinition91Enum + Outputdefinition92Enum + Outputdefinition93Enum + Outputdefinition94Enum + Outputdefinition95Enum + Outputdefinition96Enum + Outputdefinition97Enum + Outputdefinition98Enum + Outputdefinition99Enum + Outputdefinition9Enum + Outputdefinition100Enum + InputsENDEnum + AbsoluteEnum + AdaptiveTimesteppingEnum + AdjointBalancethickness2AnalysisEnum + AdjointBalancethicknessAnalysisEnum + AdjointHorizAnalysisEnum + AggressiveMigrationEnum + AmrBamgEnum + AmrNeopzEnum + AndroidFrictionCoefficientEnum + ArrheniusEnum + AutodiffJacobianEnum + AutoregressionLinearFloatingMeltRateEnum + Balancethickness2AnalysisEnum + Balancethickness2SolutionEnum + BalancethicknessAnalysisEnum + BalancethicknessApparentMassbalanceEnum + BalancethicknessSoftAnalysisEnum + BalancethicknessSoftSolutionEnum + BalancethicknessSolutionEnum + BalancevelocityAnalysisEnum + BalancevelocitySolutionEnum + BasalforcingsIsmip6Enum + BasalforcingsPicoEnum + BeckmannGoosseFloatingMeltRateEnum + BedSlopeSolutionEnum + BoolExternalResultEnum + BoolInputEnum + IntInputEnum + DoubleInputEnum + BoolParamEnum + BoundaryEnum + BuddJackaEnum + CalvingDev2Enum + CalvingHabEnum + CalvingLevermannEnum + CalvingTestEnum + CalvingParameterizationEnum + CalvingVonmisesEnum + CfdragcoeffabsgradEnum + CfsurfacelogvelEnum + CfsurfacesquareEnum + CflevelsetmisfitEnum + ChannelEnum + ChannelAreaEnum + ChannelAreaOldEnum + ChannelDischargeEnum + ClosedEnum + ColinearEnum + ConstraintsEnum + ContactEnum + ContourEnum + ContoursEnum + ControlInputEnum + ControlInputGradEnum + ControlInputMaxsEnum + ControlInputMinsEnum + ControlInputValuesEnum + CrouzeixRaviartEnum + CuffeyEnum + CuffeyTemperateEnum + DamageEvolutionAnalysisEnum + DamageEvolutionSolutionEnum + DataSetEnum + DataSetParamEnum + DatasetInputEnum + DefaultAnalysisEnum + DefaultCalvingEnum + DenseEnum + DependentObjectEnum + DepthAverageAnalysisEnum + DeviatoricStressErrorEstimatorEnum + DivergenceEnum + Domain3DsurfaceEnum + DoubleArrayInputEnum + ArrayInputEnum + DoubleExternalResultEnum + DoubleMatArrayParamEnum + DoubleMatExternalResultEnum + DoubleMatParamEnum + DoubleParamEnum + DoubleVecParamEnum + ElementEnum + ElementHookEnum + ElementSIdEnum + EnthalpyAnalysisEnum + EsaAnalysisEnum + EsaSolutionEnum + EsaTransitionsEnum + ExternalResultEnum + ExtrapolationAnalysisEnum + ExtrudeFromBaseAnalysisEnum + ExtrudeFromTopAnalysisEnum + FSApproximationEnum + FSSolverEnum + FSpressureEnum + FSvelocityEnum + FemModelEnum + FileParamEnum + FixedTimesteppingEnum + FloatingAreaEnum + FloatingAreaScaledEnum + FloatingMeltRateEnum + FreeEnum + FreeSurfaceBaseAnalysisEnum + FreeSurfaceTopAnalysisEnum + FrontalForcingsDefaultEnum + FrontalForcingsRignotEnum + FrontalForcingsRignotAutoregressionEnum + FsetEnum + FullMeltOnPartiallyFloatingEnum + GLheightadvectionAnalysisEnum + GaussPentaEnum + GaussSegEnum + GaussTetraEnum + GaussTriaEnum + GenericOptionEnum + GenericParamEnum + GenericExternalResultEnum + Gradient1Enum + Gradient2Enum + Gradient3Enum + Gradient4Enum + GroundedAreaEnum + GroundedAreaScaledEnum + GroundingOnlyEnum + GroundinglineMassFluxEnum + GsetEnum + GslEnum + HOApproximationEnum + HOFSApproximationEnum + HookEnum + HydrologyDCEfficientAnalysisEnum + HydrologyDCInefficientAnalysisEnum + HydrologyGlaDSAnalysisEnum + HydrologyGlaDSEnum + HydrologyPismAnalysisEnum + HydrologyShaktiAnalysisEnum + HydrologyShreveAnalysisEnum + HydrologySolutionEnum + HydrologydcEnum + HydrologypismEnum + HydrologyshaktiEnum + HydrologyshreveEnum + IceMassEnum + IceMassScaledEnum + IceVolumeAboveFloatationEnum + IceVolumeAboveFloatationScaledEnum + IceVolumeEnum + IceVolumeScaledEnum + IcefrontMassFluxEnum + IcefrontMassFluxLevelsetEnum + IncrementalEnum + IndexedEnum + IntExternalResultEnum + ElementInputEnum + IntMatExternalResultEnum + IntMatParamEnum + IntParamEnum + IntVecParamEnum + InputsEnum + InternalEnum + IntersectEnum + InversionVzObsEnum + JEnum + L1L2ApproximationEnum + MLHOApproximationEnum + L2ProjectionBaseAnalysisEnum + L2ProjectionEPLAnalysisEnum + LACrouzeixRaviartEnum + LATaylorHoodEnum + LambdaSEnum + LevelsetAnalysisEnum + LevelsetfunctionPicardEnum + LinearFloatingMeltRateEnum + LliboutryDuvalEnum + LoadsEnum + LoveAnalysisEnum + LoveHfEnum + LoveHtEnum + LoveKernelsImagEnum + LoveKernelsRealEnum + LoveKfEnum + LoveKtEnum + LoveLfEnum + LoveLtEnum + LoveTidalHtEnum + LoveTidalKtEnum + LoveTidalLtEnum + LovePMTF1tEnum + LovePMTF2tEnum + LoveSolutionEnum + MINIEnum + MINIcondensedEnum + MantlePlumeGeothermalFluxEnum + MassFluxEnum + MassconEnum + MassconaxpbyEnum + MassfluxatgateEnum + MasstransportAnalysisEnum + MmemasstransportAnalysisEnum + MmemasstransportSolutionEnum + MasstransportSolutionEnum + MatdamageiceEnum + MatenhancediceEnum + MaterialsEnum + MatestarEnum + MaticeEnum + MatlithoEnum + MathydroEnum + MatrixParamEnum + MaxAbsVxEnum + MaxAbsVyEnum + MaxAbsVzEnum + MaxDivergenceEnum + MaxVelEnum + MaxVxEnum + MaxVyEnum + MaxVzEnum + MelangeEnum + MeltingAnalysisEnum + MeshElementsEnum + MeshXEnum + MeshYEnum + MinVelEnum + MinVxEnum + MinVyEnum + MinVzEnum + MismipFloatingMeltRateEnum + MoulinEnum + MpiDenseEnum + MpiEnum + MpiSparseEnum + MumpsEnum + NoFrictionOnPartiallyFloatingEnum + NoMeltOnPartiallyFloatingEnum + NodalEnum + NodalvalueEnum + NodeSIdEnum + NoneApproximationEnum + NoneEnum + NumberedcostfunctionEnum + NyeCO2Enum + NyeH2OEnum + NumericalfluxEnum + OceantransportAnalysisEnum + OceantransportSolutionEnum + OldGradientEnum + OneLayerP4zEnum + OpenEnum + OptionEnum + ParamEnum + ParametersEnum + P0ArrayEnum + P0DGEnum + P1DGEnum + P1P1Enum + P1P1GLSEnum + P1bubbleEnum + P1bubblecondensedEnum + P1xP2Enum + P1xP3Enum + P1xP4Enum + P2Enum + P2bubbleEnum + P2bubblecondensedEnum + P2xP1Enum + P2xP4Enum + PatersonEnum + PengridEnum + PenpairEnum + PentaEnum + PentaInputEnum + ProfilerEnum + ProfilingCurrentFlopsEnum + ProfilingCurrentMemEnum + ProfilingSolutionTimeEnum + RegionaloutputEnum + RegularEnum + RecoveryAnalysisEnum + RiftfrontEnum + SamplingAnalysisEnum + SamplingSolutionEnum + SIAApproximationEnum + SMBautoregressionEnum + SMBcomponentsEnum + SMBd18opddEnum + SMBforcingEnum + SMBgcmEnum + SMBgembEnum + SMBgradientsEnum + SMBgradientscomponentsEnum + SMBgradientselaEnum + SMBhenningEnum + SMBmeltcomponentsEnum + SMBpddEnum + SMBpddSicopolisEnum + SMBsemicEnum + SSAApproximationEnum + SSAFSApproximationEnum + SSAHOApproximationEnum + ScaledEnum + SealevelAbsoluteEnum + SealevelEmotionEnum + SealevelchangePolarMotionXEnum + SealevelchangePolarMotionYEnum + SealevelchangePolarMotionZEnum + SealevelchangePolarMotionEnum + SealevelNmotionEnum + SealevelUmotionEnum + SealevelchangeAnalysisEnum + SegEnum + SegInputEnum + SegmentEnum + SegmentRiftfrontEnum + SeparateEnum + SeqEnum + SmbAnalysisEnum + SmbSolutionEnum + SmoothAnalysisEnum + SoftMigrationEnum + SpatialLinearFloatingMeltRateEnum + SpcDynamicEnum + SpcStaticEnum + SpcTransientEnum + SsetEnum + StatisticsSolutionEnum + SteadystateSolutionEnum + StressIntensityFactorEnum + StressbalanceAnalysisEnum + StressbalanceConvergenceNumStepsEnum + StressbalanceSIAAnalysisEnum + StressbalanceSolutionEnum + StressbalanceVerticalAnalysisEnum + StringArrayParamEnum + StringExternalResultEnum + StringParamEnum + SubelementFriction1Enum + SubelementFriction2Enum + SubelementMelt1Enum + SubelementMelt2Enum + SubelementMigrationEnum + SurfaceSlopeSolutionEnum + TaylorHoodEnum + TetraEnum + TetraInputEnum + ThermalAnalysisEnum + ThermalSolutionEnum + ThicknessErrorEstimatorEnum + TotalCalvingFluxLevelsetEnum + TotalCalvingMeltingFluxLevelsetEnum + TotalFloatingBmbEnum + TotalFloatingBmbScaledEnum + TotalGroundedBmbEnum + TotalGroundedBmbScaledEnum + TotalSmbEnum + TotalSmbScaledEnum + TransientArrayParamEnum + TransientInputEnum + TransientParamEnum + TransientSolutionEnum + TriaEnum + TriaInputEnum + UzawaPressureAnalysisEnum + VectorParamEnum + VertexEnum + VertexLIdEnum + VertexPIdEnum + VertexSIdEnum + VerticesEnum + ViscousHeatingEnum + WaterEnum + XTaylorHoodEnum + XYEnum + XYZEnum + BalancethicknessD0Enum + BalancethicknessDiffusionCoefficientEnum + BilinearInterpEnum + CalvingdevCoeffEnum + DeviatoricStressEnum + EtaAbsGradientEnum + MeshZEnum + NearestInterpEnum + OutputdefinitionListEnum + SealevelObsEnum + SealevelWeightsEnum + StrainRateEnum + StressTensorEnum + StressbalanceViscosityOvershootEnum + SubelementMigration4Enum + TimesteppingTimeAdaptEnum + TriangleInterpEnum + MaximumNumberOfDefinitionsEnum +end + +function EnumToString(enum::IssmEnum) + if(enum==ParametersSTARTEnum) return "ParametersSTART" end + if(enum==AdolcParamEnum) return "AdolcParam" end + if(enum==AmrDeviatoricErrorGroupThresholdEnum) return "AmrDeviatoricErrorGroupThreshold" end + if(enum==AmrDeviatoricErrorMaximumEnum) return "AmrDeviatoricErrorMaximum" end + if(enum==AmrDeviatoricErrorResolutionEnum) return "AmrDeviatoricErrorResolution" end + if(enum==AmrDeviatoricErrorThresholdEnum) return "AmrDeviatoricErrorThreshold" end + if(enum==AmrErrEnum) return "AmrErr" end + if(enum==AmrFieldEnum) return "AmrField" end + if(enum==AmrGradationEnum) return "AmrGradation" end + if(enum==AmrGroundingLineDistanceEnum) return "AmrGroundingLineDistance" end + if(enum==AmrGroundingLineResolutionEnum) return "AmrGroundingLineResolution" end + if(enum==AmrHmaxEnum) return "AmrHmax" end + if(enum==AmrHminEnum) return "AmrHmin" end + if(enum==AmrIceFrontDistanceEnum) return "AmrIceFrontDistance" end + if(enum==AmrIceFrontResolutionEnum) return "AmrIceFrontResolution" end + if(enum==AmrKeepMetricEnum) return "AmrKeepMetric" end + if(enum==AmrLagEnum) return "AmrLag" end + if(enum==AmrLevelMaxEnum) return "AmrLevelMax" end + if(enum==AmrRestartEnum) return "AmrRestart" end + if(enum==AmrThicknessErrorGroupThresholdEnum) return "AmrThicknessErrorGroupThreshold" end + if(enum==AmrThicknessErrorMaximumEnum) return "AmrThicknessErrorMaximum" end + if(enum==AmrThicknessErrorResolutionEnum) return "AmrThicknessErrorResolution" end + if(enum==AmrThicknessErrorThresholdEnum) return "AmrThicknessErrorThreshold" end + if(enum==AmrTypeEnum) return "AmrType" end + if(enum==AnalysisCounterEnum) return "AnalysisCounter" end + if(enum==AnalysisTypeEnum) return "AnalysisType" end + if(enum==AugmentedLagrangianREnum) return "AugmentedLagrangianR" end + if(enum==AugmentedLagrangianRholambdaEnum) return "AugmentedLagrangianRholambda" end + if(enum==AugmentedLagrangianRhopEnum) return "AugmentedLagrangianRhop" end + if(enum==AugmentedLagrangianRlambdaEnum) return "AugmentedLagrangianRlambda" end + if(enum==AugmentedLagrangianThetaEnum) return "AugmentedLagrangianTheta" end + if(enum==AutodiffCbufsizeEnum) return "AutodiffCbufsize" end + if(enum==AutodiffDependentObjectsEnum) return "AutodiffDependentObjects" end + if(enum==AutodiffDriverEnum) return "AutodiffDriver" end + if(enum==AutodiffFosForwardIndexEnum) return "AutodiffFosForwardIndex" end + if(enum==AutodiffFosReverseIndexEnum) return "AutodiffFosReverseIndex" end + if(enum==AutodiffFovForwardIndicesEnum) return "AutodiffFovForwardIndices" end + if(enum==AutodiffGcTriggerMaxSizeEnum) return "AutodiffGcTriggerMaxSize" end + if(enum==AutodiffGcTriggerRatioEnum) return "AutodiffGcTriggerRatio" end + if(enum==AutodiffIsautodiffEnum) return "AutodiffIsautodiff" end + if(enum==AutodiffLbufsizeEnum) return "AutodiffLbufsize" end + if(enum==AutodiffNumDependentsEnum) return "AutodiffNumDependents" end + if(enum==AutodiffNumIndependentsEnum) return "AutodiffNumIndependents" end + if(enum==AutodiffObufsizeEnum) return "AutodiffObufsize" end + if(enum==AutodiffTapeAllocEnum) return "AutodiffTapeAlloc" end + if(enum==AutodiffTbufsizeEnum) return "AutodiffTbufsize" end + if(enum==AutodiffXpEnum) return "AutodiffXp" end + if(enum==BalancethicknessStabilizationEnum) return "BalancethicknessStabilization" end + if(enum==BarystaticContributionsEnum) return "BarystaticContributions" end + if(enum==BasalforcingsAutoregressionInitialTimeEnum) return "BasalforcingsAutoregressionInitialTime" end + if(enum==BasalforcingsAutoregressionTimestepEnum) return "BasalforcingsAutoregressionTimestep" end + if(enum==BasalforcingsAutoregressiveOrderEnum) return "BasalforcingsAutoregressiveOrder" end + if(enum==BasalforcingsBeta0Enum) return "BasalforcingsBeta0" end + if(enum==BasalforcingsBeta1Enum) return "BasalforcingsBeta1" end + if(enum==BasalforcingsBottomplumedepthEnum) return "BasalforcingsBottomplumedepth" end + if(enum==BasalforcingsCrustthicknessEnum) return "BasalforcingsCrustthickness" end + if(enum==BasalforcingsDeepwaterElevationEnum) return "BasalforcingsDeepwaterElevation" end + if(enum==BasalforcingsDeepwaterMeltingRateEnum) return "BasalforcingsDeepwaterMeltingRate" end + if(enum==BasalforcingsDtbgEnum) return "BasalforcingsDtbg" end + if(enum==BasalforcingsEnum) return "Basalforcings" end + if(enum==BasalforcingsIsmip6AverageTfEnum) return "BasalforcingsIsmip6AverageTf" end + if(enum==BasalforcingsIsmip6BasinAreaEnum) return "BasalforcingsIsmip6BasinArea" end + if(enum==BasalforcingsIsmip6DeltaTEnum) return "BasalforcingsIsmip6DeltaT" end + if(enum==BasalforcingsIsmip6Gamma0Enum) return "BasalforcingsIsmip6Gamma0" end + if(enum==BasalforcingsIsmip6IsLocalEnum) return "BasalforcingsIsmip6IsLocal" end + if(enum==BasalforcingsIsmip6NumBasinsEnum) return "BasalforcingsIsmip6NumBasins" end + if(enum==BasalforcingsIsmip6TfDepthsEnum) return "BasalforcingsIsmip6TfDepths" end + if(enum==BasalforcingsLinearNumBasinsEnum) return "BasalforcingsLinearNumBasins" end + if(enum==BasalforcingsLowercrustheatEnum) return "BasalforcingsLowercrustheat" end + if(enum==BasalforcingsMantleconductivityEnum) return "BasalforcingsMantleconductivity" end + if(enum==BasalforcingsNusseltEnum) return "BasalforcingsNusselt" end + if(enum==BasalforcingsPhiEnum) return "BasalforcingsPhi" end + if(enum==BasalforcingsPicoAverageOverturningEnum) return "BasalforcingsPicoAverageOverturning" end + if(enum==BasalforcingsPicoAverageSalinityEnum) return "BasalforcingsPicoAverageSalinity" end + if(enum==BasalforcingsPicoAverageTemperatureEnum) return "BasalforcingsPicoAverageTemperature" end + if(enum==BasalforcingsPicoBoxAreaEnum) return "BasalforcingsPicoBoxArea" end + if(enum==BasalforcingsPicoFarOceansalinityEnum) return "BasalforcingsPicoFarOceansalinity" end + if(enum==BasalforcingsPicoFarOceantemperatureEnum) return "BasalforcingsPicoFarOceantemperature" end + if(enum==BasalforcingsPicoGammaTEnum) return "BasalforcingsPicoGammaT" end + if(enum==BasalforcingsPicoIsplumeEnum) return "BasalforcingsPicoIsplume" end + if(enum==BasalforcingsPicoMaxboxcountEnum) return "BasalforcingsPicoMaxboxcount" end + if(enum==BasalforcingsPicoNumBasinsEnum) return "BasalforcingsPicoNumBasins" end + if(enum==BasalforcingsPlumeradiusEnum) return "BasalforcingsPlumeradius" end + if(enum==BasalforcingsPlumexEnum) return "BasalforcingsPlumex" end + if(enum==BasalforcingsPlumeyEnum) return "BasalforcingsPlumey" end + if(enum==BasalforcingsThresholdThicknessEnum) return "BasalforcingsThresholdThickness" end + if(enum==BasalforcingsTopplumedepthEnum) return "BasalforcingsTopplumedepth" end + if(enum==BasalforcingsUppercrustheatEnum) return "BasalforcingsUppercrustheat" end + if(enum==BasalforcingsUppercrustthicknessEnum) return "BasalforcingsUppercrustthickness" end + if(enum==BasalforcingsUpperdepthMeltEnum) return "BasalforcingsUpperdepthMelt" end + if(enum==BasalforcingsUpperwaterElevationEnum) return "BasalforcingsUpperwaterElevation" end + if(enum==BasalforcingsUpperwaterMeltingRateEnum) return "BasalforcingsUpperwaterMeltingRate" end + if(enum==CalvingCrevasseDepthEnum) return "CalvingCrevasseDepth" end + if(enum==CalvingCrevasseThresholdEnum) return "CalvingCrevasseThreshold" end + if(enum==CalvingHeightAboveFloatationEnum) return "CalvingHeightAboveFloatation" end + if(enum==CalvingLawEnum) return "CalvingLaw" end + if(enum==CalvingMinthicknessEnum) return "CalvingMinthickness" end + if(enum==CalvingTestSpeedfactorEnum) return "CalvingTestSpeedfactor" end + if(enum==CalvingUseParamEnum) return "CalvingUseParam" end + if(enum==CalvingScaleThetaEnum) return "CalvingScaleTheta" end + if(enum==CalvingAmpAlphaEnum) return "CalvingAmpAlpha" end + if(enum==CalvingMidpointEnum) return "CalvingMidpoint" end + if(enum==CalvingNonlinearLawEnum) return "CalvingNonlinearLaw" end + if(enum==ConfigurationTypeEnum) return "ConfigurationType" end + if(enum==ConstantsGEnum) return "ConstantsG" end + if(enum==ConstantsNewtonGravityEnum) return "ConstantsNewtonGravity" end + if(enum==ConstantsReferencetemperatureEnum) return "ConstantsReferencetemperature" end + if(enum==ConstantsYtsEnum) return "ConstantsYts" end + if(enum==ControlInputSizeMEnum) return "ControlInputSizeM" end + if(enum==ControlInputSizeNEnum) return "ControlInputSizeN" end + if(enum==ControlInputInterpolationEnum) return "ControlInputInterpolation" end + if(enum==CumBslcEnum) return "CumBslc" end + if(enum==CumBslcIceEnum) return "CumBslcIce" end + if(enum==CumBslcHydroEnum) return "CumBslcHydro" end + if(enum==CumBslcOceanEnum) return "CumBslcOcean" end + if(enum==CumBslcIcePartitionEnum) return "CumBslcIcePartition" end + if(enum==CumBslcHydroPartitionEnum) return "CumBslcHydroPartition" end + if(enum==CumBslcOceanPartitionEnum) return "CumBslcOceanPartition" end + if(enum==CumGmtslcEnum) return "CumGmtslc" end + if(enum==CumGmslcEnum) return "CumGmslc" end + if(enum==DamageC1Enum) return "DamageC1" end + if(enum==DamageC2Enum) return "DamageC2" end + if(enum==DamageC3Enum) return "DamageC3" end + if(enum==DamageC4Enum) return "DamageC4" end + if(enum==DamageEnum) return "Damage" end + if(enum==DamageEquivStressEnum) return "DamageEquivStress" end + if(enum==DamageEvolutionNumRequestedOutputsEnum) return "DamageEvolutionNumRequestedOutputs" end + if(enum==DamageEvolutionRequestedOutputsEnum) return "DamageEvolutionRequestedOutputs" end + if(enum==DamageHealingEnum) return "DamageHealing" end + if(enum==DamageKappaEnum) return "DamageKappa" end + if(enum==DamageLawEnum) return "DamageLaw" end + if(enum==DamageMaxDamageEnum) return "DamageMaxDamage" end + if(enum==DamageStabilizationEnum) return "DamageStabilization" end + if(enum==DamageStressThresholdEnum) return "DamageStressThreshold" end + if(enum==DamageStressUBoundEnum) return "DamageStressUBound" end + if(enum==DebugProfilingEnum) return "DebugProfiling" end + if(enum==DomainDimensionEnum) return "DomainDimension" end + if(enum==DomainTypeEnum) return "DomainType" end + if(enum==DslModelEnum) return "DslModel" end + if(enum==DslModelidEnum) return "DslModelid" end + if(enum==DslNummodelsEnum) return "DslNummodels" end + if(enum==SolidearthIsExternalEnum) return "SolidearthIsExternal" end + if(enum==SolidearthExternalNatureEnum) return "SolidearthExternalNature" end + if(enum==SolidearthExternalModelidEnum) return "SolidearthExternalModelid" end + if(enum==SolidearthExternalNummodelsEnum) return "SolidearthExternalNummodels" end + if(enum==SolidearthSettingsComputeBpGrdEnum) return "SolidearthSettingsComputeBpGrd" end + if(enum==EarthIdEnum) return "EarthId" end + if(enum==ElasticEnum) return "Elastic" end + if(enum==EplZigZagCounterEnum) return "EplZigZagCounter" end + if(enum==EsaHElasticEnum) return "EsaHElastic" end + if(enum==EsaHemisphereEnum) return "EsaHemisphere" end + if(enum==EsaRequestedOutputsEnum) return "EsaRequestedOutputs" end + if(enum==EsaUElasticEnum) return "EsaUElastic" end + if(enum==ExtrapolationVariableEnum) return "ExtrapolationVariable" end + if(enum==FemModelCommEnum) return "FemModelComm" end + if(enum==FieldsEnum) return "Fields" end + if(enum==FlowequationFeFSEnum) return "FlowequationFeFS" end + if(enum==FlowequationIsFSEnum) return "FlowequationIsFS" end + if(enum==FlowequationIsHOEnum) return "FlowequationIsHO" end + if(enum==FlowequationIsL1L2Enum) return "FlowequationIsL1L2" end + if(enum==FlowequationIsMLHOEnum) return "FlowequationIsMLHO" end + if(enum==FlowequationIsSIAEnum) return "FlowequationIsSIA" end + if(enum==FlowequationIsSSAEnum) return "FlowequationIsSSA" end + if(enum==FlowequationIsNitscheEnum) return "FlowequationIsNitsche" end + if(enum==FeFSNitscheGammaEnum) return "FeFSNitscheGamma" end + if(enum==FrictionCouplingEnum) return "FrictionCoupling" end + if(enum==FrictionDeltaEnum) return "FrictionDelta" end + if(enum==FrictionEffectivePressureLimitEnum) return "FrictionEffectivePressureLimit" end + if(enum==FrictionFEnum) return "FrictionF" end + if(enum==FrictionGammaEnum) return "FrictionGamma" end + if(enum==FrictionLawEnum) return "FrictionLaw" end + if(enum==FrictionPseudoplasticityExponentEnum) return "FrictionPseudoplasticityExponent" end + if(enum==FrictionThresholdSpeedEnum) return "FrictionThresholdSpeed" end + if(enum==FrictionVoidRatioEnum) return "FrictionVoidRatio" end + if(enum==FrontalForcingsBasinIcefrontAreaEnum) return "FrontalForcingsBasinIcefrontArea" end + if(enum==FrontalForcingsAutoregressionInitialTimeEnum) return "FrontalForcingsAutoregressionInitialTime" end + if(enum==FrontalForcingsAutoregressionTimestepEnum) return "FrontalForcingsAutoregressionTimestep" end + if(enum==FrontalForcingsAutoregressiveOrderEnum) return "FrontalForcingsAutoregressiveOrder" end + if(enum==FrontalForcingsBeta0Enum) return "FrontalForcingsBeta0" end + if(enum==FrontalForcingsBeta1Enum) return "FrontalForcingsBeta1" end + if(enum==FrontalForcingsNumberofBasinsEnum) return "FrontalForcingsNumberofBasins" end + if(enum==FrontalForcingsParamEnum) return "FrontalForcingsParam" end + if(enum==FrontalForcingsPhiEnum) return "FrontalForcingsPhi" end + if(enum==GrdModelEnum) return "GrdModel" end + if(enum==GroundinglineFrictionInterpolationEnum) return "GroundinglineFrictionInterpolation" end + if(enum==GroundinglineMeltInterpolationEnum) return "GroundinglineMeltInterpolation" end + if(enum==GroundinglineMigrationEnum) return "GroundinglineMigration" end + if(enum==GroundinglineNumRequestedOutputsEnum) return "GroundinglineNumRequestedOutputs" end + if(enum==GroundinglineRequestedOutputsEnum) return "GroundinglineRequestedOutputs" end + if(enum==HydrologyAveragingEnum) return "HydrologyAveraging" end + if(enum==HydrologyCavitySpacingEnum) return "HydrologyCavitySpacing" end + if(enum==HydrologyChannelConductivityEnum) return "HydrologyChannelConductivity" end + if(enum==HydrologyChannelSheetWidthEnum) return "HydrologyChannelSheetWidth" end + if(enum==HydrologyEnglacialVoidRatioEnum) return "HydrologyEnglacialVoidRatio" end + if(enum==HydrologyIschannelsEnum) return "HydrologyIschannels" end + if(enum==HydrologyMeltFlagEnum) return "HydrologyMeltFlag" end + if(enum==HydrologyModelEnum) return "HydrologyModel" end + if(enum==HydrologyNumRequestedOutputsEnum) return "HydrologyNumRequestedOutputs" end + if(enum==HydrologyPressureMeltCoefficientEnum) return "HydrologyPressureMeltCoefficient" end + if(enum==HydrologyRelaxationEnum) return "HydrologyRelaxation" end + if(enum==HydrologyRequestedOutputsEnum) return "HydrologyRequestedOutputs" end + if(enum==HydrologySedimentKmaxEnum) return "HydrologySedimentKmax" end + if(enum==HydrologyStepsPerStepEnum) return "HydrologyStepsPerStep" end + if(enum==HydrologyStorageEnum) return "HydrologyStorage" end + if(enum==HydrologydcEplColapseThicknessEnum) return "HydrologydcEplColapseThickness" end + if(enum==HydrologydcEplConductivityEnum) return "HydrologydcEplConductivity" end + if(enum==HydrologydcEplInitialThicknessEnum) return "HydrologydcEplInitialThickness" end + if(enum==HydrologydcEplLayerCompressibilityEnum) return "HydrologydcEplLayerCompressibility" end + if(enum==HydrologydcEplMaxThicknessEnum) return "HydrologydcEplMaxThickness" end + if(enum==HydrologydcEplPoreWaterMassEnum) return "HydrologydcEplPoreWaterMass" end + if(enum==HydrologydcEplThickCompEnum) return "HydrologydcEplThickComp" end + if(enum==HydrologydcEplflipLockEnum) return "HydrologydcEplflipLock" end + if(enum==HydrologydcIsefficientlayerEnum) return "HydrologydcIsefficientlayer" end + if(enum==HydrologydcLeakageFactorEnum) return "HydrologydcLeakageFactor" end + if(enum==HydrologydcMaxIterEnum) return "HydrologydcMaxIter" end + if(enum==HydrologydcPenaltyFactorEnum) return "HydrologydcPenaltyFactor" end + if(enum==HydrologydcPenaltyLockEnum) return "HydrologydcPenaltyLock" end + if(enum==HydrologydcRelTolEnum) return "HydrologydcRelTol" end + if(enum==HydrologydcSedimentlimitEnum) return "HydrologydcSedimentlimit" end + if(enum==HydrologydcSedimentlimitFlagEnum) return "HydrologydcSedimentlimitFlag" end + if(enum==HydrologydcSedimentLayerCompressibilityEnum) return "HydrologydcSedimentLayerCompressibility" end + if(enum==HydrologydcSedimentPoreWaterMassEnum) return "HydrologydcSedimentPoreWaterMass" end + if(enum==HydrologydcSedimentPorosityEnum) return "HydrologydcSedimentPorosity" end + if(enum==HydrologydcSedimentThicknessEnum) return "HydrologydcSedimentThickness" end + if(enum==HydrologydcTransferFlagEnum) return "HydrologydcTransferFlag" end + if(enum==HydrologydcUnconfinedFlagEnum) return "HydrologydcUnconfinedFlag" end + if(enum==HydrologyshreveStabilizationEnum) return "HydrologyshreveStabilization" end + if(enum==IcecapToEarthCommEnum) return "IcecapToEarthComm" end + if(enum==IndexEnum) return "Index" end + if(enum==InputFileNameEnum) return "InputFileName" end + if(enum==DirectoryNameEnum) return "DirectoryName" end + if(enum==IndicesEnum) return "Indices" end + if(enum==InputToDepthaverageInEnum) return "InputToDepthaverageIn" end + if(enum==InputToDepthaverageOutEnum) return "InputToDepthaverageOut" end + if(enum==InputToExtrudeEnum) return "InputToExtrude" end + if(enum==InputToL2ProjectEnum) return "InputToL2Project" end + if(enum==InputToSmoothEnum) return "InputToSmooth" end + if(enum==InversionAlgorithmEnum) return "InversionAlgorithm" end + if(enum==InversionControlParametersEnum) return "InversionControlParameters" end + if(enum==InversionControlScalingFactorsEnum) return "InversionControlScalingFactors" end + if(enum==InversionCostFunctionsEnum) return "InversionCostFunctions" end + if(enum==InversionDxminEnum) return "InversionDxmin" end + if(enum==InversionGatolEnum) return "InversionGatol" end + if(enum==InversionGradientScalingEnum) return "InversionGradientScaling" end + if(enum==InversionGrtolEnum) return "InversionGrtol" end + if(enum==InversionGttolEnum) return "InversionGttol" end + if(enum==InversionIncompleteAdjointEnum) return "InversionIncompleteAdjoint" end + if(enum==InversionIscontrolEnum) return "InversionIscontrol" end + if(enum==InversionMaxiterEnum) return "InversionMaxiter" end + if(enum==InversionMaxiterPerStepEnum) return "InversionMaxiterPerStep" end + if(enum==InversionMaxstepsEnum) return "InversionMaxsteps" end + if(enum==InversionNstepsEnum) return "InversionNsteps" end + if(enum==InversionNumControlParametersEnum) return "InversionNumControlParameters" end + if(enum==InversionNumCostFunctionsEnum) return "InversionNumCostFunctions" end + if(enum==InversionStepThresholdEnum) return "InversionStepThreshold" end + if(enum==InversionTypeEnum) return "InversionType" end + if(enum==IvinsEnum) return "Ivins" end + if(enum==IsSlcCouplingEnum) return "IsSlcCoupling" end + if(enum==LevelsetKillIcebergsEnum) return "LevelsetKillIcebergs" end + if(enum==LevelsetReinitFrequencyEnum) return "LevelsetReinitFrequency" end + if(enum==LevelsetStabilizationEnum) return "LevelsetStabilization" end + if(enum==LockFileNameEnum) return "LockFileName" end + if(enum==LoveAllowLayerDeletionEnum) return "LoveAllowLayerDeletion" end + if(enum==LoveChandlerWobbleEnum) return "LoveChandlerWobble" end + if(enum==LoveCoreMantleBoundaryEnum) return "LoveCoreMantleBoundary" end + if(enum==LoveEarthMassEnum) return "LoveEarthMass" end + if(enum==LoveForcingTypeEnum) return "LoveForcingType" end + if(enum==LoveFrequenciesEnum) return "LoveFrequencies" end + if(enum==LoveIsTemporalEnum) return "LoveIsTemporal" end + if(enum==LoveG0Enum) return "LoveG0" end + if(enum==LoveGravitationalConstantEnum) return "LoveGravitationalConstant" end + if(enum==LoveInnerCoreBoundaryEnum) return "LoveInnerCoreBoundary" end + if(enum==LoveComplexComputationEnum) return "LoveComplexComputation" end + if(enum==LoveIntStepsPerLayerEnum) return "LoveIntStepsPerLayer" end + if(enum==LoveKernelsEnum) return "LoveKernels" end + if(enum==LoveMu0Enum) return "LoveMu0" end + if(enum==LoveNfreqEnum) return "LoveNfreq" end + if(enum==LoveNTemporalIterationsEnum) return "LoveNTemporalIterations" end + if(enum==LoveNYiEquationsEnum) return "LoveNYiEquations" end + if(enum==LoveR0Enum) return "LoveR0" end + if(enum==LoveShNmaxEnum) return "LoveShNmax" end + if(enum==LoveShNminEnum) return "LoveShNmin" end + if(enum==LoveStartingLayerEnum) return "LoveStartingLayer" end + if(enum==LoveUnderflowTolEnum) return "LoveUnderflowTol" end + if(enum==LovePostWidderThresholdEnum) return "LovePostWidderThreshold" end + if(enum==MassFluxSegmentsEnum) return "MassFluxSegments" end + if(enum==MassFluxSegmentsPresentEnum) return "MassFluxSegmentsPresent" end + if(enum==MasstransportHydrostaticAdjustmentEnum) return "MasstransportHydrostaticAdjustment" end + if(enum==MasstransportIsfreesurfaceEnum) return "MasstransportIsfreesurface" end + if(enum==MasstransportMinThicknessEnum) return "MasstransportMinThickness" end + if(enum==MasstransportNumRequestedOutputsEnum) return "MasstransportNumRequestedOutputs" end + if(enum==MasstransportPenaltyFactorEnum) return "MasstransportPenaltyFactor" end + if(enum==MasstransportRequestedOutputsEnum) return "MasstransportRequestedOutputs" end + if(enum==MasstransportStabilizationEnum) return "MasstransportStabilization" end + if(enum==MmemasstransportModelidsEnum) return "MmemasstransportModelids" end + if(enum==MmemasstransportPartitionEnum) return "MmemasstransportPartition" end + if(enum==MaterialsBetaEnum) return "MaterialsBeta" end + if(enum==MaterialsEarthDensityEnum) return "MaterialsEarthDensity" end + if(enum==MaterialsEffectiveconductivityAveragingEnum) return "MaterialsEffectiveconductivityAveraging" end + if(enum==MaterialsHeatcapacityEnum) return "MaterialsHeatcapacity" end + if(enum==MaterialsLatentheatEnum) return "MaterialsLatentheat" end + if(enum==MaterialsMeltingpointEnum) return "MaterialsMeltingpoint" end + if(enum==MaterialsMixedLayerCapacityEnum) return "MaterialsMixedLayerCapacity" end + if(enum==MaterialsMuWaterEnum) return "MaterialsMuWater" end + if(enum==MaterialsRheologyLawEnum) return "MaterialsRheologyLaw" end + if(enum==MaterialsRhoFreshwaterEnum) return "MaterialsRhoFreshwater" end + if(enum==MaterialsRhoIceEnum) return "MaterialsRhoIce" end + if(enum==MaterialsRhoSeawaterEnum) return "MaterialsRhoSeawater" end + if(enum==MaterialsTemperateiceconductivityEnum) return "MaterialsTemperateiceconductivity" end + if(enum==MaterialsThermalExchangeVelocityEnum) return "MaterialsThermalExchangeVelocity" end + if(enum==MaterialsThermalconductivityEnum) return "MaterialsThermalconductivity" end + if(enum==MeltingOffsetEnum) return "MeltingOffset" end + if(enum==MeshAverageVertexConnectivityEnum) return "MeshAverageVertexConnectivity" end + if(enum==MeshElementtypeEnum) return "MeshElementtype" end + if(enum==MeshNumberoflayersEnum) return "MeshNumberoflayers" end + if(enum==MeshNumberofverticesEnum) return "MeshNumberofvertices" end + if(enum==MeshNumberofelementsEnum) return "MeshNumberofelements" end + if(enum==MigrationMaxEnum) return "MigrationMax" end + if(enum==ModelIdEnum) return "ModelId" end + if(enum==NbinsEnum) return "Nbins" end + if(enum==NodesEnum) return "Nodes" end + if(enum==NumModelsEnum) return "NumModels" end + if(enum==OceanGridNxEnum) return "OceanGridNx" end + if(enum==OceanGridNyEnum) return "OceanGridNy" end + if(enum==OceanGridXEnum) return "OceanGridX" end + if(enum==OceanGridYEnum) return "OceanGridY" end + if(enum==OutputBufferPointerEnum) return "OutputBufferPointer" end + if(enum==OutputBufferSizePointerEnum) return "OutputBufferSizePointer" end + if(enum==OutputFileNameEnum) return "OutputFileName" end + if(enum==OutputFilePointerEnum) return "OutputFilePointer" end + if(enum==OutputdefinitionEnum) return "Outputdefinition" end + if(enum==QmuErrNameEnum) return "QmuErrName" end + if(enum==QmuInNameEnum) return "QmuInName" end + if(enum==QmuIsdakotaEnum) return "QmuIsdakota" end + if(enum==QmuOutNameEnum) return "QmuOutName" end + if(enum==QmuOutputEnum) return "QmuOutput" end + if(enum==QmuCurrEvalIdEnum) return "QmuCurrEvalId" end + if(enum==QmuNsampleEnum) return "QmuNsample" end + if(enum==QmuResponsedescriptorsEnum) return "QmuResponsedescriptors" end + if(enum==QmuVariableDescriptorsEnum) return "QmuVariableDescriptors" end + if(enum==QmuVariablePartitionsEnum) return "QmuVariablePartitions" end + if(enum==QmuVariablePartitionsNpartEnum) return "QmuVariablePartitionsNpart" end + if(enum==QmuVariablePartitionsNtEnum) return "QmuVariablePartitionsNt" end + if(enum==QmuResponsePartitionsEnum) return "QmuResponsePartitions" end + if(enum==QmuResponsePartitionsNpartEnum) return "QmuResponsePartitionsNpart" end + if(enum==QmuStatisticsEnum) return "QmuStatistics" end + if(enum==QmuNumstatisticsEnum) return "QmuNumstatistics" end + if(enum==QmuNdirectoriesEnum) return "QmuNdirectories" end + if(enum==QmuNfilesPerDirectoryEnum) return "QmuNfilesPerDirectory" end + if(enum==QmuStatisticsMethodEnum) return "QmuStatisticsMethod" end + if(enum==QmuMethodsEnum) return "QmuMethods" end + if(enum==RestartFileNameEnum) return "RestartFileName" end + if(enum==ResultsEnum) return "Results" end + if(enum==RootPathEnum) return "RootPath" end + if(enum==ModelnameEnum) return "Modelname" end + if(enum==SamplingAlphaEnum) return "SamplingAlpha" end + if(enum==SamplingNumRequestedOutputsEnum) return "SamplingNumRequestedOutputs" end + if(enum==SamplingRequestedOutputsEnum) return "SamplingRequestedOutputs" end + if(enum==SamplingRobinEnum) return "SamplingRobin" end + if(enum==SamplingSeedEnum) return "SamplingSeed" end + if(enum==SaveResultsEnum) return "SaveResults" end + if(enum==SolidearthPartitionIceEnum) return "SolidearthPartitionIce" end + if(enum==SolidearthPartitionHydroEnum) return "SolidearthPartitionHydro" end + if(enum==SolidearthPartitionOceanEnum) return "SolidearthPartitionOcean" end + if(enum==SolidearthNpartIceEnum) return "SolidearthNpartIce" end + if(enum==SolidearthNpartOceanEnum) return "SolidearthNpartOcean" end + if(enum==SolidearthNpartHydroEnum) return "SolidearthNpartHydro" end + if(enum==SolidearthPlanetRadiusEnum) return "SolidearthPlanetRadius" end + if(enum==SolidearthPlanetAreaEnum) return "SolidearthPlanetArea" end + if(enum==SolidearthSettingsAbstolEnum) return "SolidearthSettingsAbstol" end + if(enum==SolidearthSettingsCrossSectionShapeEnum) return "SolidearthSettingsCrossSectionShape" end + if(enum==SolidearthSettingsElasticEnum) return "SolidearthSettingsElastic" end + if(enum==SolidearthSettingsViscousEnum) return "SolidearthSettingsViscous" end + if(enum==SealevelchangeGeometryDoneEnum) return "SealevelchangeGeometryDone" end + if(enum==SealevelchangeViscousNumStepsEnum) return "SealevelchangeViscousNumSteps" end + if(enum==SealevelchangeViscousTimesEnum) return "SealevelchangeViscousTimes" end + if(enum==SealevelchangeViscousIndexEnum) return "SealevelchangeViscousIndex" end + if(enum==SealevelchangeViscousPolarMotionEnum) return "SealevelchangeViscousPolarMotion" end + if(enum==SealevelchangeRunCountEnum) return "SealevelchangeRunCount" end + if(enum==SealevelchangeTransitionsEnum) return "SealevelchangeTransitions" end + if(enum==SealevelchangeRequestedOutputsEnum) return "SealevelchangeRequestedOutputs" end + if(enum==RotationalAngularVelocityEnum) return "RotationalAngularVelocity" end + if(enum==RotationalEquatorialMoiEnum) return "RotationalEquatorialMoi" end + if(enum==RotationalPolarMoiEnum) return "RotationalPolarMoi" end + if(enum==LovePolarMotionTransferFunctionColinearEnum) return "LovePolarMotionTransferFunctionColinear" end + if(enum==LovePolarMotionTransferFunctionOrthogonalEnum) return "LovePolarMotionTransferFunctionOrthogonal" end + if(enum==TidalLoveHEnum) return "TidalLoveH" end + if(enum==TidalLoveKEnum) return "TidalLoveK" end + if(enum==TidalLoveLEnum) return "TidalLoveL" end + if(enum==TidalLoveK2SecularEnum) return "TidalLoveK2Secular" end + if(enum==LoadLoveHEnum) return "LoadLoveH" end + if(enum==LoadLoveKEnum) return "LoadLoveK" end + if(enum==LoadLoveLEnum) return "LoadLoveL" end + if(enum==LoveTimeFreqEnum) return "LoveTimeFreq" end + if(enum==LoveIsTimeEnum) return "LoveIsTime" end + if(enum==SealevelchangeGSelfAttractionEnum) return "SealevelchangeGSelfAttraction" end + if(enum==SealevelchangeGViscoElasticEnum) return "SealevelchangeGViscoElastic" end + if(enum==SealevelchangeUViscoElasticEnum) return "SealevelchangeUViscoElastic" end + if(enum==SealevelchangeHViscoElasticEnum) return "SealevelchangeHViscoElastic" end + if(enum==SealevelchangePolarMotionTransferFunctionColinearEnum) return "SealevelchangePolarMotionTransferFunctionColinear" end + if(enum==SealevelchangePolarMotionTransferFunctionOrthogonalEnum) return "SealevelchangePolarMotionTransferFunctionOrthogonal" end + if(enum==SealevelchangePolarMotionTransferFunctionZEnum) return "SealevelchangePolarMotionTransferFunctionZ" end + if(enum==SealevelchangeTidalK2Enum) return "SealevelchangeTidalK2" end + if(enum==SealevelchangeTidalH2Enum) return "SealevelchangeTidalH2" end + if(enum==SealevelchangeTidalL2Enum) return "SealevelchangeTidalL2" end + if(enum==SolidearthSettingsSealevelLoadingEnum) return "SolidearthSettingsSealevelLoading" end + if(enum==SolidearthSettingsGRDEnum) return "SolidearthSettingsGRD" end + if(enum==SolidearthSettingsRunFrequencyEnum) return "SolidearthSettingsRunFrequency" end + if(enum==SolidearthSettingsTimeAccEnum) return "SolidearthSettingsTimeAcc" end + if(enum==SolidearthSettingsHorizEnum) return "SolidearthSettingsHoriz" end + if(enum==SolidearthSettingsMaxiterEnum) return "SolidearthSettingsMaxiter" end + if(enum==SolidearthSettingsGrdOceanEnum) return "SolidearthSettingsGrdOcean" end + if(enum==SolidearthSettingsOceanAreaScalingEnum) return "SolidearthSettingsOceanAreaScaling" end + if(enum==StochasticForcingCovarianceEnum) return "StochasticForcingCovariance" end + if(enum==StochasticForcingDefaultDimensionEnum) return "StochasticForcingDefaultDimension" end + if(enum==StochasticForcingDimensionsEnum) return "StochasticForcingDimensions" end + if(enum==StochasticForcingFieldsEnum) return "StochasticForcingFields" end + if(enum==StochasticForcingIsEffectivePressureEnum) return "StochasticForcingIsEffectivePressure" end + if(enum==StochasticForcingIsStochasticForcingEnum) return "StochasticForcingIsStochasticForcing" end + if(enum==StochasticForcingIsWaterPressureEnum) return "StochasticForcingIsWaterPressure" end + if(enum==StochasticForcingNoisetermsEnum) return "StochasticForcingNoiseterms" end + if(enum==StochasticForcingNumFieldsEnum) return "StochasticForcingNumFields" end + if(enum==StochasticForcingRandomflagEnum) return "StochasticForcingRandomflag" end + if(enum==StochasticForcingTimestepEnum) return "StochasticForcingTimestep" end + if(enum==SolidearthSettingsReltolEnum) return "SolidearthSettingsReltol" end + if(enum==SolidearthSettingsSelfAttractionEnum) return "SolidearthSettingsSelfAttraction" end + if(enum==SolidearthSettingsRotationEnum) return "SolidearthSettingsRotation" end + if(enum==SolidearthSettingsMaxSHCoeffEnum) return "SolidearthSettingsMaxSHCoeff" end + if(enum==SettingsIoGatherEnum) return "SettingsIoGather" end + if(enum==SettingsNumResultsOnNodesEnum) return "SettingsNumResultsOnNodes" end + if(enum==SettingsOutputFrequencyEnum) return "SettingsOutputFrequency" end + if(enum==SettingsCheckpointFrequencyEnum) return "SettingsCheckpointFrequency" end + if(enum==SettingsResultsOnNodesEnum) return "SettingsResultsOnNodes" end + if(enum==SettingsSbCouplingFrequencyEnum) return "SettingsSbCouplingFrequency" end + if(enum==SettingsSolverResidueThresholdEnum) return "SettingsSolverResidueThreshold" end + if(enum==SettingsWaitonlockEnum) return "SettingsWaitonlock" end + if(enum==SmbAIceEnum) return "SmbAIce" end + if(enum==SmbAIdxEnum) return "SmbAIdx" end + if(enum==SmbASnowEnum) return "SmbASnow" end + if(enum==SmbAccualtiEnum) return "SmbAccualti" end + if(enum==SmbAccugradEnum) return "SmbAccugrad" end + if(enum==SmbAccurefEnum) return "SmbAccuref" end + if(enum==SmbAdThreshEnum) return "SmbAdThresh" end + if(enum==SmbAutoregressionInitialTimeEnum) return "SmbAutoregressionInitialTime" end + if(enum==SmbAutoregressionTimestepEnum) return "SmbAutoregressionTimestep" end + if(enum==SmbAutoregressiveOrderEnum) return "SmbAutoregressiveOrder" end + if(enum==SmbAveragingEnum) return "SmbAveraging" end + if(enum==SmbBeta0Enum) return "SmbBeta0" end + if(enum==SmbBeta1Enum) return "SmbBeta1" end + if(enum==SmbDesfacEnum) return "SmbDesfac" end + if(enum==SmbDpermilEnum) return "SmbDpermil" end + if(enum==SmbDsnowIdxEnum) return "SmbDsnowIdx" end + if(enum==SmbElevationBinsEnum) return "SmbElevationBins" end + if(enum==SmbCldFracEnum) return "SmbCldFrac" end + if(enum==SmbDelta18oEnum) return "SmbDelta18o" end + if(enum==SmbDelta18oSurfaceEnum) return "SmbDelta18oSurface" end + if(enum==SmbDenIdxEnum) return "SmbDenIdx" end + if(enum==SmbDtEnum) return "SmbDt" end + if(enum==SmbEnum) return "Smb" end + if(enum==SmbEIdxEnum) return "SmbEIdx" end + if(enum==SmbFEnum) return "SmbF" end + if(enum==SmbInitDensityScalingEnum) return "SmbInitDensityScaling" end + if(enum==SmbIsaccumulationEnum) return "SmbIsaccumulation" end + if(enum==SmbIsalbedoEnum) return "SmbIsalbedo" end + if(enum==SmbIsconstrainsurfaceTEnum) return "SmbIsconstrainsurfaceT" end + if(enum==SmbIsd18opdEnum) return "SmbIsd18opd" end + if(enum==SmbIsdelta18oEnum) return "SmbIsdelta18o" end + if(enum==SmbIsdensificationEnum) return "SmbIsdensification" end + if(enum==SmbIsdeltaLWupEnum) return "SmbIsdeltaLWup" end + if(enum==SmbIsfirnwarmingEnum) return "SmbIsfirnwarming" end + if(enum==SmbIsgraingrowthEnum) return "SmbIsgraingrowth" end + if(enum==SmbIsmeltEnum) return "SmbIsmelt" end + if(enum==SmbIsmungsmEnum) return "SmbIsmungsm" end + if(enum==SmbIsprecipscaledEnum) return "SmbIsprecipscaled" end + if(enum==SmbIssetpddfacEnum) return "SmbIssetpddfac" end + if(enum==SmbIsshortwaveEnum) return "SmbIsshortwave" end + if(enum==SmbIstemperaturescaledEnum) return "SmbIstemperaturescaled" end + if(enum==SmbIsthermalEnum) return "SmbIsthermal" end + if(enum==SmbIsturbulentfluxEnum) return "SmbIsturbulentflux" end + if(enum==SmbKEnum) return "SmbK" end + if(enum==SmbLapseRatesEnum) return "SmbLapseRates" end + if(enum==SmbNumBasinsEnum) return "SmbNumBasins" end + if(enum==SmbNumElevationBinsEnum) return "SmbNumElevationBins" end + if(enum==SmbNumRequestedOutputsEnum) return "SmbNumRequestedOutputs" end + if(enum==SmbPfacEnum) return "SmbPfac" end + if(enum==SmbPhiEnum) return "SmbPhi" end + if(enum==SmbRdlEnum) return "SmbRdl" end + if(enum==SmbRefElevationEnum) return "SmbRefElevation" end + if(enum==SmbRequestedOutputsEnum) return "SmbRequestedOutputs" end + if(enum==SmbRlapsEnum) return "SmbRlaps" end + if(enum==SmbRlapslgmEnum) return "SmbRlapslgm" end + if(enum==SmbRunoffaltiEnum) return "SmbRunoffalti" end + if(enum==SmbRunoffgradEnum) return "SmbRunoffgrad" end + if(enum==SmbRunoffrefEnum) return "SmbRunoffref" end + if(enum==SmbSealevEnum) return "SmbSealev" end + if(enum==SmbStepsPerStepEnum) return "SmbStepsPerStep" end + if(enum==SmbSwIdxEnum) return "SmbSwIdx" end + if(enum==SmbT0dryEnum) return "SmbT0dry" end + if(enum==SmbT0wetEnum) return "SmbT0wet" end + if(enum==SmbTeThreshEnum) return "SmbTeThresh" end + if(enum==SmbTdiffEnum) return "SmbTdiff" end + if(enum==SmbThermoDeltaTScalingEnum) return "SmbThermoDeltaTScaling" end + if(enum==SmbTemperaturesReconstructedYearsEnum) return "SmbTemperaturesReconstructedYears" end + if(enum==SmbPrecipitationsReconstructedYearsEnum) return "SmbPrecipitationsReconstructedYears" end + if(enum==SmoothThicknessMultiplierEnum) return "SmoothThicknessMultiplier" end + if(enum==SolutionTypeEnum) return "SolutionType" end + if(enum==SteadystateMaxiterEnum) return "SteadystateMaxiter" end + if(enum==SteadystateNumRequestedOutputsEnum) return "SteadystateNumRequestedOutputs" end + if(enum==SteadystateReltolEnum) return "SteadystateReltol" end + if(enum==SteadystateRequestedOutputsEnum) return "SteadystateRequestedOutputs" end + if(enum==StepEnum) return "Step" end + if(enum==StepsEnum) return "Steps" end + if(enum==StressbalanceAbstolEnum) return "StressbalanceAbstol" end + if(enum==StressbalanceFSreconditioningEnum) return "StressbalanceFSreconditioning" end + if(enum==StressbalanceIsnewtonEnum) return "StressbalanceIsnewton" end + if(enum==StressbalanceMaxiterEnum) return "StressbalanceMaxiter" end + if(enum==StressbalanceNumRequestedOutputsEnum) return "StressbalanceNumRequestedOutputs" end + if(enum==StressbalancePenaltyFactorEnum) return "StressbalancePenaltyFactor" end + if(enum==StressbalanceReltolEnum) return "StressbalanceReltol" end + if(enum==StressbalanceRequestedOutputsEnum) return "StressbalanceRequestedOutputs" end + if(enum==StressbalanceRestolEnum) return "StressbalanceRestol" end + if(enum==StressbalanceRiftPenaltyThresholdEnum) return "StressbalanceRiftPenaltyThreshold" end + if(enum==StressbalanceShelfDampeningEnum) return "StressbalanceShelfDampening" end + if(enum==ThermalIsdrainicecolumnEnum) return "ThermalIsdrainicecolumn" end + if(enum==ThermalIsdynamicbasalspcEnum) return "ThermalIsdynamicbasalspc" end + if(enum==ThermalIsenthalpyEnum) return "ThermalIsenthalpy" end + if(enum==ThermalMaxiterEnum) return "ThermalMaxiter" end + if(enum==ThermalNumRequestedOutputsEnum) return "ThermalNumRequestedOutputs" end + if(enum==ThermalPenaltyFactorEnum) return "ThermalPenaltyFactor" end + if(enum==ThermalPenaltyLockEnum) return "ThermalPenaltyLock" end + if(enum==ThermalPenaltyThresholdEnum) return "ThermalPenaltyThreshold" end + if(enum==ThermalReltolEnum) return "ThermalReltol" end + if(enum==ThermalRequestedOutputsEnum) return "ThermalRequestedOutputs" end + if(enum==ThermalStabilizationEnum) return "ThermalStabilization" end + if(enum==ThermalWatercolumnUpperlimitEnum) return "ThermalWatercolumnUpperlimit" end + if(enum==TimeEnum) return "Time" end + if(enum==TimesteppingCflCoefficientEnum) return "TimesteppingCflCoefficient" end + if(enum==TimesteppingCouplingTimeEnum) return "TimesteppingCouplingTime" end + if(enum==TimesteppingFinalTimeEnum) return "TimesteppingFinalTime" end + if(enum==TimesteppingInterpForcingEnum) return "TimesteppingInterpForcing" end + if(enum==TimesteppingCycleForcingEnum) return "TimesteppingCycleForcing" end + if(enum==TimesteppingStartTimeEnum) return "TimesteppingStartTime" end + if(enum==TimesteppingTimeStepEnum) return "TimesteppingTimeStep" end + if(enum==TimesteppingTimeStepMaxEnum) return "TimesteppingTimeStepMax" end + if(enum==TimesteppingTimeStepMinEnum) return "TimesteppingTimeStepMin" end + if(enum==TimesteppingTypeEnum) return "TimesteppingType" end + if(enum==ToMITgcmCommEnum) return "ToMITgcmComm" end + if(enum==ToolkitsFileNameEnum) return "ToolkitsFileName" end + if(enum==ToolkitsOptionsAnalysesEnum) return "ToolkitsOptionsAnalyses" end + if(enum==ToolkitsOptionsStringsEnum) return "ToolkitsOptionsStrings" end + if(enum==ToolkitsTypesEnum) return "ToolkitsTypes" end + if(enum==TransientAmrFrequencyEnum) return "TransientAmrFrequency" end + if(enum==TransientIsdamageevolutionEnum) return "TransientIsdamageevolution" end + if(enum==TransientIsesaEnum) return "TransientIsesa" end + if(enum==TransientIsgiaEnum) return "TransientIsgia" end + if(enum==TransientIsgroundinglineEnum) return "TransientIsgroundingline" end + if(enum==TransientIshydrologyEnum) return "TransientIshydrology" end + if(enum==TransientIsmasstransportEnum) return "TransientIsmasstransport" end + if(enum==TransientIsmmemasstransportEnum) return "TransientIsmmemasstransport" end + if(enum==TransientIsoceantransportEnum) return "TransientIsoceantransport" end + if(enum==TransientIsmovingfrontEnum) return "TransientIsmovingfront" end + if(enum==TransientIsoceancouplingEnum) return "TransientIsoceancoupling" end + if(enum==TransientIssamplingEnum) return "TransientIssampling" end + if(enum==TransientIsslcEnum) return "TransientIsslc" end + if(enum==TransientIssmbEnum) return "TransientIssmb" end + if(enum==TransientIsstressbalanceEnum) return "TransientIsstressbalance" end + if(enum==TransientIsthermalEnum) return "TransientIsthermal" end + if(enum==TransientNumRequestedOutputsEnum) return "TransientNumRequestedOutputs" end + if(enum==TransientRequestedOutputsEnum) return "TransientRequestedOutputs" end + if(enum==VelocityEnum) return "Velocity" end + if(enum==XxeEnum) return "Xxe" end + if(enum==YyeEnum) return "Yye" end + if(enum==ZzeEnum) return "Zze" end + if(enum==AreaeEnum) return "Areae" end + if(enum==WorldCommEnum) return "WorldComm" end + if(enum==ParametersENDEnum) return "ParametersEND" end + if(enum==InputsSTARTEnum) return "InputsSTART" end + if(enum==AccumulatedDeltaBottomPressureEnum) return "AccumulatedDeltaBottomPressure" end + if(enum==AccumulatedDeltaIceThicknessEnum) return "AccumulatedDeltaIceThickness" end + if(enum==AccumulatedDeltaTwsEnum) return "AccumulatedDeltaTws" end + if(enum==AdjointEnum) return "Adjoint" end + if(enum==AdjointpEnum) return "Adjointp" end + if(enum==AdjointxEnum) return "Adjointx" end + if(enum==AdjointxBaseEnum) return "AdjointxBase" end + if(enum==AdjointxShearEnum) return "AdjointxShear" end + if(enum==AdjointyEnum) return "Adjointy" end + if(enum==AdjointyBaseEnum) return "AdjointyBase" end + if(enum==AdjointyShearEnum) return "AdjointyShear" end + if(enum==AdjointzEnum) return "Adjointz" end + if(enum==AirEnum) return "Air" end + if(enum==ApproximationEnum) return "Approximation" end + if(enum==BalancethicknessMisfitEnum) return "BalancethicknessMisfit" end + if(enum==BalancethicknessOmega0Enum) return "BalancethicknessOmega0" end + if(enum==BalancethicknessOmegaEnum) return "BalancethicknessOmega" end + if(enum==BalancethicknessSpcthicknessEnum) return "BalancethicknessSpcthickness" end + if(enum==BalancethicknessThickeningRateEnum) return "BalancethicknessThickeningRate" end + if(enum==BasalCrevasseEnum) return "BasalCrevasse" end + if(enum==BasalforcingsDeepwaterMeltingRateAutoregressionEnum) return "BasalforcingsDeepwaterMeltingRateAutoregression" end + if(enum==BasalforcingsDeepwaterMeltingRateNoiseEnum) return "BasalforcingsDeepwaterMeltingRateNoise" end + if(enum==BasalforcingsDeepwaterMeltingRateValuesAutoregressionEnum) return "BasalforcingsDeepwaterMeltingRateValuesAutoregression" end + if(enum==BasalforcingsFloatingiceMeltingRateEnum) return "BasalforcingsFloatingiceMeltingRate" end + if(enum==BasalforcingsGeothermalfluxEnum) return "BasalforcingsGeothermalflux" end + if(enum==BasalforcingsGroundediceMeltingRateEnum) return "BasalforcingsGroundediceMeltingRate" end + if(enum==BasalforcingsLinearBasinIdEnum) return "BasalforcingsLinearBasinId" end + if(enum==BasalforcingsPerturbationMeltingRateEnum) return "BasalforcingsPerturbationMeltingRate" end + if(enum==BasalforcingsSpatialDeepwaterElevationEnum) return "BasalforcingsSpatialDeepwaterElevation" end + if(enum==BasalforcingsSpatialDeepwaterMeltingRateEnum) return "BasalforcingsSpatialDeepwaterMeltingRate" end + if(enum==BasalforcingsSpatialUpperwaterElevationEnum) return "BasalforcingsSpatialUpperwaterElevation" end + if(enum==BasalforcingsSpatialUpperwaterMeltingRateEnum) return "BasalforcingsSpatialUpperwaterMeltingRate" end + if(enum==BasalforcingsIsmip6BasinIdEnum) return "BasalforcingsIsmip6BasinId" end + if(enum==BasalforcingsIsmip6TfEnum) return "BasalforcingsIsmip6Tf" end + if(enum==BasalforcingsIsmip6TfShelfEnum) return "BasalforcingsIsmip6TfShelf" end + if(enum==BasalforcingsIsmip6MeltAnomalyEnum) return "BasalforcingsIsmip6MeltAnomaly" end + if(enum==BasalforcingsMeltrateFactorEnum) return "BasalforcingsMeltrateFactor" end + if(enum==BasalforcingsOceanSalinityEnum) return "BasalforcingsOceanSalinity" end + if(enum==BasalforcingsOceanTempEnum) return "BasalforcingsOceanTemp" end + if(enum==BasalforcingsPicoBasinIdEnum) return "BasalforcingsPicoBasinId" end + if(enum==BasalforcingsPicoBoxIdEnum) return "BasalforcingsPicoBoxId" end + if(enum==BasalforcingsPicoOverturningCoeffEnum) return "BasalforcingsPicoOverturningCoeff" end + if(enum==BasalforcingsPicoSubShelfOceanOverturningEnum) return "BasalforcingsPicoSubShelfOceanOverturning" end + if(enum==BasalforcingsPicoSubShelfOceanSalinityEnum) return "BasalforcingsPicoSubShelfOceanSalinity" end + if(enum==BasalforcingsPicoSubShelfOceanTempEnum) return "BasalforcingsPicoSubShelfOceanTemp" end + if(enum==BasalStressxEnum) return "BasalStressx" end + if(enum==BasalStressyEnum) return "BasalStressy" end + if(enum==BasalStressEnum) return "BasalStress" end + if(enum==BaseEnum) return "Base" end + if(enum==BaseOldEnum) return "BaseOld" end + if(enum==BaseSlopeXEnum) return "BaseSlopeX" end + if(enum==BaseSlopeYEnum) return "BaseSlopeY" end + if(enum==BaselineBasalforcingsFloatingiceMeltingRateEnum) return "BaselineBasalforcingsFloatingiceMeltingRate" end + if(enum==BaselineBasalforcingsSpatialDeepwaterMeltingRateEnum) return "BaselineBasalforcingsSpatialDeepwaterMeltingRate" end + if(enum==BaselineCalvingCalvingrateEnum) return "BaselineCalvingCalvingrate" end + if(enum==BaselineFrictionEffectivePressureEnum) return "BaselineFrictionEffectivePressure" end + if(enum==BaselineSmbMassBalanceEnum) return "BaselineSmbMassBalance" end + if(enum==BedEnum) return "Bed" end + if(enum==BedGRDEnum) return "BedGRD" end + if(enum==BedEastEnum) return "BedEast" end + if(enum==BedEastGRDEnum) return "BedEastGRD" end + if(enum==BedNorthEnum) return "BedNorth" end + if(enum==BedNorthGRDEnum) return "BedNorthGRD" end + if(enum==BedSlopeXEnum) return "BedSlopeX" end + if(enum==BedSlopeYEnum) return "BedSlopeY" end + if(enum==BottomPressureEnum) return "BottomPressure" end + if(enum==BottomPressureOldEnum) return "BottomPressureOld" end + if(enum==CalvingCalvingrateEnum) return "CalvingCalvingrate" end + if(enum==CalvingHabFractionEnum) return "CalvingHabFraction" end + if(enum==CalvingMeltingrateEnum) return "CalvingMeltingrate" end + if(enum==CalvingStressThresholdFloatingiceEnum) return "CalvingStressThresholdFloatingice" end + if(enum==CalvingStressThresholdGroundediceEnum) return "CalvingStressThresholdGroundedice" end + if(enum==CalvinglevermannCoeffEnum) return "CalvinglevermannCoeff" end + if(enum==CalvingratexAverageEnum) return "CalvingratexAverage" end + if(enum==CalvingratexEnum) return "Calvingratex" end + if(enum==CalvingrateyAverageEnum) return "CalvingrateyAverage" end + if(enum==CalvingrateyEnum) return "Calvingratey" end + if(enum==CalvingFluxLevelsetEnum) return "CalvingFluxLevelset" end + if(enum==CalvingMeltingFluxLevelsetEnum) return "CalvingMeltingFluxLevelset" end + if(enum==ConvergedEnum) return "Converged" end + if(enum==CrevasseDepthEnum) return "CrevasseDepth" end + if(enum==DamageDEnum) return "DamageD" end + if(enum==DamageDOldEnum) return "DamageDOld" end + if(enum==DamageDbarEnum) return "DamageDbar" end + if(enum==DamageDbarOldEnum) return "DamageDbarOld" end + if(enum==DamageFEnum) return "DamageF" end + if(enum==DegreeOfChannelizationEnum) return "DegreeOfChannelization" end + if(enum==DepthBelowSurfaceEnum) return "DepthBelowSurface" end + if(enum==DeltaIceThicknessEnum) return "DeltaIceThickness" end + if(enum==DeltaTwsEnum) return "DeltaTws" end + if(enum==DeltaBottomPressureEnum) return "DeltaBottomPressure" end + if(enum==DeltaDslEnum) return "DeltaDsl" end + if(enum==DslOldEnum) return "DslOld" end + if(enum==DslEnum) return "Dsl" end + if(enum==DeltaStrEnum) return "DeltaStr" end + if(enum==StrOldEnum) return "StrOld" end + if(enum==StrEnum) return "Str" end + if(enum==DeviatoricStresseffectiveEnum) return "DeviatoricStresseffective" end + if(enum==DeviatoricStressxxEnum) return "DeviatoricStressxx" end + if(enum==DeviatoricStressxyEnum) return "DeviatoricStressxy" end + if(enum==DeviatoricStressxzEnum) return "DeviatoricStressxz" end + if(enum==DeviatoricStressyyEnum) return "DeviatoricStressyy" end + if(enum==DeviatoricStressyzEnum) return "DeviatoricStressyz" end + if(enum==DeviatoricStresszzEnum) return "DeviatoricStresszz" end + if(enum==DeviatoricStress1Enum) return "DeviatoricStress1" end + if(enum==DeviatoricStress2Enum) return "DeviatoricStress2" end + if(enum==DistanceToCalvingfrontEnum) return "DistanceToCalvingfront" end + if(enum==DistanceToGroundinglineEnum) return "DistanceToGroundingline" end + if(enum==Domain2DhorizontalEnum) return "Domain2Dhorizontal" end + if(enum==Domain2DverticalEnum) return "Domain2Dvertical" end + if(enum==Domain3DEnum) return "Domain3D" end + if(enum==DragCoefficientAbsGradientEnum) return "DragCoefficientAbsGradient" end + if(enum==DrivingStressXEnum) return "DrivingStressX" end + if(enum==DrivingStressYEnum) return "DrivingStressY" end + if(enum==DummyEnum) return "Dummy" end + if(enum==EffectivePressureEnum) return "EffectivePressure" end + if(enum==EffectivePressureSubstepEnum) return "EffectivePressureSubstep" end + if(enum==EffectivePressureTransientEnum) return "EffectivePressureTransient" end + if(enum==EnthalpyEnum) return "Enthalpy" end + if(enum==EnthalpyPicardEnum) return "EnthalpyPicard" end + if(enum==EplHeadEnum) return "EplHead" end + if(enum==EplHeadOldEnum) return "EplHeadOld" end + if(enum==EplHeadSlopeXEnum) return "EplHeadSlopeX" end + if(enum==EplHeadSlopeYEnum) return "EplHeadSlopeY" end + if(enum==EplHeadSubstepEnum) return "EplHeadSubstep" end + if(enum==EplHeadTransientEnum) return "EplHeadTransient" end + if(enum==EsaEmotionEnum) return "EsaEmotion" end + if(enum==EsaNmotionEnum) return "EsaNmotion" end + if(enum==EsaRotationrateEnum) return "EsaRotationrate" end + if(enum==EsaStrainratexxEnum) return "EsaStrainratexx" end + if(enum==EsaStrainratexyEnum) return "EsaStrainratexy" end + if(enum==EsaStrainrateyyEnum) return "EsaStrainrateyy" end + if(enum==EsaUmotionEnum) return "EsaUmotion" end + if(enum==EsaXmotionEnum) return "EsaXmotion" end + if(enum==EsaYmotionEnum) return "EsaYmotion" end + if(enum==EtaDiffEnum) return "EtaDiff" end + if(enum==FlowequationBorderFSEnum) return "FlowequationBorderFS" end + if(enum==FrictionAsEnum) return "FrictionAs" end + if(enum==FrictionCEnum) return "FrictionC" end + if(enum==FrictionCmaxEnum) return "FrictionCmax" end + if(enum==FrictionCoefficientEnum) return "FrictionCoefficient" end + if(enum==FrictionCoefficientcoulombEnum) return "FrictionCoefficientcoulomb" end + if(enum==FrictionEffectivePressureEnum) return "FrictionEffectivePressure" end + if(enum==FrictionMEnum) return "FrictionM" end + if(enum==FrictionPEnum) return "FrictionP" end + if(enum==FrictionPressureAdjustedTemperatureEnum) return "FrictionPressureAdjustedTemperature" end + if(enum==FrictionQEnum) return "FrictionQ" end + if(enum==FrictionSedimentCompressibilityCoefficientEnum) return "FrictionSedimentCompressibilityCoefficient" end + if(enum==FrictionTillFrictionAngleEnum) return "FrictionTillFrictionAngle" end + if(enum==FrictionWaterLayerEnum) return "FrictionWaterLayer" end + if(enum==FrictionfEnum) return "Frictionf" end + if(enum==FrontalForcingsBasinIdEnum) return "FrontalForcingsBasinId" end + if(enum==FrontalForcingsSubglacialDischargeEnum) return "FrontalForcingsSubglacialDischarge" end + if(enum==FrontalForcingsThermalForcingEnum) return "FrontalForcingsThermalForcing" end + if(enum==GeometryHydrostaticRatioEnum) return "GeometryHydrostaticRatio" end + if(enum==NGiaEnum) return "NGia" end + if(enum==NGiaRateEnum) return "NGiaRate" end + if(enum==UGiaEnum) return "UGia" end + if(enum==UGiaRateEnum) return "UGiaRate" end + if(enum==GradientEnum) return "Gradient" end + if(enum==GroundinglineHeightEnum) return "GroundinglineHeight" end + if(enum==HydraulicPotentialEnum) return "HydraulicPotential" end + if(enum==HydraulicPotentialOldEnum) return "HydraulicPotentialOld" end + if(enum==HydrologyBasalFluxEnum) return "HydrologyBasalFlux" end + if(enum==HydrologyBumpHeightEnum) return "HydrologyBumpHeight" end + if(enum==HydrologyBumpSpacingEnum) return "HydrologyBumpSpacing" end + if(enum==HydrologydcBasalMoulinInputEnum) return "HydrologydcBasalMoulinInput" end + if(enum==HydrologydcEplThicknessEnum) return "HydrologydcEplThickness" end + if(enum==HydrologydcEplThicknessOldEnum) return "HydrologydcEplThicknessOld" end + if(enum==HydrologydcEplThicknessSubstepEnum) return "HydrologydcEplThicknessSubstep" end + if(enum==HydrologydcEplThicknessTransientEnum) return "HydrologydcEplThicknessTransient" end + if(enum==HydrologydcMaskEplactiveEltEnum) return "HydrologydcMaskEplactiveElt" end + if(enum==HydrologydcMaskEplactiveNodeEnum) return "HydrologydcMaskEplactiveNode" end + if(enum==HydrologydcMaskThawedEltEnum) return "HydrologydcMaskThawedElt" end + if(enum==HydrologydcMaskThawedNodeEnum) return "HydrologydcMaskThawedNode" end + if(enum==HydrologydcSedimentTransmitivityEnum) return "HydrologydcSedimentTransmitivity" end + if(enum==HydrologyDrainageRateEnum) return "HydrologyDrainageRate" end + if(enum==HydrologyEnglacialInputEnum) return "HydrologyEnglacialInput" end + if(enum==HydrologyGapHeightEnum) return "HydrologyGapHeight" end + if(enum==HydrologyGapHeightXEnum) return "HydrologyGapHeightX" end + if(enum==HydrologyGapHeightXXEnum) return "HydrologyGapHeightXX" end + if(enum==HydrologyGapHeightYEnum) return "HydrologyGapHeightY" end + if(enum==HydrologyGapHeightYYEnum) return "HydrologyGapHeightYY" end + if(enum==HydrologyHeadEnum) return "HydrologyHead" end + if(enum==HydrologyHeadOldEnum) return "HydrologyHeadOld" end + if(enum==HydrologyMoulinInputEnum) return "HydrologyMoulinInput" end + if(enum==HydrologyNeumannfluxEnum) return "HydrologyNeumannflux" end + if(enum==HydrologyReynoldsEnum) return "HydrologyReynolds" end + if(enum==HydrologySheetConductivityEnum) return "HydrologySheetConductivity" end + if(enum==HydrologySheetThicknessEnum) return "HydrologySheetThickness" end + if(enum==HydrologySheetThicknessOldEnum) return "HydrologySheetThicknessOld" end + if(enum==HydrologyTwsEnum) return "HydrologyTws" end + if(enum==HydrologyTwsSpcEnum) return "HydrologyTwsSpc" end + if(enum==HydrologyTwsAnalysisEnum) return "HydrologyTwsAnalysis" end + if(enum==HydrologyWatercolumnMaxEnum) return "HydrologyWatercolumnMax" end + if(enum==HydrologyWaterVxEnum) return "HydrologyWaterVx" end + if(enum==HydrologyWaterVyEnum) return "HydrologyWaterVy" end + if(enum==IceEnum) return "Ice" end + if(enum==IceMaskNodeActivationEnum) return "IceMaskNodeActivation" end + if(enum==InputEnum) return "Input" end + if(enum==InversionCostFunctionsCoefficientsEnum) return "InversionCostFunctionsCoefficients" end + if(enum==InversionSurfaceObsEnum) return "InversionSurfaceObs" end + if(enum==InversionThicknessObsEnum) return "InversionThicknessObs" end + if(enum==InversionVelObsEnum) return "InversionVelObs" end + if(enum==InversionVxObsEnum) return "InversionVxObs" end + if(enum==InversionVyObsEnum) return "InversionVyObs" end + if(enum==LevelsetfunctionSlopeXEnum) return "LevelsetfunctionSlopeX" end + if(enum==LevelsetfunctionSlopeYEnum) return "LevelsetfunctionSlopeY" end + if(enum==LevelsetObservationEnum) return "LevelsetObservation" end + if(enum==LoadingforceXEnum) return "LoadingforceX" end + if(enum==LoadingforceYEnum) return "LoadingforceY" end + if(enum==LoadingforceZEnum) return "LoadingforceZ" end + if(enum==MaskOceanLevelsetEnum) return "MaskOceanLevelset" end + if(enum==MaskIceLevelsetEnum) return "MaskIceLevelset" end + if(enum==MaskIceRefLevelsetEnum) return "MaskIceRefLevelset" end + if(enum==MasstransportSpcthicknessEnum) return "MasstransportSpcthickness" end + if(enum==MmemasstransportDeltathicknessEnum) return "MmemasstransportDeltathickness" end + if(enum==MaterialsRheologyBEnum) return "MaterialsRheologyB" end + if(enum==MaterialsRheologyBbarEnum) return "MaterialsRheologyBbar" end + if(enum==MaterialsRheologyEEnum) return "MaterialsRheologyE" end + if(enum==MaterialsRheologyEbarEnum) return "MaterialsRheologyEbar" end + if(enum==MaterialsRheologyEcEnum) return "MaterialsRheologyEc" end + if(enum==MaterialsRheologyEcbarEnum) return "MaterialsRheologyEcbar" end + if(enum==MaterialsRheologyEsEnum) return "MaterialsRheologyEs" end + if(enum==MaterialsRheologyEsbarEnum) return "MaterialsRheologyEsbar" end + if(enum==MaterialsRheologyNEnum) return "MaterialsRheologyN" end + if(enum==MeshScaleFactorEnum) return "MeshScaleFactor" end + if(enum==MeshVertexonbaseEnum) return "MeshVertexonbase" end + if(enum==MeshVertexonboundaryEnum) return "MeshVertexonboundary" end + if(enum==MeshVertexonsurfaceEnum) return "MeshVertexonsurface" end + if(enum==MisfitEnum) return "Misfit" end + if(enum==MovingFrontalVxEnum) return "MovingFrontalVx" end + if(enum==MovingFrontalVyEnum) return "MovingFrontalVy" end + if(enum==NeumannfluxEnum) return "Neumannflux" end + if(enum==NewDamageEnum) return "NewDamage" end + if(enum==NodeEnum) return "Node" end + if(enum==OmegaAbsGradientEnum) return "OmegaAbsGradient" end + if(enum==OceantransportSpcbottompressureEnum) return "OceantransportSpcbottompressure" end + if(enum==OceantransportSpcstrEnum) return "OceantransportSpcstr" end + if(enum==OceantransportSpcdslEnum) return "OceantransportSpcdsl" end + if(enum==P0Enum) return "P0" end + if(enum==P1Enum) return "P1" end + if(enum==PartitioningEnum) return "Partitioning" end + if(enum==PressureEnum) return "Pressure" end + if(enum==RadarEnum) return "Radar" end + if(enum==RadarAttenuationMacGregorEnum) return "RadarAttenuationMacGregor" end + if(enum==RadarAttenuationWolffEnum) return "RadarAttenuationWolff" end + if(enum==RadarIcePeriodEnum) return "RadarIcePeriod" end + if(enum==RadarPowerMacGregorEnum) return "RadarPowerMacGregor" end + if(enum==RadarPowerWolffEnum) return "RadarPowerWolff" end + if(enum==RheologyBAbsGradientEnum) return "RheologyBAbsGradient" end + if(enum==RheologyBInitialguessEnum) return "RheologyBInitialguess" end + if(enum==RheologyBInitialguessMisfitEnum) return "RheologyBInitialguessMisfit" end + if(enum==RheologyBbarAbsGradientEnum) return "RheologyBbarAbsGradient" end + if(enum==SampleEnum) return "Sample" end + if(enum==SampleOldEnum) return "SampleOld" end + if(enum==SampleNoiseEnum) return "SampleNoise" end + if(enum==SamplingBetaEnum) return "SamplingBeta" end + if(enum==SamplingKappaEnum) return "SamplingKappa" end + if(enum==SamplingPhiEnum) return "SamplingPhi" end + if(enum==SamplingTauEnum) return "SamplingTau" end + if(enum==SealevelEnum) return "Sealevel" end + if(enum==SealevelGRDEnum) return "SealevelGRD" end + if(enum==SealevelBarystaticMaskEnum) return "SealevelBarystaticMask" end + if(enum==SealevelBarystaticIceMaskEnum) return "SealevelBarystaticIceMask" end + if(enum==SealevelBarystaticIceWeightsEnum) return "SealevelBarystaticIceWeights" end + if(enum==SealevelBarystaticIceAreaEnum) return "SealevelBarystaticIceArea" end + if(enum==SealevelBarystaticIceLatbarEnum) return "SealevelBarystaticIceLatbar" end + if(enum==SealevelBarystaticIceLongbarEnum) return "SealevelBarystaticIceLongbar" end + if(enum==SealevelBarystaticIceLoadEnum) return "SealevelBarystaticIceLoad" end + if(enum==SealevelBarystaticHydroMaskEnum) return "SealevelBarystaticHydroMask" end + if(enum==SealevelBarystaticHydroWeightsEnum) return "SealevelBarystaticHydroWeights" end + if(enum==SealevelBarystaticHydroAreaEnum) return "SealevelBarystaticHydroArea" end + if(enum==SealevelBarystaticHydroLatbarEnum) return "SealevelBarystaticHydroLatbar" end + if(enum==SealevelBarystaticHydroLongbarEnum) return "SealevelBarystaticHydroLongbar" end + if(enum==SealevelBarystaticHydroLoadEnum) return "SealevelBarystaticHydroLoad" end + if(enum==SealevelBarystaticBpMaskEnum) return "SealevelBarystaticBpMask" end + if(enum==SealevelBarystaticBpWeightsEnum) return "SealevelBarystaticBpWeights" end + if(enum==SealevelBarystaticBpAreaEnum) return "SealevelBarystaticBpArea" end + if(enum==SealevelBarystaticBpLoadEnum) return "SealevelBarystaticBpLoad" end + if(enum==SealevelBarystaticOceanMaskEnum) return "SealevelBarystaticOceanMask" end + if(enum==SealevelBarystaticOceanWeightsEnum) return "SealevelBarystaticOceanWeights" end + if(enum==SealevelBarystaticOceanAreaEnum) return "SealevelBarystaticOceanArea" end + if(enum==SealevelBarystaticOceanLatbarEnum) return "SealevelBarystaticOceanLatbar" end + if(enum==SealevelBarystaticOceanLongbarEnum) return "SealevelBarystaticOceanLongbar" end + if(enum==SealevelBarystaticOceanLoadEnum) return "SealevelBarystaticOceanLoad" end + if(enum==SealevelNEsaEnum) return "SealevelNEsa" end + if(enum==SealevelNEsaRateEnum) return "SealevelNEsaRate" end + if(enum==SealevelRSLEnum) return "SealevelRSL" end + if(enum==BslcEnum) return "Bslc" end + if(enum==BslcIceEnum) return "BslcIce" end + if(enum==BslcHydroEnum) return "BslcHydro" end + if(enum==BslcOceanEnum) return "BslcOcean" end + if(enum==BslcRateEnum) return "BslcRate" end + if(enum==GmtslcEnum) return "Gmtslc" end + if(enum==SealevelRSLBarystaticEnum) return "SealevelRSLBarystatic" end + if(enum==SealevelRSLRateEnum) return "SealevelRSLRate" end + if(enum==SealevelUGrdEnum) return "SealevelUGrd" end + if(enum==SealevelNGrdEnum) return "SealevelNGrd" end + if(enum==SealevelUEastEsaEnum) return "SealevelUEastEsa" end + if(enum==SealevelUNorthEsaEnum) return "SealevelUNorthEsa" end + if(enum==SealevelchangeIndicesEnum) return "SealevelchangeIndices" end + if(enum==SealevelchangeGEnum) return "SealevelchangeG" end + if(enum==SealevelchangeGUEnum) return "SealevelchangeGU" end + if(enum==SealevelchangeGEEnum) return "SealevelchangeGE" end + if(enum==SealevelchangeGNEnum) return "SealevelchangeGN" end + if(enum==SealevelchangeGrotEnum) return "SealevelchangeGrot" end + if(enum==SealevelchangeGUrotEnum) return "SealevelchangeGUrot" end + if(enum==SealevelchangeGNrotEnum) return "SealevelchangeGNrot" end + if(enum==SealevelchangeGErotEnum) return "SealevelchangeGErot" end + if(enum==SealevelchangeGsubelOceanEnum) return "SealevelchangeGsubelOcean" end + if(enum==SealevelchangeGUsubelOceanEnum) return "SealevelchangeGUsubelOcean" end + if(enum==SealevelchangeGEsubelOceanEnum) return "SealevelchangeGEsubelOcean" end + if(enum==SealevelchangeGNsubelOceanEnum) return "SealevelchangeGNsubelOcean" end + if(enum==SealevelchangeGsubelIceEnum) return "SealevelchangeGsubelIce" end + if(enum==SealevelchangeGUsubelIceEnum) return "SealevelchangeGUsubelIce" end + if(enum==SealevelchangeGEsubelIceEnum) return "SealevelchangeGEsubelIce" end + if(enum==SealevelchangeGNsubelIceEnum) return "SealevelchangeGNsubelIce" end + if(enum==SealevelchangeGsubelHydroEnum) return "SealevelchangeGsubelHydro" end + if(enum==SealevelchangeGUsubelHydroEnum) return "SealevelchangeGUsubelHydro" end + if(enum==SealevelchangeGEsubelHydroEnum) return "SealevelchangeGEsubelHydro" end + if(enum==SealevelchangeGNsubelHydroEnum) return "SealevelchangeGNsubelHydro" end + if(enum==SealevelchangeViscousRSLEnum) return "SealevelchangeViscousRSL" end + if(enum==SealevelchangeViscousUEnum) return "SealevelchangeViscousU" end + if(enum==SealevelchangeViscousNEnum) return "SealevelchangeViscousN" end + if(enum==SealevelchangeViscousEEnum) return "SealevelchangeViscousE" end + if(enum==SedimentHeadEnum) return "SedimentHead" end + if(enum==SedimentHeadOldEnum) return "SedimentHeadOld" end + if(enum==SedimentHeadSubstepEnum) return "SedimentHeadSubstep" end + if(enum==SedimentHeadTransientEnum) return "SedimentHeadTransient" end + if(enum==SedimentHeadResidualEnum) return "SedimentHeadResidual" end + if(enum==SedimentHeadStackedEnum) return "SedimentHeadStacked" end + if(enum==SigmaNNEnum) return "SigmaNN" end + if(enum==SigmaVMEnum) return "SigmaVM" end + if(enum==SmbAccumulatedECEnum) return "SmbAccumulatedEC" end + if(enum==SmbAccumulatedMassBalanceEnum) return "SmbAccumulatedMassBalance" end + if(enum==SmbAccumulatedMeltEnum) return "SmbAccumulatedMelt" end + if(enum==SmbAccumulatedPrecipitationEnum) return "SmbAccumulatedPrecipitation" end + if(enum==SmbAccumulatedRainEnum) return "SmbAccumulatedRain" end + if(enum==SmbAccumulatedRefreezeEnum) return "SmbAccumulatedRefreeze" end + if(enum==SmbAccumulatedRunoffEnum) return "SmbAccumulatedRunoff" end + if(enum==SmbAEnum) return "SmbA" end + if(enum==SmbAdiffEnum) return "SmbAdiff" end + if(enum==SmbAValueEnum) return "SmbAValue" end + if(enum==SmbAccumulationEnum) return "SmbAccumulation" end + if(enum==SmbAdiffiniEnum) return "SmbAdiffini" end + if(enum==SmbAiniEnum) return "SmbAini" end + if(enum==SmbAutoregressionNoiseEnum) return "SmbAutoregressionNoise" end + if(enum==SmbBasinsIdEnum) return "SmbBasinsId" end + if(enum==SmbBMaxEnum) return "SmbBMax" end + if(enum==SmbBMinEnum) return "SmbBMin" end + if(enum==SmbBNegEnum) return "SmbBNeg" end + if(enum==SmbBPosEnum) return "SmbBPos" end + if(enum==SmbCEnum) return "SmbC" end + if(enum==SmbCcsnowValueEnum) return "SmbCcsnowValue" end + if(enum==SmbCciceValueEnum) return "SmbCciceValue" end + if(enum==SmbCotValueEnum) return "SmbCotValue" end + if(enum==SmbDEnum) return "SmbD" end + if(enum==SmbDailyairdensityEnum) return "SmbDailyairdensity" end + if(enum==SmbDailyairhumidityEnum) return "SmbDailyairhumidity" end + if(enum==SmbDailydlradiationEnum) return "SmbDailydlradiation" end + if(enum==SmbDailydsradiationEnum) return "SmbDailydsradiation" end + if(enum==SmbDailypressureEnum) return "SmbDailypressure" end + if(enum==SmbDailyrainfallEnum) return "SmbDailyrainfall" end + if(enum==SmbDailysnowfallEnum) return "SmbDailysnowfall" end + if(enum==SmbDailytemperatureEnum) return "SmbDailytemperature" end + if(enum==SmbDailywindspeedEnum) return "SmbDailywindspeed" end + if(enum==SmbDiniEnum) return "SmbDini" end + if(enum==SmbDlwrfEnum) return "SmbDlwrf" end + if(enum==SmbDulwrfValueEnum) return "SmbDulwrfValue" end + if(enum==SmbDswrfEnum) return "SmbDswrf" end + if(enum==SmbDswdiffrfEnum) return "SmbDswdiffrf" end + if(enum==SmbDzAddEnum) return "SmbDzAdd" end + if(enum==SmbDzEnum) return "SmbDz" end + if(enum==SmbDzMinEnum) return "SmbDzMin" end + if(enum==SmbDzTopEnum) return "SmbDzTop" end + if(enum==SmbDziniEnum) return "SmbDzini" end + if(enum==SmbEAirEnum) return "SmbEAir" end + if(enum==SmbECEnum) return "SmbEC" end + if(enum==SmbECDtEnum) return "SmbECDt" end + if(enum==SmbECiniEnum) return "SmbECini" end + if(enum==SmbElaEnum) return "SmbEla" end + if(enum==SmbEvaporationEnum) return "SmbEvaporation" end + if(enum==SmbFACEnum) return "SmbFAC" end + if(enum==SmbGdnEnum) return "SmbGdn" end + if(enum==SmbGdniniEnum) return "SmbGdnini" end + if(enum==SmbGspEnum) return "SmbGsp" end + if(enum==SmbGspiniEnum) return "SmbGspini" end + if(enum==SmbHrefEnum) return "SmbHref" end + if(enum==SmbIsInitializedEnum) return "SmbIsInitialized" end + if(enum==SmbMAddEnum) return "SmbMAdd" end + if(enum==SmbMassBalanceEnum) return "SmbMassBalance" end + if(enum==SmbMassBalanceSubstepEnum) return "SmbMassBalanceSubstep" end + if(enum==SmbMassBalanceTransientEnum) return "SmbMassBalanceTransient" end + if(enum==SmbMeanLHFEnum) return "SmbMeanLHF" end + if(enum==SmbMeanSHFEnum) return "SmbMeanSHF" end + if(enum==SmbMeanULWEnum) return "SmbMeanULW" end + if(enum==SmbMeltEnum) return "SmbMelt" end + if(enum==SmbMonthlytemperaturesEnum) return "SmbMonthlytemperatures" end + if(enum==SmbMSurfEnum) return "SmbMSurf" end + if(enum==SmbNetLWEnum) return "SmbNetLW" end + if(enum==SmbNetSWEnum) return "SmbNetSW" end + if(enum==SmbPAirEnum) return "SmbPAir" end + if(enum==SmbPEnum) return "SmbP" end + if(enum==SmbPddfacIceEnum) return "SmbPddfacIce" end + if(enum==SmbPddfacSnowEnum) return "SmbPddfacSnow" end + if(enum==SmbPrecipitationEnum) return "SmbPrecipitation" end + if(enum==SmbPrecipitationsAnomalyEnum) return "SmbPrecipitationsAnomaly" end + if(enum==SmbPrecipitationsLgmEnum) return "SmbPrecipitationsLgm" end + if(enum==SmbPrecipitationsPresentdayEnum) return "SmbPrecipitationsPresentday" end + if(enum==SmbPrecipitationsReconstructedEnum) return "SmbPrecipitationsReconstructed" end + if(enum==SmbRainEnum) return "SmbRain" end + if(enum==SmbReEnum) return "SmbRe" end + if(enum==SmbRefreezeEnum) return "SmbRefreeze" end + if(enum==SmbReiniEnum) return "SmbReini" end + if(enum==SmbRunoffEnum) return "SmbRunoff" end + if(enum==SmbRunoffSubstepEnum) return "SmbRunoffSubstep" end + if(enum==SmbRunoffTransientEnum) return "SmbRunoffTransient" end + if(enum==SmbS0gcmEnum) return "SmbS0gcm" end + if(enum==SmbS0pEnum) return "SmbS0p" end + if(enum==SmbS0tEnum) return "SmbS0t" end + if(enum==SmbSizeiniEnum) return "SmbSizeini" end + if(enum==SmbSmbCorrEnum) return "SmbSmbCorr" end + if(enum==SmbSmbrefEnum) return "SmbSmbref" end + if(enum==SmbSzaValueEnum) return "SmbSzaValue" end + if(enum==SmbTEnum) return "SmbT" end + if(enum==SmbTaEnum) return "SmbTa" end + if(enum==SmbTeValueEnum) return "SmbTeValue" end + if(enum==SmbTemperaturesAnomalyEnum) return "SmbTemperaturesAnomaly" end + if(enum==SmbTemperaturesLgmEnum) return "SmbTemperaturesLgm" end + if(enum==SmbTemperaturesPresentdayEnum) return "SmbTemperaturesPresentday" end + if(enum==SmbTemperaturesReconstructedEnum) return "SmbTemperaturesReconstructed" end + if(enum==SmbTiniEnum) return "SmbTini" end + if(enum==SmbTmeanEnum) return "SmbTmean" end + if(enum==SmbTzEnum) return "SmbTz" end + if(enum==SmbValuesAutoregressionEnum) return "SmbValuesAutoregression" end + if(enum==SmbVEnum) return "SmbV" end + if(enum==SmbVmeanEnum) return "SmbVmean" end + if(enum==SmbVzEnum) return "SmbVz" end + if(enum==SmbWEnum) return "SmbW" end + if(enum==SmbWAddEnum) return "SmbWAdd" end + if(enum==SmbWiniEnum) return "SmbWini" end + if(enum==SmbZMaxEnum) return "SmbZMax" end + if(enum==SmbZMinEnum) return "SmbZMin" end + if(enum==SmbZTopEnum) return "SmbZTop" end + if(enum==SmbZYEnum) return "SmbZY" end + if(enum==SolidearthExternalDisplacementEastRateEnum) return "SolidearthExternalDisplacementEastRate" end + if(enum==SolidearthExternalDisplacementNorthRateEnum) return "SolidearthExternalDisplacementNorthRate" end + if(enum==SolidearthExternalDisplacementUpRateEnum) return "SolidearthExternalDisplacementUpRate" end + if(enum==SolidearthExternalGeoidRateEnum) return "SolidearthExternalGeoidRate" end + if(enum==StochasticForcingDefaultIdEnum) return "StochasticForcingDefaultId" end + if(enum==StrainRateeffectiveEnum) return "StrainRateeffective" end + if(enum==StrainRateparallelEnum) return "StrainRateparallel" end + if(enum==StrainRateperpendicularEnum) return "StrainRateperpendicular" end + if(enum==StrainRatexxEnum) return "StrainRatexx" end + if(enum==StrainRatexyEnum) return "StrainRatexy" end + if(enum==StrainRatexzEnum) return "StrainRatexz" end + if(enum==StrainRateyyEnum) return "StrainRateyy" end + if(enum==StrainRateyzEnum) return "StrainRateyz" end + if(enum==StrainRatezzEnum) return "StrainRatezz" end + if(enum==StressMaxPrincipalEnum) return "StressMaxPrincipal" end + if(enum==StressTensorxxEnum) return "StressTensorxx" end + if(enum==StressTensorxyEnum) return "StressTensorxy" end + if(enum==StressTensorxzEnum) return "StressTensorxz" end + if(enum==StressTensoryyEnum) return "StressTensoryy" end + if(enum==StressTensoryzEnum) return "StressTensoryz" end + if(enum==StressTensorzzEnum) return "StressTensorzz" end + if(enum==SurfaceAbsMisfitEnum) return "SurfaceAbsMisfit" end + if(enum==SurfaceAbsVelMisfitEnum) return "SurfaceAbsVelMisfit" end + if(enum==AreaEnum) return "Area" end + if(enum==SealevelAreaEnum) return "SealevelArea" end + if(enum==SurfaceAreaEnum) return "SurfaceArea" end + if(enum==SurfaceAverageVelMisfitEnum) return "SurfaceAverageVelMisfit" end + if(enum==SurfaceCrevasseEnum) return "SurfaceCrevasse" end + if(enum==SurfaceEnum) return "Surface" end + if(enum==SurfaceOldEnum) return "SurfaceOld" end + if(enum==SurfaceLogVelMisfitEnum) return "SurfaceLogVelMisfit" end + if(enum==SurfaceLogVxVyMisfitEnum) return "SurfaceLogVxVyMisfit" end + if(enum==SurfaceObservationEnum) return "SurfaceObservation" end + if(enum==SurfaceRelVelMisfitEnum) return "SurfaceRelVelMisfit" end + if(enum==SurfaceSlopeXEnum) return "SurfaceSlopeX" end + if(enum==SurfaceSlopeYEnum) return "SurfaceSlopeY" end + if(enum==TemperatureEnum) return "Temperature" end + if(enum==TemperaturePDDEnum) return "TemperaturePDD" end + if(enum==TemperaturePicardEnum) return "TemperaturePicard" end + if(enum==TemperatureSEMICEnum) return "TemperatureSEMIC" end + if(enum==ThermalforcingAutoregressionNoiseEnum) return "ThermalforcingAutoregressionNoise" end + if(enum==ThermalforcingValuesAutoregressionEnum) return "ThermalforcingValuesAutoregression" end + if(enum==ThermalSpctemperatureEnum) return "ThermalSpctemperature" end + if(enum==ThicknessAbsGradientEnum) return "ThicknessAbsGradient" end + if(enum==ThicknessAbsMisfitEnum) return "ThicknessAbsMisfit" end + if(enum==ThicknessAcrossGradientEnum) return "ThicknessAcrossGradient" end + if(enum==ThicknessAlongGradientEnum) return "ThicknessAlongGradient" end + if(enum==ThicknessEnum) return "Thickness" end + if(enum==ThicknessOldEnum) return "ThicknessOld" end + if(enum==ThicknessPositiveEnum) return "ThicknessPositive" end + if(enum==ThicknessResidualEnum) return "ThicknessResidual" end + if(enum==TransientAccumulatedDeltaIceThicknessEnum) return "TransientAccumulatedDeltaIceThickness" end + if(enum==VelEnum) return "Vel" end + if(enum==VxAverageEnum) return "VxAverage" end + if(enum==VxBaseEnum) return "VxBase" end + if(enum==VxEnum) return "Vx" end + if(enum==VxMeshEnum) return "VxMesh" end + if(enum==VxObsEnum) return "VxObs" end + if(enum==VxShearEnum) return "VxShear" end + if(enum==VxSurfaceEnum) return "VxSurface" end + if(enum==VyAverageEnum) return "VyAverage" end + if(enum==VyBaseEnum) return "VyBase" end + if(enum==VyEnum) return "Vy" end + if(enum==VyMeshEnum) return "VyMesh" end + if(enum==VyObsEnum) return "VyObs" end + if(enum==VyShearEnum) return "VyShear" end + if(enum==VySurfaceEnum) return "VySurface" end + if(enum==VzEnum) return "Vz" end + if(enum==VzFSEnum) return "VzFS" end + if(enum==VzHOEnum) return "VzHO" end + if(enum==VzMeshEnum) return "VzMesh" end + if(enum==VzSSAEnum) return "VzSSA" end + if(enum==WaterColumnOldEnum) return "WaterColumnOld" end + if(enum==WatercolumnEnum) return "Watercolumn" end + if(enum==WaterfractionDrainageEnum) return "WaterfractionDrainage" end + if(enum==WaterfractionDrainageIntegratedEnum) return "WaterfractionDrainageIntegrated" end + if(enum==WaterfractionEnum) return "Waterfraction" end + if(enum==WaterheightEnum) return "Waterheight" end + if(enum==FrictionWaterPressureEnum) return "FrictionWaterPressure" end + if(enum==FrictionWaterPressureNoiseEnum) return "FrictionWaterPressureNoise" end + if(enum==WeightsLevelsetObservationEnum) return "WeightsLevelsetObservation" end + if(enum==WeightsSurfaceObservationEnum) return "WeightsSurfaceObservation" end + if(enum==OldAccumulatedDeltaBottomPressureEnum) return "OldAccumulatedDeltaBottomPressure" end + if(enum==OldAccumulatedDeltaIceThicknessEnum) return "OldAccumulatedDeltaIceThickness" end + if(enum==OldAccumulatedDeltaTwsEnum) return "OldAccumulatedDeltaTws" end + if(enum==Outputdefinition1Enum) return "Outputdefinition1" end + if(enum==Outputdefinition10Enum) return "Outputdefinition10" end + if(enum==Outputdefinition11Enum) return "Outputdefinition11" end + if(enum==Outputdefinition12Enum) return "Outputdefinition12" end + if(enum==Outputdefinition13Enum) return "Outputdefinition13" end + if(enum==Outputdefinition14Enum) return "Outputdefinition14" end + if(enum==Outputdefinition15Enum) return "Outputdefinition15" end + if(enum==Outputdefinition16Enum) return "Outputdefinition16" end + if(enum==Outputdefinition17Enum) return "Outputdefinition17" end + if(enum==Outputdefinition18Enum) return "Outputdefinition18" end + if(enum==Outputdefinition19Enum) return "Outputdefinition19" end + if(enum==Outputdefinition20Enum) return "Outputdefinition20" end + if(enum==Outputdefinition21Enum) return "Outputdefinition21" end + if(enum==Outputdefinition22Enum) return "Outputdefinition22" end + if(enum==Outputdefinition23Enum) return "Outputdefinition23" end + if(enum==Outputdefinition24Enum) return "Outputdefinition24" end + if(enum==Outputdefinition25Enum) return "Outputdefinition25" end + if(enum==Outputdefinition26Enum) return "Outputdefinition26" end + if(enum==Outputdefinition27Enum) return "Outputdefinition27" end + if(enum==Outputdefinition28Enum) return "Outputdefinition28" end + if(enum==Outputdefinition29Enum) return "Outputdefinition29" end + if(enum==Outputdefinition2Enum) return "Outputdefinition2" end + if(enum==Outputdefinition30Enum) return "Outputdefinition30" end + if(enum==Outputdefinition31Enum) return "Outputdefinition31" end + if(enum==Outputdefinition32Enum) return "Outputdefinition32" end + if(enum==Outputdefinition33Enum) return "Outputdefinition33" end + if(enum==Outputdefinition34Enum) return "Outputdefinition34" end + if(enum==Outputdefinition35Enum) return "Outputdefinition35" end + if(enum==Outputdefinition36Enum) return "Outputdefinition36" end + if(enum==Outputdefinition37Enum) return "Outputdefinition37" end + if(enum==Outputdefinition38Enum) return "Outputdefinition38" end + if(enum==Outputdefinition39Enum) return "Outputdefinition39" end + if(enum==Outputdefinition3Enum) return "Outputdefinition3" end + if(enum==Outputdefinition40Enum) return "Outputdefinition40" end + if(enum==Outputdefinition41Enum) return "Outputdefinition41" end + if(enum==Outputdefinition42Enum) return "Outputdefinition42" end + if(enum==Outputdefinition43Enum) return "Outputdefinition43" end + if(enum==Outputdefinition44Enum) return "Outputdefinition44" end + if(enum==Outputdefinition45Enum) return "Outputdefinition45" end + if(enum==Outputdefinition46Enum) return "Outputdefinition46" end + if(enum==Outputdefinition47Enum) return "Outputdefinition47" end + if(enum==Outputdefinition48Enum) return "Outputdefinition48" end + if(enum==Outputdefinition49Enum) return "Outputdefinition49" end + if(enum==Outputdefinition4Enum) return "Outputdefinition4" end + if(enum==Outputdefinition50Enum) return "Outputdefinition50" end + if(enum==Outputdefinition51Enum) return "Outputdefinition51" end + if(enum==Outputdefinition52Enum) return "Outputdefinition52" end + if(enum==Outputdefinition53Enum) return "Outputdefinition53" end + if(enum==Outputdefinition54Enum) return "Outputdefinition54" end + if(enum==Outputdefinition55Enum) return "Outputdefinition55" end + if(enum==Outputdefinition56Enum) return "Outputdefinition56" end + if(enum==Outputdefinition57Enum) return "Outputdefinition57" end + if(enum==Outputdefinition58Enum) return "Outputdefinition58" end + if(enum==Outputdefinition59Enum) return "Outputdefinition59" end + if(enum==Outputdefinition5Enum) return "Outputdefinition5" end + if(enum==Outputdefinition60Enum) return "Outputdefinition60" end + if(enum==Outputdefinition61Enum) return "Outputdefinition61" end + if(enum==Outputdefinition62Enum) return "Outputdefinition62" end + if(enum==Outputdefinition63Enum) return "Outputdefinition63" end + if(enum==Outputdefinition64Enum) return "Outputdefinition64" end + if(enum==Outputdefinition65Enum) return "Outputdefinition65" end + if(enum==Outputdefinition66Enum) return "Outputdefinition66" end + if(enum==Outputdefinition67Enum) return "Outputdefinition67" end + if(enum==Outputdefinition68Enum) return "Outputdefinition68" end + if(enum==Outputdefinition69Enum) return "Outputdefinition69" end + if(enum==Outputdefinition6Enum) return "Outputdefinition6" end + if(enum==Outputdefinition70Enum) return "Outputdefinition70" end + if(enum==Outputdefinition71Enum) return "Outputdefinition71" end + if(enum==Outputdefinition72Enum) return "Outputdefinition72" end + if(enum==Outputdefinition73Enum) return "Outputdefinition73" end + if(enum==Outputdefinition74Enum) return "Outputdefinition74" end + if(enum==Outputdefinition75Enum) return "Outputdefinition75" end + if(enum==Outputdefinition76Enum) return "Outputdefinition76" end + if(enum==Outputdefinition77Enum) return "Outputdefinition77" end + if(enum==Outputdefinition78Enum) return "Outputdefinition78" end + if(enum==Outputdefinition79Enum) return "Outputdefinition79" end + if(enum==Outputdefinition7Enum) return "Outputdefinition7" end + if(enum==Outputdefinition80Enum) return "Outputdefinition80" end + if(enum==Outputdefinition81Enum) return "Outputdefinition81" end + if(enum==Outputdefinition82Enum) return "Outputdefinition82" end + if(enum==Outputdefinition83Enum) return "Outputdefinition83" end + if(enum==Outputdefinition84Enum) return "Outputdefinition84" end + if(enum==Outputdefinition85Enum) return "Outputdefinition85" end + if(enum==Outputdefinition86Enum) return "Outputdefinition86" end + if(enum==Outputdefinition87Enum) return "Outputdefinition87" end + if(enum==Outputdefinition88Enum) return "Outputdefinition88" end + if(enum==Outputdefinition89Enum) return "Outputdefinition89" end + if(enum==Outputdefinition8Enum) return "Outputdefinition8" end + if(enum==Outputdefinition90Enum) return "Outputdefinition90" end + if(enum==Outputdefinition91Enum) return "Outputdefinition91" end + if(enum==Outputdefinition92Enum) return "Outputdefinition92" end + if(enum==Outputdefinition93Enum) return "Outputdefinition93" end + if(enum==Outputdefinition94Enum) return "Outputdefinition94" end + if(enum==Outputdefinition95Enum) return "Outputdefinition95" end + if(enum==Outputdefinition96Enum) return "Outputdefinition96" end + if(enum==Outputdefinition97Enum) return "Outputdefinition97" end + if(enum==Outputdefinition98Enum) return "Outputdefinition98" end + if(enum==Outputdefinition99Enum) return "Outputdefinition99" end + if(enum==Outputdefinition9Enum) return "Outputdefinition9" end + if(enum==Outputdefinition100Enum) return "Outputdefinition100" end + if(enum==InputsENDEnum) return "InputsEND" end + if(enum==AbsoluteEnum) return "Absolute" end + if(enum==AdaptiveTimesteppingEnum) return "AdaptiveTimestepping" end + if(enum==AdjointBalancethickness2AnalysisEnum) return "AdjointBalancethickness2Analysis" end + if(enum==AdjointBalancethicknessAnalysisEnum) return "AdjointBalancethicknessAnalysis" end + if(enum==AdjointHorizAnalysisEnum) return "AdjointHorizAnalysis" end + if(enum==AggressiveMigrationEnum) return "AggressiveMigration" end + if(enum==AmrBamgEnum) return "AmrBamg" end + if(enum==AmrNeopzEnum) return "AmrNeopz" end + if(enum==AndroidFrictionCoefficientEnum) return "AndroidFrictionCoefficient" end + if(enum==ArrheniusEnum) return "Arrhenius" end + if(enum==AutodiffJacobianEnum) return "AutodiffJacobian" end + if(enum==AutoregressionLinearFloatingMeltRateEnum) return "AutoregressionLinearFloatingMeltRate" end + if(enum==Balancethickness2AnalysisEnum) return "Balancethickness2Analysis" end + if(enum==Balancethickness2SolutionEnum) return "Balancethickness2Solution" end + if(enum==BalancethicknessAnalysisEnum) return "BalancethicknessAnalysis" end + if(enum==BalancethicknessApparentMassbalanceEnum) return "BalancethicknessApparentMassbalance" end + if(enum==BalancethicknessSoftAnalysisEnum) return "BalancethicknessSoftAnalysis" end + if(enum==BalancethicknessSoftSolutionEnum) return "BalancethicknessSoftSolution" end + if(enum==BalancethicknessSolutionEnum) return "BalancethicknessSolution" end + if(enum==BalancevelocityAnalysisEnum) return "BalancevelocityAnalysis" end + if(enum==BalancevelocitySolutionEnum) return "BalancevelocitySolution" end + if(enum==BasalforcingsIsmip6Enum) return "BasalforcingsIsmip6" end + if(enum==BasalforcingsPicoEnum) return "BasalforcingsPico" end + if(enum==BeckmannGoosseFloatingMeltRateEnum) return "BeckmannGoosseFloatingMeltRate" end + if(enum==BedSlopeSolutionEnum) return "BedSlopeSolution" end + if(enum==BoolExternalResultEnum) return "BoolExternalResult" end + if(enum==BoolInputEnum) return "BoolInput" end + if(enum==IntInputEnum) return "IntInput" end + if(enum==DoubleInputEnum) return "DoubleInput" end + if(enum==BoolParamEnum) return "BoolParam" end + if(enum==BoundaryEnum) return "Boundary" end + if(enum==BuddJackaEnum) return "BuddJacka" end + if(enum==CalvingDev2Enum) return "CalvingDev2" end + if(enum==CalvingHabEnum) return "CalvingHab" end + if(enum==CalvingLevermannEnum) return "CalvingLevermann" end + if(enum==CalvingTestEnum) return "CalvingTest" end + if(enum==CalvingParameterizationEnum) return "CalvingParameterization" end + if(enum==CalvingVonmisesEnum) return "CalvingVonmises" end + if(enum==CfdragcoeffabsgradEnum) return "Cfdragcoeffabsgrad" end + if(enum==CfsurfacelogvelEnum) return "Cfsurfacelogvel" end + if(enum==CfsurfacesquareEnum) return "Cfsurfacesquare" end + if(enum==CflevelsetmisfitEnum) return "Cflevelsetmisfit" end + if(enum==ChannelEnum) return "Channel" end + if(enum==ChannelAreaEnum) return "ChannelArea" end + if(enum==ChannelAreaOldEnum) return "ChannelAreaOld" end + if(enum==ChannelDischargeEnum) return "ChannelDischarge" end + if(enum==ClosedEnum) return "Closed" end + if(enum==ColinearEnum) return "Colinear" end + if(enum==ConstraintsEnum) return "Constraints" end + if(enum==ContactEnum) return "Contact" end + if(enum==ContourEnum) return "Contour" end + if(enum==ContoursEnum) return "Contours" end + if(enum==ControlInputEnum) return "ControlInput" end + if(enum==ControlInputGradEnum) return "ControlInputGrad" end + if(enum==ControlInputMaxsEnum) return "ControlInputMaxs" end + if(enum==ControlInputMinsEnum) return "ControlInputMins" end + if(enum==ControlInputValuesEnum) return "ControlInputValues" end + if(enum==CrouzeixRaviartEnum) return "CrouzeixRaviart" end + if(enum==CuffeyEnum) return "Cuffey" end + if(enum==CuffeyTemperateEnum) return "CuffeyTemperate" end + if(enum==DamageEvolutionAnalysisEnum) return "DamageEvolutionAnalysis" end + if(enum==DamageEvolutionSolutionEnum) return "DamageEvolutionSolution" end + if(enum==DataSetEnum) return "DataSet" end + if(enum==DataSetParamEnum) return "DataSetParam" end + if(enum==DatasetInputEnum) return "DatasetInput" end + if(enum==DefaultAnalysisEnum) return "DefaultAnalysis" end + if(enum==DefaultCalvingEnum) return "DefaultCalving" end + if(enum==DenseEnum) return "Dense" end + if(enum==DependentObjectEnum) return "DependentObject" end + if(enum==DepthAverageAnalysisEnum) return "DepthAverageAnalysis" end + if(enum==DeviatoricStressErrorEstimatorEnum) return "DeviatoricStressErrorEstimator" end + if(enum==DivergenceEnum) return "Divergence" end + if(enum==Domain3DsurfaceEnum) return "Domain3Dsurface" end + if(enum==DoubleArrayInputEnum) return "DoubleArrayInput" end + if(enum==ArrayInputEnum) return "ArrayInput" end + if(enum==DoubleExternalResultEnum) return "DoubleExternalResult" end + if(enum==DoubleMatArrayParamEnum) return "DoubleMatArrayParam" end + if(enum==DoubleMatExternalResultEnum) return "DoubleMatExternalResult" end + if(enum==DoubleMatParamEnum) return "DoubleMatParam" end + if(enum==DoubleParamEnum) return "DoubleParam" end + if(enum==DoubleVecParamEnum) return "DoubleVecParam" end + if(enum==ElementEnum) return "Element" end + if(enum==ElementHookEnum) return "ElementHook" end + if(enum==ElementSIdEnum) return "ElementSId" end + if(enum==EnthalpyAnalysisEnum) return "EnthalpyAnalysis" end + if(enum==EsaAnalysisEnum) return "EsaAnalysis" end + if(enum==EsaSolutionEnum) return "EsaSolution" end + if(enum==EsaTransitionsEnum) return "EsaTransitions" end + if(enum==ExternalResultEnum) return "ExternalResult" end + if(enum==ExtrapolationAnalysisEnum) return "ExtrapolationAnalysis" end + if(enum==ExtrudeFromBaseAnalysisEnum) return "ExtrudeFromBaseAnalysis" end + if(enum==ExtrudeFromTopAnalysisEnum) return "ExtrudeFromTopAnalysis" end + if(enum==FSApproximationEnum) return "FSApproximation" end + if(enum==FSSolverEnum) return "FSSolver" end + if(enum==FSpressureEnum) return "FSpressure" end + if(enum==FSvelocityEnum) return "FSvelocity" end + if(enum==FemModelEnum) return "FemModel" end + if(enum==FileParamEnum) return "FileParam" end + if(enum==FixedTimesteppingEnum) return "FixedTimestepping" end + if(enum==FloatingAreaEnum) return "FloatingArea" end + if(enum==FloatingAreaScaledEnum) return "FloatingAreaScaled" end + if(enum==FloatingMeltRateEnum) return "FloatingMeltRate" end + if(enum==FreeEnum) return "Free" end + if(enum==FreeSurfaceBaseAnalysisEnum) return "FreeSurfaceBaseAnalysis" end + if(enum==FreeSurfaceTopAnalysisEnum) return "FreeSurfaceTopAnalysis" end + if(enum==FrontalForcingsDefaultEnum) return "FrontalForcingsDefault" end + if(enum==FrontalForcingsRignotEnum) return "FrontalForcingsRignot" end + if(enum==FrontalForcingsRignotAutoregressionEnum) return "FrontalForcingsRignotAutoregression" end + if(enum==FsetEnum) return "Fset" end + if(enum==FullMeltOnPartiallyFloatingEnum) return "FullMeltOnPartiallyFloating" end + if(enum==GLheightadvectionAnalysisEnum) return "GLheightadvectionAnalysis" end + if(enum==GaussPentaEnum) return "GaussPenta" end + if(enum==GaussSegEnum) return "GaussSeg" end + if(enum==GaussTetraEnum) return "GaussTetra" end + if(enum==GaussTriaEnum) return "GaussTria" end + if(enum==GenericOptionEnum) return "GenericOption" end + if(enum==GenericParamEnum) return "GenericParam" end + if(enum==GenericExternalResultEnum) return "GenericExternalResult" end + if(enum==Gradient1Enum) return "Gradient1" end + if(enum==Gradient2Enum) return "Gradient2" end + if(enum==Gradient3Enum) return "Gradient3" end + if(enum==Gradient4Enum) return "Gradient4" end + if(enum==GroundedAreaEnum) return "GroundedArea" end + if(enum==GroundedAreaScaledEnum) return "GroundedAreaScaled" end + if(enum==GroundingOnlyEnum) return "GroundingOnly" end + if(enum==GroundinglineMassFluxEnum) return "GroundinglineMassFlux" end + if(enum==GsetEnum) return "Gset" end + if(enum==GslEnum) return "Gsl" end + if(enum==HOApproximationEnum) return "HOApproximation" end + if(enum==HOFSApproximationEnum) return "HOFSApproximation" end + if(enum==HookEnum) return "Hook" end + if(enum==HydrologyDCEfficientAnalysisEnum) return "HydrologyDCEfficientAnalysis" end + if(enum==HydrologyDCInefficientAnalysisEnum) return "HydrologyDCInefficientAnalysis" end + if(enum==HydrologyGlaDSAnalysisEnum) return "HydrologyGlaDSAnalysis" end + if(enum==HydrologyGlaDSEnum) return "HydrologyGlaDS" end + if(enum==HydrologyPismAnalysisEnum) return "HydrologyPismAnalysis" end + if(enum==HydrologyShaktiAnalysisEnum) return "HydrologyShaktiAnalysis" end + if(enum==HydrologyShreveAnalysisEnum) return "HydrologyShreveAnalysis" end + if(enum==HydrologySolutionEnum) return "HydrologySolution" end + if(enum==HydrologydcEnum) return "Hydrologydc" end + if(enum==HydrologypismEnum) return "Hydrologypism" end + if(enum==HydrologyshaktiEnum) return "Hydrologyshakti" end + if(enum==HydrologyshreveEnum) return "Hydrologyshreve" end + if(enum==IceMassEnum) return "IceMass" end + if(enum==IceMassScaledEnum) return "IceMassScaled" end + if(enum==IceVolumeAboveFloatationEnum) return "IceVolumeAboveFloatation" end + if(enum==IceVolumeAboveFloatationScaledEnum) return "IceVolumeAboveFloatationScaled" end + if(enum==IceVolumeEnum) return "IceVolume" end + if(enum==IceVolumeScaledEnum) return "IceVolumeScaled" end + if(enum==IcefrontMassFluxEnum) return "IcefrontMassFlux" end + if(enum==IcefrontMassFluxLevelsetEnum) return "IcefrontMassFluxLevelset" end + if(enum==IncrementalEnum) return "Incremental" end + if(enum==IndexedEnum) return "Indexed" end + if(enum==IntExternalResultEnum) return "IntExternalResult" end + if(enum==ElementInputEnum) return "ElementInput" end + if(enum==IntMatExternalResultEnum) return "IntMatExternalResult" end + if(enum==IntMatParamEnum) return "IntMatParam" end + if(enum==IntParamEnum) return "IntParam" end + if(enum==IntVecParamEnum) return "IntVecParam" end + if(enum==InputsEnum) return "Inputs" end + if(enum==InternalEnum) return "Internal" end + if(enum==IntersectEnum) return "Intersect" end + if(enum==InversionVzObsEnum) return "InversionVzObs" end + if(enum==JEnum) return "J" end + if(enum==L1L2ApproximationEnum) return "L1L2Approximation" end + if(enum==MLHOApproximationEnum) return "MLHOApproximation" end + if(enum==L2ProjectionBaseAnalysisEnum) return "L2ProjectionBaseAnalysis" end + if(enum==L2ProjectionEPLAnalysisEnum) return "L2ProjectionEPLAnalysis" end + if(enum==LACrouzeixRaviartEnum) return "LACrouzeixRaviart" end + if(enum==LATaylorHoodEnum) return "LATaylorHood" end + if(enum==LambdaSEnum) return "LambdaS" end + if(enum==LevelsetAnalysisEnum) return "LevelsetAnalysis" end + if(enum==LevelsetfunctionPicardEnum) return "LevelsetfunctionPicard" end + if(enum==LinearFloatingMeltRateEnum) return "LinearFloatingMeltRate" end + if(enum==LliboutryDuvalEnum) return "LliboutryDuval" end + if(enum==LoadsEnum) return "Loads" end + if(enum==LoveAnalysisEnum) return "LoveAnalysis" end + if(enum==LoveHfEnum) return "LoveHf" end + if(enum==LoveHtEnum) return "LoveHt" end + if(enum==LoveKernelsImagEnum) return "LoveKernelsImag" end + if(enum==LoveKernelsRealEnum) return "LoveKernelsReal" end + if(enum==LoveKfEnum) return "LoveKf" end + if(enum==LoveKtEnum) return "LoveKt" end + if(enum==LoveLfEnum) return "LoveLf" end + if(enum==LoveLtEnum) return "LoveLt" end + if(enum==LoveTidalHtEnum) return "LoveTidalHt" end + if(enum==LoveTidalKtEnum) return "LoveTidalKt" end + if(enum==LoveTidalLtEnum) return "LoveTidalLt" end + if(enum==LovePMTF1tEnum) return "LovePMTF1t" end + if(enum==LovePMTF2tEnum) return "LovePMTF2t" end + if(enum==LoveSolutionEnum) return "LoveSolution" end + if(enum==MINIEnum) return "MINI" end + if(enum==MINIcondensedEnum) return "MINIcondensed" end + if(enum==MantlePlumeGeothermalFluxEnum) return "MantlePlumeGeothermalFlux" end + if(enum==MassFluxEnum) return "MassFlux" end + if(enum==MassconEnum) return "Masscon" end + if(enum==MassconaxpbyEnum) return "Massconaxpby" end + if(enum==MassfluxatgateEnum) return "Massfluxatgate" end + if(enum==MasstransportAnalysisEnum) return "MasstransportAnalysis" end + if(enum==MmemasstransportAnalysisEnum) return "MmemasstransportAnalysis" end + if(enum==MmemasstransportSolutionEnum) return "MmemasstransportSolution" end + if(enum==MasstransportSolutionEnum) return "MasstransportSolution" end + if(enum==MatdamageiceEnum) return "Matdamageice" end + if(enum==MatenhancediceEnum) return "Matenhancedice" end + if(enum==MaterialsEnum) return "Materials" end + if(enum==MatestarEnum) return "Matestar" end + if(enum==MaticeEnum) return "Matice" end + if(enum==MatlithoEnum) return "Matlitho" end + if(enum==MathydroEnum) return "Mathydro" end + if(enum==MatrixParamEnum) return "MatrixParam" end + if(enum==MaxAbsVxEnum) return "MaxAbsVx" end + if(enum==MaxAbsVyEnum) return "MaxAbsVy" end + if(enum==MaxAbsVzEnum) return "MaxAbsVz" end + if(enum==MaxDivergenceEnum) return "MaxDivergence" end + if(enum==MaxVelEnum) return "MaxVel" end + if(enum==MaxVxEnum) return "MaxVx" end + if(enum==MaxVyEnum) return "MaxVy" end + if(enum==MaxVzEnum) return "MaxVz" end + if(enum==MelangeEnum) return "Melange" end + if(enum==MeltingAnalysisEnum) return "MeltingAnalysis" end + if(enum==MeshElementsEnum) return "MeshElements" end + if(enum==MeshXEnum) return "MeshX" end + if(enum==MeshYEnum) return "MeshY" end + if(enum==MinVelEnum) return "MinVel" end + if(enum==MinVxEnum) return "MinVx" end + if(enum==MinVyEnum) return "MinVy" end + if(enum==MinVzEnum) return "MinVz" end + if(enum==MismipFloatingMeltRateEnum) return "MismipFloatingMeltRate" end + if(enum==MoulinEnum) return "Moulin" end + if(enum==MpiDenseEnum) return "MpiDense" end + if(enum==MpiEnum) return "Mpi" end + if(enum==MpiSparseEnum) return "MpiSparse" end + if(enum==MumpsEnum) return "Mumps" end + if(enum==NoFrictionOnPartiallyFloatingEnum) return "NoFrictionOnPartiallyFloating" end + if(enum==NoMeltOnPartiallyFloatingEnum) return "NoMeltOnPartiallyFloating" end + if(enum==NodalEnum) return "Nodal" end + if(enum==NodalvalueEnum) return "Nodalvalue" end + if(enum==NodeSIdEnum) return "NodeSId" end + if(enum==NoneApproximationEnum) return "NoneApproximation" end + if(enum==NoneEnum) return "None" end + if(enum==NumberedcostfunctionEnum) return "Numberedcostfunction" end + if(enum==NyeCO2Enum) return "NyeCO2" end + if(enum==NyeH2OEnum) return "NyeH2O" end + if(enum==NumericalfluxEnum) return "Numericalflux" end + if(enum==OceantransportAnalysisEnum) return "OceantransportAnalysis" end + if(enum==OceantransportSolutionEnum) return "OceantransportSolution" end + if(enum==OldGradientEnum) return "OldGradient" end + if(enum==OneLayerP4zEnum) return "OneLayerP4z" end + if(enum==OpenEnum) return "Open" end + if(enum==OptionEnum) return "Option" end + if(enum==ParamEnum) return "Param" end + if(enum==ParametersEnum) return "Parameters" end + if(enum==P0ArrayEnum) return "P0Array" end + if(enum==P0DGEnum) return "P0DG" end + if(enum==P1DGEnum) return "P1DG" end + if(enum==P1P1Enum) return "P1P1" end + if(enum==P1P1GLSEnum) return "P1P1GLS" end + if(enum==P1bubbleEnum) return "P1bubble" end + if(enum==P1bubblecondensedEnum) return "P1bubblecondensed" end + if(enum==P1xP2Enum) return "P1xP2" end + if(enum==P1xP3Enum) return "P1xP3" end + if(enum==P1xP4Enum) return "P1xP4" end + if(enum==P2Enum) return "P2" end + if(enum==P2bubbleEnum) return "P2bubble" end + if(enum==P2bubblecondensedEnum) return "P2bubblecondensed" end + if(enum==P2xP1Enum) return "P2xP1" end + if(enum==P2xP4Enum) return "P2xP4" end + if(enum==PatersonEnum) return "Paterson" end + if(enum==PengridEnum) return "Pengrid" end + if(enum==PenpairEnum) return "Penpair" end + if(enum==PentaEnum) return "Penta" end + if(enum==PentaInputEnum) return "PentaInput" end + if(enum==ProfilerEnum) return "Profiler" end + if(enum==ProfilingCurrentFlopsEnum) return "ProfilingCurrentFlops" end + if(enum==ProfilingCurrentMemEnum) return "ProfilingCurrentMem" end + if(enum==ProfilingSolutionTimeEnum) return "ProfilingSolutionTime" end + if(enum==RegionaloutputEnum) return "Regionaloutput" end + if(enum==RegularEnum) return "Regular" end + if(enum==RecoveryAnalysisEnum) return "RecoveryAnalysis" end + if(enum==RiftfrontEnum) return "Riftfront" end + if(enum==SamplingAnalysisEnum) return "SamplingAnalysis" end + if(enum==SamplingSolutionEnum) return "SamplingSolution" end + if(enum==SIAApproximationEnum) return "SIAApproximation" end + if(enum==SMBautoregressionEnum) return "SMBautoregression" end + if(enum==SMBcomponentsEnum) return "SMBcomponents" end + if(enum==SMBd18opddEnum) return "SMBd18opdd" end + if(enum==SMBforcingEnum) return "SMBforcing" end + if(enum==SMBgcmEnum) return "SMBgcm" end + if(enum==SMBgembEnum) return "SMBgemb" end + if(enum==SMBgradientsEnum) return "SMBgradients" end + if(enum==SMBgradientscomponentsEnum) return "SMBgradientscomponents" end + if(enum==SMBgradientselaEnum) return "SMBgradientsela" end + if(enum==SMBhenningEnum) return "SMBhenning" end + if(enum==SMBmeltcomponentsEnum) return "SMBmeltcomponents" end + if(enum==SMBpddEnum) return "SMBpdd" end + if(enum==SMBpddSicopolisEnum) return "SMBpddSicopolis" end + if(enum==SMBsemicEnum) return "SMBsemic" end + if(enum==SSAApproximationEnum) return "SSAApproximation" end + if(enum==SSAFSApproximationEnum) return "SSAFSApproximation" end + if(enum==SSAHOApproximationEnum) return "SSAHOApproximation" end + if(enum==ScaledEnum) return "Scaled" end + if(enum==SealevelAbsoluteEnum) return "SealevelAbsolute" end + if(enum==SealevelEmotionEnum) return "SealevelEmotion" end + if(enum==SealevelchangePolarMotionXEnum) return "SealevelchangePolarMotionX" end + if(enum==SealevelchangePolarMotionYEnum) return "SealevelchangePolarMotionY" end + if(enum==SealevelchangePolarMotionZEnum) return "SealevelchangePolarMotionZ" end + if(enum==SealevelchangePolarMotionEnum) return "SealevelchangePolarMotion" end + if(enum==SealevelNmotionEnum) return "SealevelNmotion" end + if(enum==SealevelUmotionEnum) return "SealevelUmotion" end + if(enum==SealevelchangeAnalysisEnum) return "SealevelchangeAnalysis" end + if(enum==SegEnum) return "Seg" end + if(enum==SegInputEnum) return "SegInput" end + if(enum==SegmentEnum) return "Segment" end + if(enum==SegmentRiftfrontEnum) return "SegmentRiftfront" end + if(enum==SeparateEnum) return "Separate" end + if(enum==SeqEnum) return "Seq" end + if(enum==SmbAnalysisEnum) return "SmbAnalysis" end + if(enum==SmbSolutionEnum) return "SmbSolution" end + if(enum==SmoothAnalysisEnum) return "SmoothAnalysis" end + if(enum==SoftMigrationEnum) return "SoftMigration" end + if(enum==SpatialLinearFloatingMeltRateEnum) return "SpatialLinearFloatingMeltRate" end + if(enum==SpcDynamicEnum) return "SpcDynamic" end + if(enum==SpcStaticEnum) return "SpcStatic" end + if(enum==SpcTransientEnum) return "SpcTransient" end + if(enum==SsetEnum) return "Sset" end + if(enum==StatisticsSolutionEnum) return "StatisticsSolution" end + if(enum==SteadystateSolutionEnum) return "SteadystateSolution" end + if(enum==StressIntensityFactorEnum) return "StressIntensityFactor" end + if(enum==StressbalanceAnalysisEnum) return "StressbalanceAnalysis" end + if(enum==StressbalanceConvergenceNumStepsEnum) return "StressbalanceConvergenceNumSteps" end + if(enum==StressbalanceSIAAnalysisEnum) return "StressbalanceSIAAnalysis" end + if(enum==StressbalanceSolutionEnum) return "StressbalanceSolution" end + if(enum==StressbalanceVerticalAnalysisEnum) return "StressbalanceVerticalAnalysis" end + if(enum==StringArrayParamEnum) return "StringArrayParam" end + if(enum==StringExternalResultEnum) return "StringExternalResult" end + if(enum==StringParamEnum) return "StringParam" end + if(enum==SubelementFriction1Enum) return "SubelementFriction1" end + if(enum==SubelementFriction2Enum) return "SubelementFriction2" end + if(enum==SubelementMelt1Enum) return "SubelementMelt1" end + if(enum==SubelementMelt2Enum) return "SubelementMelt2" end + if(enum==SubelementMigrationEnum) return "SubelementMigration" end + if(enum==SurfaceSlopeSolutionEnum) return "SurfaceSlopeSolution" end + if(enum==TaylorHoodEnum) return "TaylorHood" end + if(enum==TetraEnum) return "Tetra" end + if(enum==TetraInputEnum) return "TetraInput" end + if(enum==ThermalAnalysisEnum) return "ThermalAnalysis" end + if(enum==ThermalSolutionEnum) return "ThermalSolution" end + if(enum==ThicknessErrorEstimatorEnum) return "ThicknessErrorEstimator" end + if(enum==TotalCalvingFluxLevelsetEnum) return "TotalCalvingFluxLevelset" end + if(enum==TotalCalvingMeltingFluxLevelsetEnum) return "TotalCalvingMeltingFluxLevelset" end + if(enum==TotalFloatingBmbEnum) return "TotalFloatingBmb" end + if(enum==TotalFloatingBmbScaledEnum) return "TotalFloatingBmbScaled" end + if(enum==TotalGroundedBmbEnum) return "TotalGroundedBmb" end + if(enum==TotalGroundedBmbScaledEnum) return "TotalGroundedBmbScaled" end + if(enum==TotalSmbEnum) return "TotalSmb" end + if(enum==TotalSmbScaledEnum) return "TotalSmbScaled" end + if(enum==TransientArrayParamEnum) return "TransientArrayParam" end + if(enum==TransientInputEnum) return "TransientInput" end + if(enum==TransientParamEnum) return "TransientParam" end + if(enum==TransientSolutionEnum) return "TransientSolution" end + if(enum==TriaEnum) return "Tria" end + if(enum==TriaInputEnum) return "TriaInput" end + if(enum==UzawaPressureAnalysisEnum) return "UzawaPressureAnalysis" end + if(enum==VectorParamEnum) return "VectorParam" end + if(enum==VertexEnum) return "Vertex" end + if(enum==VertexLIdEnum) return "VertexLId" end + if(enum==VertexPIdEnum) return "VertexPId" end + if(enum==VertexSIdEnum) return "VertexSId" end + if(enum==VerticesEnum) return "Vertices" end + if(enum==ViscousHeatingEnum) return "ViscousHeating" end + if(enum==WaterEnum) return "Water" end + if(enum==XTaylorHoodEnum) return "XTaylorHood" end + if(enum==XYEnum) return "XY" end + if(enum==XYZEnum) return "XYZ" end + if(enum==BalancethicknessD0Enum) return "BalancethicknessD0" end + if(enum==BalancethicknessDiffusionCoefficientEnum) return "BalancethicknessDiffusionCoefficient" end + if(enum==BilinearInterpEnum) return "BilinearInterp" end + if(enum==CalvingdevCoeffEnum) return "CalvingdevCoeff" end + if(enum==DeviatoricStressEnum) return "DeviatoricStress" end + if(enum==EtaAbsGradientEnum) return "EtaAbsGradient" end + if(enum==MeshZEnum) return "MeshZ" end + if(enum==NearestInterpEnum) return "NearestInterp" end + if(enum==OutputdefinitionListEnum) return "OutputdefinitionList" end + if(enum==SealevelObsEnum) return "SealevelObs" end + if(enum==SealevelWeightsEnum) return "SealevelWeights" end + if(enum==StrainRateEnum) return "StrainRate" end + if(enum==StressTensorEnum) return "StressTensor" end + if(enum==StressbalanceViscosityOvershootEnum) return "StressbalanceViscosityOvershoot" end + if(enum==SubelementMigration4Enum) return "SubelementMigration4" end + if(enum==TimesteppingTimeAdaptEnum) return "TimesteppingTimeAdapt" end + if(enum==TriangleInterpEnum) return "TriangleInterp" end + if(enum==MaximumNumberOfDefinitionsEnum) return "MaximumNumberOfDefinitions" end +end