Index: /issm/trunk/src/c/shared/Exp/DomainOutlineRead.cpp
===================================================================
--- /issm/trunk/src/c/shared/Exp/DomainOutlineRead.cpp	(revision 8300)
+++ /issm/trunk/src/c/shared/Exp/DomainOutlineRead.cpp	(revision 8301)
@@ -1,4 +1,4 @@
 /*!\file:  DomainOutlineRead.cpp
- * \brief DomainOutlineRead.c: read the grid coordinates defined in a domain 
+ * \brief DomainOutlineRead.c: read the vertex coordinates defined in a domain 
  * outline from Argus (.exp file). The first contour in the file is for 
  * the outside domain outline. The following contours represent holes in
@@ -11,5 +11,5 @@
 #include "../Exceptions/exceptions.h"
 
-int DomainOutlineRead(int* pnprof,int** pprofngrids,double*** ppprofx,double*** ppprofy,char* domainname){
+int DomainOutlineRead(int* pnprof,int** pprofnvertices,double*** ppprofx,double*** ppprofy,char* domainname){
 
 	
@@ -26,5 +26,5 @@
 	/*output: */
 	int nprof; //number of profiles in the domainname file
-	int* profngrids=NULL; //array holding the number of grids for the nprof profiles
+	int* profnvertices=NULL; //array holding the number of vertices for the nprof profiles
 	double** pprofx=NULL; //array of profiles x coordinates
 	double** pprofy=NULL; //array of profiles y coordinates
@@ -61,5 +61,5 @@
 	
 	/*Allocate and initialize all the profiles: */
-	profngrids=(int*)xmalloc(nprof*sizeof(int));
+	profnvertices=(int*)xmalloc(nprof*sizeof(int));
 	pprofx=(double**)xmalloc(nprof*sizeof(double*));
 	pprofy=(double**)xmalloc(nprof*sizeof(double*));
@@ -80,5 +80,5 @@
 		fscanf(fid,"%s %s %s %s\n",chardummy,chardummy,chardummy,chardummy);
 		
-		/*Get number of profile grids: */
+		/*Get number of profile vertices: */
 		fscanf(fid,"%u %s\n",&n,chardummy);
 	
@@ -86,10 +86,10 @@
 		fscanf(fid,"%s %s %s %s %s\n",chardummy,chardummy,chardummy,chardummy,chardummy);
 
-		/*Allocate grids: */
+		/*Allocate vertices: */
 		x=(double*)xmalloc(n*sizeof(double));
 		y=(double*)xmalloc(n*sizeof(double));
 		
 
