Index: /issm/trunk-jpl/src/m/array/arrayoperations.js
===================================================================
--- /issm/trunk-jpl/src/m/array/arrayoperations.js	(revision 19779)
+++ /issm/trunk-jpl/src/m/array/arrayoperations.js	(revision 19780)
@@ -92,17 +92,21 @@
 	return matrix;
 } //}}}
-function MatrixToList(matrix) { //{{{
-	
-	var width = matrix[0].length;
-	var length = matrix.length;
-	var list= new Array(width*length);
-
-	for(var i=0;i<length;i++){
-		for(var j=0;j<width;j++){
-			list[i*width+j]=matrix[i][j];
-		}
-	}
-		
-	return list;
+function MatrixToList(matrixin) { //{{{
+
+	var matrix=matrixin;
+
+	if (!IsArray(matrix[0])) return matrix;
+	else{
+		var width = matrix[0].length;
+		var length = matrix.length;
+		var list= new Array(width*length);
+
+		for(var i=0;i<length;i++){
+			for(var j=0;j<width;j++){
+				list[i*width+j]=matrix[i][j];
+			}
+		}
+		return list;
+	}
 } //}}}
 function IsArray(object) { //{{{
@@ -120,4 +124,10 @@
 	return notarray;
 } //}}}
+function ArrayCopy(array) { //{{{
+
+	var copy=[];
+	for(var i=0;i<array.length;i++)copy[i]=array[i];
+	return copy;
+} //}}}
 function ArrayPow(array,coefficient) { //{{{
 
@@ -145,8 +155,28 @@
 	return 0;
 } //}}}
+function ArrayUnique(arr) { //{{{
+
+	return arr.reverse().filter(function (e, i, arr) {
+		    return arr.indexOf(e, i+1) === -1;
+	}).reverse();
+} //}}}
+function ArraySort(array) { //{{{
+
+	return array.sort(function(a, b) {
+		return a - b;
+	});
+
+} //}}}
 function ArrayAnyEqual(array,value) { //{{{
-
-	for(var i=0;i<array.length;i++){
-		if (array[i]==value)return 1;
+	
+	if(!isNaN(value)){
+		for(var i=0;i<array.length;i++){
+			if (array[i]==value)return 1;
+		}
+	}
+	else{
+		for(var i=0;i<array.length;i++){
+			if (isNaN(array[i]))return 1;
+		}
 	}
 	return 0;
@@ -186,7 +216,30 @@
 	return array;
 } //}}}
+function ArrayIsMember(array1,array2) { //{{{
+
+	var array=NewArrayFill(array1.length,0);
+	for (i=0;i<array1.length;i++){
+		for(j=0;j<array2.length;j++){
+			if (array1[i] == array2[j]){
+				array[i]=1;
+				break;
+			}
+		}
+	}
+	return array;
+} //}}}
 function NewArrayFill(size,value) { //{{{
 
 	return new Array(size).fill(value);
+} //}}}
+function NewArrayFillIncrement(size,start,increment) { //{{{
+
+	var array=new Array(size); 
+
+	for(var i=0;i<size;i++){
+		array[i]=start+i*increment;
+	}
+
+	return array;
 } //}}}
 function ArrayFind(array,value) { //{{{
Index: /issm/trunk-jpl/src/m/classes/SMBforcing.js
===================================================================
--- /issm/trunk-jpl/src/m/classes/SMBforcing.js	(revision 19779)
+++ /issm/trunk-jpl/src/m/classes/SMBforcing.js	(revision 19780)
@@ -21,4 +21,15 @@
 
 		} // }}}
+		this.checkconsistency = function(md,solution,analyses) { //{{{
+
+			if(ArrayAnyEqual(ArrayIsMember(MasstransportAnalysisEnum(),analyses),1)){
+				checkfield(md,'fieldname','smb.mass_balance','timeseries',1,'NaN',1);
+			}
+			if(ArrayAnyEqual(ArrayIsMember(BalancethicknessAnalysisEnum(),analyses),1)){
+				checkfield(md,'fieldname','smb.mass_balance','size',[md.mesh.numberofvertices,1],'NaN',1);
+			}
+			checkfield(md,'fieldname','smb.requested_outputs','stringrow',1);
+
+		} // }}}
 	//properties 
 	this.mass_balance = NaN;
Index: /issm/trunk-jpl/src/m/classes/basalforcings.js
===================================================================
--- /issm/trunk-jpl/src/m/classes/basalforcings.js	(revision 19779)
+++ /issm/trunk-jpl/src/m/classes/basalforcings.js	(revision 19780)
@@ -30,5 +30,26 @@
 
 		} // }}}
-	//properties 
+		this.checkconsistency = function(md,solution,analyses) { //{{{
+
+			if(ArrayAnyEqual(ArrayIsMember(MasstransportAnalysisEnum(),analyses),1)){
+				if (!(solution==TransientSolutionEnum() & md.transient.ismasstransport==0)){
+					checkfield(md,'fieldname','basalforcings.groundedice_melting_rate','NaN',1,'timeseries',1);
+					checkfield(md,'fieldname','basalforcings.floatingice_melting_rate','NaN',1,'timeseries',1);
+				}
+			}
+
+			if(ArrayAnyEqual(ArrayIsMember(BalancethicknessAnalysisEnum(),analyses),1)){
+				checkfield(md,'fieldname','basalforcings.groundedice_melting_rate','NaN',1,'size',[md.mesh.numberofvertices, 1]);
+				checkfield(md,'fieldname','basalforcings.floatingice_melting_rate','NaN',1,'size',[md.mesh.numberofvertices, 1]);
+			}
+			if(ArrayAnyEqual(ArrayIsMember(ThermalAnalysisEnum(),analyses),1)){
+				if (!(solution==TransientSolutionEnum() & md.transient.isthermal==0)){
+					checkfield(md,'fieldname','basalforcings.groundedice_melting_rate','NaN',1,'timeseries',1);
+					checkfield(md,'fieldname','basalforcings.floatingice_melting_rate','NaN',1,'timeseries',1);
+					checkfield(md,'fieldname','basalforcings.geothermalflux','NaN',1,'timeseries',1,'>=',0);
+				}
+			}
+		} // }}}
+	//properties
 	//{{{
 	this.groundedice_melting_rate  = NaN;
Index: /issm/trunk-jpl/src/m/classes/constants.js
===================================================================
--- /issm/trunk-jpl/src/m/classes/constants.js	(revision 19779)
+++ /issm/trunk-jpl/src/m/classes/constants.js	(revision 19780)
@@ -29,4 +29,12 @@
 
 		} //}}}
+		this.checkconsistency = function(md,solution,analyses) {//% {{{
+
+			checkfield(md,'fieldname','constants.g','>=',0,'size',[1,1]); //We allow 0 for validation tests
+			checkfield(md,'fieldname','constants.omega','>=',0,'size',[1,1]);
+			checkfield(md,'fieldname','constants.yts','>',0,'size',[1,1]);
+			checkfield(md,'fieldname','constants.referencetemperature','size',[1,1]);
+
+		} // }}}
 	//properties 
 	// {{{
Index: /issm/trunk-jpl/src/m/classes/damage.js
===================================================================
--- /issm/trunk-jpl/src/m/classes/damage.js	(revision 19779)
+++ /issm/trunk-jpl/src/m/classes/damage.js	(revision 19780)
@@ -62,4 +62,31 @@
 		}
 	}// }}}
+		this.checkconsistency = function(md,solution,analyses) { //{{{
+			
+			checkfield(md,'fieldname','damage.isdamage','values',[1,0]);
+			if (this.isdamage){
+				checkfield(md,'fieldname','damage.law','numel',[1],'values',[0,1,2]);
+				checkfield(md,'fieldname','damage.D','>=',0,'<=',self.max_damage,'size',[md.mesh.numberofvertices ,1]);
+				checkfield(md,'fieldname','damage.spcdamage','timeseries',1);
+				checkfield(md,'fieldname','damage.max_damage','<',1,'>=',0);
+				checkfield(md,'fieldname','damage.stabilization','numel',[1],'values',[0, 1, 2, 4]);
+				checkfield(md,'fieldname','damage.maxiter','>=0',0);
+				checkfield(md,'fieldname','damage.elementinterp','values',['P1','P2']);
+				checkfield(md,'fieldname','damage.stress_threshold','>=',0);
+				checkfield(md,'fieldname','damage.kappa','>',1);
+				checkfield(md,'fieldname','damage.healing','>=',0);
+				checkfield(md,'fieldname','damage.c1','>=',0);
+				checkfield(md,'fieldname','damage.c2','>=',0);
+				checkfield(md,'fieldname','damage.c3','>=',0);
+				checkfield(md,'fieldname','damage.c4','>=',0);
+				checkfield(md,'fieldname','damage.equiv_stress','numel',[1],'values',[0, 1]);
+				checkfield(md,'fieldname','damage.requested_outputs','stringrow',1);
+			}
+			else if (this.law!=0){
+				if (solution==DamageEvolutionSolutionEnum){
+					throw Error('Invalid evolution law (md.damage.law) for a damage solution');
+				}
+			}
+		} //}}}
 	//properties 
 	// {{{
Index: /issm/trunk-jpl/src/m/classes/flowequation.js
===================================================================
--- /issm/trunk-jpl/src/m/classes/flowequation.js	(revision 19779)
+++ /issm/trunk-jpl/src/m/classes/flowequation.js	(revision 19780)
@@ -34,4 +34,56 @@
 
 	}// }}}
+		this.checkconsistency = function(md,solution,analyses) {//{{{
+
+			//Early return
+			if ( ((!ArrayAnyEqual(ArrayIsMember(StressbalanceAnalysisEnum(),analyses),1)) & (!ArrayAnyEqual(ArrayIsMember(StressbalanceSIAAnalysisEnum(),analyses),1))) | 
+					(solution==TransientSolutionEnum() & md.transient.isstressbalance==0)
+			   ) return ;
+
+			checkfield(md,'fieldname','flowequation.isSIA','numel',[1],'values',[0, 1]);
+			checkfield(md,'fieldname','flowequation.isSSA','numel',[1],'values',[0, 1]);
+			checkfield(md,'fieldname','flowequation.isL1L2','numel',[1],'values',[0, 1]);
+			checkfield(md,'fieldname','flowequation.isHO','numel',[1],'values',[0, 1]);
+			checkfield(md,'fieldname','flowequation.isFS','numel',[1],'values',[0, 1]);
+			checkfield(md,'fieldname','flowequation.fe_SSA','values',['P1','P1bubble','P1bubblecondensed','P2','P2bubble']);
+			checkfield(md,'fieldname','flowequation.fe_HO' ,'values',['P1','P1bubble','P1bubblecondensed','P1xP2','P2xP1','P2','P2bubble','P1xP3','P2xP4']);
+			checkfield(md,'fieldname','flowequation.fe_FS' ,'values',['P1P1','P1P1GLS','MINIcondensed','MINI','TaylorHood','LATaylorHood','XTaylorHood','OneLayerP4z','CrouzeixRaviart','LACrouzeixRaviart']);
+			checkfield(md,'fieldname','flowequation.augmented_lagrangian_r','numel',[1],'>=',0.);
+			checkfield(md,'fieldname','flowequation.augmented_lagrangian_rlambda','numel',[1],'>=',0.);
+			checkfield(md,'fieldname','flowequation.augmented_lagrangian_rhop','numel',[1],'>=',0.);
+			checkfield(md,'fieldname','flowequation.augmented_lagrangian_rholambda','numel',[1],'>=',0.);
+			checkfield(md,'fieldname','flowequation.XTH_theta','numel',[1],'>=',0.,'<',0.5);
+			checkfield(md,'fieldname','flowequation.borderSSA','size',[md.mesh.numberofvertices, 1],'values',[0, 1]);
+			checkfield(md,'fieldname','flowequation.borderHO','size',[md.mesh.numberofvertices, 1],'values',[0, 1]);
+			checkfield(md,'fieldname','flowequation.borderFS','size',[md.mesh.numberofvertices, 1],'values',[0, 1]);
+			if (md.mesh.domaintype() == '2Dhorizontal'){
+				checkfield(md,'fieldname','flowequation.vertex_equation','size',[md.mesh.numberofvertices, 1],'values',[1,2]);
+				checkfield(md,'fieldname','flowequation.element_equation','size',[md.mesh.numberofelements, 1],'values',[1,2]);
+			}
+			else if (md.mesh.domaintype() == '3Dsurface'){
+				checkfield(md,'fieldname','flowequation.vertex_equation','size',[md.mesh.numberofvertices, 1],'values',[1,2]);
+				checkfield(md,'fieldname','flowequation.element_equation','size',[md.mesh.numberofelements, 1],'values',[1,2]);
+			}
+			else if (md.mesh.domaintype() =='2Dvertical'){
+				checkfield(md,'fieldname','flowequation.vertex_equation','size',[md.mesh.numberofvertices, 1],'values',[2,4,5]);
+				checkfield(md,'fieldname','flowequation.element_equation','size',[md.mesh.numberofelements, 1],'values',[2,4,5]);
+			}
+			else if (md.mesh.domaintype() =='3D'){
+				checkfield(md,'fieldname','flowequation.vertex_equation','size',[md.mesh.numberofvertices, 1],'values',[0,1,2,3,4,5,6,7,8]);
+				checkfield(md,'fieldname','flowequation.element_equation','size',[md.mesh.numberofelements, 1],'values',[0,1,2,3,4,5,6,7,8]);
+			}
+			else throw Error('Case not supported yet');
+			
+			if (!(this.isSIA | this.isSSA | this.isL1L2 | this.isHO | this.isFS)){
+				md = checkmessage(md,['no element types set for this model']);
+			}
+			if(ArrayAnyEqual(ArrayIsMember(StressbalanceSIAAnalysisEnum(), analyses),1)){
+				if (ArrayAnyEqual(this.element_equation,1)){
+					if(this.vertex_equation & ArrayAnyBelowStrict(md.mask.groundedice_levelset)){
+						console.log(sprintf("\n !!! Warning: SIA's model is not consistent on ice shelves !!!\n"));
+					}
+				}
+			}
+		} // }}}
 	//properties 
 	// {{{
Index: /issm/trunk-jpl/src/m/classes/friction.js
===================================================================
--- /issm/trunk-jpl/src/m/classes/friction.js	(revision 19779)
+++ /issm/trunk-jpl/src/m/classes/friction.js	(revision 19780)
@@ -15,4 +15,15 @@
 		fielddisplay(this,'q','q exponent');
 	} // }}}
+		this.checkconsistency = function(md,solution,analyses){ //{{{
+
+			//Early return
+			if ((!ArrayAnyEqual(ArrayIsMember(StressbalanceAnalysisEnum(),analyses),1)) & (!ArrayAnyEqual(ArrayIsMember(StressbalanceAnalysisEnum(),analyses),1))){
+				return; 
+			}
+			md = checkfield(md,'fieldname','friction.coefficient','timeseries',1,'NaN',1);
+			md = checkfield(md,'fieldname','friction.q','NaN',1,'size',[md.mesh.numberofelements ,1]);
+			md = checkfield(md,'fieldname','friction.p','NaN',1,'size',[md.mesh.numberofelements ,1]);
+
+		} // }}}
 	//properties 
 	//{{{
Index: /issm/trunk-jpl/src/m/classes/geometry.js
===================================================================
--- /issm/trunk-jpl/src/m/classes/geometry.js	(revision 19779)
+++ /issm/trunk-jpl/src/m/classes/geometry.js	(revision 19780)
@@ -16,4 +16,24 @@
 			fielddisplay(this,'bed','bed elevation [m]');
 		} //}}}
+		this.checkconsistency = function(md,solution,analyses) { //{{{
+
+			if ((solution==TransientSolutionEnum() & md.transient.isgia) | (solution==GiaSolutionEnum())){
+				checkfield(md,'fieldname','geometry.thickness','timeseries',1,'NaN',1,'>=',0);
+			}
+			else{
+				checkfield(md,'fieldname','geometry.surface'  ,'NaN',1,'size',[md.mesh.numberofvertices, 1]);
+				checkfield(md,'fieldname','geometry.base'      ,'NaN',1,'size',[md.mesh.numberofvertices, 1]);
+				checkfield(md,'fieldname','geometry.thickness','NaN',1,'size',[md.mesh.numberofvertices, 1],'>',0);
+				for(var i=0;i<md.mesh.numberofvertices;i++){
+					if (Math.abs(md.geometry.thickness.thickness-md.geometry.surface+md.geometry.base)>Math.pow(10,9)){
+						md = checkmessage(md,'equality thickness=surface-base violated');
+						break;
+					}
+				}
+				if (solution==TransientSolutionEnum() & md.transient.isgroundingline){
+					checkfield(md,'fieldname','geometry.bed','NaN',1,'size',[md.mesh.numberofvertices, 1]);
+				}
+			}
+		} // }}}
 	//properties 
 	// {{{
Index: /issm/trunk-jpl/src/m/classes/hydrologyshreve.js
===================================================================
--- /issm/trunk-jpl/src/m/classes/hydrologyshreve.js	(revision 19779)
+++ /issm/trunk-jpl/src/m/classes/hydrologyshreve.js	(revision 19780)
@@ -19,4 +19,8 @@
 
 	}// }}}
