Index: /issm/trunk-jpl/src/c/shared/TriMesh/SplitMeshForRifts.cpp
===================================================================
--- /issm/trunk-jpl/src/c/shared/TriMesh/SplitMeshForRifts.cpp	(revision 12079)
+++ /issm/trunk-jpl/src/c/shared/TriMesh/SplitMeshForRifts.cpp	(revision 12080)
@@ -57,5 +57,5 @@
 		for (j=0;j<2;j++){
 	
-			node=*(riftsegments+4*i+j+2);
+			node=riftsegments[4*i+j+2];
 			if(flags[node-1]){
 				/*This node was already split, skip:*/
@@ -94,5 +94,5 @@
 
 	/*update segments: they got modified completely by adding new nodes.*/
-	UpdateSegments(&segments,&segmentmarkerlist, &nsegs,index,x,y,riftsegments,nriftsegs);
+	UpdateSegments(&segments,&segmentmarkerlist, &nsegs,index,x,y,riftsegments,nriftsegs,nods,nel);
 
 	/*Assign output pointers: */
Index: /issm/trunk-jpl/src/c/shared/TriMesh/TriMeshUtils.cpp
===================================================================
--- /issm/trunk-jpl/src/c/shared/TriMesh/TriMeshUtils.cpp	(revision 12079)
+++ /issm/trunk-jpl/src/c/shared/TriMesh/TriMeshUtils.cpp	(revision 12080)
@@ -11,4 +11,5 @@
 
 #define RIFTPENALTYPAIRSWIDTH 8
+/*FUNCTION IsGridOnRift{{{*/
 int IsGridOnRift(int* riftsegments, int nriftsegs, int node){
 
@@ -32,7 +33,6 @@
 		return 0;
 	}
-}
-				
-
+}/*}}}*/
+/*FUNCTION GridElementsList{{{*/
 int GridElementsList(int** pGridElements, int* pNumGridElements,int node,double * index,int nel){
 
@@ -87,7 +87,6 @@
 	*pNumGridElements=NumGridElements;
 	return noerr;
-}
-
-
+}/*}}}*/
+/*FUNCTION IsNeighbor{{{*/
 int IsNeighbor(int el1,int el2,double* index){
 	/*From a triangulation held in index, figure out if elements 1 and 2 have two nodes in common: */
@@ -105,7 +104,6 @@
 		return 0;
 	}
-}
-							
-
+}/*}}}*/
+/*FUNCTION IsOnRift{{{*/
 int IsOnRift(int el,int nriftsegs,int* riftsegments){
 	/*From a list of elements segments, figure out if el belongs to it: */
@@ -117,11 +115,6 @@
 	}
 	return 0;