-		/*Read grids: */
+		/*Read vertices: */
 		for (i=0;i<n;i++){
 			fscanf(fid,"%lf %lf\n",x+i,y+i);
@@ -102,5 +102,5 @@
 
 		/*Assign pointers: */
-		profngrids[counter]=n;
+		profnvertices[counter]=n;
 		pprofx[counter]=x;
 		pprofy[counter]=y;
@@ -120,5 +120,5 @@
 	/*Assign output pointers: */
 	*pnprof=nprof;
-	*pprofngrids=profngrids;
+	*pprofnvertices=profnvertices;
 	*ppprofx=pprofx;
 	*ppprofy=pprofy;
Index: /issm/trunk/src/c/shared/Exp/IsInPoly.cpp
===================================================================
--- /issm/trunk/src/c/shared/Exp/IsInPoly.cpp	(revision 8300)
+++ /issm/trunk/src/c/shared/Exp/IsInPoly.cpp	(revision 8301)
@@ -15,5 +15,5 @@
 
 /*IsInPoly {{{1*/
-int IsInPoly(Vec in,double* xc,double* yc,int numgrids,double* x,double* y,int i0,int i1, int edgevalue){
+int IsInPoly(Vec in,double* xc,double* yc,int numvertices,double* x,double* y,int i0,int i1, int edgevalue){
 
 	int i;
@@ -26,5 +26,5 @@
 
 	/*Get extrema*/
-	for (i=1;i<numgrids;i++){
+	for (i=1;i<numvertices;i++){
 		if(xc[i]<xmin) xmin=xc[i];
 		if(xc[i]>xmax) xmax=xc[i];
@@ -33,5 +33,5 @@
 	}
 
-	/*Go through all grids of the mesh:*/
+	/*Go through all vertices of the mesh:*/
 	for (i=i0;i<i1;i++){
 
@@ -39,9 +39,9 @@
 		VecGetValues(in,1,&i,&value);
 		if (value){
-			/*this grid already is inside one of the contours, continue*/
+			/*this vertex already is inside one of the contours, continue*/
 			continue;
 		}
 
-		/*pick up grid (x[i],y[i]) and figure out if located inside contour (xc,yc)*/
+		/*pick up vertex (x[i],y[i]) and figure out if located inside contour (xc,yc)*/
 		x0=x[i]; y0=y[i];
 		if(x0<xmin || x0>xmax || y0<ymin || y0>ymax){
@@ -49,5 +49,5 @@
 		}
 		else{
-			value=pnpoly(numgrids,xc,yc,x0,y0,edgevalue);
+			value=pnpoly(numvertices,xc,yc,x0,y0,edgevalue);
 		}
 		VecSetValues(in,1,&i,&value,INSERT_VALUES);
@@ -56,5 +56,5 @@
 }/*}}}*/
 /*IsOutsidePoly {{{1*/
-int IsOutsidePoly(Vec in,double* xc,double* yc,int numgrids,double* x,double* y,int i0,int i1, int edgevalue){
+int IsOutsidePoly(Vec in,double* xc,double* yc,int numvertices,double* x,double* y,int i0,int i1, int edgevalue){
 
 	int i,j;
@@ -67,5 +67,5 @@
 
 	/*Get extrema*/
-	for (i=1;i<numgrids;i++){
+	for (i=1;i<numvertices;i++){
 		if(xc[i]<xmin) xmin=xc[i];
 		if(xc[i]>xmax) xmax=xc[i];
@@ -74,5 +74,5 @@
 	}
 
-	/*Go through all grids of the mesh:*/
+	/*Go through all vertices of the mesh:*/
 	for (i=i0;i<i1;i++){
 
@@ -80,9 +80,9 @@
 		VecGetValues(in,1,&i,&value);
 		if (value){
-			/*this grid already is inside one of the contours, continue*/
+			/*this vertex already is inside one of the contours, continue*/
 			continue;
 		}
 
-		/*pick up grid (x[i],y[i]) and figure out if located inside contour (xc,yc)*/
+		/*pick up vertex (x[i],y[i]) and figure out if located inside contour (xc,yc)*/
 		x0=x[i]; y0=y[i];
 		if(x0<xmin || x0>xmax || y0<ymin || y0>ymax){
@@ -90,5 +90,5 @@
 		}
 		else{
-			value=1-pnpoly(numgrids,xc,yc,x0,y0,edgevalue);
+			value=1-pnpoly(numvertices,xc,yc,x0,y0,edgevalue);
 		}
 		VecSetValues(in,1,&i,&value,INSERT_VALUES);
Index: /issm/trunk/src/c/shared/Exp/IsInPolySerial.cpp
===================================================================
--- /issm/trunk/src/c/shared/Exp/IsInPolySerial.cpp	(revision 8300)
+++ /issm/trunk/src/c/shared/Exp/IsInPolySerial.cpp	(revision 8301)
@@ -9,19 +9,19 @@
 
 
-int IsInPolySerial(double* in,double* xc,double* yc,int numgrids,double* x,double* y,int nods, int edgevalue){
+int IsInPolySerial(double* in,double* xc,double* yc,int numvertices,double* x,double* y,int nods, int edgevalue){
 
 	int i,j;
 	double x0,y0;
 
-	/*Go through all grids of the mesh:*/
+	/*Go through all vertices of the mesh:*/
 	for (i=0;i<nods;i++){
 		if (in[i]){
-			/*this grid already is inside one of the contours, continue*/
+			/*this vertex already is inside one of the contours, continue*/
 			continue;
 		}
-		/*pick up grid: */
+		/*pick up vertex: */
 		x0=x[i];
 		y0=y[i];
-		if (pnpoly(numgrids,xc,yc,x0,y0,edgevalue)){
+		if (pnpoly(numvertices,xc,yc,x0,y0,edgevalue)){
 			in[i]=1;
 		}
Index: /issm/trunk/src/c/shared/Exp/exp.h
===================================================================
--- /issm/trunk/src/c/shared/Exp/exp.h	(revision 8300)
+++ /issm/trunk/src/c/shared/Exp/exp.h	(revision 8301)
@@ -9,8 +9,8 @@
 #include "../../toolkits/toolkits.h"
 
-int IsInPoly(Vec in,double* xc,double* yc,int numgrids,double* x,double* y,int i0,int i1, int edgevalue);
-int IsOutsidePoly(Vec in,double* xc,double* yc,int numgrids,double* x,double* y,int i0,int i1, int edgevalue);
-int IsInPolySerial(double* in,double* xc,double* yc,int numgrids,double* x,double* y,int nods, int edgevalue);
-int DomainOutlineRead(int* pnprof,int** pprofngrids,double*** ppprofx,double*** ppprofy,char* domainname);
+int IsInPoly(Vec in,double* xc,double* yc,int numvertices,double* x,double* y,int i0,int i1, int edgevalue);
+int IsOutsidePoly(Vec in,double* xc,double* yc,int numvertices,double* x,double* y,int i0,int i1, int edgevalue);
+int IsInPolySerial(double* in,double* xc,double* yc,int numvertices,double* x,double* y,int nods, int edgevalue);
+int DomainOutlineRead(int* pnprof,int** pprofnvertices,double*** ppprofx,double*** ppprofy,char* domainname);
 int pnpoly(int npol, double *xp, double *yp, double x, double y, int edgevalue);
 
Index: /issm/trunk/src/c/shared/TriMesh/AssociateSegmentToElement.cpp
===================================================================
--- /issm/trunk/src/c/shared/TriMesh/AssociateSegmentToElement.cpp	(revision 8300)
+++ /issm/trunk/src/c/shared/TriMesh/AssociateSegmentToElement.cpp	(revision 8301)
@@ -14,5 +14,5 @@
 	double* segments=NULL;
 
-	/*grid indices: */
+	/*node indices: */
 	double A,B;
 
Index: /issm/trunk/src/c/shared/TriMesh/GridInsideHole.cpp
===================================================================
--- /issm/trunk/src/c/shared/TriMesh/GridInsideHole.cpp	(revision 8300)
+++ /issm/trunk/src/c/shared/TriMesh/GridInsideHole.cpp	(revision 8301)
@@ -18,5 +18,5 @@
 	double yA,yB,yC,yD,yE;
 
-	/*Take first and last grids: */
+	/*Take first and last vertices: */
 	xA=x[0];
 	yA=y[0];
Index: /issm/trunk/src/c/shared/TriMesh/OrderSegments.cpp
===================================================================
--- /issm/trunk/src/c/shared/TriMesh/OrderSegments.cpp	(revision 8300)
+++ /issm/trunk/src/c/shared/TriMesh/OrderSegments.cpp	(revision 8301)
@@ -14,5 +14,5 @@
 	double* segments=NULL;
 
-	/*grid indices: */
+	/*vertex indices: */
 	double A,B;
 	/*element indices: */
Index: /issm/trunk/src/c/shared/TriMesh/SplitMeshForRifts.cpp
===================================================================
--- /issm/trunk/src/c/shared/TriMesh/SplitMeshForRifts.cpp	(revision 8300)
+++ /issm/trunk/src/c/shared/TriMesh/SplitMeshForRifts.cpp	(revision 8301)
@@ -17,5 +17,5 @@
 	
 	int i,j,k,l;
-	int grid;
+	int node;
 	int el;
 
@@ -50,48 +50,48 @@
 	/*Establish list of segments that belong to a rift: */
 	RiftSegmentsFromSegments(&nriftsegs,&riftsegments,nel,index,nsegs,segments); /*riftsegments of size nriftsegsx4 (4 for first element on segment,second element, 
-																				   first grid and second sgrid)*/
+																				   first node and second snode)*/
 
-	/*Go through all grids of the rift segments, and start splitting the mesh: */
-	flags=(int*)xcalloc(nods,sizeof(int)); //to make sure we don't split the same grids twice!
+	/*Go through all nodes of the rift segments, and start splitting the mesh: */
+	flags=(int*)xcalloc(nods,sizeof(int)); //to make sure we don't split the same nodes twice!
 	for (i=0;i<nriftsegs;i++){
 		for (j=0;j<2;j++){
 	
-			grid=*(riftsegments+4*i+j+2);
-			if(flags[grid-1]){
-				/*This grid was already split, skip:*/
+			node=*(riftsegments+4*i+j+2);
+			if(flags[node-1]){
+				/*This node was already split, skip:*/
 				continue;
 			}
 			else{
-				flags[grid-1]=1;
+				flags[node-1]=1;
 			}
 
-			if(IsGridOnRift(riftsegments,nriftsegs,grid)){
+			if(IsGridOnRift(riftsegments,nriftsegs,node)){
 			
-				DetermineGridElementListOnOneSideOfRift(&NumGridElementListOnOneSideOfRift,&GridElementListOnOneSideOfRift,i,nriftsegs,riftsegments,grid,index,nel);
+				DetermineGridElementListOnOneSideOfRift(&NumGridElementListOnOneSideOfRift,&GridElementListOnOneSideOfRift,i,nriftsegs,riftsegments,node,index,nel);
 			
-				/*Summary: we have for grid, a list of elements (GridElementListOnOneSideOfRift, of size NumGridElementListOnOneSideOfRift) that all contain grid 
-				 *and that are on the same side of the rift. For all these elements, we clone grid into another grid, and we swap all instances of grid in the triangulation 
-				 *for those elements, to the new grid.*/
+				/*Summary: we have for node, a list of elements (GridElementListOnOneSideOfRift, of size NumGridElementListOnOneSideOfRift) that all contain node 
+				 *and that are on the same side of the rift. For all these elements, we clone node into another node, and we swap all instances of node in the triangulation 
+				 *for those elements, to the new node.*/
 				
-				//augment number of grids 
+				//augment number of nodes 
 				nods=nods+1;
-				//create new grid
+				//create new node
 				x=(double*)xrealloc(x,nods*sizeof(double));
 				y=(double*)xrealloc(y,nods*sizeof(double));
-				x[nods-1]=x[grid-1]; //matlab indexing
-				y[nods-1]=y[grid-1]; //matlab indexing
+				x[nods-1]=x[node-1]; //matlab indexing
+				y[nods-1]=y[node-1]; //matlab indexing
 
-				//change elements owning this grid
+				//change elements owning this node
 				for (k=0;k<NumGridElementListOnOneSideOfRift;k++){
 					el=GridElementListOnOneSideOfRift[k];
 					for (l=0;l<3;l++){
-						if (*(index+3*el+l)==grid)*(index+3*el+l)=nods; //again, matlab indexing.
+						if (*(index+3*el+l)==node)*(index+3*el+l)=nods; //again, matlab indexing.
 					}
 				}
-			}// if(IsGridOnRift(riftsegments,nriftsegs,grid))
+			}// if(IsGridOnRift(riftsegments,nriftsegs,node))
 		} //for(j=0;j<2;j++)
 	} //for (i=0;i<nriftsegs;i++)
 
-	/*update segments: they got modified completely by adding new grids.*/
+	/*update segments: they got modified completely by adding new nodes.*/
 	UpdateSegments(&segments,&segmentmarkerlist, &nsegs,index,x,y,riftsegments,nriftsegs);
 
Index: /issm/trunk/src/c/shared/TriMesh/TriMeshUtils.cpp
===================================================================
--- /issm/trunk/src/c/shared/TriMesh/TriMeshUtils.cpp	(revision 8300)
+++ /issm/trunk/src/c/shared/TriMesh/TriMeshUtils.cpp	(revision 8301)
@@ -11,7 +11,7 @@
 
 #define RIFTPENALTYPAIRSWIDTH 8
-int IsGridOnRift(int* riftsegments, int nriftsegs, int grid){
-
-	/*Does this grid belong to 4 elements, or just 2? If it belongs to 4 elements, it is inside a rift, 
+int IsGridOnRift(int* riftsegments, int nriftsegs, int node){
+
+	/*Does this node belong to 4 elements, or just 2? If it belongs to 4 elements, it is inside a rift, 
 	 *if it belongs to 2 elements, it is on the tip of a rift, or it has already been split across the rift (see below).*/
 	
@@ -23,5 +23,5 @@
 	for (i=0;i<nriftsegs;i++){
 		for (j=0;j<2;j++){
-			if ((*(riftsegments+4*i+2+j))==grid) count++;
+			if ((*(riftsegments+4*i+2+j))==node) count++;
 		}
 	}
@@ -35,7 +35,7 @@
 				
 
-int GridElementsList(int** pGridElements, int* pNumGridElements,int grid,double * index,int nel){
-
-	/*From a grid, recover all the elements that are connected to it: */
+int GridElementsList(int** pGridElements, int* pNumGridElements,int node,double * index,int nel){
+
+	/*From a node, recover all the elements that are connected to it: */
 	int i,j;
 	int noerr=1;
@@ -48,5 +48,5 @@
 
 	/*From a mesh with 30 degrees minimum angle, we get 12 possible elements that own 
-	 * the grid. We start by allocating GridElements with that size, and realloc 
+	 * the node. We start by allocating GridElements with that size, and realloc 
 	 * more if needed.*/
 
@@ -57,5 +57,5 @@
 	for (i=0;i<nel;i++){
 		for (j=0;j<3;j++){
-			if ((int)*(index+3*i+j)==grid){
+			if ((int)*(index+3*i+j)==node){
 				if (NumGridElements<=(current_size-1)){
 					GridElements[NumGridElements]=i;
@@ -91,5 +91,5 @@
 
 int IsNeighbor(int el1,int el2,double* index){
-	/*From a triangulation held in index, figure out if elements 1 and 2 have two grids in common: */
+	/*From a triangulation held in index, figure out if elements 1 and 2 have two nodes in common: */
 	int i,j;
 	int count=0;
@@ -132,5 +132,5 @@
 	int* riftsegments=NULL;
 	int* riftsegments_uncompressed=NULL; 
-	double element_grids[3];
+	double element_nodes[3];
 
 	/*Allocate segmentflags: */
@@ -142,10 +142,10 @@
 	for (i=0;i<nsegs;i++){
 		el=(int)*(segments+3*i+2)-1; //element found in AssociateSegmentToElements
-		/*Temporarily set grids belonging to the segments to -1 in the triangulation index, and 
+		/*Temporarily set nodes belonging to the segments to -1 in the triangulation index, and 
 		 *then  proceed to find another element that owns the segment. If we don't find it, we know 
 		 *we are dealing with a boundary or hole, otherwise, we are dealing with a rift: */
-		element_grids[0]=*(index+3*el+0);
-		element_grids[1]=*(index+3*el+1);
-		element_grids[2]=*(index+3*el+2);
+		element_nodes[0]=*(index+3*el+0);
+		element_nodes[1]=*(index+3*el+1);
+		element_nodes[2]=*(index+3*el+2);
 
 		*(index+3*el+0)=-1;
@@ -156,7 +156,7 @@
 
 		/*Restore index: */
-		*(index+3*el+0)=element_grids[0];
-		*(index+3*el+1)=element_grids[1];
-		*(index+3*el+2)=element_grids[2];
+		*(index+3*el+0)=element_nodes[0];
+		*(index+3*el+1)=element_nodes[1];
+		*(index+3*el+2)=element_nodes[2];
 
 		if (el2!=-1){
@@ -195,5 +195,5 @@
 ******************************************************************************************************************************/
 
-int DetermineGridElementListOnOneSideOfRift(int* pNumGridElementListOnOneSideOfRift, int** pGridElementListOnOneSideOfRift, int segmentnumber, int nriftsegs, int* riftsegments, int grid,double* index,int nel){
+int DetermineGridElementListOnOneSideOfRift(int* pNumGridElementListOnOneSideOfRift, int** pGridElementListOnOneSideOfRift, int segmentnumber, int nriftsegs, int* riftsegments, int node,double* index,int nel){
 
 	int noerr=1;
@@ -208,6 +208,6 @@
 	int* GridElementListOnOneSideOfRift=NULL;
 
-	/*Build a list of all the elements connected to this grid: */
-	GridElementsList(&GridElements,&NumGridElements,grid,index,nel);
+	/*Build a list of all the elements connected to this node: */
+	GridElementsList(&GridElements,&NumGridElements,node,index,nel);
 
 	/*Figure out the list of elements  that are on the same side of the rift. To do so, we start from one 
@@ -282,5 +282,5 @@
 	segmentmarkerlist=(double*)xrealloc(segmentmarkerlist,(nsegs+nriftsegs)*sizeof(double));
 
-	/*First, update the existing segments to the new grids :*/
+	/*First, update the existing segments to the new nodes :*/
 	for (i=0;i<nriftsegs;i++){
 		el1=*(riftsegments+4*i+0);
@@ -290,5 +290,5 @@
 				/*segment j is the same as rift segment i.Let's update segments[j][:] using  element el1 and the corresponding rift segment.
 				 *Because riftsegments does not represent a list of rift segments anymore (it got heavily modified in SplitElementsForRifts, 
-				 *we can only rely on the position (x,y) of the rift grids to create a segment:*/
+				 *we can only rely on the position (x,y) of the rift nodes to create a segment:*/
 				for (k=0;k<3;k++){
 					if ((x[(int)*(index+el1*3+k)-1]==x[(int)*(segments+3*j+0)-1]) && (y[(int)*(index+el1*3+k)-1]==y[(int)*(segments+3*j+0)-1])){
@@ -379,19 +379,19 @@
                                    IsInPoly
 ******************************************************************************************************************************/
-int IsInPoly(double* in,double* xc,double* yc,int numgrids,double* x,double* y,int nods){
+int IsInPoly(double* in,double* xc,double* yc,int numnodes,double* x,double* y,int nods){
 
 	int i,j;
 	double x0,y0;
 
-	/*Go through all grids of the mesh:*/
+	/*Go through all nodes of the mesh:*/
 	for (i=0;i<nods;i++){
 		if (in[i]){
-			/*this grid already is inside one of the contours, continue*/
+			/*this node already is inside one of the contours, continue*/
 			continue;
 		}
-		/*pick up grid: */
+		/*pick up node: */
 		x0=x[i];
 		y0=y[i];
-		if (pnpoly(numgrids,xc,yc,x0,y0)){
+		if (pnpoly(numnodes,xc,yc,x0,y0)){
 			in[i]=1;
 		}
@@ -524,5 +524,5 @@
 	double* segments=NULL;
 	double* pairs=NULL;
-	int     grid1,grid2,grid3,grid4;
+	int     node1,node2,node3,node4;
 
 	riftsnumpairs=(int*)xmalloc(numrifts*sizeof(int));
@@ -535,12 +535,12 @@
 		for (j=0;j<numsegs;j++){
 			*(pairs+2*j+0)=*(segments+3*j+2); //retrieve element to which this segment belongs.
-			grid1=(int)*(segments+3*j+0)-1; grid2=(int)*(segments+3*j+1)-1;
+			node1=(int)*(segments+3*j+0)-1; node2=(int)*(segments+3*j+1)-1;
 			/*Find element facing on other side of rift: */
 			for (k=0;k<numsegs;k++){
 				if (k==j)continue;
-				grid3=(int)*(segments+3*k+0)-1; grid4=(int)*(segments+3*k+1)-1;
-				/*We are trying to find 2 elements, where position of grid3 == position of grid1, and position of grid4 == position of grid2*/
-				if (   (x[grid3]==x[grid1]) && (y[grid3]==y[grid1]) && (x[grid4]==x[grid2]) && (y[grid4]==y[grid2])
-				    || (x[grid3]==x[grid2]) && (y[grid3]==y[grid2]) && (x[grid4]==x[grid1]) && (y[grid4]==y[grid1])  ){
+				node3=(int)*(segments+3*k+0)-1; node4=(int)*(segments+3*k+1)-1;
+				/*We are trying to find 2 elements, where position of node3 == position of node1, and position of node4 == position of node2*/
+				if (   (x[node3]==x[node1]) && (y[node3]==y[node1]) && (x[node4]==x[node2]) && (y[node4]==y[node2])
+				    || (x[node3]==x[node2]) && (y[node3]==y[node2]) && (x[node4]==x[node1]) && (y[node4]==y[node1])  ){
 					/*We found the corresponding element: */
 					*(pairs+2*j+1)=*(segments+3*k+2);
@@ -585,12 +585,12 @@
 	double* riftsegments=NULL;
 	double* riftpairs=NULL;
-	int     grid1,grid2,grid3,grid4,temp_grid;
+	int     node1,node2,node3,node4,temp_node;
 	double  el1,el2;
-	int     newnods; //temporary # grid counter.
+	int     newnods; //temporary # node counter.
 	double  xmin,ymin;
 	double* xreal=NULL;
 	double* yreal=NULL;
-	int* grids=NULL;
-	int* merginggrids=NULL;
+	int* nodes=NULL;
+	int* mergingnodes=NULL;
 	int     max_size;
 	int     redundant;
@@ -608,5 +608,5 @@
 	newnods=nods;
 
-	/*Figure out a unique value to flag x and y for grid removal: */
+	/*Figure out a unique value to flag x and y for node removal: */
 	xmin=x[0];
 	ymin=y[0];
@@ -618,14 +618,14 @@
 	ymin=ymin-dabs(ymin);
 
-	/*Initialize two arrays, one for grids that are going to be merged, the other with corresponding grids being merge into: */
+	/*Initialize two arrays, one for nodes that are going to be merged, the other with corresponding nodes being merge into: */
 	max_size=0;
 	for (i=0;i<numrifts1;i++){
 		max_size+=rifts1numsegs[i];
 	}
-	grids=(int*)xmalloc(max_size*sizeof(int));
-	merginggrids=(int*)xmalloc(max_size*sizeof(int));
-
-	/*Go through the rifts segments, and identify which grid we are going to merge with its counterpart on the other side 
-	 *of the rift. The way we identify this grid is by looking at the element pairs, and the corresponding grids: */
+	nodes=(int*)xmalloc(max_size*sizeof(int));
+	mergingnodes=(int*)xmalloc(max_size*sizeof(int));
+
+	/*Go through the rifts segments, and identify which node we are going to merge with its counterpart on the other side 
+	 *of the rift. The way we identify this node is by looking at the element pairs, and the corresponding nodes: */
 	counter=0;
 	for (i=0;i<numrifts1;i++){
@@ -635,47 +635,47 @@
 			el1=*(riftpairs+2*j+0);
 			el2=*(riftpairs+2*j+1);
-			grid1=(int)*(riftsegments+3*j+0);
-			grid2=(int)*(riftsegments+3*j+1);
-			/*Summary, el1 and el2 are facing one another across the rift. grid1 and grid2 belong to el1 and 
-			 *are located on the rift. Find grid3 and grid4, grids belonging to el2 and located on the rift: */
+			node1=(int)*(riftsegments+3*j+0);
+			node2=(int)*(riftsegments+3*j+1);
+			/*Summary, el1 and el2 are facing one another across the rift. node1 and node2 belong to el1 and 
+			 *are located on the rift. Find node3 and node4, nodes belonging to el2 and located on the rift: */
 			for (k=0;k<rifts1numsegs[i];k++){
 				if (*(riftsegments+3*k+2)==el2){
-					grid3=(int)*(riftsegments+3*k+0);
-					grid4=(int)*(riftsegments+3*k+1);
+					node3=(int)*(riftsegments+3*k+0);
+					node4=(int)*(riftsegments+3*k+1);
 					break;
 				}
 			}
-			/* Make sure grid3 faces grid1 and grid4 faces grid2: */
-			if ((x[grid1]==x[grid4]) && (y[grid1]==y[grid4])){
-				/*Swap grid3 and grid4:*/
-				temp_grid=grid3;
-				grid3=grid4;
-				grid4=temp_grid;
-			}
-			/* Is any of these two grid pairs on the tip of a rift, in which case, we don't include it in grids or merginggrids: */
-			if ((grid1==grid3) || (grid2==grid4)){
-				if(grid1!=grid3){
-					/*Add grid1 and grid3 to grids and merginggrids if they have not already been added: */
+			/* Make sure node3 faces node1 and node4 faces node2: */
+			if ((x[node1]==x[node4]) && (y[node1]==y[node4])){
+				/*Swap node3 and node4:*/
+				temp_node=node3;
+				node3=node4;
+				node4=temp_node;
+			}
+			/* Is any of these two node pairs on the tip of a rift, in which case, we don't include it in nodes or mergingnodes: */
+			if ((node1==node3) || (node2==node4)){
+				if(node1!=node3){
+					/*Add node1 and node3 to nodes and mergingnodes if they have not already been added: */
 					redundant=0;
 					for (k=0;k<counter;k++){
-						if ((merginggrids[k]==grid1) || (grids[k]==grid1))redundant=1;
+						if ((mergingnodes[k]==node1) || (nodes[k]==node1))redundant=1;
 					}
 					if(!redundant){
-						/*Ok, add grid1 to grids, and grid3 to merginggrids: */
-						grids[counter]=grid1;
-						merginggrids[counter]=grid3;
+						/*Ok, add node1 to nodes, and node3 to mergingnodes: */
+						nodes[counter]=node1;
+						mergingnodes[counter]=node3;
 						counter++;
 					}
 				}
-				if(grid2!=grid4){
-					/*Add grid2 and grid4 to grids and merginggrids if they have not already been added: */
+				if(node2!=node4){
+					/*Add node2 and node4 to nodes and mergingnodes if they have not already been added: */
 					redundant=0;
 					for (k=0;k<counter;k++){
-						if ((merginggrids[k]==grid2) || (grids[k]==grid2))redundant=1;
+						if ((mergingnodes[k]==node2) || (nodes[k]==node2))redundant=1;
 					}
 					if(!redundant){
-						/*Ok, add grid2 to grids, and grid4 to merginggrids: */
-						grids[counter]=grid2;
-						merginggrids[counter]=grid4;
+						/*Ok, add node2 to nodes, and node4 to mergingnodes: */
+						nodes[counter]=node2;
+						mergingnodes[counter]=node4;
 						counter++;
 					}
@@ -683,24 +683,24 @@
 			}
 			else{
-				/*Check that grid1 is not already present in the merginggrids: */
+				/*Check that node1 is not already present in the mergingnodes: */
 				redundant=0;
 				for (k=0;k<counter;k++){
-					if ((merginggrids[k]==grid1) || (grids[k]==grid1))redundant=1;
+					if ((mergingnodes[k]==node1) || (nodes[k]==node1))redundant=1;
 				}
 				if(!redundant){
-					/*Ok, add grid1 to grids, and grid3 to merginggrids: */
-					grids[counter]=grid1;
-					merginggrids[counter]=grid3;
+					/*Ok, add node1 to nodes, and node3 to mergingnodes: */
+					nodes[counter]=node1;
+					mergingnodes[counter]=node3;
 					counter++;
 				}
-				/*Check that grid2 is not already present in the merginggrids: */
+				/*Check that node2 is not already present in the mergingnodes: */
 				redundant=0;
 				for (k=0;k<counter;k++){
-					if ((merginggrids[k]==grid1) || (grids[k]==grid1))redundant=1;
+					if ((mergingnodes[k]==node1) || (nodes[k]==node1))redundant=1;
 				}
 				if(!redundant){
-					/*Ok, add grid2 to grids, and grid4 to merginggrids: */
-					grids[counter]=grid2;
-					merginggrids[counter]=grid4;
+					/*Ok, add node2 to nodes, and node4 to mergingnodes: */
+					nodes[counter]=node2;
+					mergingnodes[counter]=node4;
 					counter++;
 				}
@@ -709,17 +709,17 @@
 	}
 
-	/*Ok, we have counter pairs of grids (grids and merginggrids): start merging grids in the triangulation: */
+	/*Ok, we have counter pairs of nodes (nodes and mergingnodes): start merging nodes in the triangulation: */
 	newnods=nods;
 	for (i=0;i<counter;i++){
-		grid1=grids[i];
-		grid3=merginggrids[i];
-		/*Merge grid3 into grid1: */ 
-		x[grid3]=xmin; //flag  for later removal from x
-		y[grid3]=ymin; //flag  for later removal from y
+		node1=nodes[i];
+		node3=mergingnodes[i];
+		/*Merge node3 into node1: */ 
+		x[node3]=xmin; //flag  for later removal from x
+		y[node3]=ymin; //flag  for later removal from y
 		newnods--;
 		for (k=0;k<nel;k++){
-			if (*(index+3*k+0)==grid3)*(index+3*k+0)=grid1;
-			if (*(index+3*k+1)==grid3)*(index+3*k+1)=grid1;
-			if (*(index+3*k+2)==grid3)*(index+3*k+2)=grid1;
+			if (*(index+3*k+0)==node3)*(index+3*k+0)=node1;
+			if (*(index+3*k+1)==node3)*(index+3*k+1)=node1;
+			if (*(index+3*k+2)==node3)*(index+3*k+2)=node1;
 		}
 	}
@@ -805,6 +805,6 @@
 	double* riftpairs_copy=NULL;
 
-	/*grid and element manipulation: */
-	int     grid1,grid2,grid3,grid4,temp_grid,tip1,tip2,grid;
+	/*node and element manipulation: */
+	int     node1,node2,node3,node4,temp_node,tip1,tip2,node;
 	double  el1,el2;
 	int     already_ordered=0;
@@ -830,5 +830,5 @@
 		order=(int*)xmalloc(numsegs*sizeof(int));
 
-		/*First find the tips, using the pairs. If a pair of elements has one grid in common, this grid is a rift tip: */
+		/*First find the tips, using the pairs. If a pair of elements has one node in common, this node is a rift tip: */
 		tip1=-1;
 		tip2=-1;
@@ -837,44 +837,44 @@
 			el1=*(riftpairs+2*j+0);
 			el2=*(riftpairs+2*j+1);
-			grid1=(int)*(riftsegments+3*j+0);
-			grid2=(int)*(riftsegments+3*j+1);
-			/*Summary, el1 and el2 are facing one another across the rift. grid1 and grid2 belong to el1 and 
-			 *are located on the rift. Find grid3 and grid4, grids belonging to el2 and located on the rift: */
+			node1=(int)*(riftsegments+3*j+0);
+			node2=(int)*(riftsegments+3*j+1);
+			/*Summary, el1 and el2 are facing one another across the rift. node1 and node2 belong to el1 and 
+			 *are located on the rift. Find node3 and node4, nodes belonging to el2 and located on the rift: */
 			for (k=0;k<numsegs;k++){
 				if (*(riftsegments+3*k+2)==el2){
-					grid3=(int)*(riftsegments+3*k+0);
-					grid4=(int)*(riftsegments+3*k+1);
+					node3=(int)*(riftsegments+3*k+0);
+					node4=(int)*(riftsegments+3*k+1);
 					break;
 				}
 			}
-			/* Make sure grid3 faces grid1 and grid4 faces grid2: */
-			if ((x[grid1]==x[grid4]) && (y[grid1]==y[grid4])){
-				/*Swap grid3 and grid4:*/
-				temp_grid=grid3;
-				grid3=grid4;
-				grid4=temp_grid;
+			/* Make sure node3 faces node1 and node4 faces node2: */
+			if ((x[node1]==x[node4]) && (y[node1]==y[node4])){
+				/*Swap node3 and node4:*/
+				temp_node=node3;
+				node3=node4;
+				node4=temp_node;
 			}
 
 			/*Figure out if a tip is on this element: */
-			if (grid3==grid1){
-				/*grid1 is a tip*/
+			if (node3==node1){
+				/*node1 is a tip*/
 				if (tip1==-1) {
-					tip1=grid1;
+					tip1=node1;
 					continue;
 				}
-				if ((tip2==-1) && (grid1!=tip1)){
-					tip2=grid1;
+				if ((tip2==-1) && (node1!=tip1)){
+					tip2=node1;
 					break;
 				}
 			}
 		
-			if (grid4==grid2){
-				/*grid2 is a tip*/
+			if (node4==node2){
+				/*node2 is a tip*/
 				if (tip1==-1){
-					tip1=grid2;
+					tip1=node2;
 					continue;
 				}
-				if ((tip2==-1) && (grid2!=tip1)){
-					tip2=grid2;
+				if ((tip2==-1) && (node2!=tip1)){
+					tip2=node2;
 					break;
 				}
@@ -889,12 +889,12 @@
 		/*We have the two tips for this rift.  Go from tip1 to tip2, and figure out the order in which segments are sequential. 
 		 *Because two elements are connected to tip1, we chose one first, which defines the direction we are rotating along the rift. */
-		grid=tip1;
+		node=tip1;
 		for (counter=0;counter<numsegs;counter++){
 			for (j=0;j<numsegs;j++){
-				grid1=(int)*(riftsegments+3*j+0);
-				grid2=(int)*(riftsegments+3*j+1);
+				node1=(int)*(riftsegments+3*j+0);
+				node2=(int)*(riftsegments+3*j+1);
 				
-				if ((grid1==grid) || (grid2==grid)){
-					/*Ok, this segment is connected to grid, plug its index into order, unless we already plugged it before: */
+				if ((node1==node) || (node2==node)){
+					/*Ok, this segment is connected to node, plug its index into order, unless we already plugged it before: */
 					already_ordered=0;
 					for (k=0;k<counter;k++){
@@ -906,9 +906,9 @@
 					if (!already_ordered){
 						order[counter]=j;
-						if(grid1==grid){
-							grid=grid2;
+						if(node1==node){
+							node=node2;
 						}
-						else if(grid2==grid){
-							grid=grid1;
+						else if(node2==node){
+							node=node1;
 						}
 						break;
@@ -958,6 +958,6 @@
 	int i,j,k,k0;
 
-	double el1,el2,grid1,grid2,grid3,grid4;
-	double tip1,tip2,temp_grid;
+	double el1,el2,node1,node2,node3,node4;
+	double tip1,tip2,temp_node;
 
 	/*output: */
@@ -994,7 +994,7 @@
 			el1=*(riftpairs+2*j+0);
 			el2=*(riftpairs+2*j+1);
-			grid1=*(riftsegments+3*j+0);
-			grid2=*(riftsegments+3*j+1);
-			/*Find segment index to recover grid3 and grid4, facing grid1 and grid2: */
+			node1=*(riftsegments+3*j+0);
+			node2=*(riftsegments+3*j+1);
+			/*Find segment index to recover node3 and node4, facing node1 and node2: */
 			k0=-1;
 			for(k=0;k<numsegs;k++){
@@ -1004,28 +1004,28 @@
 				}
 			}
-			grid3=*(riftsegments+3*k0+0);
-			grid4=*(riftsegments+3*k0+1);
-
-			/* Make sure grid3 faces grid1 and grid4 faces grid2: */
-			if ((x[(int)grid1-1]==x[(int)grid4-1]) && (y[(int)grid1-1]==y[(int)grid4-1])){
-				/*Swap grid3 and grid4:*/
-				temp_grid=grid3;
-				grid3=grid4;
-				grid4=temp_grid;
+			node3=*(riftsegments+3*k0+0);
+			node4=*(riftsegments+3*k0+1);
+
+			/* Make sure node3 faces node1 and node4 faces node2: */
+			if ((x[(int)node1-1]==x[(int)node4-1]) && (y[(int)node1-1]==y[(int)node4-1])){
+				/*Swap node3 and node4:*/
+				temp_node=node3;
+				node3=node4;
+				node4=temp_node;
 			}	
-			/*Ok, we have grid1 facing grid3, and grid2 facing grid4. Compute the normal to 
+			/*Ok, we have node1 facing node3, and node2 facing node4. Compute the normal to 
 			 *this segment, and its length: */
-			normal[0]=cos(atan2(x[(int)grid1-1]-x[(int)grid2-1],y[(int)grid2-1]-y[(int)grid1-1]));
-			normal[1]=sin(atan2(x[(int)grid1-1]-x[(int)grid2-1],y[(int)grid2-1]-y[(int)grid1-1]));
-			length=sqrt(pow(x[(int)grid2-1]-x[(int)grid1-1],(double)2)+pow(y[(int)grid2-1]-y[(int)grid1-1],(double)2));
-
-			/*Be careful here, we want penalty loads on each grid, not on each segment. This means we cannot plug grid1,
-			 * grid2, grid3 and grid4 directly into riftpenaltypairs. We need to include grid1, grid2, grid3 and grid4, 
+			normal[0]=cos(atan2(x[(int)node1-1]-x[(int)node2-1],y[(int)node2-1]-y[(int)node1-1]));
+			normal[1]=sin(atan2(x[(int)node1-1]-x[(int)node2-1],y[(int)node2-1]-y[(int)node1-1]));
+			length=sqrt(pow(x[(int)node2-1]-x[(int)node1-1],(double)2)+pow(y[(int)node2-1]-y[(int)node1-1],(double)2));
+
+			/*Be careful here, we want penalty loads on each node, not on each segment. This means we cannot plug node1,
+			 * node2, node3 and node4 directly into riftpenaltypairs. We need to include node1, node2, node3 and node4, 
 			 * only once. We'll add the normals and the lengths : */
 
-			if(grid1!=grid3){ //exclude tips from loads
+			if(node1!=node3){ //exclude tips from loads
 				k1=-1;
 				for(k=0;k<counter;k++){
-					if( (*(riftpenaltypairs+k*7+0))==grid1){
+					if( (*(riftpenaltypairs+k*7+0))==node1){
 						k1=k; 
 						break;
@@ -1033,6 +1033,6 @@
 				}
 				if(k1==-1){
-					*(riftpenaltypairs+counter*7+0)=grid1;
-					*(riftpenaltypairs+counter*7+1)=grid3;
+					*(riftpenaltypairs+counter*7+0)=node1;
+					*(riftpenaltypairs+counter*7+1)=node3;
 					*(riftpenaltypairs+counter*7+2)=el1;
 					*(riftpenaltypairs+counter*7+3)=el2;
@@ -1048,8 +1048,8 @@
 				}
 			}
-			if(grid2!=grid4){
+			if(node2!=node4){
 				k2=-1;
 				for(k=0;k<counter;k++){
-					if( (*(riftpenaltypairs+k*7+0))==grid2){
+					if( (*(riftpenaltypairs+k*7+0))==node2){
 						k2=k;
 						break;
@@ -1057,6 +1057,6 @@
 				}
 				if(k2==-1){
-					*(riftpenaltypairs+counter*7+0)=grid2;
-					*(riftpenaltypairs+counter*7+1)=grid4;
+					*(riftpenaltypairs+counter*7+0)=node2;
+					*(riftpenaltypairs+counter*7+1)=node4;
 					*(riftpenaltypairs+counter*7+2)=el1;
 					*(riftpenaltypairs+counter*7+3)=el2;
@@ -1101,5 +1101,5 @@
 	int noerr=1;
 	int i,j,k;
-	double grid1,grid2,grid3;
+	double node1,node2,node3;
 	int el;
 
@@ -1123,23 +1123,23 @@
 
 	for (i=0;i<num_seg;i++){
-		grid1=*(segments+3*i+0);
-		grid2=*(segments+3*i+1);
-		/*Find all elements connected to [grid1 grid2]: */
+		node1=*(segments+3*i+0);
+		node2=*(segments+3*i+1);
+		/*Find all elements connected to [node1 node2]: */
 		pair_count=0;
 		for (j=0;j<nel;j++){
-			if (*(index+3*j+0)==grid1){
-				if ((*(index+3*j+1)==grid2) || (*(index+3*j+2)==grid2)){
+			if (*(index+3*j+0)==node1){
+				if ((*(index+3*j+1)==node2) || (*(index+3*j+2)==node2)){
 					pair[pair_count]=j;
 					pair_count++;
 				}
 			}
-			if (*(index+3*j+1)==grid1){
-				if ((*(index+3*j+0)==grid2) || (*(index+3*j+2)==grid2)){
+			if (*(index+3*j+1)==node1){
+				if ((*(index+3*j+0)==node2) || (*(index+3*j+2)==node2)){
 					pair[pair_count]=j;
 					pair_count++;
 				}
 			}
-			if (*(index+3*j+2)==grid1){
-				if ((*(index+3*j+0)==grid2) || (*(index+3*j+1)==grid2)){
+			if (*(index+3*j+2)==node1){
+				if ((*(index+3*j+0)==node2) || (*(index+3*j+1)==node2)){
 					pair[pair_count]=j;
 					pair_count++;
@@ -1148,5 +1148,5 @@
 		}
 		/*Ok, we have pair_count elements connected to this segment. For each of these elements, 
-		 *figure out if the third grid also belongs to a segment: */
+		 *figure out if the third node also belongs to a segment: */
 		if ((pair_count==0) || (pair_count==1)){ //we only select the rift segments, which belong to  2 elements
 			continue;
@@ -1156,20 +1156,20 @@
 				el=(int)pair[j];
 				triple=0;
-				/*First find grid3: */
-				if (*(index+3*el+0)==grid1){
-					if (*(index+3*el+1)==grid2)grid3=*(index+3*el+2);
-					else grid3=*(index+3*el+1);
-				}
-				if (*(index+3*el+1)==grid1){
-					if (*(index+3*el+0)==grid2)grid3=*(index+3*el+2);
-					else grid3=*(index+3*el+0);
-				}
-				if (*(index+3*el+2)==grid1){
-					if (*(index+3*el+0)==grid2)grid3=*(index+3*el+1);
-					else grid3=*(index+3*el+0);
-				}
-				/*Ok, we have grid3. Does grid3 belong to a segment? : */
+				/*First find node3: */
+				if (*(index+3*el+0)==node1){
+					if (*(index+3*el+1)==node2)node3=*(index+3*el+2);
+					else node3=*(index+3*el+1);
+				}
+				if (*(index+3*el+1)==node1){
+					if (*(index+3*el+0)==node2)node3=*(index+3*el+2);
+					else node3=*(index+3*el+0);
+				}
+				if (*(index+3*el+2)==node1){
+					if (*(index+3*el+0)==node2)node3=*(index+3*el+1);
+					else node3=*(index+3*el+0);
+				}
+				/*Ok, we have node3. Does node3 belong to a segment? : */
 				for (k=0;k<num_seg;k++){
-					if ((grid3==*(segments+3*k+0)) || (grid3==*(segments+3*k+1))){
+					if ((node3==*(segments+3*k+0)) || (node3==*(segments+3*k+1))){
 						triple=1;
 						break;
@@ -1180,26 +1180,26 @@
 					x=(double*)xrealloc(x,(nods+1)*sizeof(double));
 					y=(double*)xrealloc(y,(nods+1)*sizeof(double));
-					x[nods]=(x[(int)grid1-1]+x[(int)grid2-1]+x[(int)grid3-1])/3;
-					y[nods]=(y[(int)grid1-1]+y[(int)grid2-1]+y[(int)grid3-1])/3;
+					x[nods]=(x[(int)node1-1]+x[(int)node2-1]+x[(int)node3-1])/3;
+					y[nods]=(y[(int)node1-1]+y[(int)node2-1]+y[(int)node3-1])/3;
 
 					index=(double*)xrealloc(index,(nel+2)*3*sizeof(double));
 					/*First, reassign element el: */
-					*(index+3*el+0)=grid1;
-					*(index+3*el+1)=grid2;
+					*(index+3*el+0)=node1;
+					*(index+3*el+1)=node2;
 					*(index+3*el+2)=nods+1;
 					/*Other two elements: */
-					*(index+3*nel+0)=grid2;
-					*(index+3*nel+1)=grid3;
+					*(index+3*nel+0)=node2;
+					*(index+3*nel+1)=node3;
 					*(index+3*nel+2)=nods+1;
 
-					*(index+3*(nel+1)+0)=grid3;
-					*(index+3*(nel+1)+1)=grid1;
+					*(index+3*(nel+1)+0)=node3;
+					*(index+3*(nel+1)+1)=node1;
 					*(index+3*(nel+1)+2)=nods+1;
 					/*we need  to change the segment elements corresponding to el: */
 					for (k=0;k<num_seg;k++){
 						if (*(segments+3*k+2)==(double)(el+1)){
-							if ( ((*(segments+3*k+0)==grid1) && (*(segments+3*k+1)==grid2)) || ((*(segments+3*k+0)==grid2) && (*(segments+3*k+1)==grid1))) *(segments+3*k+2)=(double)(el+1);
-							if ( ((*(segments+3*k+0)==grid2) && (*(segments+3*k+1)==grid3)) || ((*(segments+3*k+0)==grid3) && (*(segments+3*k+1)==grid2))) *(segments+3*k+2)=(double)(nel+1);
-							if ( ((*(segments+3*k+0)==grid3) && (*(segments+3*k+1)==grid1)) || ((*(segments+3*k+0)==grid1) && (*(segments+3*k+1)==grid3))) *(segments+3*k+2)=(double)(nel+2);
+							if ( ((*(segments+3*k+0)==node1) && (*(segments+3*k+1)==node2)) || ((*(segments+3*k+0)==node2) && (*(segments+3*k+1)==node1))) *(segments+3*k+2)=(double)(el+1);
+							if ( ((*(segments+3*k+0)==node2) && (*(segments+3*k+1)==node3)) || ((*(segments+3*k+0)==node3) && (*(segments+3*k+1)==node2))) *(segments+3*k+2)=(double)(nel+1);
+							if ( ((*(segments+3*k+0)==node3) && (*(segments+3*k+1)==node1)) || ((*(segments+3*k+0)==node1) && (*(segments+3*k+1)==node3))) *(segments+3*k+2)=(double)(nel+2);
 						}
 					}
Index: /issm/trunk/src/c/shared/TriMesh/trimesh.h
===================================================================
--- /issm/trunk/src/c/shared/TriMesh/trimesh.h	(revision 8300)
+++ /issm/trunk/src/c/shared/TriMesh/trimesh.h	(revision 8301)
@@ -22,10 +22,10 @@
 int SplitMeshForRifts(int* pnel,double** pindex,int* pnods,double** px,double** py,int* pnsegs,double** psegments,double** psegmentmarkerlist);
 
-int IsGridOnRift(int* riftsegments, int nriftsegs, int grid);
-int GridElementsList(int** pGridElements, int* pNumGridElements,int grid,double * index,int nel);
+int IsGridOnRift(int* riftsegments, int nriftsegs, int node);
+int GridElementsList(int** pGridElements, int* pNumGridElements,int node,double * index,int nel);
 int IsNeighbor(int el1,int el2,double* index);
 int IsOnRift(int el,int nriftsegs,int* riftsegments);
 int RiftSegmentsFromSegments(int* pnriftsegs, int** priftsegments, int nel, double* index, int nsegs,double* segments);
-int DetermineGridElementListOnOneSideOfRift(int* pNumGridElementListOnOneSideOfRift, int** pGridElementListOnOneSideOfRift, int segmentnumber, int nriftsegs, int* riftsegments, int grid,double* index,int nel);
+int DetermineGridElementListOnOneSideOfRift(int* pNumGridElementListOnOneSideOfRift, int** pGridElementListOnOneSideOfRift, int segmentnumber, int nriftsegs, int* riftsegments, int node,double* index,int nel);
 int UpdateSegments(double** psegments,double** psegmentmarkerlist, int* pnsegs, double* index, double* x,double* y,int* riftsegments,int nriftsegs);
 int pnpoly(int npol, double *xp, double *yp, double x, double y);