+	this.type= function(){// {{{
+
+		return "hydrologyshreve";
+	}// }}}
 	//properties 
 	// {{{
Index: /issm/trunk-jpl/src/m/classes/initialization.js
===================================================================
--- /issm/trunk-jpl/src/m/classes/initialization.js	(revision 19779)
+++ /issm/trunk-jpl/src/m/classes/initialization.js	(revision 19780)
@@ -24,4 +24,61 @@
 
 	}// }}}
+		this.checkconsistency = function(md,solution,analyses) { //{{{
+			if(ArrayAnyEqual(ArrayIsMember(StressbalanceAnalysisEnum(),analyses),1)){
+				if (!(isNaN(md.initialization.vx) | isNaN(md.initialization.vy))){
+					checkfield(md,'fieldname','initialization.vx','NaN',1,'size',[md.mesh.numberofvertices, 1]);
+					checkfield(md,'fieldname','initialization.vy','NaN',1,'size',[md.mesh.numberofvertices, 1]);
+				}
+			}
+			if(ArrayAnyEqual(ArrayIsMember(MasstransportAnalysisEnum(),analyses),1)){
+				checkfield(md,'fieldname','initialization.vx','NaN',1,'size',[md.mesh.numberofvertices, 1]);
+				checkfield(md,'fieldname','initialization.vy','NaN',1,'size',[md.mesh.numberofvertices, 1]);
+			}
+			if(ArrayAnyEqual(ArrayIsMember(BalancethicknessSolutionEnum(),analyses),1) & (solution==BalancethicknessSolutionEnum)){
+				checkfield(md,'fieldname','initialization.vx','NaN',1,'size',[md.mesh.numberofvertices, 1]);
+				checkfield(md,'fieldname','initialization.vy','NaN',1,'size',[md.mesh.numberofvertices, 1]);
+				//Triangle with zero velocity
+				for(var i=0;i<md.mesh.numberofelements;i++){
+					var sum=0;
+					for(var j=0;j<md.mesh.elements[0].length;j++){
+						if  ((md.initialization.vx[md.mesh.elements[i][j]-1]==0) & (md.initialization.vy[md.mesh.elements[i][j]-1]==0)) sum+=1;
+					}
+					if (sum==md.mesh.elements[0].length){
+						md.checkmessage('at least one triangle has all its vertices with a zero velocity');
+					}
+				}
+			}
+			if(ArrayAnyEqual(ArrayIsMember(ThermalAnalysisEnum(),analyses),1)){
+				checkfield(md,'fieldname','initialization.vx','NaN',1,'size',[md.mesh.numberofvertices, 1]);
+				checkfield(md,'fieldname','initialization.vy','NaN',1,'size',[md.mesh.numberofvertices, 1]);
+				if (md.mesh.dimension() == 3){
+					checkfield(md,'fieldname','initialization.vz','NaN',1,'size',[md.mesh.numberofvertices ,1]);
+				}
+				checkfield(md,'fieldname','initialization.pressure','NaN',1,'size',[md.mesh.numberofvertices ,1]);
+				checkfield(md,'fieldname','initialization.temperature','NaN',1,'size',[md.mesh.numberofvertices ,1]);
+			}
+			if( ArrayAnyEqual(ArrayIsMember(EnthalpyAnalysisEnum(),analyses),1) & md.thermal.isenthalpy){
+				checkfield(md,'fieldname','initialization.waterfraction','>=',0,'size',[md.mesh.numberofvertices, 1]);
+				checkfield(md,'fieldname','initialization.watercolumn'  ,'>=',0,'size',[md.mesh.numberofvertices, 1]);
+			}
+			if(ArrayAnyEqual(ArrayIsMember(HydrologyShreveAnalysisEnum(),analyses),1)){
+				if (md.hydrology.type() == 'hydrologyshreve'){
+					checkfield(md,'fieldname','initialization.watercolumn','NaN',1,'size',[md.mesh.numberofvertices ,1]);
+				}
+			}
+			if(ArrayAnyEqual(ArrayIsMember(HydrologyDCInefficientAnalysisEnum(),analyses),1)){
+				if (md.hydrology.type() == 'hydrologydc'){
+					checkfield(md,'fieldname','initialization.sediment_head','NaN',1,'size',[md.mesh.numberofvertices, 1]);
+				}
+			}
+			if(ArrayAnyEqual(ArrayIsMember(HydrologyDCEfficientAnalysisEnum(),analyses),1)){
+				if (md.hydrology.type() == 'hydrologydc'){
+					if (md.hydrology.isefficientlayer==1){
+						checkfield(md,'fieldname','initialization.epl_head','NaN',1,'size',[md.mesh.numberofvertices ,1]);
+						checkfield(md,'fieldname','initialization.epl_thickness','NaN',1,'size',[md.mesh.numberofvertices ,1]);
+					}
+				}
+			}
+		} //}}}
 	//properties 
 	// {{{
Index: /issm/trunk-jpl/src/m/classes/mask.js
===================================================================
--- /issm/trunk-jpl/src/m/classes/mask.js	(revision 19779)
+++ /issm/trunk-jpl/src/m/classes/mask.js	(revision 19780)
@@ -19,4 +19,32 @@
 			fielddisplay(this,"ice_levelset","presence of ice if < 0, icefront position if = 0, no ice if > 0");
 		} //}}}
+		this.checkconsistency = function(md,solution,analyses){ //{{{
 
+			checkfield(md,'fieldname','mask.groundedice_levelset','size',[md.mesh.numberofvertices, 1]);
+			checkfield(md,'fieldname','mask.ice_levelset'        ,'size',[md.mesh.numberofvertices, 1]);
+			isice=NewArrayFill(md.mesh.numberofvertices,0); 
+			for(var i=0;i<md.mesh.numberofvertices;i++)if(md.mask.ice_levelset[i]<=0)isice[i]=1;
+			if (ArraySum(isice)==0){
+				console.log('no ice present in the domain');
+			}
+			if (ArrayMax(md.mask.ice_levelset)<0){
+				console.log('no ice front provided');
+			}
+				
+			icefront=NewArrayFill(md.mesh.numberofelements,0);
+			for(var i=0;i<md.mesh.numberofelements;i++){
+				for(var j=0;j<md.mesh.elements[0].length;j++){
+					icefront[i]+=(md.mask.ice_levelset[md.mesh.elements[i][j]-1]==0);
+				}
+			}
+			if ((ArrayMax(icefront)==3 & (md.mesh.elementtype() == 'Tria')) | (ArrayMax(icefront)==6 & md.mesh.elementtype() == 'Penta')){
+				if (md.mesh.elementtype()=='Tria'){
+					pos=ArrayFindEqual(icefront,3); numberemptyelements=pos.length;
+				}
+				else if (md.mesh.elementtype() == 'Penta'){
+					pos=ArrayFindEqual(icefront,6); numberemptyelements=pos.length;
+				}
+				throw Error(sprintf(" %i have all nodes on ice front, change md.mask.ice_levelset to fix it",numberemptyelements));
+			}
+		} // }}}
 }
Index: /issm/trunk-jpl/src/m/classes/matice.js
===================================================================
--- /issm/trunk-jpl/src/m/classes/matice.js	(revision 19779)
+++ /issm/trunk-jpl/src/m/classes/matice.js	(revision 19780)
@@ -78,4 +78,21 @@
 			fielddisplay(this,'mantle_density','Mantle density [g/cm^-3]');
 		} // }}}
+		this.checkconsistency = function(md,solution,analyses) { // {{{
+			checkfield(md,'fieldname','materials.rho_ice','>',0);
+			checkfield(md,'fieldname','materials.rho_water','>',0);
+			checkfield(md,'fieldname','materials.rho_freshwater','>',0);
+			checkfield(md,'fieldname','materials.mu_water','>',0);
+			checkfield(md,'fieldname','materials.rheology_B','>',0,'timeseries',1,'NaN',1);
+			checkfield(md,'fieldname','materials.rheology_n','>',0,'size',[md.mesh.numberofelements,1]);
+			checkfield(md,'fieldname','materials.rheology_law','values',['None','Cuffey','Paterson','Arrhenius','LliboutryDuval']);
+
+			if(ArrayAnyEqual(ArrayIsMember(GiaAnalysisEnum(),analyses),1)){
+				checkfield(md,'fieldname','materials.lithosphere_shear_modulus','>',0,'numel',1);
+				checkfield(md,'fieldname','materials.lithosphere_density','>',0,'numel',1);
+				checkfield(md,'fieldname','materials.mantle_shear_modulus','>',0,'numel',1);
+				checkfield(md,'fieldname','materials.mantle_density','>',0,'numel',1);
+			}
+
+		} // }}}
 	//properties 
 	// {{{
Index: /issm/trunk-jpl/src/m/classes/mesh2d.js
===================================================================
--- /issm/trunk-jpl/src/m/classes/mesh2d.js	(revision 19779)
+++ /issm/trunk-jpl/src/m/classes/mesh2d.js	(revision 19780)
@@ -53,4 +53,26 @@
 			return 'Tria';
 		} // }}}
+		this.checkconsistency = function(md,solution,analyses){ //{{{
+
+			checkfield(md,'fieldname','mesh.x','NaN',1,'size',[md.mesh.numberofvertices, 1]);
+			checkfield(md,'fieldname','mesh.y','NaN',1,'size',[md.mesh.numberofvertices, 1]);
+			checkfield(md,'fieldname','mesh.elements','NaN',1,'>',0,'values',NewArrayFillIncrement(md.mesh.numberofvertices,1,1));
+			checkfield(md,'fieldname','mesh.elements','size',[md.mesh.numberofelements, 3]);
+			if(ArrayAnyEqual(ArrayIsMember(NewArrayFillIncrement(md.mesh.numberofvertices,1,1),ArraySort(ArrayUnique(MatrixToList(md.mesh.elements)))),0)){
+				md.checkmessage('orphan nodes have been found. Check the mesh outline');
+			}
+			checkfield(md,'fieldname','mesh.numberofelements','>',0);
+			checkfield(md,'fieldname','mesh.numberofvertices','>',0);
+			checkfield(md,'fieldname','mesh.average_vertex_connectivity','>=',9,'message',"'mesh.average_vertex_connectivity' should be at least 9 in 2d");
+			checkfield(md,'fieldname','mesh.segments','NaN',1,'>',0,'size',[NaN, 3]);
+
+			switch(solution){
+			case ThermalSolutionEnum():
+				checkmessage(md,'thermal not supported for 2d mesh');
+				break;
+			default:
+				break
+			}
+		} // }}}
 	//properties 
 	// {{{
Index: /issm/trunk-jpl/src/m/classes/model.js
===================================================================
--- /issm/trunk-jpl/src/m/classes/model.js	(revision 19779)
+++ /issm/trunk-jpl/src/m/classes/model.js	(revision 19780)
@@ -86,4 +86,8 @@
 			this.private          = new private();
 		} //}}}
+		this.checkmessage = function(string){ //{{{
+			console.log('model not consistent: ' + string);
+			md.private.isconsistent=false;
+		} //}}}
 	//properties
 	// {{{
Index: /issm/trunk-jpl/src/m/classes/timestepping.js
===================================================================
--- /issm/trunk-jpl/src/m/classes/timestepping.js	(revision 19779)
+++ /issm/trunk-jpl/src/m/classes/timestepping.js	(revision 19780)
@@ -39,4 +39,16 @@
 
 	}// }}}
+		this.checkconsistency = function(md,solution,analyses) { //{{{
+			
+			checkfield(md,'fieldname','timestepping.start_time','numel',[1],'NaN',1);
+			checkfield(md,'fieldname','timestepping.final_time','numel',[1],'NaN',1);
+			checkfield(md,'fieldname','timestepping.time_step','numel',[1],'>=',0,'NaN',1);
+			checkfield(md,'fieldname','timestepping.time_adapt','numel',[1],'values',[0,1]);
+			checkfield(md,'fieldname','timestepping.cfl_coefficient','numel',[1],'>',0,'<=',1);
+			checkfield(md,'fieldname','timestepping.interp_forcings','numel',[1],'values',[0,1]);
+			if (this.final_time-this.start_time<0){
+				md.checkmessage('timestepping.final_time should be larger than timestepping.start_time');
+			}
+		} // }}}
 	//properties 
 	// {{{