-}
-
-
-/******************************************************************************************************************************
-                                   RiftSegmentsFromSegments
-******************************************************************************************************************************/
-
+}/*}}}*/
+/*FUNCTION RiftSegmentsFromSegments{{{*/
 void RiftSegmentsFromSegments(int* pnriftsegs, int** priftsegments, int nel, double* index, int nsegs,double* segments){
 	
@@ -189,10 +182,6 @@
 	*priftsegments=riftsegments;
 	*pnriftsegs=nriftsegs;
-}
-
-/******************************************************************************************************************************
-                                   DetermineGridElementListOnOneSideOfRift
-******************************************************************************************************************************/
-
+}/*}}}*/
+/*FUNCTION DetermineGridElementListOnOneSideOfRift{{{*/
 int DetermineGridElementListOnOneSideOfRift(int* pNumGridElementListOnOneSideOfRift, int** pGridElementListOnOneSideOfRift, int segmentnumber, int nriftsegs, int* riftsegments, int node,double* index,int nel){
 
@@ -257,11 +246,7 @@
 	*pGridElementListOnOneSideOfRift=GridElementListOnOneSideOfRift;
 	return noerr;
-}
-
-/******************************************************************************************************************************
-                                   UpdateSegments
-******************************************************************************************************************************/
-
-int UpdateSegments(double** psegments,double** psegmentmarkerlist, int* pnsegs, double* index, double* x,double* y,int* riftsegments,int nriftsegs){
+}/*}}}*/
+/*FUNCTION UpdateSegments{{{*/
+int UpdateSegments(double** psegments,double** psegmentmarkerlist, int* pnsegs, double* index, double* x,double* y,int* riftsegments,int nriftsegs,int nods,int nel){
 
 	int noerr=1;
@@ -284,8 +269,8 @@
 	/*First, update the existing segments to the new nodes :*/
 	for (i=0;i<nriftsegs;i++){
-		el1=*(riftsegments+4*i+0);
-		el2=*(riftsegments+4*i+1);
+		el1=riftsegments[4*i+0];
+		el2=riftsegments[4*i+1];
 		for (j=0;j<nsegs;j++){
-			if (*(segments+3*j+2)==(el1+1)){
+			if (segments[3*j+2]==(el1+1)){
 				/*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, 
@@ -293,5 +278,5 @@
 				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])){
-						*(segments+3*j+0)=*(index+el1*3+k);
+						*(segments+3*j+0)=*(index+el1*3+k); _assert_(segments[3*j+0]<nods);
 						break;
 					}
@@ -299,5 +284,5 @@
 				for (k=0;k<3;k++){
 					if ((x[(int)*(index+el1*3+k)-1]==x[(int)*(segments+3*j+1)-1])  && (y[(int)*(index+el1*3+k)-1]==y[(int)*(segments+3*j+1)-1])){
-						*(segments+3*j+1)=*(index+el1*3+k);
+						*(segments+3*j+1)=*(index+el1*3+k); _assert_(segments[3*j+1]<nods);
 						break;
 					}
@@ -308,5 +293,5 @@
 				for (k=0;k<3;k++){
 					if ((x[(int)*(index+el2*3+k)-1]==x[(int)*(segments+3*j+0)-1]) && (y[(int)*(index+el2*3+k)-1]==y[(int)*(segments+3*j+0)-1])){
-						*(segments+3*(nsegs+i)+0)=*(index+el2*3+k);
+						*(segments+3*(nsegs+i)+0)=*(index+el2*3+k); _assert_(segments[3*(nsegs+i)+0]<nods);
 						break;
 					}
@@ -314,5 +299,5 @@
 				for (k=0;k<3;k++){
 					if ((x[(int)*(index+el2*3+k)-1]==x[(int)*(segments+3*j+1)-1]) && (y[(int)*(index+el2*3+k)-1]==y[(int)*(segments+3*j+1)-1])){
-						*(segments+3*(nsegs+i)+1)=*(index+el2*3+k);
+						*(segments+3*(nsegs+i)+1)=*(index+el2*3+k); _assert_(segments[3*(nsegs+i)+1]<nods);
 						break;
 					}
@@ -324,5 +309,5 @@
 				for (k=0;k<3;k++){
 					if ((x[(int)*(index+el2*3+k)-1]==x[(int)*(segments+3*j+0)-1]) && (y[(int)*(index+el2*3+k)-1]==y[(int)*(segments+3*j+0)-1])){
-						*(segments+3*j+0)=*(index+el2*3+k);
+						*(segments+3*j+0)=*(index+el2*3+k); _assert_(segments[3*j+0]<nods);
 						break;
 					}
@@ -330,5 +315,5 @@
 				for (k=0;k<3;k++){
 					if ((x[(int)*(index+el2*3+k)-1]==x[(int)*(segments+3*j+1)-1]) && (y[(int)*(index+el2*3+k)-1]==y[(int)*(segments+3*j+1)-1])){
-						*(segments+3*j+1)=*(index+el2*3+k);
+						*(segments+3*j+1)=*(index+el2*3+k);_assert_(segments[3*j+1]<nods);
 						break;
 					}
@@ -339,5 +324,5 @@
 				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])){
-						*(segments+3*(nsegs+i)+0)=*(index+el1*3+k);
+						*(segments+3*(nsegs+i)+0)=*(index+el1*3+k);_assert_(segments[3*(nsegs+i)+0]<nods);
 						break;
 					}
@@ -345,5 +330,5 @@
 				for (k=0;k<3;k++){
 					if ((x[(int)*(index+el1*3+k)-1]==x[(int)*(segments+3*j+1)-1]) && (y[(int)*(index+el1*3+k)-1]==y[(int)*(segments+3*j+1)-1])){
-						*(segments+3*(nsegs+i)+1)=*(index+el1*3+k);
+						*(segments+3*(nsegs+i)+1)=*(index+el1*3+k);_assert_(segments[3*(nsegs+i)+1]<nods);
 						break;
 					}
@@ -360,9 +345,6 @@
 	
 	return noerr;
-}
-
-/******************************************************************************************************************************
-                                   pnpoly
-******************************************************************************************************************************/
+}/*}}}*/
+/*FUNCTION pnpoly{{{*/
 int pnpoly(int npol, double *xp, double *yp, double x, double y) {
 	int i, j, c = 0;
@@ -374,33 +356,6 @@
 	}
 	return c;
-}
-
-/******************************************************************************************************************************
-                                   IsInPoly
-******************************************************************************************************************************/
-//void IsInPoly(double* in,double* xc,double* yc,int numnodes,double* x,double* y,int nods){
-//
-//	int i;
-//	double x0,y0;
-//
-//	/*Go through all nodes of the mesh:*/
-//	for (i=0;i<nods;i++){
-//		if (in[i]){
-//			/*this node already is inside one of the contours, continue*/
-//			continue;
-//		}
-//		/*pick up node: */
-//		x0=x[i];
-//		y0=y[i];
-//		if (pnpoly(numnodes,xc,yc,x0,y0)){
-//			in[i]=1;
-//		}
-//	}
-//}
-
-/******************************************************************************************************************************
-                                   FindElement
-******************************************************************************************************************************/
-
+}/*}}}*/
+/*FUNCTION FindElement{{{*/
 int FindElement(double A,double B,double* index,int nel){
 
@@ -414,10 +369,7 @@
 	}
 	return el;
-}
-/******************************************************************************************************************************
-                                   SplitRiftSegments
-******************************************************************************************************************************/
-
-int SplitRiftSegments(double** psegments,double** psegmentmarkerlist, int* pnumsegs, int* pnumrifts,int** priftsnumsegs,double*** priftssegments,int numrifts){
+}/*}}}*/
+/*FUNCTION SplitRiftSegments{{{*/
+int SplitRiftSegments(double** psegments,double** psegmentmarkerlist, int* pnumsegs, int* pnumrifts,int** priftsnumsegs,double*** priftssegments,int numrifts,int nods,int nel){
 
 	/*Using segment markers, wring out the rift segments from the segments. Rift markers are 
@@ -461,7 +413,7 @@
 	for (i=0;i<numsegs;i++){
 		if (segmentmarkerlist[i]==1){
-			*(new_segments+3*counter+0)=*(segments+3*i+0);
-			*(new_segments+3*counter+1)=*(segments+3*i+1);
-			*(new_segments+3*counter+2)=*(segments+3*i+2);
+			new_segments[3*counter+0]=segments[3*i+0];
+			new_segments[3*counter+1]=segments[3*i+1];
+			new_segments[3*counter+2]=segments[3*i+2];
 			new_segmentmarkers[counter]=segmentmarkerlist[i];
 			counter++;
@@ -484,7 +436,7 @@
 		for (j=0;j<numsegs;j++){
 			if (segmentmarkerlist[j]==(2+i)){
-				*(riftsegment+3*counter+0)=*(segments+3*j+0);
-				*(riftsegment+3*counter+1)=*(segments+3*j+1);
-				*(riftsegment+3*counter+2)=*(segments+3*j+2);
+				riftsegment[3*counter+0]=segments[3*j+0];_assert_(riftsegment[3*counter+0]<nods);
+				riftsegment[3*counter+1]=segments[3*j+1];_assert_(riftsegment[3*counter+1]<nods);
+				riftsegment[3*counter+2]=segments[3*j+2];_assert_(riftsegment[3*counter+2]<nel);
 				counter++;
 			}
@@ -504,10 +456,6 @@
 	*priftsnumsegs=riftsnumsegs;
 	return noerr;
-}
-
-/******************************************************************************************************************************
-                                   PairRiftElements
-******************************************************************************************************************************/
-
+}/*}}}*/
+/*FUNCTION PairRiftElements{{{*/
 int PairRiftElements(int** priftsnumpairs, double*** priftspairs,int numrifts,int* riftsnumsegments, double** riftssegments,double* x,double* y){
 
@@ -558,15 +506,6 @@
 
 	return noerr;
-}
-
-
-/******************************************************************************************************************************
-                                   RemoveRifts
-******************************************************************************************************************************/
-
-double dabs(double x){
-	if (x<0)x=-x;
-	return x;
-}
+}/*}}}*/
+/*FUNCTION RemoveRifts{{{*/
 int RemoveRifts(double** pindex,double** px,double** py,int* pnods,double** psegments,int* pnumsegs,int numrifts1,int* rifts1numsegs,double** rifts1segments,double** rifts1pairs,int nel){
 
@@ -615,6 +554,6 @@
 		if (y[i]<ymin)ymin=y[i];
 	}
