Index: /issm/trunk-jpl/src/c/analyses/AdjointBalancethicknessAnalysis.cpp
===================================================================
--- /issm/trunk-jpl/src/c/analyses/AdjointBalancethicknessAnalysis.cpp	(revision 17584)
+++ /issm/trunk-jpl/src/c/analyses/AdjointBalancethicknessAnalysis.cpp	(revision 17585)
@@ -59,5 +59,5 @@
 			break;
 		case Mesh3DEnum:
-			if(!element->IsOnBed()) return NULL;
+			if(!element->IsOnBase()) return NULL;
 			basalelement = element->SpawnBasalElement();
 			break;
Index: /issm/trunk-jpl/src/c/analyses/AdjointHorizAnalysis.cpp
===================================================================
--- /issm/trunk-jpl/src/c/analyses/AdjointHorizAnalysis.cpp	(revision 17584)
+++ /issm/trunk-jpl/src/c/analyses/AdjointHorizAnalysis.cpp	(revision 17585)
@@ -65,5 +65,5 @@
 			break;
 		case Mesh3DEnum:
-			if(!element->IsOnBed()) return NULL;
+			if(!element->IsOnBase()) return NULL;
 			basalelement = element->SpawnBasalElement();
 			break;
@@ -694,5 +694,5 @@
 			break;
 		case Mesh3DEnum:
-			if(!element->IsOnBed()) return NULL;
+			if(!element->IsOnBase()) return NULL;
 			basalelement = element->SpawnBasalElement();
 			break;