Index: /issm/trunk-jpl/src/m/consistency/checkfield.js
===================================================================
--- /issm/trunk-jpl/src/m/consistency/checkfield.js	(revision 19780)
+++ /issm/trunk-jpl/src/m/consistency/checkfield.js	(revision 19780)
@@ -0,0 +1,263 @@
+function checkfield(md){
+//CHECKFIELD - check field consistency
+//
+//   Used to check model consistency.
+//   Requires: 
+//     'field' or 'fieldname' option. If 'fieldname' is provided, it will retrieve it from the model md. (md.(fieldname)) 
+//             If 'field' is provided, it will assume the argument following 'field' is a numeric array.
+//   Available options:
+//      - NaN: 1 if check that there is no NaN
+//      - size: [lines cols], NaN for non checked dimensions
+//      - >:  greater than provided value
+//      - >=: greater or equal to provided value
+//      - <:  smallerthan provided value
+//      - <=: smaller or equal to provided value
+//      - < vec:  smallerthan provided values on each vertex
+//      - timeseries: 1 if check time series consistency (size and time)
+//      - values: array of strings or vector of acceptable values
+//      - numel: list of acceptable number of elements
+//      - array: 1 if check that is array
+//      - empty: 1 if check that non empty
+//      - message: overloaded error message
+//
+//   Usage:
+//      checkfield(md,fieldname,options);
+
+	//get options
+	var args = Array.prototype.slice.call(arguments);
+	var  options = new pairoptions(args.slice(1,args.length));
+	
+	//get field: 
+	if (options.exist('field')){
+		field=options.getfieldvalue('field'); 
+		fieldname=options.getfieldvalue('fieldname','no fieldname'); 
+	}
+	else{
+		fieldname=options.getfieldvalue('fieldname'); 
+		eval("field=md." + fieldname + ";");
+	}
+
+	//check empty
+	if (options.exist('empty')){
+		if (field.length == 0){
+			md.checkmessage(options.getfieldvalue('message','field ' + "'" + fieldname + "'" + 'is empty'));
+		}
+	}
+
+	//Check size
+	if (options.exist('size')){
+		fieldsize=options.getfieldvalue('size');
+		if (isNaN(fieldsize[0])){
+			if (field[0].length !=fieldsize[1]){
+				md.checkmessage(options.getfieldvalue('message', sprintf("field '%s' should have %i columns",fieldname,fieldsize[1])));
+			}
+		}
+		else if (isNaN(fieldsize[1])){
+			if (field.length!= fieldsize[0]){
+				md.checkmessage(options.getfieldvalue('message',sprintf("field '%s' should have %i lines",fieldname,fieldsize[0])));
+			}
+		}
+		else{
+			if (IsArray(field)){
+				if ((field.length!=fieldsize[0])){
+					md.checkmessage(options.getfieldvalue('message', sprintf("field '%s' should be %ix%i",fieldname,fieldsize[0],fieldsize[1])));
+				}
+			}
+			if (IsArray(field[0])){
+				if(field[0].length!=fieldsize[1]){
+					md.checkmessage(options.getfieldvalue('message', sprintf("field '%s' should be %ix%i",fieldname,fieldsize[0],fieldsize[1])));
+				}
+			}
+		}
+	}
+
+	//Check numel
+	if (options.exist('numel')){
+		fieldnumel=options.getfieldvalue('numel');
+		if (!ArrayIsMember(fieldnumel,[field.length])){
+			if (fieldnumel.length==1){
+				md.checkmessage(options.getfieldvalue('message',sprintf("field '%s' size should be %i",fieldname,fieldnumel[0])));
+			}
+			else if (fieldnumel.length==2){
+				md.checkmessage(options.getfieldvalue('message',sprintf("field '%s' size should be %i or %i",fieldname,fieldnumel[0],fieldnumel[1])));
+			}
+			else{
+				var string=''; 
+				for (var i=0;i<fieldnumel.length;i++)string=sprintf("%s or %i",string,fieldnumel[i]);
+				md.checkmessage(options.getfieldvalue('message',sprintf("field '%s' size should be %s",fieldname,string)));
+			}
+		}
+	}
+
+	//check NaN
+	if (options.getfieldvalue('NaN',0)){
+		field2=MatrixToList(field);
+		if (ArrayAnyEqual(field2,NaN)){
+			md.checkmessage(options.getfieldvalue('message',sprintf("NaN values found in field %s",field)));
+		}
+	}
+
+	//check arry
+	if (options.getfieldvalue('array',0)){
+		if (!IsArray(field)){
+			md.checkmessage(options.getfieldvalue('message',sprintf("field '%s' should be an array!",fieldname)));
+		}
+	}
+
+	//check values
+	if (options.exist('values')){
+		fieldvalues=options.getfieldvalue('values');
+		if (typeof fieldvalues[0]== 'string'){
+			if (typeof field == 'string'){
+				if(ArrayAnyEqual(ArrayIsMember([field],fieldvalues),0)){
+					if (fieldvalues.length==1){
+						md.checkmessage(options.getfieldvalue('message',sprintf("field '%s' value should be %s",fieldname,fieldvalues[0])));
+					}
+					else if (fieldvalues.length==2){
+						md.checkmessage(options.getfieldvalue('message',sprintf("field '%s' values should be %s or %s",fieldname,fieldvalues[0],fieldvalues[1])));
+					}
+					else{
+						var string=''; 
+						for (var i=0;i<fieldvalues.length;i++)string=sprintf("%s or %s",string,fieldvalues[i]);
+						md.checkmessage(options.getfieldvalue('message',sprintf("field '%s' should have values in %s",fieldname,string)));
+					}
+				}
+			}
+			else{
+				var string=''; for (var i=0;i<fieldvalues.length;i++)string=sprintf("%s or %s",string,fieldvalues[i]);
+				md.checkmessage(options.getfieldvalue('message',sprintf("field '%s' should have values in %s",fieldname,string)));
+			}
+		}
+		else{
+			if (typeof field == 'number') field2=MatrixToList([field]);
+			else field2=MatrixToList(field);
+			if (typeof field2[0] == 'number'){
+				if(ArrayAnyEqual(ArrayIsMember(field2,fieldvalues),0)){
+					var string=''; for (var i=0;i<fieldvalues.length;i++)string=sprintf("%s or %g",string,fieldvalues[i]);
+					md.checkmessage(options.getfieldvalue('message',sprintf("field '%s' should have values in %s",fieldname,string)));
+				}
+			}
+			else{
+				var string=''; for (var i=0;i<fieldvalues.length;i++)string=sprintf("%s or %g",string,fieldvalues[i]);
+				md.checkmessage(options.getfieldvalue('message',sprintf("field '%s' should be a number in %s",fieldname,string)));
+			}
+		}
+	}
+	
+	//check greater
+	if (options.exist('>=')){
+		lowerbound=options.getfieldvalue('>=');
+		field2=MatrixToList(field);
+		if (options.getfieldvalue('timeseries',0)) field2=MatrixToList(ArrayCopy(field).splice(-1,1));
+
+		if (ArrayAnyBelowStrict(field2,lowerbound)){
+			md.checkmessage(options.getfieldvalue('message',sprintf("field '%s' should have values above %g",fieldname,lowerbound)));
+		}
+	}
+	if (options.exist('>')){
+		lowerbound=options.getfieldvalue('>');
+		field2=MatrixToList(field);
+		if (options.getfieldvalue('timeseries',0)) field2=MatrixToList(ArrayCopy(field).splice(-1,1));
+
+		if (ArrayAnyBelowOrEqual(field2,lowerbound)){
+			md.checkmessage(options.getfieldvalue('message',sprintf("field '%s' should have values above %g",fieldname,lowerbound)));
+		}
+	}
+	
+	//check smaller
+	if (options.exist('<=')){
+		upperbound=options.getfieldvalue('<=');
+		field2=MatrixToList(field);
+		if (options.getfieldvalue('timeseries',0)) field2=MatrixToList(ArrayCopy(field).splice(-1,1));
+
+		if (ArrayAnyAboveOrEqual(field2,upperbound)){
+			md.checkmessage(options.getfieldvalue('message',sprintf("field '%s' should have values below %g",fieldname,upperbound)));
+		}
+	}
+	
+	
+	if (options.exist('<')){
+		upperbound=options.getfieldvalue('<');
+		field2=MatrixToList(field);
+		if (options.getfieldvalue('timeseries',0)) field2=MatrixToList(ArrayCopy(field).splice(-1,1));
+		if (ArrayAnyAboveStrict(field2,upperbound)){
+			md.checkmessage(options.getfieldvalue('message',sprintf("field '%s' should have values below %g",fieldname,upperbound)));
+		}
+	}
+
+	//Check row of stringrow
+	if (options.getfieldvalue('stringrow',0)){
+		if (IsArray(field[0])){
+			md.checkmessage(options.getfieldvalue('message',sprintf("field '%s' should have only one row",field)));
+		}
+		if (!IsArray(field)){
+			md.checkmessage(options.getfieldvalue('message',sprintf("field '%s' should be an array of string",fieldname)));
+		}
+		else{
+			for(var i=0;i<field.length;i++){
+				if (!(typeof field[i] == 'string')){
+					md.checkmessage(options.getfieldvalue('message',sprintf("field '%s' values should be a cell of strings",fieldname)));
+				}
+			}
+		}
+	}
+
+	//check file
+	if (options.getfieldvalue('file',0)){
+		/*if ~exist(field,'file')
+			md.checkmessage(['file provided in ''' fieldname ''': ''' field ''' does not exist']);
+		end*/
+		throw Error("checkfield error message: file checking on javascript not supported yet!");
+	}
+
+	//Check forcings (size and times)
+	if (options.getfieldvalue('timeseries',0)){
+		if (field.length==md.mesh.numberofvertices | field.length==md.mesh.numberofelements){
+			if (IsArray(field[0])){
+				md.checkmessage(options.getfieldvalue('message',sprintf("field '%s' should have only one column as there are md.mesh.numberofvertices lines",fieldname)));
+			}
+		}
+		else if ((field.length==md.mesh.numberofvertices+1) | (field.length==md.mesh.numberofelements+1)){
+			var times=field[field.length-1]; var sorted_times=ArraySort(times);
+			for(var i=0;i<times.length;i++){
+				if(times[i] !=sorted_times[i]){
+					md.checkmessage(options.getfieldvalue('message',sprintf("field '%s' columns should be sorted chronologically",fieldname)));
+					break;
+				}
+			}
+			var timesm=ArrayCopy(times).splice(0,-1); var timesp=ArrayCopy(times).shift();
+			for(var i=0;i<timesm.length;i++){
+				if(timesm[i]==timesp[i]){
+					md.checkmessage(options.getfieldvalue('message',sprintf("field '%s' columns must not contain duplicate timesteps",fieldname)));
+					break;
+				}
+			}
+		}
+		else{
+			md.checkmessage(options.getfieldvalue('message',sprintf("field '%s' should have md.mesh.numberofvertices or md.mesh.numberofvertices+1 lines",fieldname)));
+		}
+	}
+
+	//Check single value forcings (size and times)
+	if (options.getfieldvalue('singletimeseries',0)){
+		if (field.length==2){
+			var times=field[1]; var sorted_times=ArraySort(times);
+			for(var i=0;i<times.length;i++){
+				if(times[i] !=sorted_times[i]){
+					md.checkmessage(options.getfieldvalue('message',sprintf("field '%s' columns should be sorted chronologically",fieldname)));
+					break;
+				}
+			}
+			var timesm=ArrayCopy(times).splice(0,-1); var timesp=ArrayCopy(times).shift();
+			for(var i=0;i<timesm.length;i++){
+				if(timesm[i]==timesp[i]){
+					md.checkmessage(options.getfieldvalue('message',sprintf("field '%s' columns must not contain duplicate timesteps",fieldname)));
+					break;
+				}
+			}
+		}
+		else{
+			md.checkmessage(options.getfieldvalue('message',sprintf("field '%s' should have 2 lines",fieldname)));
+		}
+	}
+}
Index: /issm/trunk-jpl/src/m/consistency/ismodelselfconsistent.js
===================================================================
--- /issm/trunk-jpl/src/m/consistency/ismodelselfconsistent.js	(revision 19780)
+++ /issm/trunk-jpl/src/m/consistency/ismodelselfconsistent.js	(revision 19780)
@@ -0,0 +1,111 @@
+function ismodelselfconsistent(md){
+//ISMODELSELFCONSISTENT - check that model forms a closed form solvable problem.
+//
+//   Usage:
+//      ismodelselfconsistent(md),
+
+	//initialize consistency as true
+	md.private.isconsistent=true;
+
+	//Get solution and associated analyses
+	solution=md.private.solution;
+	var analyses = AnalysisConfiguration(solution);
+
+	//Go through a model field, check that it is a class, and call checkconsistency
+	for(field in md){
+
+		//Some properties do not need to be checked
+		if (field == 'results' | field == 'debug' | field == 'radaroverlay'){
+			continue;
+		}
+
+		//Check that current field is a class
+		if(typeof md[field] == 'function'){
+			continue;
+		}
+		console.log(field);
+
+		//Check consistency of the class
+		md[field].checkconsistency(md,solution,analyses);
+	}
+
+	//error message if mode is not consistent
+	if (md.private.isconsistent==false){
+		throw Error('Model not consistent, see messages above');
+	}
+}
+
+function AnalysisConfiguration(solutiontype){ // {{{
+	//ANALYSISCONFIGURATION - return type of analyses, number of analyses 
+	//
+	//   Usage:
+	//      [analyses]=AnalysisConfiguration(solutiontype);
+
+	var analyses=[];
+	switch (solutiontype){
+
+		case StressbalanceSolutionEnum():
+			analyses=[StressbalanceAnalysisEnum(),StressbalanceVerticalAnalysisEnum(),StressbalanceSIAAnalysisEnum(),L2ProjectionBaseAnalysisEnum()];
+			break;
+
+		case SteadystateSolutionEnum():
+			analyses=[StressbalanceAnalysisEnum(),StressbalanceVerticalAnalysisEnum(),StressbalanceSIAAnalysisEnum(),L2ProjectionBaseAnalysisEnum(),ThermalAnalysisEnum(),MeltingAnalysisEnum()];
+			break;
+
+		case ThermalSolutionEnum():
+			analyses=[EnthalpyAnalysisEnum(),ThermalAnalysisEnum(),MeltingAnalysisEnum()];
+			break;
+
+		case MasstransportSolutionEnum():
+			analyses=[MasstransportAnalysisEnum()];
+			break;
+
+		case BalancethicknessSolutionEnum():
+			analyses=[BalancethicknessAnalysisEnum()];
+			break;
+
+		case Balancethickness2SolutionEnum():
+			analyses=[Balancethickness2AnalysisEnum()];
+			break;
+
+		case BalancethicknessSoftSolutionEnum():
+			analyses=[BalancethicknessAnalysisEnum()];
+			break;
+
+		case BalancevelocitySolutionEnum():
+			analyses=[BalancevelocityAnalysisEnum()];
+			break;
+
+		case SurfaceSlopeSolutionEnum():
+			analyses=[L2ProjectionBaseAnalysisEnum()];
+			break;
+
+		case BedSlopeSolutionEnum():
+			analyses=[L2ProjectionBaseAnalysisEnum()];
+			break;
+
+		case GiaSolutionEnum():
+			analyses=[GiaAnalysisEnum()];
+			break;
+
+		case TransientSolutionEnum():
+			analyses=[StressbalanceAnalysisEnum(),StressbalanceVerticalAnalysisEnum(),StressbalanceSIAAnalysisEnum(),L2ProjectionBaseAnalysisEnum(),ThermalAnalysisEnum(),MeltingAnalysisEnum(),EnthalpyAnalysisEnum(),MasstransportAnalysisEnum(),HydrologySommersAnalysisEnum];
+			break;
+
+		case FlaimSolutionEnum():
+			analyses=[FlaimAnalysisEnum()];
+			break;
+
+		case HydrologySolutionEnum():
+			analyses=[L2ProjectionBaseAnalysisEnum(),HydrologyShreveAnalysisEnum(),HydrologyDCInefficientAnalysisEnum(),HydrologyDCEfficientAnalysisEnum()];
+			break;
+
+		case DamageEvolutionSolutionEnum():
+			analyses=[DamageEvolutionAnalysisEnum()];
+			break;
+
+		default:
+			throw Error(sprintf("%s%s%s\n",' solution type: ',EnumToString(solutiontype),' not supported yet!'));
+	}
+	return analyses;
+} // }}}
Index: /issm/trunk-jpl/src/m/enum/EnumDefinitions.js
===================================================================
--- /issm/trunk-jpl/src/m/enum/EnumDefinitions.js	(revision 19780)
+++ /issm/trunk-jpl/src/m/enum/EnumDefinitions.js	(revision 19780)
@@ -0,0 +1,952 @@
+//WARNING: DO NOT MODIFY THIS FILE
+//this file has been automatically generated by src/c/shared/Enum/Synchronize.sh
+//Please read src/c/shared/Enum/README for more information
+function FemModelEnum(){ return StringToEnum("FemModel");}
+function AutodiffIsautodiffEnum(){ return StringToEnum("AutodiffIsautodiff");}
+function AutodiffNumDependentsEnum(){ return StringToEnum("AutodiffNumDependents");}
+function AutodiffNumDependentObjectsEnum(){ return StringToEnum("AutodiffNumDependentObjects");}
+function AutodiffDependentObjectNamesEnum(){ return StringToEnum("AutodiffDependentObjectNames");}
+function AutodiffDependentObjectTypesEnum(){ return StringToEnum("AutodiffDependentObjectTypes");}
+function AutodiffDependentObjectIndicesEnum(){ return StringToEnum("AutodiffDependentObjectIndices");}
+function AutodiffDependentObjectsEnum(){ return StringToEnum("AutodiffDependentObjects");}
+function AutodiffNumIndependentsEnum(){ return StringToEnum("AutodiffNumIndependents");}
+function AutodiffNumIndependentObjectsEnum(){ return StringToEnum("AutodiffNumIndependentObjects");}
+function AutodiffIndependentObjectNamesEnum(){ return StringToEnum("AutodiffIndependentObjectNames");}
+function AutodiffIndependentObjectTypesEnum(){ return StringToEnum("AutodiffIndependentObjectTypes");}
+function AutodiffIndependentObjectsEnum(){ return StringToEnum("AutodiffIndependentObjects");}
+function AutodiffJacobianEnum(){ return StringToEnum("AutodiffJacobian");}
+function AutodiffXpEnum(){ return StringToEnum("AutodiffXp");}
+function AutodiffDriverEnum(){ return StringToEnum("AutodiffDriver");}
+function AutodiffFosForwardIndexEnum(){ return StringToEnum("AutodiffFosForwardIndex");}
+function AutodiffFovForwardIndicesEnum(){ return StringToEnum("AutodiffFovForwardIndices");}
+function AutodiffFosReverseIndexEnum(){ return StringToEnum("AutodiffFosReverseIndex");}
+function AutodiffMassFluxSegmentsPresentEnum(){ return StringToEnum("AutodiffMassFluxSegmentsPresent");}
+function AutodiffKeepEnum(){ return StringToEnum("AutodiffKeep");}
+function AutodiffObufsizeEnum(){ return StringToEnum("AutodiffObufsize");}
+function AutodiffLbufsizeEnum(){ return StringToEnum("AutodiffLbufsize");}
+function AutodiffCbufsizeEnum(){ return StringToEnum("AutodiffCbufsize");}
+function AutodiffTbufsizeEnum(){ return StringToEnum("AutodiffTbufsize");}
+function AutodiffGcTriggerRatioEnum(){ return StringToEnum("AutodiffGcTriggerRatio");}
+function AutodiffGcTriggerMaxSizeEnum(){ return StringToEnum("AutodiffGcTriggerMaxSize");}
+function BalancethicknessSpcthicknessEnum(){ return StringToEnum("BalancethicknessSpcthickness");}
+function BalancethicknessStabilizationEnum(){ return StringToEnum("BalancethicknessStabilization");}
+function BalancethicknessThickeningRateEnum(){ return StringToEnum("BalancethicknessThickeningRate");}
+function BasalforcingsEnum(){ return StringToEnum("Basalforcings");}
+function BasalforcingsGeothermalfluxEnum(){ return StringToEnum("BasalforcingsGeothermalflux");}
+function BasalforcingsGroundediceMeltingRateEnum(){ return StringToEnum("BasalforcingsGroundediceMeltingRate");}
+function BasalforcingsFloatingiceMeltingRateEnum(){ return StringToEnum("BasalforcingsFloatingiceMeltingRate");}
+function BasalforcingsDeepwaterMeltingRateEnum(){ return StringToEnum("BasalforcingsDeepwaterMeltingRate");}
+function BasalforcingsDeepwaterElevationEnum(){ return StringToEnum("BasalforcingsDeepwaterElevation");}
+function BasalforcingsUpperwaterElevationEnum(){ return StringToEnum("BasalforcingsUpperwaterElevation");}
+function BasalforcingsMeltrateFactorEnum(){ return StringToEnum("BasalforcingsMeltrateFactor");}
+function BasalforcingsThresholdThicknessEnum(){ return StringToEnum("BasalforcingsThresholdThickness");}
+function BasalforcingsUpperdepthMeltEnum(){ return StringToEnum("BasalforcingsUpperdepthMelt");}
+function FloatingMeltRateEnum(){ return StringToEnum("FloatingMeltRate");}
+function LinearFloatingMeltRateEnum(){ return StringToEnum("LinearFloatingMeltRate");}
+function MismipFloatingMeltRateEnum(){ return StringToEnum("MismipFloatingMeltRate");}
+function BedEnum(){ return StringToEnum("Bed");}
+function BaseEnum(){ return StringToEnum("Base");}
+function ConstantsGEnum(){ return StringToEnum("ConstantsG");}
+function ConstantsReferencetemperatureEnum(){ return StringToEnum("ConstantsReferencetemperature");}
+function ConstantsYtsEnum(){ return StringToEnum("ConstantsYts");}
+function DependentObjectEnum(){ return StringToEnum("DependentObject");}
+function StressbalanceAbstolEnum(){ return StringToEnum("StressbalanceAbstol");}
+function StressbalanceIsnewtonEnum(){ return StringToEnum("StressbalanceIsnewton");}
+function StressbalanceMaxiterEnum(){ return StringToEnum("StressbalanceMaxiter");}
+function StressbalancePenaltyFactorEnum(){ return StringToEnum("StressbalancePenaltyFactor");}
+function StressbalanceReferentialEnum(){ return StringToEnum("StressbalanceReferential");}
+function StressbalanceReltolEnum(){ return StringToEnum("StressbalanceReltol");}
+function StressbalanceNumRequestedOutputsEnum(){ return StringToEnum("StressbalanceNumRequestedOutputs");}
+function StressbalanceRequestedOutputsEnum(){ return StringToEnum("StressbalanceRequestedOutputs");}
+function StressbalanceRestolEnum(){ return StringToEnum("StressbalanceRestol");}
+function StressbalanceRiftPenaltyLockEnum(){ return StringToEnum("StressbalanceRiftPenaltyLock");}
+function StressbalanceRiftPenaltyThresholdEnum(){ return StringToEnum("StressbalanceRiftPenaltyThreshold");}
+function StressbalanceShelfDampeningEnum(){ return StringToEnum("StressbalanceShelfDampening");}
+function StressbalanceSpcvxEnum(){ return StringToEnum("StressbalanceSpcvx");}
+function StressbalanceSpcvyEnum(){ return StringToEnum("StressbalanceSpcvy");}
+function StressbalanceSpcvzEnum(){ return StringToEnum("StressbalanceSpcvz");}
+function StressbalanceFSreconditioningEnum(){ return StringToEnum("StressbalanceFSreconditioning");}
+function StressbalanceVertexPairingEnum(){ return StringToEnum("StressbalanceVertexPairing");}
+function StressbalanceViscosityOvershootEnum(){ return StringToEnum("StressbalanceViscosityOvershoot");}
+function LoadingforceXEnum(){ return StringToEnum("LoadingforceX");}
+function LoadingforceYEnum(){ return StringToEnum("LoadingforceY");}
+function LoadingforceZEnum(){ return StringToEnum("LoadingforceZ");}
+function FlowequationBorderSSAEnum(){ return StringToEnum("FlowequationBorderSSA");}
+function FlowequationBorderHOEnum(){ return StringToEnum("FlowequationBorderHO");}
+function FlowequationBorderFSEnum(){ return StringToEnum("FlowequationBorderFS");}
+function FlowequationElementEquationEnum(){ return StringToEnum("FlowequationElementEquation");}
+function FlowequationIsSIAEnum(){ return StringToEnum("FlowequationIsSIA");}
+function FlowequationIsSSAEnum(){ return StringToEnum("FlowequationIsSSA");}
+function FlowequationIsL1L2Enum(){ return StringToEnum("FlowequationIsL1L2");}
+function FlowequationIsHOEnum(){ return StringToEnum("FlowequationIsHO");}
+function FlowequationIsFSEnum(){ return StringToEnum("FlowequationIsFS");}
+function FlowequationFeSSAEnum(){ return StringToEnum("FlowequationFeSSA");}
+function FlowequationFeHOEnum(){ return StringToEnum("FlowequationFeHO");}
+function FlowequationFeFSEnum(){ return StringToEnum("FlowequationFeFS");}
+function FlowequationVertexEquationEnum(){ return StringToEnum("FlowequationVertexEquation");}
+function FrictionAsEnum(){ return StringToEnum("FrictionAs");}
+function FrictionCoefficientEnum(){ return StringToEnum("FrictionCoefficient");}
+function FrictionCoefficientcoulombEnum(){ return StringToEnum("FrictionCoefficientcoulomb");}
+function FrictionPEnum(){ return StringToEnum("FrictionP");}
+function FrictionQEnum(){ return StringToEnum("FrictionQ");}
+function FrictionMEnum(){ return StringToEnum("FrictionM");}
+function FrictionCEnum(){ return StringToEnum("FrictionC");}
+function FrictionLawEnum(){ return StringToEnum("FrictionLaw");}
+function FrictionGammaEnum(){ return StringToEnum("FrictionGamma");}
+function FrictionFEnum(){ return StringToEnum("FrictionF");}
+function FrictionWaterLayerEnum(){ return StringToEnum("FrictionWaterLayer");}
+function FrictionEffectivePressureEnum(){ return StringToEnum("FrictionEffectivePressure");}
+function FrictionCouplingEnum(){ return StringToEnum("FrictionCoupling");}
+function GeometryHydrostaticRatioEnum(){ return StringToEnum("GeometryHydrostaticRatio");}
+function HydrologyModelEnum(){ return StringToEnum("HydrologyModel");}
+function HydrologyshreveEnum(){ return StringToEnum("Hydrologyshreve");}
+function HydrologyshreveSpcwatercolumnEnum(){ return StringToEnum("HydrologyshreveSpcwatercolumn");}
+function HydrologyshreveStabilizationEnum(){ return StringToEnum("HydrologyshreveStabilization");}
+function HydrologydcEnum(){ return StringToEnum("Hydrologydc");}
+function SedimentHeadEnum(){ return StringToEnum("SedimentHead");}
+function SedimentHeadOldEnum(){ return StringToEnum("SedimentHeadOld");}
+function SedimentHeadResidualEnum(){ return StringToEnum("SedimentHeadResidual");}
+function EffectivePressureEnum(){ return StringToEnum("EffectivePressure");}
+function EplHeadEnum(){ return StringToEnum("EplHead");}
+function EplHeadOldEnum(){ return StringToEnum("EplHeadOld");}
+function EplHeadSlopeXEnum(){ return StringToEnum("EplHeadSlopeX");}
+function EplHeadSlopeYEnum(){ return StringToEnum("EplHeadSlopeY");}
+function EplZigZagCounterEnum(){ return StringToEnum("EplZigZagCounter");}
+function HydrologydcMaxIterEnum(){ return StringToEnum("HydrologydcMaxIter");}
+function HydrologydcRelTolEnum(){ return StringToEnum("HydrologydcRelTol");}
+function HydrologydcSpcsedimentHeadEnum(){ return StringToEnum("HydrologydcSpcsedimentHead");}
+function HydrologydcSedimentCompressibilityEnum(){ return StringToEnum("HydrologydcSedimentCompressibility");}
+function HydrologydcSedimentPorosityEnum(){ return StringToEnum("HydrologydcSedimentPorosity");}
+function HydrologydcSedimentThicknessEnum(){ return StringToEnum("HydrologydcSedimentThickness");}
+function HydrologydcSedimentTransmitivityEnum(){ return StringToEnum("HydrologydcSedimentTransmitivity");}
+function HydrologydcWaterCompressibilityEnum(){ return StringToEnum("HydrologydcWaterCompressibility");}
+function HydrologydcSpceplHeadEnum(){ return StringToEnum("HydrologydcSpceplHead");}
+function HydrologydcMaskEplactiveNodeEnum(){ return StringToEnum("HydrologydcMaskEplactiveNode");}
+function HydrologydcMaskEplactiveEltEnum(){ return StringToEnum("HydrologydcMaskEplactiveElt");}
+function HydrologydcEplCompressibilityEnum(){ return StringToEnum("HydrologydcEplCompressibility");}
+function HydrologydcEplPorosityEnum(){ return StringToEnum("HydrologydcEplPorosity");}
+function HydrologydcEplInitialThicknessEnum(){ return StringToEnum("HydrologydcEplInitialThickness");}
+function HydrologydcEplColapseThicknessEnum(){ return StringToEnum("HydrologydcEplColapseThickness");}
+function HydrologydcEplMaxThicknessEnum(){ return StringToEnum("HydrologydcEplMaxThickness");}
+function HydrologydcEplThicknessEnum(){ return StringToEnum("HydrologydcEplThickness");}
+function HydrologydcEplThicknessOldEnum(){ return StringToEnum("HydrologydcEplThicknessOld");}
+function HydrologydcEplThickCompEnum(){ return StringToEnum("HydrologydcEplThickComp");}
+function HydrologydcEplConductivityEnum(){ return StringToEnum("HydrologydcEplConductivity");}
+function HydrologydcIsefficientlayerEnum(){ return StringToEnum("HydrologydcIsefficientlayer");}
+function HydrologydcSedimentlimitFlagEnum(){ return StringToEnum("HydrologydcSedimentlimitFlag");}
+function HydrologydcSedimentlimitEnum(){ return StringToEnum("HydrologydcSedimentlimit");}
+function HydrologydcTransferFlagEnum(){ return StringToEnum("HydrologydcTransferFlag");}
+function HydrologydcLeakageFactorEnum(){ return StringToEnum("HydrologydcLeakageFactor");}
+function HydrologydcPenaltyFactorEnum(){ return StringToEnum("HydrologydcPenaltyFactor");}
+function HydrologydcPenaltyLockEnum(){ return StringToEnum("HydrologydcPenaltyLock");}
+function HydrologydcEplflipLockEnum(){ return StringToEnum("HydrologydcEplflipLock");}
+function HydrologydcBasalMoulinInputEnum(){ return StringToEnum("HydrologydcBasalMoulinInput");}
+function HydrologyLayerEnum(){ return StringToEnum("HydrologyLayer");}
+function HydrologySedimentEnum(){ return StringToEnum("HydrologySediment");}
+function HydrologyEfficientEnum(){ return StringToEnum("HydrologyEfficient");}
+function HydrologySedimentKmaxEnum(){ return StringToEnum("HydrologySedimentKmax");}
+function HydrologysommersEnum(){ return StringToEnum("Hydrologysommers");}
+function HydrologyHeadEnum(){ return StringToEnum("HydrologyHead");}
+function HydrologyGapHeightEnum(){ return StringToEnum("HydrologyGapHeight");}
+function HydrologyBumpSpacingEnum(){ return StringToEnum("HydrologyBumpSpacing");}
+function HydrologyBumpHeightEnum(){ return StringToEnum("HydrologyBumpHeight");}
+function HydrologyEnglacialInputEnum(){ return StringToEnum("HydrologyEnglacialInput");}
+function HydrologyMoulinInputEnum(){ return StringToEnum("HydrologyMoulinInput");}
+function HydrologyReynoldsEnum(){ return StringToEnum("HydrologyReynolds");}
+function HydrologyNeumannfluxEnum(){ return StringToEnum("HydrologyNeumannflux");}
+function HydrologySpcheadEnum(){ return StringToEnum("HydrologySpchead");}
+function HydrologyConductivityEnum(){ return StringToEnum("HydrologyConductivity");}
+function IndependentObjectEnum(){ return StringToEnum("IndependentObject");}
+function InversionControlParametersEnum(){ return StringToEnum("InversionControlParameters");}
+function InversionControlScalingFactorsEnum(){ return StringToEnum("InversionControlScalingFactors");}
+function InversionCostFunctionThresholdEnum(){ return StringToEnum("InversionCostFunctionThreshold");}
+function InversionCostFunctionsCoefficientsEnum(){ return StringToEnum("InversionCostFunctionsCoefficients");}
+function InversionCostFunctionsEnum(){ return StringToEnum("InversionCostFunctions");}
+function InversionGradientScalingEnum(){ return StringToEnum("InversionGradientScaling");}
+function InversionIscontrolEnum(){ return StringToEnum("InversionIscontrol");}
+function InversionTypeEnum(){ return StringToEnum("InversionType");}
+function InversionIncompleteAdjointEnum(){ return StringToEnum("InversionIncompleteAdjoint");}
+function InversionMaxParametersEnum(){ return StringToEnum("InversionMaxParameters");}
+function InversionMaxiterPerStepEnum(){ return StringToEnum("InversionMaxiterPerStep");}
+function InversionMaxiterEnum(){ return StringToEnum("InversionMaxiter");}
+function InversionMaxstepsEnum(){ return StringToEnum("InversionMaxsteps");}
+function InversionFatolEnum(){ return StringToEnum("InversionFatol");}
+function InversionFrtolEnum(){ return StringToEnum("InversionFrtol");}
+function InversionGatolEnum(){ return StringToEnum("InversionGatol");}
+function InversionGrtolEnum(){ return StringToEnum("InversionGrtol");}
+function InversionGttolEnum(){ return StringToEnum("InversionGttol");}
+function InversionAlgorithmEnum(){ return StringToEnum("InversionAlgorithm");}
+function InversionMinParametersEnum(){ return StringToEnum("InversionMinParameters");}
+function InversionNstepsEnum(){ return StringToEnum("InversionNsteps");}
+function InversionDxminEnum(){ return StringToEnum("InversionDxmin");}
+function InversionNumControlParametersEnum(){ return StringToEnum("InversionNumControlParameters");}
+function InversionNumCostFunctionsEnum(){ return StringToEnum("InversionNumCostFunctions");}
+function InversionStepThresholdEnum(){ return StringToEnum("InversionStepThreshold");}
+function InversionThicknessObsEnum(){ return StringToEnum("InversionThicknessObs");}
+function InversionSurfaceObsEnum(){ return StringToEnum("InversionSurfaceObs");}
+function InversionVxObsEnum(){ return StringToEnum("InversionVxObs");}
+function InversionVyObsEnum(){ return StringToEnum("InversionVyObs");}
+function InversionVzObsEnum(){ return StringToEnum("InversionVzObs");}
+function MaskIceLevelsetEnum(){ return StringToEnum("MaskIceLevelset");}
+function MaterialsBetaEnum(){ return StringToEnum("MaterialsBeta");}
+function MaterialsHeatcapacityEnum(){ return StringToEnum("MaterialsHeatcapacity");}
+function MaterialsLatentheatEnum(){ return StringToEnum("MaterialsLatentheat");}
+function MaterialsMeltingpointEnum(){ return StringToEnum("MaterialsMeltingpoint");}
+function MaterialsMixedLayerCapacityEnum(){ return StringToEnum("MaterialsMixedLayerCapacity");}
+function MaterialsRheologyBEnum(){ return StringToEnum("MaterialsRheologyB");}
+function MaterialsRheologyBbarEnum(){ return StringToEnum("MaterialsRheologyBbar");}
+function MaterialsRheologyLawEnum(){ return StringToEnum("MaterialsRheologyLaw");}
+function MaterialsRheologyNEnum(){ return StringToEnum("MaterialsRheologyN");}
+function DamageIsdamageEnum(){ return StringToEnum("DamageIsdamage");}
+function DamageDEnum(){ return StringToEnum("DamageD");}
+function DamageFEnum(){ return StringToEnum("DamageF");}
+function DamageDbarEnum(){ return StringToEnum("DamageDbar");}
+function DamageLawEnum(){ return StringToEnum("DamageLaw");}
+function DamageC1Enum(){ return StringToEnum("DamageC1");}
+function DamageC2Enum(){ return StringToEnum("DamageC2");}
+function DamageC3Enum(){ return StringToEnum("DamageC3");}
+function DamageC4Enum(){ return StringToEnum("DamageC4");}
+function DamageElementinterpEnum(){ return StringToEnum("DamageElementinterp");}
+function DamageHealingEnum(){ return StringToEnum("DamageHealing");}
+function DamageStressThresholdEnum(){ return StringToEnum("DamageStressThreshold");}
+function DamageKappaEnum(){ return StringToEnum("DamageKappa");}
+function DamageStabilizationEnum(){ return StringToEnum("DamageStabilization");}
+function DamageMaxiterEnum(){ return StringToEnum("DamageMaxiter");}
+function DamageSpcdamageEnum(){ return StringToEnum("DamageSpcdamage");}
+function DamageMaxDamageEnum(){ return StringToEnum("DamageMaxDamage");}
+function DamageEquivStressEnum(){ return StringToEnum("DamageEquivStress");}
+function DamageEvolutionNumRequestedOutputsEnum(){ return StringToEnum("DamageEvolutionNumRequestedOutputs");}
+function DamageEvolutionRequestedOutputsEnum(){ return StringToEnum("DamageEvolutionRequestedOutputs");}
+function DamageEnum(){ return StringToEnum("Damage");}
+function NewDamageEnum(){ return StringToEnum("NewDamage");}
+function StressIntensityFactorEnum(){ return StringToEnum("StressIntensityFactor");}
+function CalvingLawEnum(){ return StringToEnum("CalvingLaw");}
+function CalvingCalvingrateEnum(){ return StringToEnum("CalvingCalvingrate");}
+function CalvingMeltingrateEnum(){ return StringToEnum("CalvingMeltingrate");}
+function CalvingLevermannEnum(){ return StringToEnum("CalvingLevermann");}
+function CalvingPiEnum(){ return StringToEnum("CalvingPi");}
+function CalvingDevEnum(){ return StringToEnum("CalvingDev");}
+function DefaultCalvingEnum(){ return StringToEnum("DefaultCalving");}
+function CalvingRequestedOutputsEnum(){ return StringToEnum("CalvingRequestedOutputs");}
+function CalvinglevermannCoeffEnum(){ return StringToEnum("CalvinglevermannCoeff");}
+function CalvinglevermannMeltingrateEnum(){ return StringToEnum("CalvinglevermannMeltingrate");}
+function CalvingpiCoeffEnum(){ return StringToEnum("CalvingpiCoeff");}
+function CalvingpiMeltingrateEnum(){ return StringToEnum("CalvingpiMeltingrate");}
+function CalvingratexEnum(){ return StringToEnum("Calvingratex");}
+function CalvingrateyEnum(){ return StringToEnum("Calvingratey");}
+function CalvingratexAverageEnum(){ return StringToEnum("CalvingratexAverage");}
+function CalvingrateyAverageEnum(){ return StringToEnum("CalvingrateyAverage");}
+function StrainRateparallelEnum(){ return StringToEnum("StrainRateparallel");}
+function StrainRateperpendicularEnum(){ return StringToEnum("StrainRateperpendicular");}
+function StrainRateeffectiveEnum(){ return StringToEnum("StrainRateeffective");}
+function MaterialsRhoIceEnum(){ return StringToEnum("MaterialsRhoIce");}
+function MaterialsRhoSeawaterEnum(){ return StringToEnum("MaterialsRhoSeawater");}
+function MaterialsRhoFreshwaterEnum(){ return StringToEnum("MaterialsRhoFreshwater");}
+function MaterialsMuWaterEnum(){ return StringToEnum("MaterialsMuWater");}
+function MaterialsThermalExchangeVelocityEnum(){ return StringToEnum("MaterialsThermalExchangeVelocity");}
+function MaterialsThermalconductivityEnum(){ return StringToEnum("MaterialsThermalconductivity");}
+function MaterialsTemperateiceconductivityEnum(){ return StringToEnum("MaterialsTemperateiceconductivity");}
+function MaterialsLithosphereShearModulusEnum(){ return StringToEnum("MaterialsLithosphereShearModulus");}
+function MaterialsLithosphereDensityEnum(){ return StringToEnum("MaterialsLithosphereDensity");}
+function MaterialsMantleShearModulusEnum(){ return StringToEnum("MaterialsMantleShearModulus");}
+function MaterialsMantleDensityEnum(){ return StringToEnum("MaterialsMantleDensity");}
+function MeshAverageVertexConnectivityEnum(){ return StringToEnum("MeshAverageVertexConnectivity");}
+function MeshElements2dEnum(){ return StringToEnum("MeshElements2d");}
+function MeshElementsEnum(){ return StringToEnum("MeshElements");}
+function MeshLowerelementsEnum(){ return StringToEnum("MeshLowerelements");}
+function MeshNumberofelements2dEnum(){ return StringToEnum("MeshNumberofelements2d");}
+function MeshNumberofelementsEnum(){ return StringToEnum("MeshNumberofelements");}
+function MeshNumberoflayersEnum(){ return StringToEnum("MeshNumberoflayers");}
+function MeshNumberofvertices2dEnum(){ return StringToEnum("MeshNumberofvertices2d");}
+function MeshNumberofverticesEnum(){ return StringToEnum("MeshNumberofvertices");}
+function MeshUpperelementsEnum(){ return StringToEnum("MeshUpperelements");}
+function MeshVertexonbaseEnum(){ return StringToEnum("MeshVertexonbase");}
+function MeshVertexonsurfaceEnum(){ return StringToEnum("MeshVertexonsurface");}
+function MeshVertexonboundaryEnum(){ return StringToEnum("MeshVertexonboundary");}
+function MeshXEnum(){ return StringToEnum("MeshX");}
+function MeshYEnum(){ return StringToEnum("MeshY");}
+function MeshZEnum(){ return StringToEnum("MeshZ");}
+function MeshElementtypeEnum(){ return StringToEnum("MeshElementtype");}
+function MeshSegmentsEnum(){ return StringToEnum("MeshSegments");}
+function DomainTypeEnum(){ return StringToEnum("DomainType");}
+function DomainDimensionEnum(){ return StringToEnum("DomainDimension");}
+function Domain2DhorizontalEnum(){ return StringToEnum("Domain2Dhorizontal");}
+function Domain2DverticalEnum(){ return StringToEnum("Domain2Dvertical");}
+function Domain3DEnum(){ return StringToEnum("Domain3D");}
+function MiscellaneousNameEnum(){ return StringToEnum("MiscellaneousName");}
+function MasstransportHydrostaticAdjustmentEnum(){ return StringToEnum("MasstransportHydrostaticAdjustment");}
+function MasstransportIsfreesurfaceEnum(){ return StringToEnum("MasstransportIsfreesurface");}
+function MasstransportMinThicknessEnum(){ return StringToEnum("MasstransportMinThickness");}
+function MasstransportPenaltyFactorEnum(){ return StringToEnum("MasstransportPenaltyFactor");}
+function MasstransportSpcthicknessEnum(){ return StringToEnum("MasstransportSpcthickness");}
+function MasstransportStabilizationEnum(){ return StringToEnum("MasstransportStabilization");}
+function MasstransportVertexPairingEnum(){ return StringToEnum("MasstransportVertexPairing");}
+function MasstransportNumRequestedOutputsEnum(){ return StringToEnum("MasstransportNumRequestedOutputs");}
+function MasstransportRequestedOutputsEnum(){ return StringToEnum("MasstransportRequestedOutputs");}
+function QmuIsdakotaEnum(){ return StringToEnum("QmuIsdakota");}
+function MassFluxSegmentsEnum(){ return StringToEnum("MassFluxSegments");}
+function MassFluxSegmentsPresentEnum(){ return StringToEnum("MassFluxSegmentsPresent");}
+function QmuMassFluxSegmentsPresentEnum(){ return StringToEnum("QmuMassFluxSegmentsPresent");}
+function QmuNumberofpartitionsEnum(){ return StringToEnum("QmuNumberofpartitions");}
+function QmuNumberofresponsesEnum(){ return StringToEnum("QmuNumberofresponses");}
+function QmuPartitionEnum(){ return StringToEnum("QmuPartition");}
+function QmuResponsedescriptorsEnum(){ return StringToEnum("QmuResponsedescriptors");}
+function QmuVariabledescriptorsEnum(){ return StringToEnum("QmuVariabledescriptors");}
+function RiftsNumriftsEnum(){ return StringToEnum("RiftsNumrifts");}
+function RiftsRiftstructEnum(){ return StringToEnum("RiftsRiftstruct");}
+function SettingsResultsOnNodesEnum(){ return StringToEnum("SettingsResultsOnNodes");}
+function SettingsIoGatherEnum(){ return StringToEnum("SettingsIoGather");}
+function SettingsLowmemEnum(){ return StringToEnum("SettingsLowmem");}
+function SettingsOutputFrequencyEnum(){ return StringToEnum("SettingsOutputFrequency");}
+function SettingsRecordingFrequencyEnum(){ return StringToEnum("SettingsRecordingFrequency");}
+function SettingsWaitonlockEnum(){ return StringToEnum("SettingsWaitonlock");}
+function DebugProfilingEnum(){ return StringToEnum("DebugProfiling");}
+function ProfilingCurrentMemEnum(){ return StringToEnum("ProfilingCurrentMem");}
+function ProfilingCurrentFlopsEnum(){ return StringToEnum("ProfilingCurrentFlops");}
+function ProfilingSolutionTimeEnum(){ return StringToEnum("ProfilingSolutionTime");}
+function SteadystateMaxiterEnum(){ return StringToEnum("SteadystateMaxiter");}
+function SteadystateNumRequestedOutputsEnum(){ return StringToEnum("SteadystateNumRequestedOutputs");}
+function SteadystateReltolEnum(){ return StringToEnum("SteadystateReltol");}
+function SteadystateRequestedOutputsEnum(){ return StringToEnum("SteadystateRequestedOutputs");}
+function SurfaceEnum(){ return StringToEnum("Surface");}
+function ThermalIsenthalpyEnum(){ return StringToEnum("ThermalIsenthalpy");}
+function ThermalIsdynamicbasalspcEnum(){ return StringToEnum("ThermalIsdynamicbasalspc");}
+function ThermalReltolEnum(){ return StringToEnum("ThermalReltol");}
+function ThermalMaxiterEnum(){ return StringToEnum("ThermalMaxiter");}
+function ThermalPenaltyFactorEnum(){ return StringToEnum("ThermalPenaltyFactor");}
+function ThermalPenaltyLockEnum(){ return StringToEnum("ThermalPenaltyLock");}
+function ThermalPenaltyThresholdEnum(){ return StringToEnum("ThermalPenaltyThreshold");}
+function ThermalSpctemperatureEnum(){ return StringToEnum("ThermalSpctemperature");}
+function ThermalStabilizationEnum(){ return StringToEnum("ThermalStabilization");}
+function ThermalNumRequestedOutputsEnum(){ return StringToEnum("ThermalNumRequestedOutputs");}
+function ThermalRequestedOutputsEnum(){ return StringToEnum("ThermalRequestedOutputs");}
+function GiaMantleViscosityEnum(){ return StringToEnum("GiaMantleViscosity");}
+function GiaLithosphereThicknessEnum(){ return StringToEnum("GiaLithosphereThickness");}
+function ThicknessEnum(){ return StringToEnum("Thickness");}
+function TimesteppingStartTimeEnum(){ return StringToEnum("TimesteppingStartTime");}
+function TimesteppingFinalTimeEnum(){ return StringToEnum("TimesteppingFinalTime");}
+function TimesteppingCflCoefficientEnum(){ return StringToEnum("TimesteppingCflCoefficient");}
+function TimesteppingTimeAdaptEnum(){ return StringToEnum("TimesteppingTimeAdapt");}
+function TimesteppingTimeStepEnum(){ return StringToEnum("TimesteppingTimeStep");}
+function TimesteppingInterpForcingsEnum(){ return StringToEnum("TimesteppingInterpForcings");}
+function TransientIssmbEnum(){ return StringToEnum("TransientIssmb");}
+function TransientIsstressbalanceEnum(){ return StringToEnum("TransientIsstressbalance");}
+function TransientIsgroundinglineEnum(){ return StringToEnum("TransientIsgroundingline");}
+function TransientIsmasstransportEnum(){ return StringToEnum("TransientIsmasstransport");}
+function TransientIsthermalEnum(){ return StringToEnum("TransientIsthermal");}
+function TransientIsgiaEnum(){ return StringToEnum("TransientIsgia");}
+function TransientIsdamageevolutionEnum(){ return StringToEnum("TransientIsdamageevolution");}
+function TransientIshydrologyEnum(){ return StringToEnum("TransientIshydrology");}
+function TransientIscalvingEnum(){ return StringToEnum("TransientIscalving");}
+function TransientNumRequestedOutputsEnum(){ return StringToEnum("TransientNumRequestedOutputs");}
+function TransientRequestedOutputsEnum(){ return StringToEnum("TransientRequestedOutputs");}
+function PotentialEnum(){ return StringToEnum("Potential");}
+function BalancethicknessSpcpotentialEnum(){ return StringToEnum("BalancethicknessSpcpotential");}
+function BalancethicknessApparentMassbalanceEnum(){ return StringToEnum("BalancethicknessApparentMassbalance");}
+function Balancethickness2MisfitEnum(){ return StringToEnum("Balancethickness2Misfit");}
+function BalancethicknessDiffusionCoefficientEnum(){ return StringToEnum("BalancethicknessDiffusionCoefficient");}
+function BalancethicknessCmuEnum(){ return StringToEnum("BalancethicknessCmu");}
+function BalancethicknessOmegaEnum(){ return StringToEnum("BalancethicknessOmega");}
+function BalancethicknessD0Enum(){ return StringToEnum("BalancethicknessD0");}
+function SmbEnum(){ return StringToEnum("Smb");}
+function SmbAnalysisEnum(){ return StringToEnum("SmbAnalysis");}
+function SmbSolutionEnum(){ return StringToEnum("SmbSolution");}
+function SmbNumRequestedOutputsEnum(){ return StringToEnum("SmbNumRequestedOutputs");}
+function SmbRequestedOutputsEnum(){ return StringToEnum("SmbRequestedOutputs");}
+function SmbIsInitializedEnum(){ return StringToEnum("SmbIsInitialized");}
+function SMBforcingEnum(){ return StringToEnum("SMBforcing");}
+function SmbMassBalanceEnum(){ return StringToEnum("SmbMassBalance");}
+function SMBgembEnum(){ return StringToEnum("SMBgemb");}
+function SmbInitDensityScalingEnum(){ return StringToEnum("SmbInitDensityScaling");}
+function SmbTaEnum(){ return StringToEnum("SmbTa");}
+function SmbVEnum(){ return StringToEnum("SmbV");}
+function SmbDswrfEnum(){ return StringToEnum("SmbDswrf");}
+function SmbDlwrfEnum(){ return StringToEnum("SmbDlwrf");}
+function SmbPEnum(){ return StringToEnum("SmbP");}
+function SmbSwfEnum(){ return StringToEnum("SmbSwf");}
+function SmbEAirEnum(){ return StringToEnum("SmbEAir");}
+function SmbPAirEnum(){ return StringToEnum("SmbPAir");}
+function SmbTmeanEnum(){ return StringToEnum("SmbTmean");}
+function SmbCEnum(){ return StringToEnum("SmbC");}
+function SmbTzEnum(){ return StringToEnum("SmbTz");}
+function SmbVzEnum(){ return StringToEnum("SmbVz");}
+function SmbDtEnum(){ return StringToEnum("SmbDt");}
+function SmbDzEnum(){ return StringToEnum("SmbDz");}
+function SmbAIdxEnum(){ return StringToEnum("SmbAIdx");}
+function SmbSwIdxEnum(){ return StringToEnum("SmbSwIdx");}
+function SmbDenIdxEnum(){ return StringToEnum("SmbDenIdx");}
+function SmbZTopEnum(){ return StringToEnum("SmbZTop");}
+function SmbDzTopEnum(){ return StringToEnum("SmbDzTop");}
+function SmbDzMinEnum(){ return StringToEnum("SmbDzMin");}
+function SmbZYEnum(){ return StringToEnum("SmbZY");}
+function SmbZMaxEnum(){ return StringToEnum("SmbZMax");}
+function SmbZMinEnum(){ return StringToEnum("SmbZMin");}
+function SmbOutputFreqEnum(){ return StringToEnum("SmbOutputFreq");}
+function SmbASnowEnum(){ return StringToEnum("SmbASnow");}
+function SmbAIceEnum(){ return StringToEnum("SmbAIce");}
+function SmbCldFracEnum(){ return StringToEnum("SmbCldFrac");}
+function SmbT0wetEnum(){ return StringToEnum("SmbT0wet");}
+function SmbT0dryEnum(){ return StringToEnum("SmbT0dry");}
+function SmbKEnum(){ return StringToEnum("SmbK");}
+function SmbDEnum(){ return StringToEnum("SmbD");}
+function SmbReEnum(){ return StringToEnum("SmbRe");}
+function SmbGdnEnum(){ return StringToEnum("SmbGdn");}
+function SmbGspEnum(){ return StringToEnum("SmbGsp");}
+function SmbECEnum(){ return StringToEnum("SmbEC");}
+function SmbCondensationEnum(){ return StringToEnum("SmbCondensation");}
+function SmbWEnum(){ return StringToEnum("SmbW");}
+function SmbAEnum(){ return StringToEnum("SmbA");}
+function SmbTEnum(){ return StringToEnum("SmbT");}
+function SmbIsgraingrowthEnum(){ return StringToEnum("SmbIsgraingrowth");}
+function SmbIsalbedoEnum(){ return StringToEnum("SmbIsalbedo");}
+function SmbIsshortwaveEnum(){ return StringToEnum("SmbIsshortwave");}
+function SmbIsthermalEnum(){ return StringToEnum("SmbIsthermal");}
+function SmbIsaccumulationEnum(){ return StringToEnum("SmbIsaccumulation");}
+function SmbIsmeltEnum(){ return StringToEnum("SmbIsmelt");}
+function SmbIsdensificationEnum(){ return StringToEnum("SmbIsdensification");}
+function SmbIsturbulentfluxEnum(){ return StringToEnum("SmbIsturbulentflux");}
+function SMBpddEnum(){ return StringToEnum("SMBpdd");}
+function SmbDelta18oEnum(){ return StringToEnum("SmbDelta18o");}
+function SmbDelta18oSurfaceEnum(){ return StringToEnum("SmbDelta18oSurface");}
+function SmbIsdelta18oEnum(){ return StringToEnum("SmbIsdelta18o");}
+function SmbIsmungsmEnum(){ return StringToEnum("SmbIsmungsm");}
+function SmbIsd18opdEnum(){ return StringToEnum("SmbIsd18opd");}
+function SmbPrecipitationsPresentdayEnum(){ return StringToEnum("SmbPrecipitationsPresentday");}
+function SmbPrecipitationsLgmEnum(){ return StringToEnum("SmbPrecipitationsLgm");}
+function SmbTemperaturesPresentdayEnum(){ return StringToEnum("SmbTemperaturesPresentday");}
+function SmbTemperaturesLgmEnum(){ return StringToEnum("SmbTemperaturesLgm");}
+function SmbPrecipitationEnum(){ return StringToEnum("SmbPrecipitation");}
+function SmbDesfacEnum(){ return StringToEnum("SmbDesfac");}
+function SmbS0pEnum(){ return StringToEnum("SmbS0p");}
+function SmbS0tEnum(){ return StringToEnum("SmbS0t");}
+function SmbRlapsEnum(){ return StringToEnum("SmbRlaps");}
+function SmbRlapslgmEnum(){ return StringToEnum("SmbRlapslgm");}
+function SmbPfacEnum(){ return StringToEnum("SmbPfac");}
+function SmbTdiffEnum(){ return StringToEnum("SmbTdiff");}
+function SmbSealevEnum(){ return StringToEnum("SmbSealev");}
+function SMBd18opddEnum(){ return StringToEnum("SMBd18opdd");}
+function SmbDpermilEnum(){ return StringToEnum("SmbDpermil");}
+function SMBgradientsEnum(){ return StringToEnum("SMBgradients");}
+function SmbMonthlytemperaturesEnum(){ return StringToEnum("SmbMonthlytemperatures");}
+function SmbHrefEnum(){ return StringToEnum("SmbHref");}
+function SmbSmbrefEnum(){ return StringToEnum("SmbSmbref");}
+function SmbBPosEnum(){ return StringToEnum("SmbBPos");}
+function SmbBNegEnum(){ return StringToEnum("SmbBNeg");}
+function SMBhenningEnum(){ return StringToEnum("SMBhenning");}
+function SMBcomponentsEnum(){ return StringToEnum("SMBcomponents");}
+function SmbAccumulationEnum(){ return StringToEnum("SmbAccumulation");}
+function SmbEvaporationEnum(){ return StringToEnum("SmbEvaporation");}
+function SmbRunoffEnum(){ return StringToEnum("SmbRunoff");}
+function SMBmeltcomponentsEnum(){ return StringToEnum("SMBmeltcomponents");}
+function SmbMeltEnum(){ return StringToEnum("SmbMelt");}
+function SmbRefreezeEnum(){ return StringToEnum("SmbRefreeze");}
+function SMBgcmEnum(){ return StringToEnum("SMBgcm");}
+function SmbIspddEnum(){ return StringToEnum("SmbIspdd");}
+function SmbIssmbgradientsEnum(){ return StringToEnum("SmbIssmbgradients");}
+function SolutionTypeEnum(){ return StringToEnum("SolutionType");}
+function AnalysisTypeEnum(){ return StringToEnum("AnalysisType");}
+function ConfigurationTypeEnum(){ return StringToEnum("ConfigurationType");}
+function AdjointBalancethicknessAnalysisEnum(){ return StringToEnum("AdjointBalancethicknessAnalysis");}
+function AdjointBalancethickness2AnalysisEnum(){ return StringToEnum("AdjointBalancethickness2Analysis");}
+function AdjointHorizAnalysisEnum(){ return StringToEnum("AdjointHorizAnalysis");}
+function AnalysisCounterEnum(){ return StringToEnum("AnalysisCounter");}
+function DefaultAnalysisEnum(){ return StringToEnum("DefaultAnalysis");}
+function BalancethicknessAnalysisEnum(){ return StringToEnum("BalancethicknessAnalysis");}
+function BalancethicknessSolutionEnum(){ return StringToEnum("BalancethicknessSolution");}
+function Balancethickness2AnalysisEnum(){ return StringToEnum("Balancethickness2Analysis");}
+function Balancethickness2SolutionEnum(){ return StringToEnum("Balancethickness2Solution");}
+function BalancethicknessSoftAnalysisEnum(){ return StringToEnum("BalancethicknessSoftAnalysis");}
+function BalancethicknessSoftSolutionEnum(){ return StringToEnum("BalancethicknessSoftSolution");}
+function BalancevelocityAnalysisEnum(){ return StringToEnum("BalancevelocityAnalysis");}
+function BalancevelocitySolutionEnum(){ return StringToEnum("BalancevelocitySolution");}
+function L2ProjectionEPLAnalysisEnum(){ return StringToEnum("L2ProjectionEPLAnalysis");}
+function L2ProjectionBaseAnalysisEnum(){ return StringToEnum("L2ProjectionBaseAnalysis");}
+function BedSlopeSolutionEnum(){ return StringToEnum("BedSlopeSolution");}
+function DamageEvolutionSolutionEnum(){ return StringToEnum("DamageEvolutionSolution");}
+function DamageEvolutionAnalysisEnum(){ return StringToEnum("DamageEvolutionAnalysis");}
+function StressbalanceAnalysisEnum(){ return StringToEnum("StressbalanceAnalysis");}
+function StressbalanceSIAAnalysisEnum(){ return StringToEnum("StressbalanceSIAAnalysis");}
+function StressbalanceSolutionEnum(){ return StringToEnum("StressbalanceSolution");}
+function StressbalanceVerticalAnalysisEnum(){ return StringToEnum("StressbalanceVerticalAnalysis");}
+function EnthalpyAnalysisEnum(){ return StringToEnum("EnthalpyAnalysis");}
+function FlaimAnalysisEnum(){ return StringToEnum("FlaimAnalysis");}
+function FlaimSolutionEnum(){ return StringToEnum("FlaimSolution");}
+function HydrologyShreveAnalysisEnum(){ return StringToEnum("HydrologyShreveAnalysis");}
+function HydrologyDCInefficientAnalysisEnum(){ return StringToEnum("HydrologyDCInefficientAnalysis");}
+function HydrologyDCEfficientAnalysisEnum(){ return StringToEnum("HydrologyDCEfficientAnalysis");}
+function HydrologySommersAnalysisEnum(){ return StringToEnum("HydrologySommersAnalysis");}
+function HydrologySolutionEnum(){ return StringToEnum("HydrologySolution");}
+function MeltingAnalysisEnum(){ return StringToEnum("MeltingAnalysis");}
+function MasstransportAnalysisEnum(){ return StringToEnum("MasstransportAnalysis");}
+function MasstransportSolutionEnum(){ return StringToEnum("MasstransportSolution");}
+function FreeSurfaceBaseAnalysisEnum(){ return StringToEnum("FreeSurfaceBaseAnalysis");}
+function FreeSurfaceTopAnalysisEnum(){ return StringToEnum("FreeSurfaceTopAnalysis");}
+function SurfaceNormalVelocityEnum(){ return StringToEnum("SurfaceNormalVelocity");}
+function ExtrudeFromBaseAnalysisEnum(){ return StringToEnum("ExtrudeFromBaseAnalysis");}
+function ExtrudeFromTopAnalysisEnum(){ return StringToEnum("ExtrudeFromTopAnalysis");}
+function DepthAverageAnalysisEnum(){ return StringToEnum("DepthAverageAnalysis");}
+function SteadystateSolutionEnum(){ return StringToEnum("SteadystateSolution");}
+function SurfaceSlopeSolutionEnum(){ return StringToEnum("SurfaceSlopeSolution");}
+function SmoothAnalysisEnum(){ return StringToEnum("SmoothAnalysis");}
+function ThermalAnalysisEnum(){ return StringToEnum("ThermalAnalysis");}
+function ThermalSolutionEnum(){ return StringToEnum("ThermalSolution");}
+function TransientSolutionEnum(){ return StringToEnum("TransientSolution");}
+function UzawaPressureAnalysisEnum(){ return StringToEnum("UzawaPressureAnalysis");}
+function GiaSolutionEnum(){ return StringToEnum("GiaSolution");}
+function GiaAnalysisEnum(){ return StringToEnum("GiaAnalysis");}
+function MeshdeformationSolutionEnum(){ return StringToEnum("MeshdeformationSolution");}
+function MeshdeformationAnalysisEnum(){ return StringToEnum("MeshdeformationAnalysis");}
+function LevelsetAnalysisEnum(){ return StringToEnum("LevelsetAnalysis");}
+function LevelsetStabilizationEnum(){ return StringToEnum("LevelsetStabilization");}
+function ExtrapolationAnalysisEnum(){ return StringToEnum("ExtrapolationAnalysis");}
+function LsfReinitializationAnalysisEnum(){ return StringToEnum("LsfReinitializationAnalysis");}
+function ApproximationEnum(){ return StringToEnum("Approximation");}
+function NoneApproximationEnum(){ return StringToEnum("NoneApproximation");}
+function SIAApproximationEnum(){ return StringToEnum("SIAApproximation");}
+function SSAApproximationEnum(){ return StringToEnum("SSAApproximation");}
+function SSAHOApproximationEnum(){ return StringToEnum("SSAHOApproximation");}
+function SSAFSApproximationEnum(){ return StringToEnum("SSAFSApproximation");}
+function L1L2ApproximationEnum(){ return StringToEnum("L1L2Approximation");}
+function HOApproximationEnum(){ return StringToEnum("HOApproximation");}
+function HOFSApproximationEnum(){ return StringToEnum("HOFSApproximation");}
+function FSApproximationEnum(){ return StringToEnum("FSApproximation");}
+function FSvelocityEnum(){ return StringToEnum("FSvelocity");}
+function FSpressureEnum(){ return StringToEnum("FSpressure");}
+function DataSetEnum(){ return StringToEnum("DataSet");}
+function ConstraintsEnum(){ return StringToEnum("Constraints");}
+function LoadsEnum(){ return StringToEnum("Loads");}
+function MaterialsEnum(){ return StringToEnum("Materials");}
+function NodesEnum(){ return StringToEnum("Nodes");}
+function ContoursEnum(){ return StringToEnum("Contours");}
+function ParametersEnum(){ return StringToEnum("Parameters");}
+function VerticesEnum(){ return StringToEnum("Vertices");}
+function ResultsEnum(){ return StringToEnum("Results");}
+function GenericParamEnum(){ return StringToEnum("GenericParam");}
+function AdolcParamEnum(){ return StringToEnum("AdolcParam");}
+function BoolInputEnum(){ return StringToEnum("BoolInput");}
+function BoolParamEnum(){ return StringToEnum("BoolParam");}
+function ContourEnum(){ return StringToEnum("Contour");}
+function ControlInputEnum(){ return StringToEnum("ControlInput");}
+function DatasetInputEnum(){ return StringToEnum("DatasetInput");}
+function DoubleInputEnum(){ return StringToEnum("DoubleInput");}
+function DoubleArrayInputEnum(){ return StringToEnum("DoubleArrayInput");}
+function DataSetParamEnum(){ return StringToEnum("DataSetParam");}
+function DoubleMatArrayParamEnum(){ return StringToEnum("DoubleMatArrayParam");}
+function DoubleMatParamEnum(){ return StringToEnum("DoubleMatParam");}
+function DoubleParamEnum(){ return StringToEnum("DoubleParam");}
+function DoubleVecParamEnum(){ return StringToEnum("DoubleVecParam");}
+function ElementEnum(){ return StringToEnum("Element");}
+function ElementHookEnum(){ return StringToEnum("ElementHook");}
+function HookEnum(){ return StringToEnum("Hook");}
+function ExternalResultEnum(){ return StringToEnum("ExternalResult");}
+function FileParamEnum(){ return StringToEnum("FileParam");}
+function InputEnum(){ return StringToEnum("Input");}
+function IntInputEnum(){ return StringToEnum("IntInput");}
+function InputToExtrudeEnum(){ return StringToEnum("InputToExtrude");}
+function InputToL2ProjectEnum(){ return StringToEnum("InputToL2Project");}
+function InputToDepthaverageEnum(){ return StringToEnum("InputToDepthaverage");}
+function InputToSmoothEnum(){ return StringToEnum("InputToSmooth");}
+function SmoothThicknessMultiplierEnum(){ return StringToEnum("SmoothThicknessMultiplier");}
+function IntParamEnum(){ return StringToEnum("IntParam");}
+function IntVecParamEnum(){ return StringToEnum("IntVecParam");}
+function TransientParamEnum(){ return StringToEnum("TransientParam");}
+function MaticeEnum(){ return StringToEnum("Matice");}
+function MatdamageiceEnum(){ return StringToEnum("Matdamageice");}
+function MatparEnum(){ return StringToEnum("Matpar");}
+function NodeEnum(){ return StringToEnum("Node");}
+function NumericalfluxEnum(){ return StringToEnum("Numericalflux");}
+function NumericalfluxTypeEnum(){ return StringToEnum("NumericalfluxType");}
+function NeumannfluxEnum(){ return StringToEnum("Neumannflux");}
+function ParamEnum(){ return StringToEnum("Param");}
+function MoulinEnum(){ return StringToEnum("Moulin");}
+function PengridEnum(){ return StringToEnum("Pengrid");}
+function PenpairEnum(){ return StringToEnum("Penpair");}
+function ProfilerEnum(){ return StringToEnum("Profiler");}
+function MatrixParamEnum(){ return StringToEnum("MatrixParam");}
+function MassconEnum(){ return StringToEnum("Masscon");}
+function MassconNameEnum(){ return StringToEnum("MassconName");}
+function MassconDefinitionenumEnum(){ return StringToEnum("MassconDefinitionenum");}
+function MassconLevelsetEnum(){ return StringToEnum("MassconLevelset");}
+function MassconaxpbyEnum(){ return StringToEnum("Massconaxpby");}
+function MassconaxpbyNameEnum(){ return StringToEnum("MassconaxpbyName");}
+function MassconaxpbyDefinitionenumEnum(){ return StringToEnum("MassconaxpbyDefinitionenum");}
+function MassconaxpbyNamexEnum(){ return StringToEnum("MassconaxpbyNamex");}
+function MassconaxpbyNameyEnum(){ return StringToEnum("MassconaxpbyNamey");}
+function MassconaxpbyAlphaEnum(){ return StringToEnum("MassconaxpbyAlpha");}
+function MassconaxpbyBetaEnum(){ return StringToEnum("MassconaxpbyBeta");}
+function NodeSIdEnum(){ return StringToEnum("NodeSId");}
+function VectorParamEnum(){ return StringToEnum("VectorParam");}
+function RiftfrontEnum(){ return StringToEnum("Riftfront");}
+function RiftfrontTypeEnum(){ return StringToEnum("RiftfrontType");}
+function SegmentEnum(){ return StringToEnum("Segment");}
+function SegmentRiftfrontEnum(){ return StringToEnum("SegmentRiftfront");}
+function SpcDynamicEnum(){ return StringToEnum("SpcDynamic");}
+function SpcStaticEnum(){ return StringToEnum("SpcStatic");}
+function SpcTransientEnum(){ return StringToEnum("SpcTransient");}
+function StringArrayParamEnum(){ return StringToEnum("StringArrayParam");}
+function StringParamEnum(){ return StringToEnum("StringParam");}
+function SegEnum(){ return StringToEnum("Seg");}
+function SegInputEnum(){ return StringToEnum("SegInput");}
+function TriaEnum(){ return StringToEnum("Tria");}
+function TriaInputEnum(){ return StringToEnum("TriaInput");}
+function TetraEnum(){ return StringToEnum("Tetra");}
+function TetraInputEnum(){ return StringToEnum("TetraInput");}
+function PentaEnum(){ return StringToEnum("Penta");}
+function PentaInputEnum(){ return StringToEnum("PentaInput");}
+function VertexEnum(){ return StringToEnum("Vertex");}
+function VertexPIdEnum(){ return StringToEnum("VertexPId");}
+function VertexSIdEnum(){ return StringToEnum("VertexSId");}
+function AirEnum(){ return StringToEnum("Air");}
+function IceEnum(){ return StringToEnum("Ice");}
+function MelangeEnum(){ return StringToEnum("Melange");}
+function WaterEnum(){ return StringToEnum("Water");}
+function ClosedEnum(){ return StringToEnum("Closed");}
+function FreeEnum(){ return StringToEnum("Free");}
+function OpenEnum(){ return StringToEnum("Open");}
+function AdjointpEnum(){ return StringToEnum("Adjointp");}
+function AdjointxEnum(){ return StringToEnum("Adjointx");}
+function AdjointyEnum(){ return StringToEnum("Adjointy");}
+function AdjointzEnum(){ return StringToEnum("Adjointz");}
+function BalancethicknessMisfitEnum(){ return StringToEnum("BalancethicknessMisfit");}
+function BedSlopeXEnum(){ return StringToEnum("BedSlopeX");}
+function BedSlopeYEnum(){ return StringToEnum("BedSlopeY");}
+function BoundaryEnum(){ return StringToEnum("Boundary");}
+function ConvergedEnum(){ return StringToEnum("Converged");}
+function FillEnum(){ return StringToEnum("Fill");}
+function FractionIncrementEnum(){ return StringToEnum("FractionIncrement");}
+function FrictionEnum(){ return StringToEnum("Friction");}
+function InternalEnum(){ return StringToEnum("Internal");}
+function MassFluxEnum(){ return StringToEnum("MassFlux");}
+function MeltingOffsetEnum(){ return StringToEnum("MeltingOffset");}
+function MisfitEnum(){ return StringToEnum("Misfit");}
+function PressureEnum(){ return StringToEnum("Pressure");}
+function PressurePicardEnum(){ return StringToEnum("PressurePicard");}
+function AndroidFrictionCoefficientEnum(){ return StringToEnum("AndroidFrictionCoefficient");}
+function ResetPenaltiesEnum(){ return StringToEnum("ResetPenalties");}
+function SegmentOnIceShelfEnum(){ return StringToEnum("SegmentOnIceShelf");}
+function SurfaceAbsVelMisfitEnum(){ return StringToEnum("SurfaceAbsVelMisfit");}
+function SurfaceAreaEnum(){ return StringToEnum("SurfaceArea");}
+function SurfaceAverageVelMisfitEnum(){ return StringToEnum("SurfaceAverageVelMisfit");}
+function SurfaceLogVelMisfitEnum(){ return StringToEnum("SurfaceLogVelMisfit");}
+function SurfaceLogVxVyMisfitEnum(){ return StringToEnum("SurfaceLogVxVyMisfit");}
+function SurfaceRelVelMisfitEnum(){ return StringToEnum("SurfaceRelVelMisfit");}
+function SurfaceSlopeXEnum(){ return StringToEnum("SurfaceSlopeX");}
+function SurfaceSlopeYEnum(){ return StringToEnum("SurfaceSlopeY");}
+function TemperatureEnum(){ return StringToEnum("Temperature");}
+function TemperaturePicardEnum(){ return StringToEnum("TemperaturePicard");}
+function TemperaturePDDEnum(){ return StringToEnum("TemperaturePDD");}
+function ThicknessAbsMisfitEnum(){ return StringToEnum("ThicknessAbsMisfit");}
+function SurfaceAbsMisfitEnum(){ return StringToEnum("SurfaceAbsMisfit");}
+function VelEnum(){ return StringToEnum("Vel");}
+function VelocityEnum(){ return StringToEnum("Velocity");}
+function VxAverageEnum(){ return StringToEnum("VxAverage");}
+function VxEnum(){ return StringToEnum("Vx");}
+function VxPicardEnum(){ return StringToEnum("VxPicard");}
+function VyAverageEnum(){ return StringToEnum("VyAverage");}
+function VyEnum(){ return StringToEnum("Vy");}
+function VyPicardEnum(){ return StringToEnum("VyPicard");}
+function VzEnum(){ return StringToEnum("Vz");}
+function VzSSAEnum(){ return StringToEnum("VzSSA");}
+function VzHOEnum(){ return StringToEnum("VzHO");}
+function VzPicardEnum(){ return StringToEnum("VzPicard");}
+function VzFSEnum(){ return StringToEnum("VzFS");}
+function VxMeshEnum(){ return StringToEnum("VxMesh");}
+function VyMeshEnum(){ return StringToEnum("VyMesh");}
+function VzMeshEnum(){ return StringToEnum("VzMesh");}
+function EnthalpyEnum(){ return StringToEnum("Enthalpy");}
+function EnthalpyPicardEnum(){ return StringToEnum("EnthalpyPicard");}
+function ThicknessAbsGradientEnum(){ return StringToEnum("ThicknessAbsGradient");}
+function ThicknessAlongGradientEnum(){ return StringToEnum("ThicknessAlongGradient");}
+function ThicknessAcrossGradientEnum(){ return StringToEnum("ThicknessAcrossGradient");}
+function IntMatParamEnum(){ return StringToEnum("IntMatParam");}
+function RheologyBbarAbsGradientEnum(){ return StringToEnum("RheologyBbarAbsGradient");}
+function RheologyBAbsGradientEnum(){ return StringToEnum("RheologyBAbsGradient");}
+function DragCoefficientAbsGradientEnum(){ return StringToEnum("DragCoefficientAbsGradient");}
+function TransientInputEnum(){ return StringToEnum("TransientInput");}
+function WaterfractionEnum(){ return StringToEnum("Waterfraction");}
+function WatercolumnEnum(){ return StringToEnum("Watercolumn");}
+function BasalFrictionEnum(){ return StringToEnum("BasalFriction");}
+function ViscousHeatingEnum(){ return StringToEnum("ViscousHeating");}
+function HydrologyWaterVxEnum(){ return StringToEnum("HydrologyWaterVx");}
+function HydrologyWaterVyEnum(){ return StringToEnum("HydrologyWaterVy");}
+function DrivingStressXEnum(){ return StringToEnum("DrivingStressX");}
+function DrivingStressYEnum(){ return StringToEnum("DrivingStressY");}
+function SigmaNNEnum(){ return StringToEnum("SigmaNN");}
+function StressTensorEnum(){ return StringToEnum("StressTensor");}
+function StressTensorxxEnum(){ return StringToEnum("StressTensorxx");}
+function StressTensorxyEnum(){ return StringToEnum("StressTensorxy");}
+function StressTensorxzEnum(){ return StringToEnum("StressTensorxz");}
+function StressTensoryyEnum(){ return StringToEnum("StressTensoryy");}
+function StressTensoryzEnum(){ return StringToEnum("StressTensoryz");}
+function StressTensorzzEnum(){ return StringToEnum("StressTensorzz");}
+function StressMaxPrincipalEnum(){ return StringToEnum("StressMaxPrincipal");}
+function DeviatoricStressEnum(){ return StringToEnum("DeviatoricStress");}
+function DeviatoricStressxxEnum(){ return StringToEnum("DeviatoricStressxx");}
+function DeviatoricStressxyEnum(){ return StringToEnum("DeviatoricStressxy");}
+function DeviatoricStressxzEnum(){ return StringToEnum("DeviatoricStressxz");}
+function DeviatoricStressyyEnum(){ return StringToEnum("DeviatoricStressyy");}
+function DeviatoricStressyzEnum(){ return StringToEnum("DeviatoricStressyz");}
+function DeviatoricStresszzEnum(){ return StringToEnum("DeviatoricStresszz");}
+function StrainRateEnum(){ return StringToEnum("StrainRate");}
+function StrainRatexxEnum(){ return StringToEnum("StrainRatexx");}
+function StrainRatexyEnum(){ return StringToEnum("StrainRatexy");}
+function StrainRatexzEnum(){ return StringToEnum("StrainRatexz");}
+function StrainRateyyEnum(){ return StringToEnum("StrainRateyy");}
+function StrainRateyzEnum(){ return StringToEnum("StrainRateyz");}
+function StrainRatezzEnum(){ return StringToEnum("StrainRatezz");}
+function DivergenceEnum(){ return StringToEnum("Divergence");}
+function MaxDivergenceEnum(){ return StringToEnum("MaxDivergence");}
+function GiaCrossSectionShapeEnum(){ return StringToEnum("GiaCrossSectionShape");}
+function GiadWdtEnum(){ return StringToEnum("GiadWdt");}
+function GiaWEnum(){ return StringToEnum("GiaW");}
+function P0Enum(){ return StringToEnum("P0");}
+function P0ArrayEnum(){ return StringToEnum("P0Array");}
+function P1Enum(){ return StringToEnum("P1");}
+function P1DGEnum(){ return StringToEnum("P1DG");}
+function P1bubbleEnum(){ return StringToEnum("P1bubble");}
+function P1bubblecondensedEnum(){ return StringToEnum("P1bubblecondensed");}
+function P2Enum(){ return StringToEnum("P2");}
+function P2bubbleEnum(){ return StringToEnum("P2bubble");}
+function P2bubblecondensedEnum(){ return StringToEnum("P2bubblecondensed");}
+function P2xP1Enum(){ return StringToEnum("P2xP1");}
+function P1xP2Enum(){ return StringToEnum("P1xP2");}
+function P1xP3Enum(){ return StringToEnum("P1xP3");}
+function P2xP4Enum(){ return StringToEnum("P2xP4");}
+function P1P1Enum(){ return StringToEnum("P1P1");}
+function P1P1GLSEnum(){ return StringToEnum("P1P1GLS");}
+function MINIEnum(){ return StringToEnum("MINI");}
+function MINIcondensedEnum(){ return StringToEnum("MINIcondensed");}
+function TaylorHoodEnum(){ return StringToEnum("TaylorHood");}
+function LATaylorHoodEnum(){ return StringToEnum("LATaylorHood");}
+function XTaylorHoodEnum(){ return StringToEnum("XTaylorHood");}
+function OneLayerP4zEnum(){ return StringToEnum("OneLayerP4z");}
+function CrouzeixRaviartEnum(){ return StringToEnum("CrouzeixRaviart");}
+function LACrouzeixRaviartEnum(){ return StringToEnum("LACrouzeixRaviart");}
+function SaveResultsEnum(){ return StringToEnum("SaveResults");}
+function BoolExternalResultEnum(){ return StringToEnum("BoolExternalResult");}
+function DoubleExternalResultEnum(){ return StringToEnum("DoubleExternalResult");}
+function DoubleMatExternalResultEnum(){ return StringToEnum("DoubleMatExternalResult");}
+function IntExternalResultEnum(){ return StringToEnum("IntExternalResult");}
+function JEnum(){ return StringToEnum("J");}
+function StringExternalResultEnum(){ return StringToEnum("StringExternalResult");}
+function StepEnum(){ return StringToEnum("Step");}
+function TimeEnum(){ return StringToEnum("Time");}
+function WaterColumnOldEnum(){ return StringToEnum("WaterColumnOld");}
+function OutputdefinitionEnum(){ return StringToEnum("Outputdefinition");}
+function Outputdefinition1Enum(){ return StringToEnum("Outputdefinition1");}
+function Outputdefinition2Enum(){ return StringToEnum("Outputdefinition2");}
+function Outputdefinition3Enum(){ return StringToEnum("Outputdefinition3");}
+function Outputdefinition4Enum(){ return StringToEnum("Outputdefinition4");}
+function Outputdefinition5Enum(){ return StringToEnum("Outputdefinition5");}
+function Outputdefinition6Enum(){ return StringToEnum("Outputdefinition6");}
+function Outputdefinition7Enum(){ return StringToEnum("Outputdefinition7");}
+function Outputdefinition8Enum(){ return StringToEnum("Outputdefinition8");}
+function Outputdefinition9Enum(){ return StringToEnum("Outputdefinition9");}
+function Outputdefinition10Enum(){ return StringToEnum("Outputdefinition10");}
+function Outputdefinition11Enum(){ return StringToEnum("Outputdefinition11");}
+function Outputdefinition12Enum(){ return StringToEnum("Outputdefinition12");}
+function Outputdefinition13Enum(){ return StringToEnum("Outputdefinition13");}
+function Outputdefinition14Enum(){ return StringToEnum("Outputdefinition14");}
+function Outputdefinition15Enum(){ return StringToEnum("Outputdefinition15");}
+function Outputdefinition16Enum(){ return StringToEnum("Outputdefinition16");}
+function Outputdefinition17Enum(){ return StringToEnum("Outputdefinition17");}
+function Outputdefinition18Enum(){ return StringToEnum("Outputdefinition18");}
+function Outputdefinition19Enum(){ return StringToEnum("Outputdefinition19");}
+function Outputdefinition20Enum(){ return StringToEnum("Outputdefinition20");}
+function Outputdefinition21Enum(){ return StringToEnum("Outputdefinition21");}
+function Outputdefinition22Enum(){ return StringToEnum("Outputdefinition22");}
+function Outputdefinition23Enum(){ return StringToEnum("Outputdefinition23");}
+function Outputdefinition24Enum(){ return StringToEnum("Outputdefinition24");}
+function Outputdefinition25Enum(){ return StringToEnum("Outputdefinition25");}
+function Outputdefinition26Enum(){ return StringToEnum("Outputdefinition26");}
+function Outputdefinition27Enum(){ return StringToEnum("Outputdefinition27");}
+function Outputdefinition28Enum(){ return StringToEnum("Outputdefinition28");}
+function Outputdefinition29Enum(){ return StringToEnum("Outputdefinition29");}
+function Outputdefinition30Enum(){ return StringToEnum("Outputdefinition30");}
+function Outputdefinition31Enum(){ return StringToEnum("Outputdefinition31");}
+function Outputdefinition32Enum(){ return StringToEnum("Outputdefinition32");}
+function Outputdefinition33Enum(){ return StringToEnum("Outputdefinition33");}
+function Outputdefinition34Enum(){ return StringToEnum("Outputdefinition34");}
+function Outputdefinition35Enum(){ return StringToEnum("Outputdefinition35");}
+function Outputdefinition36Enum(){ return StringToEnum("Outputdefinition36");}
+function Outputdefinition37Enum(){ return StringToEnum("Outputdefinition37");}
+function Outputdefinition38Enum(){ return StringToEnum("Outputdefinition38");}
+function Outputdefinition39Enum(){ return StringToEnum("Outputdefinition39");}
+function Outputdefinition40Enum(){ return StringToEnum("Outputdefinition40");}
+function Outputdefinition41Enum(){ return StringToEnum("Outputdefinition41");}
+function Outputdefinition42Enum(){ return StringToEnum("Outputdefinition42");}
+function Outputdefinition43Enum(){ return StringToEnum("Outputdefinition43");}
+function Outputdefinition44Enum(){ return StringToEnum("Outputdefinition44");}
+function Outputdefinition45Enum(){ return StringToEnum("Outputdefinition45");}
+function Outputdefinition46Enum(){ return StringToEnum("Outputdefinition46");}
+function Outputdefinition47Enum(){ return StringToEnum("Outputdefinition47");}
+function Outputdefinition48Enum(){ return StringToEnum("Outputdefinition48");}
+function Outputdefinition49Enum(){ return StringToEnum("Outputdefinition49");}
+function Outputdefinition50Enum(){ return StringToEnum("Outputdefinition50");}
+function Outputdefinition51Enum(){ return StringToEnum("Outputdefinition51");}
+function Outputdefinition52Enum(){ return StringToEnum("Outputdefinition52");}
+function Outputdefinition53Enum(){ return StringToEnum("Outputdefinition53");}
+function Outputdefinition54Enum(){ return StringToEnum("Outputdefinition54");}
+function Outputdefinition55Enum(){ return StringToEnum("Outputdefinition55");}
+function Outputdefinition56Enum(){ return StringToEnum("Outputdefinition56");}
+function Outputdefinition57Enum(){ return StringToEnum("Outputdefinition57");}
+function Outputdefinition58Enum(){ return StringToEnum("Outputdefinition58");}
+function Outputdefinition59Enum(){ return StringToEnum("Outputdefinition59");}
+function Outputdefinition60Enum(){ return StringToEnum("Outputdefinition60");}
+function Outputdefinition61Enum(){ return StringToEnum("Outputdefinition61");}
+function Outputdefinition62Enum(){ return StringToEnum("Outputdefinition62");}
+function Outputdefinition63Enum(){ return StringToEnum("Outputdefinition63");}
+function Outputdefinition64Enum(){ return StringToEnum("Outputdefinition64");}
+function Outputdefinition65Enum(){ return StringToEnum("Outputdefinition65");}
+function Outputdefinition66Enum(){ return StringToEnum("Outputdefinition66");}
+function Outputdefinition67Enum(){ return StringToEnum("Outputdefinition67");}
+function Outputdefinition68Enum(){ return StringToEnum("Outputdefinition68");}
+function Outputdefinition69Enum(){ return StringToEnum("Outputdefinition69");}
+function Outputdefinition70Enum(){ return StringToEnum("Outputdefinition70");}
+function Outputdefinition71Enum(){ return StringToEnum("Outputdefinition71");}
+function Outputdefinition72Enum(){ return StringToEnum("Outputdefinition72");}
+function Outputdefinition73Enum(){ return StringToEnum("Outputdefinition73");}
+function Outputdefinition74Enum(){ return StringToEnum("Outputdefinition74");}
+function Outputdefinition75Enum(){ return StringToEnum("Outputdefinition75");}
+function Outputdefinition76Enum(){ return StringToEnum("Outputdefinition76");}
+function Outputdefinition77Enum(){ return StringToEnum("Outputdefinition77");}
+function Outputdefinition78Enum(){ return StringToEnum("Outputdefinition78");}
+function Outputdefinition79Enum(){ return StringToEnum("Outputdefinition79");}
+function Outputdefinition80Enum(){ return StringToEnum("Outputdefinition80");}
+function Outputdefinition81Enum(){ return StringToEnum("Outputdefinition81");}
+function Outputdefinition82Enum(){ return StringToEnum("Outputdefinition82");}
+function Outputdefinition83Enum(){ return StringToEnum("Outputdefinition83");}
+function Outputdefinition84Enum(){ return StringToEnum("Outputdefinition84");}
+function Outputdefinition85Enum(){ return StringToEnum("Outputdefinition85");}
+function Outputdefinition86Enum(){ return StringToEnum("Outputdefinition86");}
+function Outputdefinition87Enum(){ return StringToEnum("Outputdefinition87");}
+function Outputdefinition88Enum(){ return StringToEnum("Outputdefinition88");}
+function Outputdefinition89Enum(){ return StringToEnum("Outputdefinition89");}
+function Outputdefinition90Enum(){ return StringToEnum("Outputdefinition90");}
+function Outputdefinition91Enum(){ return StringToEnum("Outputdefinition91");}
+function Outputdefinition92Enum(){ return StringToEnum("Outputdefinition92");}
+function Outputdefinition93Enum(){ return StringToEnum("Outputdefinition93");}
+function Outputdefinition94Enum(){ return StringToEnum("Outputdefinition94");}
+function Outputdefinition95Enum(){ return StringToEnum("Outputdefinition95");}
+function Outputdefinition96Enum(){ return StringToEnum("Outputdefinition96");}
+function Outputdefinition97Enum(){ return StringToEnum("Outputdefinition97");}
+function Outputdefinition98Enum(){ return StringToEnum("Outputdefinition98");}
+function Outputdefinition99Enum(){ return StringToEnum("Outputdefinition99");}
+function Outputdefinition100Enum(){ return StringToEnum("Outputdefinition100");}
+function OutputdefinitionListEnum(){ return StringToEnum("OutputdefinitionList");}
+function MassfluxatgateEnum(){ return StringToEnum("Massfluxatgate");}
+function MassfluxatgateNameEnum(){ return StringToEnum("MassfluxatgateName");}
+function MassfluxatgateDefinitionenumEnum(){ return StringToEnum("MassfluxatgateDefinitionenum");}
+function MassfluxatgateSegmentsEnum(){ return StringToEnum("MassfluxatgateSegments");}
+function MisfitNameEnum(){ return StringToEnum("MisfitName");}
+function MisfitDefinitionenumEnum(){ return StringToEnum("MisfitDefinitionenum");}
+function MisfitModelEnumEnum(){ return StringToEnum("MisfitModelEnum");}
+function MisfitObservationEnum(){ return StringToEnum("MisfitObservation");}
+function MisfitObservationEnumEnum(){ return StringToEnum("MisfitObservationEnum");}
+function MisfitLocalEnum(){ return StringToEnum("MisfitLocal");}
+function MisfitTimeinterpolationEnum(){ return StringToEnum("MisfitTimeinterpolation");}
+function MisfitWeightsEnum(){ return StringToEnum("MisfitWeights");}
+function MisfitWeightsEnumEnum(){ return StringToEnum("MisfitWeightsEnum");}
+function SurfaceObservationEnum(){ return StringToEnum("SurfaceObservation");}
+function WeightsSurfaceObservationEnum(){ return StringToEnum("WeightsSurfaceObservation");}
+function VxObsEnum(){ return StringToEnum("VxObs");}
+function WeightsVxObsEnum(){ return StringToEnum("WeightsVxObs");}
+function VyObsEnum(){ return StringToEnum("VyObs");}
+function WeightsVyObsEnum(){ return StringToEnum("WeightsVyObs");}
+function MinVelEnum(){ return StringToEnum("MinVel");}
+function MaxVelEnum(){ return StringToEnum("MaxVel");}
+function MinVxEnum(){ return StringToEnum("MinVx");}
+function MaxVxEnum(){ return StringToEnum("MaxVx");}
+function MaxAbsVxEnum(){ return StringToEnum("MaxAbsVx");}
+function MinVyEnum(){ return StringToEnum("MinVy");}
+function MaxVyEnum(){ return StringToEnum("MaxVy");}
+function MaxAbsVyEnum(){ return StringToEnum("MaxAbsVy");}
+function MinVzEnum(){ return StringToEnum("MinVz");}
+function MaxVzEnum(){ return StringToEnum("MaxVz");}
+function MaxAbsVzEnum(){ return StringToEnum("MaxAbsVz");}
+function FloatingAreaEnum(){ return StringToEnum("FloatingArea");}
+function GroundedAreaEnum(){ return StringToEnum("GroundedArea");}
+function IceMassEnum(){ return StringToEnum("IceMass");}
+function IceVolumeEnum(){ return StringToEnum("IceVolume");}
+function IceVolumeAboveFloatationEnum(){ return StringToEnum("IceVolumeAboveFloatation");}
+function TotalSmbEnum(){ return StringToEnum("TotalSmb");}
+function AbsoluteEnum(){ return StringToEnum("Absolute");}
+function IncrementalEnum(){ return StringToEnum("Incremental");}
+function AugmentedLagrangianREnum(){ return StringToEnum("AugmentedLagrangianR");}
+function AugmentedLagrangianRhopEnum(){ return StringToEnum("AugmentedLagrangianRhop");}
+function AugmentedLagrangianRlambdaEnum(){ return StringToEnum("AugmentedLagrangianRlambda");}
+function AugmentedLagrangianRholambdaEnum(){ return StringToEnum("AugmentedLagrangianRholambda");}
+function AugmentedLagrangianThetaEnum(){ return StringToEnum("AugmentedLagrangianTheta");}
+function NoneEnum(){ return StringToEnum("None");}
+function AggressiveMigrationEnum(){ return StringToEnum("AggressiveMigration");}
+function SoftMigrationEnum(){ return StringToEnum("SoftMigration");}
+function SubelementMigrationEnum(){ return StringToEnum("SubelementMigration");}
+function SubelementMigration2Enum(){ return StringToEnum("SubelementMigration2");}
+function ContactEnum(){ return StringToEnum("Contact");}
+function GroundingOnlyEnum(){ return StringToEnum("GroundingOnly");}
+function MaskGroundediceLevelsetEnum(){ return StringToEnum("MaskGroundediceLevelset");}
+function GaussSegEnum(){ return StringToEnum("GaussSeg");}
+function GaussTriaEnum(){ return StringToEnum("GaussTria");}
+function GaussTetraEnum(){ return StringToEnum("GaussTetra");}
+function GaussPentaEnum(){ return StringToEnum("GaussPenta");}
+function FSSolverEnum(){ return StringToEnum("FSSolver");}
+function AdjointEnum(){ return StringToEnum("Adjoint");}
+function ColinearEnum(){ return StringToEnum("Colinear");}
+function ControlSteadyEnum(){ return StringToEnum("ControlSteady");}
+function FsetEnum(){ return StringToEnum("Fset");}
+function Gradient1Enum(){ return StringToEnum("Gradient1");}
+function Gradient2Enum(){ return StringToEnum("Gradient2");}
+function Gradient3Enum(){ return StringToEnum("Gradient3");}
+function GradientEnum(){ return StringToEnum("Gradient");}
+function GroundinglineMigrationEnum(){ return StringToEnum("GroundinglineMigration");}
+function GsetEnum(){ return StringToEnum("Gset");}
+function IndexEnum(){ return StringToEnum("Index");}
+function IndexedEnum(){ return StringToEnum("Indexed");}
+function IntersectEnum(){ return StringToEnum("Intersect");}
+function NodalEnum(){ return StringToEnum("Nodal");}
+function OldGradientEnum(){ return StringToEnum("OldGradient");}
+function OutputFilePointerEnum(){ return StringToEnum("OutputFilePointer");}
+function ToolkitsFileNameEnum(){ return StringToEnum("ToolkitsFileName");}
+function RootPathEnum(){ return StringToEnum("RootPath");}
+function OutputFileNameEnum(){ return StringToEnum("OutputFileName");}
+function InputFileNameEnum(){ return StringToEnum("InputFileName");}
+function LockFileNameEnum(){ return StringToEnum("LockFileName");}
+function RestartFileNameEnum(){ return StringToEnum("RestartFileName");}
+function ToolkitsOptionsAnalysesEnum(){ return StringToEnum("ToolkitsOptionsAnalyses");}
+function ToolkitsOptionsStringsEnum(){ return StringToEnum("ToolkitsOptionsStrings");}
+function QmuErrNameEnum(){ return StringToEnum("QmuErrName");}
+function QmuInNameEnum(){ return StringToEnum("QmuInName");}
+function QmuOutNameEnum(){ return StringToEnum("QmuOutName");}
+function RegularEnum(){ return StringToEnum("Regular");}
+function ScaledEnum(){ return StringToEnum("Scaled");}
+function SeparateEnum(){ return StringToEnum("Separate");}
+function SsetEnum(){ return StringToEnum("Sset");}
+function VerboseEnum(){ return StringToEnum("Verbose");}
+function TriangleInterpEnum(){ return StringToEnum("TriangleInterp");}
+function BilinearInterpEnum(){ return StringToEnum("BilinearInterp");}
+function NearestInterpEnum(){ return StringToEnum("NearestInterp");}
+function XYEnum(){ return StringToEnum("XY");}
+function XYZEnum(){ return StringToEnum("XYZ");}
+function DenseEnum(){ return StringToEnum("Dense");}
+function MpiDenseEnum(){ return StringToEnum("MpiDense");}
+function MpiSparseEnum(){ return StringToEnum("MpiSparse");}
+function SeqEnum(){ return StringToEnum("Seq");}
+function MpiEnum(){ return StringToEnum("Mpi");}
+function MumpsEnum(){ return StringToEnum("Mumps");}
+function GslEnum(){ return StringToEnum("Gsl");}
+function OptionEnum(){ return StringToEnum("Option");}
+function GenericOptionEnum(){ return StringToEnum("GenericOption");}
+function OptionCellEnum(){ return StringToEnum("OptionCell");}
+function OptionStructEnum(){ return StringToEnum("OptionStruct");}
+function CuffeyEnum(){ return StringToEnum("Cuffey");}
+function PatersonEnum(){ return StringToEnum("Paterson");}
+function ArrheniusEnum(){ return StringToEnum("Arrhenius");}
+function LliboutryDuvalEnum(){ return StringToEnum("LliboutryDuval");}
+function TransientIslevelsetEnum(){ return StringToEnum("TransientIslevelset");}
+function SpcLevelsetEnum(){ return StringToEnum("SpcLevelset");}
+function ExtrapolationVariableEnum(){ return StringToEnum("ExtrapolationVariable");}
+function IceMaskNodeActivationEnum(){ return StringToEnum("IceMaskNodeActivation");}
+function LevelsetfunctionSlopeXEnum(){ return StringToEnum("LevelsetfunctionSlopeX");}
+function LevelsetfunctionSlopeYEnum(){ return StringToEnum("LevelsetfunctionSlopeY");}
+function LevelsetfunctionPicardEnum(){ return StringToEnum("LevelsetfunctionPicard");}
+function MaximumNumberOfDefinitionsEnum(){ return StringToEnum("MaximumNumberOfDefinitions");}
Index: /issm/trunk-jpl/src/m/parameterization/setmask.js
===================================================================
--- /issm/trunk-jpl/src/m/parameterization/setmask.js	(revision 19779)
+++ /issm/trunk-jpl/src/m/parameterization/setmask.js	(revision 19780)
@@ -42,7 +42,7 @@
 	
 	//Get assigned fields