-	xmin=xmin-dabs(xmin); 
-	ymin=ymin-dabs(ymin);
+	xmin=xmin-fabs(xmin); 
+	ymin=ymin-fabs(ymin);
 
 	/*Initialize two arrays, one for nodes that are going to be merged, the other with corresponding nodes being merge into: */
@@ -751,10 +690,6 @@
 
 	return noerr;
-}
-
-/******************************************************************************************************************************
-                                   IsRiftPresent
-******************************************************************************************************************************/
-
+}/*}}}*/
+/*FUNCTION IsRiftPresent{{{*/
 int IsRiftPresent(int* priftflag,int* pnumrifts, double* segmentmarkerlist,int nsegs){
 
@@ -783,10 +718,6 @@
 
 	return noerr;
-}
-
-/******************************************************************************************************************************
-                                   OrderRifts
-******************************************************************************************************************************/
-
+}/*}}}*/
+/*FUNCTION OrderRifts{{{*/
 int OrderRifts(double** priftstips, double** riftssegments,double** riftspairs,int numrifts,int* riftsnumsegments,double* x,double* y,int nods,int nels){
 	
@@ -944,10 +875,6 @@
 	*priftstips=riftstips;
 	return noerr;
-}
-
-/******************************************************************************************************************************
-                                   PenaltyPairs
-******************************************************************************************************************************/
-
+}/*}}}*/
+/*FUNCTION PenaltyPairs{{{*/
 int PenaltyPairs(double*** priftspenaltypairs,int** priftsnumpenaltypairs,int numrifts,double** riftssegments,
 		int* riftsnumsegs,double** riftspairs,double* riftstips,double* x,double* y){
Index: /issm/trunk-jpl/src/c/shared/TriMesh/trimesh.h
===================================================================
--- /issm/trunk-jpl/src/c/shared/TriMesh/trimesh.h	(revision 12079)
+++ /issm/trunk-jpl/src/c/shared/TriMesh/trimesh.h	(revision 12080)
@@ -6,20 +6,13 @@
 #define _SHARED_TRIMESH_H
 
-
 #include <stdio.h>
 #include <math.h>
 
-
-
 //#define REAL double //took  it out because it may conflict with stdlib.h defines. put back if necessary
-
 int AssociateSegmentToElement(double** psegments,int nseg, double* index,int nel);
 int OrderSegments(double** psegments,int nseg, double* index,int nel);
-		
 int GridInsideHole(double* px0,double* py0,int n,double* x,double* y);
 int FindElement(double A,double B,double* index,int nel);
-
 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 node);
 int GridElementsList(int** pGridElements, int* pNumGridElements,int node,double * index,int nel);