Index: /issm/trunk-jpl/src/c/analyses/BalancethicknessAnalysis.cpp
===================================================================
--- /issm/trunk-jpl/src/c/analyses/BalancethicknessAnalysis.cpp	(revision 17584)
+++ /issm/trunk-jpl/src/c/analyses/BalancethicknessAnalysis.cpp	(revision 17585)
@@ -126,5 +126,5 @@
 ElementMatrix* BalancethicknessAnalysis::CreateKMatrix(Element* element){/*{{{*/
 
-	if(!element->IsOnBed()) return NULL;
+	if(!element->IsOnBase()) return NULL;
 	Element* basalelement = element->SpawnBasalElement();
 
@@ -318,5 +318,5 @@
 ElementVector* BalancethicknessAnalysis::CreatePVector(Element* element){/*{{{*/
 
-	if(!element->IsOnBed()) return NULL;
+	if(!element->IsOnBase()) return NULL;
 	Element* basalelement = element->SpawnBasalElement();
 
Index: /issm/trunk-jpl/src/c/analyses/BalancevelocityAnalysis.cpp
===================================================================
--- /issm/trunk-jpl/src/c/analyses/BalancevelocityAnalysis.cpp	(revision 17584)
+++ /issm/trunk-jpl/src/c/analyses/BalancevelocityAnalysis.cpp	(revision 17585)
@@ -158,5 +158,5 @@
 			break;
 		case Mesh3DEnum:
-			if(!element->IsOnBed()) return NULL;
+			if(!element->IsOnBase()) return NULL;
 			basalelement = element->SpawnBasalElement();
 			break;
Index: /issm/trunk-jpl/src/c/analyses/DamageEvolutionAnalysis.cpp
===================================================================
--- /issm/trunk-jpl/src/c/analyses/DamageEvolutionAnalysis.cpp	(revision 17584)
+++ /issm/trunk-jpl/src/c/analyses/DamageEvolutionAnalysis.cpp	(revision 17585)
@@ -123,5 +123,5 @@
 			break;
 		case Mesh3DEnum:
-			if(!element->IsOnBed()) return NULL;
+			if(!element->IsOnBase()) return NULL;
 			basalelement = element->SpawnBasalElement();
 			dim = 2;
@@ -271,5 +271,5 @@
 			break;
 		case Mesh3DEnum:
-			if(!element->IsOnBed()) return NULL;
+			if(!element->IsOnBase()) return NULL;
 			basalelement = element->SpawnBasalElement();
 			break;
@@ -384,5 +384,5 @@
 	element->FindParam(&meshtype,MeshTypeEnum);
 	if(meshtype!=Mesh2DhorizontalEnum){
-		if(!element->IsOnBed()) return;
+		if(!element->IsOnBase()) return;
 		basalelement=element->SpawnBasalElement();
 	}
Index: /issm/trunk-jpl/src/c/analyses/EnthalpyAnalysis.cpp
===================================================================
--- /issm/trunk-jpl/src/c/analyses/EnthalpyAnalysis.cpp	(revision 17584)
+++ /issm/trunk-jpl/src/c/analyses/EnthalpyAnalysis.cpp	(revision 17585)
@@ -354,5 +354,5 @@
 
 	/*Initialize Element matrix and return if necessary*/
-	if(!element->IsOnBed() || !element->IsFloating()) return NULL;
+	if(!element->IsOnBase() || !element->IsFloating()) return NULL;
 
 	/*Intermediaries*/
@@ -539,5 +539,5 @@
 
 	/* implementation of the basal condition decision chart of Aschwanden 2012, Fig.5 */
-	if(!element->IsOnBed() || element->IsFloating()) return NULL;
+	if(!element->IsOnBase() || element->IsFloating()) return NULL;
 
 	IssmDouble  dt,Jdet,enthalpy,pressure,watercolumn,geothermalflux,vx,vy,vz;
@@ -629,5 +629,5 @@
 
 	/*Get basal element*/
-	if(!element->IsOnBed() || !element->IsFloating()) return NULL;
+	if(!element->IsOnBase() || !element->IsFloating()) return NULL;
 
 	IssmDouble  h_pmp,dt,Jdet,scalar_ocean,pressure;
@@ -902,5 +902,5 @@
 
 	/* Only compute melt rates at the base of grounded ice*/
-	if(!element->IsOnBed() || element->IsFloating()) return;
+	if(!element->IsOnBase() || element->IsFloating()) return;
 
 	/* Intermediaries */
@@ -1048,5 +1048,5 @@
 
 	/* Only drain waterfraction of ice column from element at base*/
-	if(!element->IsOnBed()) return; //FIXME: allow freeze on for floating elements
+	if(!element->IsOnBase()) return; //FIXME: allow freeze on for floating elements
 
 	/* Intermediaries*/
@@ -1150,5 +1150,5 @@
 
 	/* Only update Constraints at the base of grounded ice*/
-	if(!(element->IsOnBed()) || element->IsFloating()) return;
+	if(!(element->IsOnBase()) || element->IsFloating()) return;
 
 	/*Intermediary*/
Index: /issm/trunk-jpl/src/c/analyses/ExtrapolationAnalysis.cpp
===================================================================
--- /issm/trunk-jpl/src/c/analyses/ExtrapolationAnalysis.cpp	(revision 17584)
+++ /issm/trunk-jpl/src/c/analyses/ExtrapolationAnalysis.cpp	(revision 17585)
@@ -84,5 +84,5 @@
 ElementMatrix* ExtrapolationAnalysis::CreateKMatrix(Element* element){/*{{{*/
 
-	if(!element->IsOnBed()) return NULL;
+	if(!element->IsOnBase()) return NULL;
 	Element* basalelement = element->SpawnBasalElement();
 
@@ -219,5 +219,5 @@
 ElementVector* ExtrapolationAnalysis::CreatePVector(Element* element){/*{{{*/
 
-	if(!element->IsOnBed()) return NULL;
+	if(!element->IsOnBase()) return NULL;
 	Element* basalelement = element->SpawnBasalElement();
 
Index: /issm/trunk-jpl/src/c/analyses/ExtrudeFromBaseAnalysis.cpp
===================================================================
--- /issm/trunk-jpl/src/c/analyses/ExtrudeFromBaseAnalysis.cpp	(revision 17584)
+++ /issm/trunk-jpl/src/c/analyses/ExtrudeFromBaseAnalysis.cpp	(revision 17585)
@@ -163,5 +163,5 @@
 ElementMatrix* ExtrudeFromBaseAnalysis::CreateKMatrixBed(Element* element){/*{{{*/
 
-	if(!element->IsOnBed()) return NULL;
+	if(!element->IsOnBase()) return NULL;
 
 	/*Intermediaries */
Index: /issm/trunk-jpl/src/c/analyses/ExtrudeFromTopAnalysis.cpp
===================================================================
--- /issm/trunk-jpl/src/c/analyses/ExtrudeFromTopAnalysis.cpp	(revision 17584)
+++ /issm/trunk-jpl/src/c/analyses/ExtrudeFromTopAnalysis.cpp	(revision 17585)
@@ -163,5 +163,5 @@
 ElementMatrix* ExtrudeFromTopAnalysis::CreateKMatrixBed(Element* element){/*{{{*/
 
-	if(!element->IsOnBed()) return NULL;
+	if(!element->IsOnBase()) return NULL;
 
 	/*Intermediaries */
Index: /issm/trunk-jpl/src/c/analyses/FreeSurfaceBaseAnalysis.cpp
===================================================================
--- /issm/trunk-jpl/src/c/analyses/FreeSurfaceBaseAnalysis.cpp	(revision 17584)
+++ /issm/trunk-jpl/src/c/analyses/FreeSurfaceBaseAnalysis.cpp	(revision 17585)
@@ -119,10 +119,10 @@
 			break;
 		case Mesh2DverticalEnum:
-			if(!element->IsOnBed()) return NULL;
+			if(!element->IsOnBase()) return NULL;
 			basalelement = element->SpawnBasalElement();
 			dim = 1;
 			break;
 		case Mesh3DEnum:
-			if(!element->IsOnBed()) return NULL;
+			if(!element->IsOnBase()) return NULL;
 			basalelement = element->SpawnBasalElement();
 			dim = 2;
@@ -242,10 +242,10 @@
 			break;
 		case Mesh2DverticalEnum:
-			if(!element->IsOnBed()) return NULL;
+			if(!element->IsOnBase()) return NULL;
 			basalelement = element->SpawnBasalElement();
 			dim = 1;
 			break;
 		case Mesh3DEnum:
-			if(!element->IsOnBed()) return NULL;
+			if(!element->IsOnBase()) return NULL;
 			basalelement = element->SpawnBasalElement();
 			dim = 2;
@@ -373,5 +373,5 @@
 
 		Element* element=dynamic_cast<Element*>(femmodel->elements->GetObjectByOffset(i));
-		if(!element->IsOnBed()) continue;
+		if(!element->IsOnBase()) continue;
 
 		int             numnodes = element->GetNumberOfNodes();
Index: /issm/trunk-jpl/src/c/analyses/HydrologyDCEfficientAnalysis.cpp
===================================================================
--- /issm/trunk-jpl/src/c/analyses/HydrologyDCEfficientAnalysis.cpp	(revision 17584)
+++ /issm/trunk-jpl/src/c/analyses/HydrologyDCEfficientAnalysis.cpp	(revision 17585)
@@ -121,5 +121,5 @@
 			break;
 		case Mesh3DEnum:
-			if(!element->IsOnBed()) return NULL;
+			if(!element->IsOnBase()) return NULL;
 			basalelement = element->SpawnBasalElement();
 			break;
@@ -225,5 +225,5 @@
 			break;
 		case Mesh3DEnum:
-			if(!element->IsOnBed()) return NULL;
+			if(!element->IsOnBase()) return NULL;
 			basalelement = element->SpawnBasalElement();
 			break;
@@ -323,5 +323,5 @@
 
 	if(meshtype!=Mesh2DhorizontalEnum){
-		if(!element->IsOnBed()) return;
+		if(!element->IsOnBase()) return;
 		basalelement=element->SpawnBasalElement();
 	}
@@ -494,5 +494,5 @@
 		switch(meshtype){
 		case Mesh2DhorizontalEnum:
-			if(!element->IsOnBed()) return;			
+			if(!element->IsOnBase()) return;			
 			B = element->GetMaterialParameter(MaterialsRheologyBbarEnum);
 			break;
@@ -614,5 +614,5 @@
 			break;
 		case Mesh3DEnum:
-			if(!element->IsOnBed()) return;
+			if(!element->IsOnBase()) return;
 			basalelement = element->SpawnBasalElement();
 			break;
@@ -694,5 +694,5 @@
 			break;
 		case Mesh3DEnum:
-			if(!element->IsOnBed()) return;
+			if(!element->IsOnBase()) return;
 			basalelement = element->SpawnBasalElement();
 			break;
Index: /issm/trunk-jpl/src/c/analyses/HydrologyDCInefficientAnalysis.cpp
===================================================================
--- /issm/trunk-jpl/src/c/analyses/HydrologyDCInefficientAnalysis.cpp	(revision 17584)
+++ /issm/trunk-jpl/src/c/analyses/HydrologyDCInefficientAnalysis.cpp	(revision 17585)
@@ -165,5 +165,5 @@
 			break;
 		case Mesh3DEnum:
-			if(!element->IsOnBed()) return NULL;
+			if(!element->IsOnBase()) return NULL;
 			basalelement = element->SpawnBasalElement();
 			break;
@@ -270,5 +270,5 @@
 			break;
 		case Mesh3DEnum:
-			if(!element->IsOnBed()) return NULL;
+			if(!element->IsOnBase()) return NULL;
 			basalelement = element->SpawnBasalElement();
 			break;
@@ -399,5 +399,5 @@
 	element->FindParam(&meshtype,MeshTypeEnum);
 	if(meshtype!=Mesh2DhorizontalEnum){
-		if(!element->IsOnBed()) return;
+		if(!element->IsOnBase()) return;
 		basalelement=element->SpawnBasalElement();
 	}
Index: /issm/trunk-jpl/src/c/analyses/L2ProjectionBaseAnalysis.cpp
===================================================================
--- /issm/trunk-jpl/src/c/analyses/L2ProjectionBaseAnalysis.cpp	(revision 17584)
+++ /issm/trunk-jpl/src/c/analyses/L2ProjectionBaseAnalysis.cpp	(revision 17585)
@@ -78,13 +78,13 @@
 			break;
 		case Mesh2DverticalEnum:
-			if(!element->IsOnBed()) return NULL;
+			if(!element->IsOnBase()) return NULL;
 			basalelement = element->SpawnBasalElement();
 			break;
 		case Mesh3DEnum:
-			if(!element->IsOnBed()) return NULL;
+			if(!element->IsOnBase()) return NULL;
 			basalelement = element->SpawnBasalElement();
 			break;
 		case Mesh3DtetrasEnum:
-			if(!element->IsOnBed()) return NULL;
+			if(!element->IsOnBase()) return NULL;
 			basalelement = element->SpawnBasalElement();
 			break;
@@ -141,13 +141,13 @@
 			break;
 		case Mesh2DverticalEnum:
-			if(!element->IsOnBed()) return NULL;
+			if(!element->IsOnBase()) return NULL;
 			basalelement = element->SpawnBasalElement();
 			break;
 		case Mesh3DEnum:
-			if(!element->IsOnBed()) return NULL;
+			if(!element->IsOnBase()) return NULL;
 			basalelement = element->SpawnBasalElement();
 			break;
 		case Mesh3DtetrasEnum:
-			if(!element->IsOnBed()) return NULL;
+			if(!element->IsOnBase()) return NULL;
 			basalelement = element->SpawnBasalElement();
 			break;
Index: /issm/trunk-jpl/src/c/analyses/L2ProjectionEPLAnalysis.cpp
===================================================================
--- /issm/trunk-jpl/src/c/analyses/L2ProjectionEPLAnalysis.cpp	(revision 17584)
+++ /issm/trunk-jpl/src/c/analyses/L2ProjectionEPLAnalysis.cpp	(revision 17585)
@@ -94,9 +94,9 @@
 			break;
 		case Mesh2DverticalEnum:
-			if(!element->IsOnBed()) return NULL;
+			if(!element->IsOnBase()) return NULL;
 			basalelement = element->SpawnBasalElement();
 			break;
 		case Mesh3DEnum:
-			if(!element->IsOnBed()) return NULL;
+			if(!element->IsOnBase()) return NULL;
 			basalelement = element->SpawnBasalElement();
 			break;
@@ -166,5 +166,5 @@
 			break;
 		case Mesh3DEnum:
-			if(!element->IsOnBed()) return NULL;
+			if(!element->IsOnBase()) return NULL;
 			basalelement = element->SpawnBasalElement();
 			break;
Index: /issm/trunk-jpl/src/c/analyses/LevelsetAnalysis.cpp
===================================================================
--- /issm/trunk-jpl/src/c/analyses/LevelsetAnalysis.cpp	(revision 17584)
+++ /issm/trunk-jpl/src/c/analyses/LevelsetAnalysis.cpp	(revision 17585)
@@ -84,5 +84,5 @@
 ElementMatrix* LevelsetAnalysis::CreateKMatrix(Element* element){/*{{{*/
 
-	if(!element->IsOnBed()) return NULL;
+	if(!element->IsOnBase()) return NULL;
 	Element* basalelement = element->SpawnBasalElement();
 
@@ -253,5 +253,5 @@
 ElementVector* LevelsetAnalysis::CreatePVector(Element* element){/*{{{*/
 	
-	if(!element->IsOnBed()) return NULL;
+	if(!element->IsOnBase()) return NULL;
 	Element* basalelement = element->SpawnBasalElement();
 
Index: /issm/trunk-jpl/src/c/analyses/MasstransportAnalysis.cpp
===================================================================
--- /issm/trunk-jpl/src/c/analyses/MasstransportAnalysis.cpp	(revision 17584)
+++ /issm/trunk-jpl/src/c/analyses/MasstransportAnalysis.cpp	(revision 17585)
@@ -244,5 +244,5 @@
 	if(!element->IsIceInElement()) return NULL;
 
-	if(!element->IsOnBed()) return NULL;
+	if(!element->IsOnBase()) return NULL;
 	Element* basalelement = element->SpawnBasalElement();
 
@@ -490,5 +490,5 @@
 	if(!element->IsIceInElement()) return NULL;
 
-	if(!element->IsOnBed()) return NULL;
+	if(!element->IsOnBase()) return NULL;
 	Element* basalelement = element->SpawnBasalElement();
 
@@ -677,5 +677,5 @@
 	element->FindParam(&meshtype,MeshTypeEnum);
 	if(meshtype!=Mesh2DhorizontalEnum){
-		if(!element->IsOnBed()) return;
+		if(!element->IsOnBase()) return;
 		basalelement=element->SpawnBasalElement();
 	}
Index: /issm/trunk-jpl/src/c/analyses/MeltingAnalysis.cpp
===================================================================
--- /issm/trunk-jpl/src/c/analyses/MeltingAnalysis.cpp	(revision 17584)
+++ /issm/trunk-jpl/src/c/analyses/MeltingAnalysis.cpp	(revision 17585)
@@ -85,5 +85,5 @@
 
 	/*Get basal element*/
-	if(!element->IsOnBed()) return NULL;
+	if(!element->IsOnBase()) return NULL;
 	Element* basalelement = element->SpawnBasalElement();
 
Index: /issm/trunk-jpl/src/c/analyses/SmoothedSurfaceSlopeXAnalysis.cpp
===================================================================
--- /issm/trunk-jpl/src/c/analyses/SmoothedSurfaceSlopeXAnalysis.cpp	(revision 17584)
+++ /issm/trunk-jpl/src/c/analyses/SmoothedSurfaceSlopeXAnalysis.cpp	(revision 17585)
@@ -115,5 +115,5 @@
 			break;
 		case Mesh3DEnum:
-			if(!element->IsOnBed()) return NULL;
+			if(!element->IsOnBase()) return NULL;
 			basalelement = element->SpawnBasalElement();
 			break;
Index: /issm/trunk-jpl/src/c/analyses/SmoothedSurfaceSlopeYAnalysis.cpp
===================================================================
--- /issm/trunk-jpl/src/c/analyses/SmoothedSurfaceSlopeYAnalysis.cpp	(revision 17584)
+++ /issm/trunk-jpl/src/c/analyses/SmoothedSurfaceSlopeYAnalysis.cpp	(revision 17585)
@@ -115,5 +115,5 @@
 			break;
 		case Mesh3DEnum:
-			if(!element->IsOnBed()) return NULL;
+			if(!element->IsOnBase()) return NULL;
 			basalelement = element->SpawnBasalElement();
 			break;
Index: /issm/trunk-jpl/src/c/analyses/StressbalanceAnalysis.cpp
===================================================================
--- /issm/trunk-jpl/src/c/analyses/StressbalanceAnalysis.cpp	(revision 17584)
+++ /issm/trunk-jpl/src/c/analyses/StressbalanceAnalysis.cpp	(revision 17585)
@@ -1085,5 +1085,5 @@
 			break;
 		case Mesh3DEnum:
-			if(!element->IsOnBed()) return NULL;
+			if(!element->IsOnBase()) return NULL;
 			basalelement = element->SpawnBasalElement();
 			break;
@@ -1171,5 +1171,5 @@
 			break;
 		case Mesh3DEnum: case Mesh2DverticalEnum:
-			if(!element->IsOnBed()) return NULL;
+			if(!element->IsOnBase()) return NULL;
 			basalelement = element->SpawnBasalElement();
 			break;
@@ -1374,5 +1374,5 @@
 			break;
 		case Mesh3DEnum: case Mesh2DverticalEnum:
-			if(!element->IsOnBed()) return NULL;
+			if(!element->IsOnBase()) return NULL;
 			basalelement = element->SpawnBasalElement();
 			break;
@@ -1692,5 +1692,5 @@
 			break;
 		case Mesh3DEnum: case Mesh2DverticalEnum:
-			if(!element->IsOnBed()){xDelete<IssmDouble>(xyz_list); return;}
+			if(!element->IsOnBase()){xDelete<IssmDouble>(xyz_list); return;}
 			basalelement=element->SpawnBasalElement();
 			break;
@@ -1773,5 +1773,5 @@
 ElementMatrix* StressbalanceAnalysis::CreateKMatrixL1L2Friction(Element* element){/*{{{*/
 
-	if(!element->IsOnBed() || element->IsFloating()) return NULL;
+	if(!element->IsOnBase() || element->IsFloating()) return NULL;
 	Element* basalelement = element->SpawnBasalElement();
 	ElementMatrix* Ke = CreateKMatrixSSAFriction(basalelement);
@@ -1854,5 +1854,5 @@
 			break;
 		case Mesh3DEnum:
-			if(!element->IsOnBed()) return NULL;
+			if(!element->IsOnBase()) return NULL;
 			basalelement = element->SpawnBasalElement();
 			break;
@@ -2018,5 +2018,5 @@
 			break;
 		case Mesh3DEnum:
-			if(!element->IsOnBed()){xDelete<IssmDouble>(xyz_list); return;}
+			if(!element->IsOnBase()){xDelete<IssmDouble>(xyz_list); return;}
 			basalelement=element->SpawnBasalElement();
 			break;
@@ -2236,5 +2236,5 @@
 	if(!element->IsIceInElement()) return NULL;
 
-	if(element->IsFloating() || !element->IsOnBed()) return NULL;
+	if(element->IsFloating() || !element->IsOnBase()) return NULL;
 
 	/*Intermediaries*/
@@ -3041,5 +3041,5 @@
 ElementMatrix* StressbalanceAnalysis::CreateKMatrixFSFriction(Element* element){/*{{{*/
 
-	if(element->IsFloating() || !element->IsOnBed()) return NULL;
+	if(element->IsFloating() || !element->IsOnBase()) return NULL;
 
 	/*If on water or not FS, skip stiffness: */
@@ -3134,5 +3134,5 @@
 ElementMatrix* StressbalanceAnalysis::CreateKMatrixFSShelf(Element* element){/*{{{*/
 
-	if(!element->IsFloating() || !element->IsOnBed()) return NULL;
+	if(!element->IsFloating() || !element->IsOnBase()) return NULL;
 
 	/*If on not water or not FS, skip stiffness: */
@@ -3565,5 +3565,5 @@
 
 	/*Get basal element*/
-	if(!element->IsOnBed() || !element->IsFloating()) return NULL;
+	if(!element->IsOnBase() || !element->IsFloating()) return NULL;
 
 	/*Get problem dimension*/
@@ -4509,5 +4509,5 @@
 
 	/*Initialize Element matrix and return if necessary*/
-	if(element->IsFloating() || !element->IsOnBed()) return NULL;
+	if(element->IsFloating() || !element->IsOnBase()) return NULL;
 
 	/*Build a tria element using the 3 nodes of the base of the penta. Then use 
@@ -4733,5 +4733,5 @@
 ElementMatrix* StressbalanceAnalysis::CreateKMatrixCouplingSSAHOFriction(Element* element){/*{{{*/
 
-	if(element->IsFloating() || !element->IsOnBed()) return NULL;
+	if(element->IsFloating() || !element->IsOnBase()) return NULL;
 
 	/*Constants*/
@@ -4939,5 +4939,5 @@
 	/*If on water or not FS, skip stiffness: */
 	element->GetInputValue(&approximation,ApproximationEnum);
-	if(element->IsFloating() || !element->IsOnBed()) return NULL;
+	if(element->IsFloating() || !element->IsOnBase()) return NULL;
 
 	int vnumnodes = element->NumberofNodesVelocity();
@@ -5224,5 +5224,5 @@
 
 	/*Initialize Element vector and return if necessary*/
-	if(!element->IsOnBed() || element->IsFloating()) return NULL;
+	if(!element->IsOnBase() || element->IsFloating()) return NULL;
 	element->GetInputValue(&approximation,ApproximationEnum);
 	if(approximation!=HOFSApproximationEnum) return NULL;
@@ -5388,5 +5388,5 @@
 
 	/*Initialize Element vector and return if necessary*/
-	if(!element->IsOnBed() || element->IsFloating()) return NULL;
+	if(!element->IsOnBase() || element->IsFloating()) return NULL;
 	element->GetInputValue(&approximation,ApproximationEnum);
 	if(approximation!=SSAFSApproximationEnum) return NULL;
Index: /issm/trunk-jpl/src/c/analyses/StressbalanceSIAAnalysis.cpp
===================================================================
--- /issm/trunk-jpl/src/c/analyses/StressbalanceSIAAnalysis.cpp	(revision 17584)
+++ /issm/trunk-jpl/src/c/analyses/StressbalanceSIAAnalysis.cpp	(revision 17585)
@@ -227,5 +227,5 @@
 
 		/*Create matrix for these two nodes*/
-		if(element->IsOnBed() && element->IsOnSurface()){
+		if(element->IsOnBase() && element->IsOnSurface()){
 			Ke->values[i0*numdof+i0] = +one0;
 			Ke->values[i1*numdof+i1] = +one0;
@@ -235,5 +235,5 @@
 			Ke->values[j1*numdof+j1] = +one1;
 		}
-		else if(element->IsOnBed()){
+		else if(element->IsOnBase()){
 			Ke->values[i0*numdof+i0] = one0;
 			Ke->values[i1*numdof+i1] = one0;
@@ -419,5 +419,5 @@
 
 		/*Deal with basal velocities*/
-		if(element->IsOnBed()){
+		if(element->IsOnBase()){
 			drag_input->GetInputValue(&drag,gauss);
 
Index: /issm/trunk-jpl/src/c/analyses/StressbalanceVerticalAnalysis.cpp
===================================================================
--- /issm/trunk-jpl/src/c/analyses/StressbalanceVerticalAnalysis.cpp	(revision 17584)
+++ /issm/trunk-jpl/src/c/analyses/StressbalanceVerticalAnalysis.cpp	(revision 17585)
@@ -278,5 +278,5 @@
 	IssmDouble  vx,vy,vz=0.,dbdx,dbdy,basalmeltingvalue;
 
-	if(!element->IsOnBed()) return NULL;
+	if(!element->IsOnBase()) return NULL;
 
 	/*Fetch number of nodes for this finite element*/
Index: /issm/trunk-jpl/src/c/analyses/ThermalAnalysis.cpp
===================================================================
--- /issm/trunk-jpl/src/c/analyses/ThermalAnalysis.cpp	(revision 17584)
+++ /issm/trunk-jpl/src/c/analyses/ThermalAnalysis.cpp	(revision 17585)
@@ -281,5 +281,5 @@
 
 	/*Initialize Element matrix and return if necessary*/
-	if(!element->IsOnBed() || !element->IsFloating()) return NULL;
+	if(!element->IsOnBase() || !element->IsFloating()) return NULL;
 
 	IssmDouble  dt,Jdet,D;
@@ -287,5 +287,5 @@
 
 	/*Get basal element*/
-	if(!element->IsOnBed() || !element->IsFloating()) return NULL;
+	if(!element->IsOnBase() || !element->IsFloating()) return NULL;
 
 	/*Fetch number of nodes for this finite element*/
@@ -434,5 +434,5 @@
 
 	/* Geothermal flux on ice sheet base and basal friction */
-	if(!element->IsOnBed() || element->IsFloating()) return NULL;
+	if(!element->IsOnBase() || element->IsFloating()) return NULL;
 
 	IssmDouble  dt,Jdet,geothermalflux,vx,vy,vz;
@@ -499,5 +499,5 @@
 
 	/*Get basal element*/
-	if(!element->IsOnBed() || !element->IsFloating()) return NULL;
+	if(!element->IsOnBase() || !element->IsFloating()) return NULL;
 
 	/*Fetch number of nodes for this finite element*/
Index: /issm/trunk-jpl/src/c/classes/Elements/Element.cpp
===================================================================
--- /issm/trunk-jpl/src/c/classes/Elements/Element.cpp	(revision 17584)
+++ /issm/trunk-jpl/src/c/classes/Elements/Element.cpp	(revision 17585)
@@ -549,5 +549,5 @@
 }
 /*}}}*/
-bool Element::HasNodeOnBed(){/*{{{*/
+bool Element::HasNodeOnBase(){/*{{{*/
 	return (this->inputs->Max(MeshVertexonbedEnum)>0.);
 }/*}}}*/
Index: /issm/trunk-jpl/src/c/classes/Elements/Element.h
===================================================================
--- /issm/trunk-jpl/src/c/classes/Elements/Element.h	(revision 17584)
+++ /issm/trunk-jpl/src/c/classes/Elements/Element.h	(revision 17585)
@@ -89,5 +89,5 @@
 		void       GetVerticesSidList(int* sidlist);
 		void       GetVerticesConnectivityList(int* connectivitylist);
-		bool       HasNodeOnBed();
+		bool       HasNodeOnBase();
 		bool       HasNodeOnSurface();
 		int        Id();
@@ -183,5 +183,5 @@
 
 		virtual bool   IsNodeOnShelfFromFlags(IssmDouble* flags)=0; 
-		virtual bool   IsOnBed()=0;
+		virtual bool   IsOnBase()=0;
 		virtual bool   IsOnSurface()=0;
 		virtual void   GetGroundedPart(int* point1,IssmDouble* fraction1,IssmDouble* fraction2, bool* mainlyfloating)=0;
Index: /issm/trunk-jpl/src/c/classes/Elements/Penta.cpp
===================================================================
--- /issm/trunk-jpl/src/c/classes/Elements/Penta.cpp	(revision 17584)
+++ /issm/trunk-jpl/src/c/classes/Elements/Penta.cpp	(revision 17585)
@@ -119,5 +119,5 @@
 
 	_assert_(this->inputs);
-	if(!IsOnBed()) return;
+	if(!IsOnBase()) return;
 	else{
 		if(interpolation_enum==P1Enum){
@@ -152,5 +152,5 @@
 
 	/* Basal friction can only be found at the base of an ice sheet: */
-	if (!IsOnBed() || IsFloating()){
+	if (!IsOnBase() || IsFloating()){
 		//empty friction: 
 		this->inputs->AddInput(new PentaInput(BasalFrictionEnum,&basalfriction[0],P1Enum));
@@ -219,5 +219,5 @@
 	this->parameters->FindParam(&FSreconditioning,StressbalanceFSreconditioningEnum);
 
-	if(!IsOnBed()){
+	if(!IsOnBase()){
 		//put zero
 		sigma_b->SetValue(id-1,0.0,INS_VAL);
@@ -374,5 +374,5 @@
 void  Penta::Delta18oParameterization(void){
         /*Are we on the base? If not, return*/
-        if(!IsOnBed()) return;
+        if(!IsOnBase()) return;
 
 	int        i;
@@ -544,5 +544,5 @@
 	for(;;){
 		/*Stop if we have reached the surface, else, take lower penta*/
-		if (penta->IsOnBed()) break;
+		if (penta->IsOnBase()) break;
 
 		/* get lower Penta*/
@@ -1125,5 +1125,5 @@
 
 	/*Are we on the base? If not, return*/
-	if(!IsOnBed()) return;
+	if(!IsOnBase()) return;
 
 	/*OK, we are on bed. Initialize global inputs as 0*/
@@ -1225,5 +1225,5 @@
 
 	/*Are we on the base, not on the surface?:*/
-	if(!IsOnBed()) return;
+	if(!IsOnBase()) return;
 
 	/*Step1: Get and Extrude original input: */
@@ -1415,5 +1415,5 @@
 
 	/*If not on bed, return*/
-	if (!IsOnBed()) return;
+	if (!IsOnBase()) return;
 
 	/*Get dof list: */
@@ -1504,6 +1504,6 @@
 }
 /*}}}*/
-/*FUNCTION Penta::IsOnBed{{{*/
-bool Penta::IsOnBed(void){
+/*FUNCTION Penta::IsOnBase{{{*/
+bool Penta::IsOnBase(void){
 
 	bool onbed;
@@ -1913,5 +1913,5 @@
 	/*For FS only: we want the CS to be tangential to the bedrock*/
 	inputs->GetInputValue(&approximation,ApproximationEnum);
-	if(!IsOnBed() || (approximation!=FSApproximationEnum && approximation!=SSAFSApproximationEnum &&  approximation!=HOFSApproximationEnum)) return;
+	if(!IsOnBase() || (approximation!=FSApproximationEnum && approximation!=SSAFSApproximationEnum &&  approximation!=HOFSApproximationEnum)) return;
 
 	/*Get number of nodes for velocity only and base*/
@@ -2022,5 +2022,5 @@
 Element*  Penta::SpawnBasalElement(void){
 
-	_assert_(this->IsOnBed());
+	_assert_(this->IsOnBase());
 
 	this->InputDepthAverageAtBase(MaterialsRheologyBEnum,MaterialsRheologyBbarEnum);
@@ -2109,5 +2109,5 @@
 	 * -> Non SSA not on the surface
 	 * -> SSA (2d model) and not on bed) */
-	if ((approximation!=SSAApproximationEnum && !IsOnSurface()) || (approximation==SSAApproximationEnum && !IsOnBed())){
+	if ((approximation!=SSAApproximationEnum && !IsOnSurface()) || (approximation==SSAApproximationEnum && !IsOnBase())){
 		return 0;
 	}
@@ -2490,5 +2490,5 @@
 void  Penta::UpdateConstraintsExtrudeFromBase(void){
 
-	if(!IsOnBed()) return;
+	if(!IsOnBase()) return;
 
 	int        extrusioninput;
@@ -2665,5 +2665,5 @@
 	IssmDouble xyz_list[NUMVERTICES][3];
 
-	if(!IsIceInElement() || IsFloating() || !IsOnBed())return 0;
+	if(!IsIceInElement() || IsFloating() || !IsOnBase())return 0;
 
 	rho_ice=matpar->GetRhoIce();
@@ -2733,5 +2733,5 @@
 	IssmDouble mass_flux=0;
 
-	if(!IsOnBed()) return mass_flux;
+	if(!IsOnBase()) return mass_flux;
 
 	/*Depth Averaging Vx and Vy*/
@@ -2757,5 +2757,5 @@
 	IssmDouble mass_flux=0;
 
-	if(!IsOnBed()) return mass_flux;
+	if(!IsOnBase()) return mass_flux;
 
 	/*Depth Averaging Vx and Vy*/
@@ -2923,9 +2923,9 @@
 
 	if(enum_type==MaterialsRheologyBbarEnum){
-		if(!IsOnBed()) return;
+		if(!IsOnBase()) return;
 		input=(Input*)inputs->GetInput(MaterialsRheologyBEnum);
 	}
 	else if(enum_type==DamageDbarEnum){
-		if(!IsOnBed()) return;
+		if(!IsOnBase()) return;
 		input=(Input*)inputs->GetInput(DamageDEnum);
 	}
@@ -3115,5 +3115,5 @@
 			break;
 		case DragCoefficientAbsGradientEnum:
-			if(IsOnBed()){
+			if(IsOnBase()){
 				tria=(Tria*)SpawnTria(0,1,2);
 				tria->GradjDragGradient(gradient,control_index);
@@ -3122,5 +3122,5 @@
 			break;
 		case RheologyBbarAbsGradientEnum:
-			if(IsOnBed()){
+			if(IsOnBase()){
 				tria=(Tria*)SpawnTria(0,1,2);
 				tria->GradjBGradient(gradient,control_index);
@@ -3138,5 +3138,5 @@
 
 	/*Gradient is 0 if on shelf or not on bed*/
-	if(IsFloating() || !IsOnBed()) return;
+	if(IsFloating() || !IsOnBase()) return;
 
 	/*Spawn tria*/
@@ -3164,5 +3164,5 @@
 
 	/*Gradient is 0 if on shelf or not on bed*/
-	if(IsFloating() || !IsOnBed()) return;
+	if(IsFloating() || !IsOnBase()) return;
 
 	/*Retrieve all inputs and parameters*/
@@ -3237,5 +3237,5 @@
 
 	/*Gradient is 0 if on shelf or not on bed*/
-	if(IsFloating() || !IsOnBed()) return;
+	if(IsFloating() || !IsOnBase()) return;
 
 	/*Retrieve all inputs and parameters*/
@@ -3313,5 +3313,5 @@
 
 	/*This element should be collapsed into a tria element at its base*/
-	if (!IsOnBed()) return; 
+	if (!IsOnBase()) return; 
 
 	/*Depth Average B*/
@@ -3333,5 +3333,5 @@
 
 	/*Gradient is computed on bed only (Bbar)*/
-	if (!IsOnBed()) return;
+	if (!IsOnBase()) return;
 
 	/*Depth Average B and D*/
@@ -3352,5 +3352,5 @@
 
 	/*Gradient is computed on bed only (Bbar)*/
-	if (!IsOnBed()) return;
+	if (!IsOnBase()) return;
 
 	/*Depth Average B and D*/
@@ -3382,9 +3382,9 @@
 
 		if(control_type[i]==MaterialsRheologyBbarEnum){
-			if (!IsOnBed()) goto cleanup_and_return;
+			if (!IsOnBase()) goto cleanup_and_return;
 			input=(Input*)this->inputs->GetInput(MaterialsRheologyBEnum); _assert_(input);
 		}
 		else if(control_type[i]==DamageDbarEnum){
-			if (!IsOnBed()) goto cleanup_and_return;
+			if (!IsOnBase()) goto cleanup_and_return;
 			input=(Input*)this->inputs->GetInput(DamageDEnum); _assert_(input);
 		}
@@ -3427,5 +3427,5 @@
 	 * -> Non SSA and not on the surface
 	 * -> SSA (2d model) and not on bed) */
-	if ((approximation!=SSAApproximationEnum && !IsOnSurface()) || (approximation==SSAApproximationEnum && !IsOnBed())){
+	if ((approximation!=SSAApproximationEnum && !IsOnSurface()) || (approximation==SSAApproximationEnum && !IsOnBase())){
 		return 0;
 	}
@@ -3464,5 +3464,5 @@
 	 * -> Non SSA and not on the surface
 	 * -> SSA (2d model) and not on bed) */
-	if ((approximation!=SSAApproximationEnum && !IsOnSurface()) || (approximation==SSAApproximationEnum && !IsOnBed())){
+	if ((approximation!=SSAApproximationEnum && !IsOnSurface()) || (approximation==SSAApproximationEnum && !IsOnBase())){
 		return 0;
 	}
@@ -3501,5 +3501,5 @@
 	 * -> Non SSA and not on the surface
 	 * -> SSA (2d model) and not on bed) */
-	if ((approximation!=SSAApproximationEnum && !IsOnSurface()) || (approximation==SSAApproximationEnum && !IsOnBed())){
+	if ((approximation!=SSAApproximationEnum && !IsOnSurface()) || (approximation==SSAApproximationEnum && !IsOnBase())){
 		return 0;
 	}
@@ -3540,5 +3540,5 @@
 	 * -> Non SSA and not on the surface
 	 * -> SSA (2d model) and not on bed) */
-	if ((approximation!=SSAApproximationEnum && !IsOnSurface()) || (approximation==SSAApproximationEnum && !IsOnBed())){
+	if ((approximation!=SSAApproximationEnum && !IsOnSurface()) || (approximation==SSAApproximationEnum && !IsOnBase())){
 		return 0;
 	}
@@ -3577,5 +3577,5 @@
 	 * -> Non SSA and not on the surface
 	 * -> SSA (2d model) and not on bed) */
-	if ((approximation!=SSAApproximationEnum && !IsOnSurface()) || (approximation==SSAApproximationEnum && !IsOnBed())){
+	if ((approximation!=SSAApproximationEnum && !IsOnSurface()) || (approximation==SSAApproximationEnum && !IsOnBase())){
 		return 0;
 	}
@@ -3631,5 +3631,5 @@
 
 	/*If on water, on shelf or not on bed, skip: */
-	if(!IsIceInElement()|| IsFloating() || !IsOnBed()) return 0;
+	if(!IsIceInElement()|| IsFloating() || !IsOnBase()) return 0;
 
 	tria=(Tria*)SpawnTria(0,1,2); //lower face is 0, upper face is 1
@@ -3646,5 +3646,5 @@
 
 	/*If on water, on shelf or not on bed, skip: */
-	if(!IsIceInElement() || !IsOnBed()) return 0;
+	if(!IsIceInElement() || !IsOnBase()) return 0;
 
 	tria=(Tria*)SpawnTria(0,1,2);
@@ -3891,5 +3891,5 @@
 	IssmDouble melting[NUMVERTICES],phi[NUMVERTICES];
 
-	if(!IsOnBed()) return;
+	if(!IsOnBase()) return;
 
 	/*Recover info at the vertices: */
Index: /issm/trunk-jpl/src/c/classes/Elements/Penta.h
===================================================================
--- /issm/trunk-jpl/src/c/classes/Elements/Penta.h	(revision 17584)
+++ /issm/trunk-jpl/src/c/classes/Elements/Penta.h	(revision 17585)
@@ -187,5 +187,5 @@
 		void           InputUpdateFromSolutionOneDofCollapsed(IssmDouble* solutiong,int enum_type);
 		bool	         IsOnSurface(void);
-		bool	         IsOnBed(void);
+		bool	         IsOnBase(void);
 		bool           IsNodeOnShelfFromFlags(IssmDouble* flags);
 		void           JacobianDeterminant(IssmDouble*  Jdet, IssmDouble* xyz_list,Gauss* gauss);
Index: /issm/trunk-jpl/src/c/classes/Elements/Seg.h
===================================================================
--- /issm/trunk-jpl/src/c/classes/Elements/Seg.h	(revision 17584)
+++ /issm/trunk-jpl/src/c/classes/Elements/Seg.h	(revision 17585)
@@ -72,5 +72,5 @@
 		void        GetVerticesCoordinatesBase(IssmDouble** pxyz_list){_error_("not implemented yet");};
 		void        GetVerticesCoordinatesTop(IssmDouble** pxyz_list){_error_("not implemented yet");};
-		bool        IsOnBed(){_error_("not implemented yet");};
+		bool        IsOnBase(){_error_("not implemented yet");};
 		bool        IsOnSurface(){_error_("not implemented yet");};
 		bool        IsNodeOnShelfFromFlags(IssmDouble* flags){_error_("not implemented yet");};
Index: /issm/trunk-jpl/src/c/classes/Elements/Tetra.cpp
===================================================================
--- /issm/trunk-jpl/src/c/classes/Elements/Tetra.cpp	(revision 17584)
+++ /issm/trunk-jpl/src/c/classes/Elements/Tetra.cpp	(revision 17585)
@@ -103,6 +103,6 @@
 }
 /*}}}*/
-/*FUNCTION Tetra::FaceOnBedIndices{{{*/
-void Tetra::FaceOnBedIndices(int* pindex1,int* pindex2,int* pindex3){
+/*FUNCTION Tetra::FaceOnBaseIndices{{{*/
+void Tetra::FaceOnBaseIndices(int* pindex1,int* pindex2,int* pindex3){
 
 	IssmDouble values[NUMVERTICES];
@@ -187,5 +187,5 @@
 	/*Allocate Output*/
 	IssmDouble* xyz_list_edge = xNew<IssmDouble>(3*3);
-	this->FaceOnBedIndices(&indices[0],&indices[1],&indices[2]);
+	this->FaceOnBaseIndices(&indices[0],&indices[1],&indices[2]);
 	for(int i=0;i<3;i++) for(int j=0;j<3;j++) xyz_list_edge[i*3+j]=xyz_list[indices[i]][j];
 
@@ -227,6 +227,6 @@
 }
 /*}}}*/
-/*FUNCTION Tetra::HasFaceOnBed{{{*/
-bool Tetra::HasFaceOnBed(){
+/*FUNCTION Tetra::HasFaceOnBase{{{*/
+bool Tetra::HasFaceOnBase(){
 
 	IssmDouble values[NUMVERTICES];
@@ -398,7 +398,7 @@
 }
 /*}}}*/
-/*FUNCTION Tetra::IsOnBed {{{*/
-bool Tetra::IsOnBed(){
-	return HasFaceOnBed();
+/*FUNCTION Tetra::IsOnBase {{{*/
+bool Tetra::IsOnBase(){
+	return HasFaceOnBase();
 }
 /*}}}*/
@@ -476,5 +476,5 @@
 
 	int indices[3];
-	this->FaceOnBedIndices(&indices[0],&indices[1],&indices[2]);
+	this->FaceOnBaseIndices(&indices[0],&indices[1],&indices[2]);
 	return new GaussTetra(indices[0],indices[1],indices[2],order);
 }
@@ -660,5 +660,5 @@
 	/*For FS only: we want the CS to be tangential to the bedrock*/
 	inputs->GetInputValue(&approximation,ApproximationEnum);
-	if(IsFloating() || !HasNodeOnBed() ||  approximation!=FSApproximationEnum) return;
+	if(IsFloating() || !HasNodeOnBase() ||  approximation!=FSApproximationEnum) return;
 
 	//printf("element number %i \n",this->id);
@@ -727,8 +727,8 @@
 Element*  Tetra::SpawnBasalElement(void){
 
-	_assert_(HasFaceOnBed());
+	_assert_(HasFaceOnBase());
 
 	int index1,index2,index3;
-	this->FaceOnBedIndices(&index1,&index2,&index3);
+	this->FaceOnBaseIndices(&index1,&index2,&index3);
 	return SpawnTria(index1,index2,index3);
 }/*}}}*/
Index: /issm/trunk-jpl/src/c/classes/Elements/Tetra.h
===================================================================
--- /issm/trunk-jpl/src/c/classes/Elements/Tetra.h	(revision 17584)
+++ /issm/trunk-jpl/src/c/classes/Elements/Tetra.h	(revision 17585)
@@ -61,5 +61,5 @@
 		void        ElementSizes(IssmDouble* hx,IssmDouble* hy,IssmDouble* hz){_error_("not implemented yet");};
 		void        FaceOnFrontIndices(int* pindex1,int* pindex2,int* pindex3);
-		void        FaceOnBedIndices(int* pindex1,int* pindex2,int* pindex3);
+		void        FaceOnBaseIndices(int* pindex1,int* pindex2,int* pindex3);
 		void        FaceOnSurfaceIndices(int* pindex1,int* pindex2,int* pindex3);
 		void        FSContactMigration(Vector<IssmDouble>* vertexgrounded,Vector<IssmDouble>* vertexfloating){_error_("not implemented yet");};
@@ -74,7 +74,7 @@
 		void        GetVerticesCoordinatesBase(IssmDouble** pxyz_list);
 		void        GetVerticesCoordinatesTop(IssmDouble** pxyz_list);
-		bool        HasFaceOnBed();
+		bool        HasFaceOnBase();
 		bool        HasFaceOnSurface();
-		bool        IsOnBed();
+		bool        IsOnBase();
 		bool        IsOnSurface();
 		bool        IsNodeOnShelfFromFlags(IssmDouble* flags){_error_("not implemented yet");};
Index: /issm/trunk-jpl/src/c/classes/Elements/Tria.cpp
===================================================================
--- /issm/trunk-jpl/src/c/classes/Elements/Tria.cpp	(revision 17584)
+++ /issm/trunk-jpl/src/c/classes/Elements/Tria.cpp	(revision 17585)
@@ -112,5 +112,5 @@
 				int        numindices;
 				int       *indices = NULL;
-				int        index = this->EdgeOnBedIndex();
+				int        index = this->EdgeOnBaseIndex();
 				NodeOnEdgeIndices(&numindices,&indices,index,this->FiniteElement());
 				for(int i=0;i<numindices;i++){
@@ -476,5 +476,5 @@
 
 	if(meshtype==Mesh2DverticalEnum){
-		this->EdgeOnBedIndices(&index1,&index2);
+		this->EdgeOnBaseIndices(&index1,&index2);
 		if(gl[index1]>0 && gl[index2]>0) phi=1; // All grounded
 		else if(gl[index1]<0 && gl[index2]<0) phi=0; // All floating
@@ -585,5 +585,5 @@
 	/*Allocate Output*/
 	IssmDouble* xyz_list_edge = xNew<IssmDouble>(2*3);
-	this->EdgeOnBedIndices(&indices[0],&indices[1]);
+	this->EdgeOnBaseIndices(&indices[0],&indices[1]);
 	for(int i=0;i<2;i++) for(int j=0;j<2;j++) xyz_list_edge[i*3+j]=xyz_list[indices[i]][j];
 
@@ -1132,6 +1132,6 @@
 }
 /*}}}*/
-/*FUNCTION Tria::IsOnBed {{{*/
-bool Tria::IsOnBed(){
+/*FUNCTION Tria::IsOnBase {{{*/
+bool Tria::IsOnBase(){
 
 	int meshtype;
@@ -1139,5 +1139,5 @@
 	switch(meshtype){
 		case Mesh2DverticalEnum:
-			return HasEdgeOnBed();
+			return HasEdgeOnBase();
 		case Mesh2DhorizontalEnum:
 			return true;
@@ -1192,6 +1192,6 @@
 }
 /*}}}*/
-/*FUNCTION Tria::HasEdgeOnBed {{{*/
-bool Tria::HasEdgeOnBed(){
+/*FUNCTION Tria::HasEdgeOnBase {{{*/
+bool Tria::HasEdgeOnBase(){
 
 	IssmDouble values[NUMVERTICES];
@@ -1236,6 +1236,6 @@
 }
 /*}}}*/
-/*FUNCTION Tria::EdgeOnBedIndices{{{*/
-void Tria::EdgeOnBedIndices(int* pindex1,int* pindex2){
+/*FUNCTION Tria::EdgeOnBaseIndices{{{*/
+void Tria::EdgeOnBaseIndices(int* pindex1,int* pindex2){
 
 	IssmDouble values[NUMVERTICES];
@@ -1278,6 +1278,6 @@
 }
 /*}}}*/
-/*FUNCTION Tria::EdgeOnBedIndex{{{*/
-int Tria::EdgeOnBedIndex(void){
+/*FUNCTION Tria::EdgeOnBaseIndex{{{*/
+int Tria::EdgeOnBaseIndex(void){
 
 	IssmDouble values[NUMVERTICES];
@@ -1319,5 +1319,5 @@
 void Tria::FSContactMigration(Vector<IssmDouble>* vertexgrounded,Vector<IssmDouble>* vertexfloating){
 
-	if(!IsOnBed()) return;
+	if(!IsOnBase()) return;
 
 	/*Intermediaries*/
@@ -1398,5 +1398,5 @@
 
 	int indices[2];
-	this->EdgeOnBedIndices(&indices[0],&indices[1]);
+	this->EdgeOnBaseIndices(&indices[0],&indices[1]);
 	return new GaussTria(indices[0],indices[1],order);
 }
@@ -1644,5 +1644,5 @@
 	/*For FS only: we want the CS to be tangential to the bedrock*/
 	inputs->GetInputValue(&approximation,ApproximationEnum);
-	if(!HasNodeOnBed() ||  approximation!=FSApproximationEnum) return;
+	if(!HasNodeOnBase() ||  approximation!=FSApproximationEnum) return;
 
 	//printf("element number %i \n",this->id);
@@ -1774,6 +1774,6 @@
 			return this;
 		case Mesh2DverticalEnum:
-			_assert_(HasEdgeOnBed());
-			this->EdgeOnBedIndices(&index1,&index2);
+			_assert_(HasEdgeOnBase());
+			this->EdgeOnBaseIndices(&index1,&index2);
 			return SpawnSeg(index1,index2);
 		default:
@@ -1987,5 +1987,5 @@
 void  Tria::UpdateConstraintsExtrudeFromBase(void){
 
-	if(!HasEdgeOnBed()) return;
+	if(!HasEdgeOnBase()) return;
 
 	int        extrusioninput;
Index: /issm/trunk-jpl/src/c/classes/Elements/Tria.h
===================================================================
--- /issm/trunk-jpl/src/c/classes/Elements/Tria.h	(revision 17584)
+++ /issm/trunk-jpl/src/c/classes/Elements/Tria.h	(revision 17585)
@@ -70,11 +70,11 @@
 		int         GetNumberOfNodes(void);
 		int         GetNumberOfVertices(void);
-		bool        IsOnBed();
+		bool        IsOnBase();
 		bool        IsOnSurface();
-		bool        HasEdgeOnBed();
+		bool        HasEdgeOnBase();
 		bool        HasEdgeOnSurface();
 		void        EdgeOnSurfaceIndices(int* pindex1,int* pindex);
-		void        EdgeOnBedIndices(int* pindex1,int* pindex);
-		int         EdgeOnBedIndex();
+		void        EdgeOnBaseIndices(int* pindex1,int* pindex);
+		int         EdgeOnBaseIndex();
 		int         EdgeOnSurfaceIndex();
 		bool        IsNodeOnShelfFromFlags(IssmDouble* flags);
Index: /issm/trunk-jpl/src/c/classes/Loads/Pengrid.cpp
===================================================================
--- /issm/trunk-jpl/src/c/classes/Loads/Pengrid.cpp	(revision 17584)
+++ /issm/trunk-jpl/src/c/classes/Loads/Pengrid.cpp	(revision 17585)
@@ -614,5 +614,5 @@
 		return;
 	}
-	if(!element->IsOnBed()){
+	if(!element->IsOnBase()){
 		unstable=0;
 		active=0;