-	x=md.mesh.x;
-	y=md.mesh.y;
-	elements=md.mesh.elements;
+	var x=md.mesh.x;
+	var y=md.mesh.y;
+	var elements=md.mesh.elements;
 
 	//Assign elementonfloatingice, elementongroundedice, vertexongroundedice and vertexonfloatingice. 
Index: /issm/trunk-jpl/src/m/solve/solve.js
===================================================================
--- /issm/trunk-jpl/src/m/solve/solve.js	(revision 19780)
+++ /issm/trunk-jpl/src/m/solve/solve.js	(revision 19780)
@@ -0,0 +1,173 @@
+function solve(md,solutionenum){
+//SOLVE - apply solution sequence for this model
+//
+//   Usage:
+//      solve(md,solutionenum,varargin)
+//      where varargin is a lit of paired arguments of string OR enums
+//
+//   solution types available comprise:
+//		 - StressbalanceSolutionEnum
+//		 - MasstransportSolutionEnum
+//		 - ThermalSolutionEnum
+//		 - SteadystateSolutionEnum
+//		 - TransientSolutionEnum
+//		 - BalancethicknessSolutionEnum
+//		 - BedSlopeSolutionEnum
+//		 - SurfaceSlopeSolutionEnum
+//		 - HydrologySolutionEnum
+//		 - FlaimSolutionEnum
+//
+//  extra options:
+//      - loadonly    : does not solve. only load results
+//      - runtimename : true or false (default is true), makes name unique
+//      - checkconsistency : 'yes' or 'no' (default is 'yes'), ensures checks on consistency of model
+//      - restart: 'directory name (relative to the execution directory) where the restart file is located.
+//
+//   Examples:
+//      md=solve(md,StressbalanceSolutionEnum);
+
+	solutionstring=EnumToString(solutionenum);
+	
+	//recover and process solve options
+	if (solutionstring.slice(-8) !== 'Solution'){
+		throw Error(sprintf("%s%s%s\n",'solutionenum ',solutionstring,' not supported!'));
+	}
+	
+	//Process options
+	var args = Array.prototype.slice.call(arguments);
+	var options = new pairoptions(args.slice(2,args.length));
+	options.addfield('solutionenum',solutionenum);
+
+	//recover some fields
+	md.private.solution=solutionenum;
+	cluster=md.cluster;
+
+	//check model consistency
+	if (options.getfieldvalue('checkconsistency','yes') == 'yes'){
+		if (md.verbose.solution){
+			console.log('checking model consistency');
+		}
+		if (solutionenum == FlaimSolutionEnum()){
+			md.private.isconsistent=true;
+			md.mesh.checkconsistency(md,solutionenum);
+			md.flaim.checkconsistency(md,solutionenum);
+			if (md.private.isconsistent==false){
+				throw error('solve error message: model not consistent, see messages above');
+			}
+		}
+		else{
+			ismodelselfconsistent(md);
+		}
+	}
+
+	//If we are restarting, actually use the provided runtime name:
+	restart=options.getfieldvalue('restart','');
+	//First, build a runtime name that is unique
+	if (restart==1 ){
+		//Leave the runtimename as is
+		}
+	else{
+		if (!(restart == '')){
+			md.private.runtimename=restart;
+		}
+		else if (options.getfieldvalue('runtimename',true)){
+			c=new Date().getTime();
+			md.private.runtimename=sprintf('%s-%g',md.miscellaneous.name,c);
+		}
+		else{
+			md.private.runtimename=md.miscellaneous.name;
+		}
+	}
+
+	//if running qmu analysis, some preprocessing of dakota files using models
+	//fields needs to be carried out. 
+	if (md.qmu.isdakota){
+		throw Error("solve error message: qmu runs not supported yet!");
+		//md.preqmu(options);
+	}
+
+	//flaim analysis (To be removed?)
+	if (solutionenum == FlaimSolutionEnum()){
+		//fmdir     = options.getfieldvalue('fmdir',['fm' num2str(feature('GetPid'))]);
+		//overwrite = options.getfieldvalue('overwrite','n');
+		//keep      = options.getfieldvalue('keep','y');
+		//latsgn    = options.getfieldvalue('latsgn',0);
+		//cmap      = options.getfieldvalue('cmap',[]);
+		throw  Error("solve error message: flaim runs not supported yet!");
+		//flaim_sol(md,options);
+		//md.private.solution=EnumToString(solutionenum);
+		//return;
+	}
+
+	//Do we load results only?
+	if (options.getfieldvalue('loadonly',false)){
+		loadresultsfromcluster(md);
+		return;
+	}
+
+	//Write all input files
+	marshall(md);                                          // bin file
+	ToolkitsFile(md.toolkits,md.miscellaneous.name + '.toolkits'); // toolkits file
+	cluster.BuildQueueScript(md.private.runtimename,md.miscellaneous.name,md.private.solution,md.settings.io_gather,md.debug.valgrind,md.debug.gprof,md.qmu.isdakota); // queue file
+
+	//Stop here if batch mode
+	if (options.getfieldvalue('batch','no') === 'yes'){
+		if (md.verbose.solution){
+			console.log('batch mode requested: not launching job interactively');
+			console.log('launch solution sequence on remote cluster by hand');
+		}
+		return;
+	}
+
+	//Upload all required files
+	modelname = md.miscellaneous.name;
+	filelist  = [modelname + '.bin ',modelname + '.toolkits '];
+	if (ispc){
+		filelist.push(modelname + '.bat ');
+	}
+	else{
+		filelist.push(modelname + '.queue ');
+	}
+
+	if (md.qmu.isdakota){
+		filelist.push(modelname + '.qmu.in');
+	}
+
+	if (restart == ''){
+		cluster.UploadQueueJob(md.miscellaneous.name,md.private.runtimename,filelist);
+	}
+
+	//launch queue job: 
+	cluster.LaunchQueueJob(md.miscellaneous.name,md.private.runtimename,filelist,restart);
+
+	//wait on lock
+	if (md.settings.waitonlock == 'NaN'){
+		//load when user enters 'y'
+		console.log('solution launched on remote cluster. log in to detect job completion.');
+		throw Error("solve error message: user detection of successfull completion of job not support yet!");
+		/*choice=input('Is the job successfully completed? (y/n)','s');
+		if ~strcmp(choice,'y'), 
+			console.log('Results not loaded... exiting'); 
+		else
+			md=loadresultsfromcluster(md);
+		end*/
+	}
+	else if (md.settings.waitonlock>0){
+		//we wait for the done file
+		done=waitonlock(md);
+		if (md.verbose.solution){
+			console.log('loading results from cluster');
+		}
+		loadresultsfromcluster(md);
+	}
+	else if (md.settings.waitonlock==0){
+		 console.log('Model results must be loaded manually with md=loadresultsfromcluster(md);');
+	}
+
+	//post processes qmu results if necessary
+	if (md.qmu.isdakota){
+		/*if ~strncmpi(options.getfieldvalue('keep','y'),'y',1)
+			system(['rm -rf qmu' num2str(feature('GetPid'))]);
+		end*/
+	}
+}