@@ -28,17 +21,15 @@
 void 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 node,double* index,int nel);
-int UpdateSegments(double** psegments,double** psegmentmarkerlist, int* pnsegs, double* index, double* x,double* y,int* riftsegments,int nriftsegs);
+int UpdateSegments(double** psegments,double** psegmentmarkerlist, int* pnsegs, double* index, double* x,double* y,int* riftsegments,int nriftsegs,int nods,int nel);
 int pnpoly(int npol, double *xp, double *yp, double x, double y);
 int FindElement(double A,double B,double* index,int nel);
 int RemoveRifts(double** pindex,double** px,double** py,int* pnods,double** psegments,int* pnumsegs,int numrifts1,int* rifts1numsegs,double** rifts1segments,double** rifts1pairs,int nel);
 int IsRiftPresent(int* priftflag,int* pnumrifts, double* segmentmarkerlist,int nsegs);
-int SplitRiftSegments(double** psegments,double** psegmentmarkerlist, int* pnumsegs, int* pnumrifts,int** priftsnumsegs,double*** priftssegments,int numrifts);
+int SplitRiftSegments(double** psegments,double** psegmentmarkerlist, int* pnumsegs, int* pnumrifts,int** priftsnumsegs,double*** priftssegments,int numrifts,int nods,int nels);
 int OrderRifts(double** priftstips, double** riftssegments,double** riftspairs,int numrifts,int* riftsnumsegments,double* x,double* y,int nods,int nels);
 int PenaltyPairs(double*** priftspenaltypairs,int** priftsnumpenaltypairs,int numrifts,double**  riftssegments,
 		int* riftsnumsegments,double** riftspairs,double* riftstips,double* x,double* y);
-
 int RemoveCornersFromRifts(double** pindex,int* pnel,double** px,double** py,int* pnods, double* segments,double* segmentmarkers,int num_seg);
 int PairRiftElements(int** priftsnumpairs, double*** priftspairs,int numrifts,int* riftsnumsegments, double** riftssegments,double* x,double* y);
 
-
 #endif  /* _SHARED_TRIMESH_H */