Index: /issm/trunk-jpl/src/c/classes/RiftStruct.cpp
===================================================================
--- /issm/trunk-jpl/src/c/classes/RiftStruct.cpp	(revision 14221)
+++ /issm/trunk-jpl/src/c/classes/RiftStruct.cpp	(revision 14222)
@@ -22,5 +22,5 @@
 
 }/*}}}*/
-RiftStruct::RiftStruct(int numrifts_in,int *riftsnumsegments_in,double **riftssegments_in,int *riftsnumpairs_in,double **riftspairs_in,int *riftsnumpenaltypairs_in,double **riftspenaltypairs_in,double* riftstips_in){/*{{{*/
+RiftStruct::RiftStruct(int numrifts_in,int *riftsnumsegments_in,int**riftssegments_in,int *riftsnumpairs_in,int**riftspairs_in,int *riftsnumpenaltypairs_in,double **riftspenaltypairs_in,int * riftstips_in){/*{{{*/
 
 	int i;
@@ -37,8 +37,8 @@
 	/*riftssegments*/
 	_assert_(riftssegments_in);
-	this->riftssegments=xNew<double*>(numrifts_in);
+	this->riftssegments=xNew<int*>(numrifts_in);
 	for(i=0;i<numrifts_in;i++){
-		this->riftssegments[i]=xNew<double>(riftsnumsegments_in[i]*3);
-		xMemCpy<double>(this->riftssegments[i],riftssegments_in[i],riftsnumsegments_in[i]*3);
+		this->riftssegments[i]=xNew<int>(riftsnumsegments_in[i]*3);
+		xMemCpy<int>(this->riftssegments[i],riftssegments_in[i],riftsnumsegments_in[i]*3);
 	}
 
@@ -50,8 +50,8 @@
 	/*riftspairs*/
 	_assert_(riftspairs_in);
-	this->riftspairs=xNew<double*>(numrifts_in);
+	this->riftspairs=xNew<int*>(numrifts_in);
 	for(i=0;i<numrifts_in;i++){
-		this->riftspairs[i]=xNew<double>(riftsnumpairs_in[i]*2);
-		xMemCpy<double>(this->riftspairs[i],riftspairs_in[i],riftsnumpairs_in[i]*2);
+		this->riftspairs[i]=xNew<int>(riftsnumpairs_in[i]*2);
+		xMemCpy<int>(this->riftspairs[i],riftspairs_in[i],riftsnumpairs_in[i]*2);
 	}
 
@@ -71,6 +71,6 @@
 	/*riftstips*/
 	_assert_(riftstips_in);
-	this->riftstips=xNew<double>(2*numrifts_in);
-	xMemCpy<double>(this->riftstips,riftstips_in,2*numrifts_in);
+	this->riftstips=xNew<int>(2*numrifts_in);
+	xMemCpy<int>(this->riftstips,riftstips_in,2*numrifts_in);
 
 	/*state*/
@@ -85,10 +85,10 @@
 
 	xDelete<int>(this->riftsnumsegments);
-	xDelete<double*>(this->riftssegments);
+	xDelete<int*>(this->riftssegments);
 	xDelete<int>(this->riftsnumpairs);
-	xDelete<double*>(this->riftspairs);
+	xDelete<int*>(this->riftspairs);
 	xDelete<int>(this->riftsnumpenaltypairs);
 	xDelete<double*>(this->riftspenaltypairs);
-	xDelete<double>(this->riftstips);
+	xDelete<int>(this->riftstips);
 	xDelete<double*>(this->state);
 
Index: /issm/trunk-jpl/src/c/classes/RiftStruct.h
===================================================================
--- /issm/trunk-jpl/src/c/classes/RiftStruct.h	(revision 14221)
+++ /issm/trunk-jpl/src/c/classes/RiftStruct.h	(revision 14222)
@@ -10,15 +10,15 @@
 	public:
 		int      numrifts;
-		double **riftssegments;
+		int    **riftssegments;
 		int     *riftsnumsegments;
-		double **riftspairs;
+		int    **riftspairs;
 		int     *riftsnumpairs;
 		double **riftspenaltypairs;
 		int     *riftsnumpenaltypairs;
-		double  *riftstips;
+		int     *riftstips;
 		double **state;
 
 		RiftStruct();
-		RiftStruct(int numrifts_in,int *riftsnumsegments_in,double **riftssegments_in,int *riftsnumpairs_in,double **riftspairs_in,int *riftsnumpenaltypairs_in,double **riftspenaltypairs_in,double* riftstips_in);
+		RiftStruct(int numrifts_in,int *riftsnumsegments_in,int **riftssegments_in,int *riftsnumpairs_in,int **riftspairs_in,int *riftsnumpenaltypairs_in,double **riftspenaltypairs_in,int* riftstips_in);
 		~RiftStruct();
 };
Index: /issm/trunk-jpl/src/c/modules/TriMeshProcessRiftsx/TriMeshProcessRiftsx.cpp
===================================================================
--- /issm/trunk-jpl/src/c/modules/TriMeshProcessRiftsx/TriMeshProcessRiftsx.cpp	(revision 14221)
+++ /issm/trunk-jpl/src/c/modules/TriMeshProcessRiftsx/TriMeshProcessRiftsx.cpp	(revision 14222)
@@ -9,13 +9,13 @@
 #include "../../toolkits/toolkits.h"
 
-void TriMeshProcessRiftsx(double** pindex, int* pnel,double** px,double** py,int* pnods,double** psegments,double** psegmentmarkers,int *pnum_seg,RiftStruct **priftstruct){
+void TriMeshProcessRiftsx(int** pindex, int* pnel,double** px,double** py,int* pnods,int** psegments,int** psegmentmarkers,int *pnum_seg,RiftStruct **priftstruct){
 
 	/*Output*/
 	int      numrifts,numrifts0;
 	int     *riftsnumsegments     = NULL;
-	double **riftssegments        = NULL;
+	int    **riftssegments        = NULL;
 	int     *riftsnumpairs        = NULL;
-	double **riftspairs           = NULL;
-	double  *riftstips            = NULL;
+	int    **riftspairs           = NULL;
+	int     *riftstips            = NULL;
 	double **riftspenaltypairs    = NULL;
 	int     *riftsnumpenaltypairs = NULL;
@@ -23,10 +23,10 @@
 	/*Recover initial mesh*/
 	int     nel            = *pnel;
-	double *index          = *pindex;
+	int    *index          = *pindex;
 	double *x              = *px;
 	double *y              = *py;
 	int     nods           = *pnods;
-	double *segments       = *psegments;
-	double *segmentmarkers = *psegmentmarkers;
+	int    *segments       = *psegments;
+	int    *segmentmarkers = *psegmentmarkers;
 	int     num_seg        = *pnum_seg;
 
Index: /issm/trunk-jpl/src/c/modules/TriMeshProcessRiftsx/TriMeshProcessRiftsx.h
===================================================================
--- /issm/trunk-jpl/src/c/modules/TriMeshProcessRiftsx/TriMeshProcessRiftsx.h	(revision 14221)
+++ /issm/trunk-jpl/src/c/modules/TriMeshProcessRiftsx/TriMeshProcessRiftsx.h	(revision 14222)
@@ -8,5 +8,5 @@
 class RiftStruct;
 
-void TriMeshProcessRiftsx(double** pindex, int* pnel,double** px,double** py,int* pnods,double** psegments,double** psegmentmarkers,int *pnum_seg,RiftStruct **priftstruct);
+void TriMeshProcessRiftsx(int** pindex,int* pnel,double** px,double** py,int* pnods,int** psegments,int** psegmentmarkers,int *pnum_seg,RiftStruct **priftstruct);
 
 #endif  /* _TRIMESHPROCESSRIFTX_H*/
Index: /issm/trunk-jpl/src/c/modules/TriMeshx/TriMeshx.cpp
===================================================================
--- /issm/trunk-jpl/src/c/modules/TriMeshx/TriMeshx.cpp	(revision 14221)
+++ /issm/trunk-jpl/src/c/modules/TriMeshx/TriMeshx.cpp	(revision 14222)
@@ -22,5 +22,5 @@
 /*}}}*/
 
-void TriMeshx(SeqMat<IssmPDouble>** pindex,SeqVec<IssmPDouble>** px,SeqVec<IssmPDouble>** py,SeqMat<IssmPDouble>** psegments,SeqVec<IssmPDouble>** psegmentmarkerlist,DataSet* domain,DataSet* rifts,double area){
+void TriMeshx(SeqMat<int>** pindex,SeqVec<IssmPDouble>** px,SeqVec<IssmPDouble>** py,SeqMat<int>** psegments,SeqVec<int>** psegmentmarkerlist,DataSet* domain,DataSet* rifts,double area){
 
 #if !defined(_HAVE_TRIANGLE_)
@@ -31,11 +31,11 @@
 
 	/*output: */
-	IssmPDouble         *index             = NULL;
-	SeqMat<IssmPDouble> *index_matrix      = NULL;
-	double              *x                 = NULL;
-	double              *y                 = NULL;
-	double              *segments          = NULL;
-	SeqMat<IssmPDouble> *segments_matrix   = NULL;
-	double              *segmentmarkerlist = NULL;
+	int         *index             = NULL;
+	SeqMat<int> *index_matrix      = NULL;
+	double      *x                 = NULL;
+	double      *y                 = NULL;
+	int         *segments          = NULL;
+	SeqMat<int> *segments_matrix   = NULL;
+	int         *segmentmarkerlist = NULL;
 
 	/*intermediary: */
@@ -169,23 +169,23 @@
 
 	/*Allocate index, x and y: */
-	index=xNew<double>(3*out.numberoftriangles);
+	index=xNew<int>(3*out.numberoftriangles);
 	x=xNew<double>(out.numberofpoints);
 	y=xNew<double>(out.numberofpoints);
-	segments=xNew<double>(3*out.numberofsegments);
-	segmentmarkerlist=xNew<double>(out.numberofsegments);
+	segments=xNew<int>(3*out.numberofsegments);
+	segmentmarkerlist=xNew<int>(out.numberofsegments);
 
 	for (i = 0; i< out.numberoftriangles; i++) {
 		for (j = 0; j < out.numberofcorners; j++) {
-			index[3*i+j]=(double)out.trianglelist[i*out.numberofcorners+j]+1;
+			index[3*i+j]=(int)out.trianglelist[i*out.numberofcorners+j]+1;
 		}
 	}
 	for (i = 0; i< out.numberofpoints; i++){
-		x[i]=out.pointlist[i*2+0];
-		y[i]=out.pointlist[i*2+1];
+		x[i]=(double)out.pointlist[i*2+0];
+		y[i]=(double)out.pointlist[i*2+1];
 	}
 	for (i = 0; i<out.numberofsegments;i++){
-		segments[3*i+0]=(double)out.segmentlist[i*2+0]+1;
-		segments[3*i+1]=(double)out.segmentlist[i*2+1]+1;
-		segmentmarkerlist[i]=(double)out.segmentmarkerlist[i];
+		segments[3*i+0]=(int)out.segmentlist[i*2+0]+1;
+		segments[3*i+1]=(int)out.segmentlist[i*2+1]+1;
+		segmentmarkerlist[i]=(int)out.segmentmarkerlist[i];
 	}
 
@@ -197,13 +197,13 @@
 
 	/*Output : */
-	index_matrix=new SeqMat<IssmPDouble>(index,out.numberoftriangles,3,1.0);
+	index_matrix=new SeqMat<int>(index,out.numberoftriangles,3,1);
 	*pindex=index_matrix;
 
-	segments_matrix=new SeqMat<IssmPDouble>(segments,out.numberofsegments,3,1.0);
+	segments_matrix=new SeqMat<int>(segments,out.numberofsegments,3,1);
 	*psegments=segments_matrix;
 
 	*px=new SeqVec<IssmPDouble>(x,out.numberofpoints);
 	*py=new SeqVec<IssmPDouble>(y,out.numberofpoints);
-	*psegmentmarkerlist=new SeqVec<IssmPDouble>(segmentmarkerlist,out.numberofsegments);
+	*psegmentmarkerlist=new SeqVec<int>(segmentmarkerlist,out.numberofsegments);
 #endif
 }
Index: /issm/trunk-jpl/src/c/modules/TriMeshx/TriMeshx.h
===================================================================
--- /issm/trunk-jpl/src/c/modules/TriMeshx/TriMeshx.h	(revision 14221)
+++ /issm/trunk-jpl/src/c/modules/TriMeshx/TriMeshx.h	(revision 14222)
@@ -11,5 +11,5 @@
 
 /* local prototypes: */
-void TriMeshx(SeqMat<IssmPDouble>** pindex,SeqVec<IssmPDouble>** px,SeqVec<IssmPDouble>** py,SeqMat<IssmPDouble>** psegments,SeqVec<IssmPDouble>** psegmentmarkerlist,DataSet* domain,DataSet* rifts,double area);
+void TriMeshx(SeqMat<int>** pindex,SeqVec<IssmPDouble>** px,SeqVec<IssmPDouble>** py,SeqMat<int>** psegments,SeqVec<int>** psegmentmarkerlist,DataSet* domain,DataSet* rifts,double area);
 
 #endif  /* _TRIMESHX_H */
Index: /issm/trunk-jpl/src/c/shared/TriMesh/AssociateSegmentToElement.cpp
===================================================================
--- /issm/trunk-jpl/src/c/shared/TriMesh/AssociateSegmentToElement.cpp	(revision 14221)
+++ /issm/trunk-jpl/src/c/shared/TriMesh/AssociateSegmentToElement.cpp	(revision 14222)
@@ -5,27 +5,20 @@
 #include "./trimesh.h"
 
-int AssociateSegmentToElement(double** psegments,int nseg, double* index,int nel){
-
-	/*Error management: */
-	int i;
-	int noerr=1;
-
-	/*Input: */
-	double* segments=NULL;
+int AssociateSegmentToElement(int** psegments,int nseg,int* index,int nel){
 
 	/*node indices: */
-	double A,B;
+	int A,B;
 
 	/*Recover segments: */
-	segments=*psegments;
+	int* segments=*psegments;
 
-	for (i=0;i<nseg;i++){
-		A=*(segments+3*i+0);
-		B=*(segments+3*i+1);
-		*(segments+3*i+2)=FindElement(A,B,index,nel)+1; //matlab indexing.
+	for(int i=0;i<nseg;i++){
+		A=segments[3*i+0];
+		B=segments[3*i+1];
+		segments[3*i+2]=FindElement(A,B,index,nel)+1; //matlab indexing.
 	}
 
 	/*Assign output pointers: */
 	*psegments=segments;
-	return noerr;
+	return 1;
 }
Index: /issm/trunk-jpl/src/c/shared/TriMesh/OrderSegments.cpp
===================================================================
--- /issm/trunk-jpl/src/c/shared/TriMesh/OrderSegments.cpp	(revision 14221)
+++ /issm/trunk-jpl/src/c/shared/TriMesh/OrderSegments.cpp	(revision 14222)
@@ -5,25 +5,19 @@
 #include "./trimesh.h"
 
-int OrderSegments(double** psegments,int nseg, double* index,int nel){
-
-	/*Error management: */
-	int i;
-	int noerr=1;
-
-	/*Input: */
-	double* segments=NULL;
+int OrderSegments(int** psegments,int nseg,int* index,int nel){
 
 	/*vertex indices: */
-	double A,B;
-	/*element indices: */
+	int A,B;
+
+	/*element index*/
 	int el;
 
 	/*Recover segments: */
-	segments=*psegments;
+	int* segments=*psegments;
 
-	for (i=0;i<nseg;i++){
+	for(int i=0;i<nseg;i++){
 		A=segments[3*i+0];
 		B=segments[3*i+1];
-		el=(int)segments[3*i+2]-1; //after AssociateSegmentToElement, el was a matlab index, we need the c index now.
+		el=segments[3*i+2]-1; //after AssociateSegmentToElement, el was a matlab index, we need the c index now.
 
 		if (index[3*el+0]==A){
@@ -49,4 +43,4 @@
 	/*Assign output pointers: */
 	*psegments=segments;
-	return noerr;
+	return 1;
 }
Index: /issm/trunk-jpl/src/c/shared/TriMesh/SplitMeshForRifts.cpp
===================================================================
--- /issm/trunk-jpl/src/c/shared/TriMesh/SplitMeshForRifts.cpp	(revision 14221)
+++ /issm/trunk-jpl/src/c/shared/TriMesh/SplitMeshForRifts.cpp	(revision 14222)
@@ -6,5 +6,5 @@
 #include "../Alloc/alloc.h"
 
-int SplitMeshForRifts(int* pnel,double** pindex,int* pnods,double** px,double** py,int* pnsegs,double** psegments,double** psegmentmarkerlist){
+int SplitMeshForRifts(int* pnel,int** pindex,int* pnods,double** px,double** py,int* pnsegs,int** psegments,int** psegmentmarkerlist){
 
 	/*Some notes on dimensions: 
@@ -13,37 +13,22 @@
 	segments of size nsegsx3*/
 
-	/*Error management: */
-	int noerr=1;
-
 	int i,j,k,l;
 	int node;
 	int el;
-
 	int  nriftsegs;
 	int* riftsegments=NULL; 
 	int* flags=NULL;
-
 	int  NumGridElementListOnOneSideOfRift;
 	int* GridElementListOnOneSideOfRift=NULL;
 
-	/*Input: */
-	int     nel;
-	double* index=NULL;
-	int     nods;
-	double* x=NULL;
-	double* y=NULL;
-	double* segments=NULL;
-	double*    segmentmarkerlist=NULL;
-	int     nsegs;
-
 	/*Recover input: */
-	nel=*pnel;
-	index=*pindex;
-	nods=*pnods;
-	x=*px;
-	y=*py;
-	nsegs=*pnsegs;
-	segments=*psegments;
-	segmentmarkerlist=*psegmentmarkerlist;
+	int     nel               = *pnel;
+	int    *index             = *pindex;
+	int     nods              = *pnods;
+	double *x                 = *px;
+	double *y                 = *py;
+	int     nsegs             = *pnsegs;
+	int    *segments          = *psegments;
+	int    *segmentmarkerlist = *psegmentmarkerlist;
 
 	/*Establish list of segments that belong to a rift: */
@@ -90,5 +75,5 @@
 					el=GridElementListOnOneSideOfRift[k];
 					for (l=0;l<3;l++){
-						if (*(index+3*el+l)==node)*(index+3*el+l)=nods; //again, matlab indexing.
+						if (index[3*el+l]==node) index[3*el+l]=nods; //again, matlab indexing.
 					}
 				}
@@ -109,4 +94,4 @@
 	*psegments=segments;
 	*psegmentmarkerlist=segmentmarkerlist;
-	return noerr;
+	return 1;
 }
Index: /issm/trunk-jpl/src/c/shared/TriMesh/TriMeshUtils.cpp
===================================================================
--- /issm/trunk-jpl/src/c/shared/TriMesh/TriMeshUtils.cpp	(revision 14221)
+++ /issm/trunk-jpl/src/c/shared/TriMesh/TriMeshUtils.cpp	(revision 14222)
@@ -36,5 +36,5 @@
 }/*}}}*/
 /*FUNCTION GridElementsList{{{*/
-int GridElementsList(int** pGridElements, int* pNumGridElements,int node,double * index,int nel){
+int GridElementsList(int** pGridElements, int* pNumGridElements,int node,int* index,int nel){
 
 	/*From a node, recover all the elements that are connected to it: */
@@ -58,5 +58,5 @@
 	for (i=0;i<nel;i++){
 		for (j=0;j<3;j++){
-			if ((int)*(index+3*i+j)==node){
+			if (index[3*i+j]==node){
 				if (NumGridElements<=(current_size-1)){
 					GridElements[NumGridElements]=i;
@@ -90,5 +90,5 @@
 }/*}}}*/
 /*FUNCTION IsNeighbor{{{*/
-int IsNeighbor(int el1,int el2,double* index){
+int IsNeighbor(int el1,int el2,int* index){
 	/*From a triangulation held in index, figure out if elements 1 and 2 have two nodes in common: */
 	int i,j;
@@ -96,5 +96,5 @@
 	for (i=0;i<3;i++){
 		for (j=0;j<3;j++){
-			if (*(index+3*el1+i)==*(index+3*el2+j))count++;
+			if (index[3*el1+i]==index[3*el2+j])count++;
 		}
 	}
@@ -118,5 +118,5 @@
 }/*}}}*/
 /*FUNCTION RiftSegmentsFromSegments{{{*/
-void RiftSegmentsFromSegments(int* pnriftsegs, int** priftsegments, int nel, double* index, int nsegs,double* segments){
+void RiftSegmentsFromSegments(int* pnriftsegs, int** priftsegments, int nel,int* index,int nsegs,int* segments){
 
 	int i,counter;
@@ -126,5 +126,5 @@
 	int* riftsegments=NULL;
 	int* riftsegments_uncompressed=NULL; 
-	double element_nodes[3];
+	int  element_nodes[3];
 
 	/*Allocate segmentflags: */
@@ -143,23 +143,23 @@
 		element_nodes[2]=*(index+3*el+2);
 
-		*(index+3*el+0)=-1;
-		*(index+3*el+1)=-1;
-		*(index+3*el+2)=-1;
+		index[3*el+0]=-1;
+		index[3*el+1]=-1;
+		index[3*el+2]=-1;
 
 		el2=FindElement(*(segments+3*i+0),*(segments+3*i+1),index,nel); 
 
 		/*Restore index: */
-		*(index+3*el+0)=element_nodes[0];
-		*(index+3*el+1)=element_nodes[1];
-		*(index+3*el+2)=element_nodes[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){
 			/*el and el2 are on a segment rift, facing one another, plug them into riftsegments_uncompressed: */
-		    *(riftsegments_uncompressed+5*i+0)=1;
-		    *(riftsegments_uncompressed+5*i+1)=el;
-		    *(riftsegments_uncompressed+5*i+2)=el2;
-		    *(riftsegments_uncompressed+5*i+3)=(int)*(segments+3*i+0);
-		    *(riftsegments_uncompressed+5*i+4)=(int)*(segments+3*i+1);
-			nriftsegs++;
+		    riftsegments_uncompressed[5*i+0]=1;
+		    riftsegments_uncompressed[5*i+1]=el;
+		    riftsegments_uncompressed[5*i+2]=el2;
+		    riftsegments_uncompressed[5*i+3]=segments[3*i+0];
+			 riftsegments_uncompressed[5*i+4]=segments[3*i+1];
+			 nriftsegs++;
 		}
 	}
@@ -169,13 +169,12 @@
 	counter=0;
 	for (i=0;i<nsegs;i++){
-		if (*(riftsegments_uncompressed+5*i+0)){
-			*(riftsegments+counter*4+0)=*(riftsegments_uncompressed+5*i+1);
-			*(riftsegments+counter*4+1)=*(riftsegments_uncompressed+5*i+2);
-			*(riftsegments+counter*4+2)=*(riftsegments_uncompressed+5*i+3);
-			*(riftsegments+counter*4+3)=*(riftsegments_uncompressed+5*i+4);
+		if (riftsegments_uncompressed[5*i+0]){
+			riftsegments[counter*4+0]=riftsegments_uncompressed[5*i+1];
+			riftsegments[counter*4+1]=riftsegments_uncompressed[5*i+2];
+			riftsegments[counter*4+2]=riftsegments_uncompressed[5*i+3];
+			riftsegments[counter*4+3]=riftsegments_uncompressed[5*i+4];
 			counter++;
 		}
 	}
-
 	xDelete<int>(riftsegments_uncompressed);
 
@@ -185,5 +184,5 @@
 }/*}}}*/
 /*FUNCTION DetermineGridElementListOnOneSideOfRift{{{*/
-int DetermineGridElementListOnOneSideOfRift(int* pNumGridElementListOnOneSideOfRift, int** pGridElementListOnOneSideOfRift, int segmentnumber, int nriftsegs, int* riftsegments, int node,double* index,int nel){
+int DetermineGridElementListOnOneSideOfRift(int* pNumGridElementListOnOneSideOfRift, int** pGridElementListOnOneSideOfRift, int segmentnumber, int nriftsegs, int* riftsegments, int node,int* index,int nel){
 
 	int noerr=1;
@@ -249,5 +248,5 @@
 }/*}}}*/
 /*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 UpdateSegments(int** psegments,int** psegmentmarkerlist, int* pnsegs,int* index, double* x,double* y,int* riftsegments,int nriftsegs,int nods,int nel){
 
 	int noerr=1;
@@ -255,7 +254,7 @@
 	int el1,el2;
 
-	double *segments          = NULL;
-	double *segmentmarkerlist = NULL;
-	int     nsegs;
+	int *segments          = NULL;
+	int *segmentmarkerlist = NULL;
+	int  nsegs;
 
 	/*Recover input: */
@@ -265,6 +264,6 @@
 
 	/*Reallocate segments: */
-	segments         =xReNew<double>(segments,         nsegs*3,(nsegs+nriftsegs)*3);
-	segmentmarkerlist=xReNew<double>(segmentmarkerlist,nsegs,(nsegs+nriftsegs));
+	segments         =xReNew<int>(segments,         nsegs*3,(nsegs+nriftsegs)*3);
+	segmentmarkerlist=xReNew<int>(segmentmarkerlist,nsegs,(nsegs+nriftsegs));
 
 	/*First, update the existing segments to the new nodes :*/
@@ -278,5 +277,5 @@
 				 *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])){
+					if ((x[*(index+el1*3+k)-1]==x[*(segments+3*j+0)-1]) && (y[*(index+el1*3+k)-1]==y[*(segments+3*j+0)-1])){
 						*(segments+3*j+0)=*(index+el1*3+k); _assert_(segments[3*j+0]<nods+1);
 						break;
@@ -284,5 +283,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])){
+					if ((x[*(index+el1*3+k)-1]==x[*(segments+3*j+1)-1])  && (y[*(index+el1*3+k)-1]==y[*(segments+3*j+1)-1])){
 						*(segments+3*j+1)=*(index+el1*3+k); _assert_(segments[3*j+1]<nods+1);
 						break;
@@ -293,5 +292,5 @@
 				*(segmentmarkerlist+(nsegs+i))=*(segmentmarkerlist+j);
 				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])){
+					if ((x[*(index+el2*3+k)-1]==x[*(segments+3*j+0)-1]) && (y[*(index+el2*3+k)-1]==y[*(segments+3*j+0)-1])){
 						*(segments+3*(nsegs+i)+0)=*(index+el2*3+k); _assert_(segments[3*(nsegs+i)+0]<nods+1);
 						break;
@@ -299,5 +298,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])){
+					if ((x[*(index+el2*3+k)-1]==x[*(segments+3*j+1)-1]) && (y[*(index+el2*3+k)-1]==y[*(segments+3*j+1)-1])){
 						*(segments+3*(nsegs+i)+1)=*(index+el2*3+k); _assert_(segments[3*(nsegs+i)+1]<nods+1);
 						break;
@@ -309,5 +308,5 @@
 				/*Let's update segments[j][:] using  element el2 and the corresponding rift segment: */
 				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])){
+					if ((x[*(index+el2*3+k)-1]==x[*(segments+3*j+0)-1]) && (y[*(index+el2*3+k)-1]==y[*(segments+3*j+0)-1])){
 						*(segments+3*j+0)=*(index+el2*3+k); _assert_(segments[3*j+0]<nods+1);
 						break;
@@ -315,5 +314,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])){
+					if ((x[*(index+el2*3+k)-1]==x[*(segments+3*j+1)-1]) && (y[*(index+el2*3+k)-1]==y[*(segments+3*j+1)-1])){
 						*(segments+3*j+1)=*(index+el2*3+k);_assert_(segments[3*j+1]<nods+1);
 						break;
@@ -324,5 +323,5 @@
 				*(segmentmarkerlist+(nsegs+i))=*(segmentmarkerlist+j);
 				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])){
+					if ((x[*(index+el1*3+k)-1]==x[*(segments+3*j+0)-1]) && (y[*(index+el1*3+k)-1]==y[*(segments+3*j+0)-1])){
 						*(segments+3*(nsegs+i)+0)=*(index+el1*3+k);_assert_(segments[3*(nsegs+i)+0]<nods+1);
 						break;
@@ -330,5 +329,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])){
+					if ((x[*(index+el1*3+k)-1]==x[*(segments+3*j+1)-1]) && (y[*(index+el1*3+k)-1]==y[*(segments+3*j+1)-1])){
 						*(segments+3*(nsegs+i)+1)=*(index+el1*3+k);_assert_(segments[3*(nsegs+i)+1]<nods+1);
 						break;
@@ -348,10 +347,9 @@
 }/*}}}*/
 /*FUNCTION FindElement{{{*/
-int FindElement(double A,double B,double* index,int nel){
-
-	int n;
+int FindElement(int A,int B,int* index,int nel){
+
 	int el=-1;
-	for (n=0;n<nel;n++){
-		if (((*(index+3*n+0)==A)  || (*(index+3*n+1)==A) || (*(index+3*n+2)==A) ) && ((*(index+3*n+0)==B)  || (*(index+3*n+1)==B) || (*(index+3*n+2)==B))){
+	for (int n=0;n<nel;n++){
+		if(((index[3*n+0]==A) || (index[3*n+1]==A) || (index[3*n+2]==A)) && ((index[3*n+0]==B) || (index[3*n+1]==B) || (index[3*n+2]==B))){
 			el=n;
 			break;
@@ -361,5 +359,5 @@
 }/*}}}*/
 /*FUNCTION SplitRiftSegments{{{*/
-int SplitRiftSegments(double** psegments,double** psegmentmarkerlist, int* pnumsegs, int* pnumrifts,int** priftsnumsegs,double*** priftssegments,int numrifts,int nods,int nel){
+int SplitRiftSegments(int** psegments,int** psegmentmarkerlist, int* pnumsegs, int* pnumrifts,int** priftsnumsegs,int*** priftssegments,int numrifts,int nods,int nel){
 
 	/*Using segment markers, wring out the rift segments from the segments. Rift markers are 
@@ -370,22 +368,22 @@
 
 	/*input: */
-	double *segments          = NULL;
-	double *segmentmarkerlist = NULL;
+	int *segments          = NULL;
+	int *segmentmarkerlist = NULL;
 	int numsegs;
 
 	/*output: */
-	int      new_numsegs;
-	int     *riftsnumsegs       = NULL;
-	double **riftssegments      = NULL;
-	double  *new_segments       = NULL;
-	double  *new_segmentmarkers = NULL;
+	int   new_numsegs;
+	int  *riftsnumsegs       = NULL;
+	int **riftssegments      = NULL;
+	int  *new_segments       = NULL;
+	int  *new_segmentmarkers = NULL;
 
 	/*intermediary: */
-	double* riftsegment=NULL;
+	int* riftsegment=NULL;
 
 	/*Recover input arguments: */
-	segments=*psegments;
-	numsegs=*pnumsegs;
-	segmentmarkerlist=*psegmentmarkerlist;
+	segments          = *psegments;
+	numsegs           = *pnumsegs;
+	segmentmarkerlist = *psegmentmarkerlist;
 
 	/*First, figure out  how many segments will be left in 'segments': */
@@ -396,6 +394,6 @@
 	/*Allocate new segments: */
 	new_numsegs=counter;
-	new_segments=xNew<double>(new_numsegs*3);
-	new_segmentmarkers=xNew<double>(new_numsegs);
+	new_segments=xNew<int>(new_numsegs*3);
+	new_segmentmarkers=xNew<int>(new_numsegs);
 
 	/*Copy new segments info : */
@@ -413,5 +411,5 @@
 	/*Now deal with rift segments: */
 	riftsnumsegs=xNew<int>(numrifts);
-	riftssegments=xNew<double*>(numrifts);
+	riftssegments=xNew<int*>(numrifts);
 	for (i=0;i<numrifts;i++){
 		/*Figure out how many segments for rift i: */
@@ -421,5 +419,5 @@
 		}
 		riftsnumsegs[i]=counter;
-		riftsegment=xNew<double>(counter*3);
+		riftsegment=xNew<int>(counter*3);
 		/*Copy new segments info :*/
 		counter=0;
@@ -436,5 +434,5 @@
 
 	/*Free ressources: */
-	xDelete<double>(segments);
+	xDelete<int>(segments);
 
 	/*Assign output pointers: */
@@ -448,5 +446,5 @@
 }/*}}}*/
 /*FUNCTION PairRiftElements{{{*/
-int PairRiftElements(int** priftsnumpairs, double*** priftspairs,int numrifts,int* riftsnumsegments, double** riftssegments,double* x,double* y){
+int PairRiftElements(int** priftsnumpairs,int*** priftspairs,int numrifts,int* riftsnumsegments,int** riftssegments,double* x,double* y){
 
 	int noerr=1;
@@ -454,32 +452,32 @@
 
 	/*output: */
-	int     *riftsnumpairs = NULL;
-	double **riftspairs    = NULL;
+	int  *riftsnumpairs = NULL;
+	int **riftspairs    = NULL;
 
 	/*intermediary :*/
-	int     numsegs;
-	double* segments=NULL;
-	double* pairs=NULL;
-	int     node1,node2,node3,node4;
+	int  numsegs;
+	int* segments=NULL;
+	int* pairs=NULL;
+	int  node1,node2,node3,node4;
 
 	riftsnumpairs=xNew<int>(numrifts);
-	riftspairs=xNew<double*>(numrifts);
+	riftspairs=xNew<int*>(numrifts);
 	for (i=0;i<numrifts;i++){
 		segments=riftssegments[i];
-		numsegs=riftsnumsegments[i];
+		numsegs =riftsnumsegments[i];
 		riftsnumpairs[i]=numsegs;
-		pairs=xNew<double>(2*numsegs);
+		pairs=xNew<int>(2*numsegs);
 		for (j=0;j<numsegs;j++){
-			*(pairs+2*j+0)=*(segments+3*j+2); //retrieve element to which this segment belongs.
-			node1=(int)*(segments+3*j+0)-1; node2=(int)*(segments+3*j+1)-1;
+			pairs[2*j+0]=segments[3*j+2]; //retrieve element to which this segment belongs.
+			node1=segments[3*j+0]-1; node2=segments[3*j+1]-1;
 			/*Find element facing on other side of rift: */
 			for (k=0;k<numsegs;k++){
 				if (k==j)continue;
-				node3=(int)*(segments+3*k+0)-1; node4=(int)*(segments+3*k+1)-1;
+				node3=segments[3*k+0]-1; node4=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);
+					pairs[2*j+1]=segments[3*k+2];
 					break;
 				}
@@ -495,22 +493,14 @@
 }/*}}}*/
 /*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){
+int RemoveRifts(int** pindex,double** px,double** py,int* pnods,int** psegments,int* pnumsegs,int numrifts1,int* rifts1numsegs,int** rifts1segments,int** rifts1pairs,int nel){
 
 	int noerr=1;
 	int i,j,k,counter,counter1,counter2;
 
-	/*input: */
-	double* index=NULL;
-	double* x=NULL;
-	double* y=NULL;
-	int     nods;
-	double* segments=NULL;
-	int     numsegs;
-
 	/*intermediary: */
-	double *riftsegments = NULL;
-	double *riftpairs    = NULL;
+	int    *riftsegments = NULL;
+	int    *riftpairs    = NULL;
 	int     node1,node2,node3,node4,temp_node;
-	double  el2;
+	int     el2;
 	int     newnods; //temporary # node counter.
 	double  xmin,ymin;
@@ -523,10 +513,10 @@
 
 	/*Recover input: */
-	index=*pindex;
-	x=*px;
-	y=*py;
-	nods=*pnods;;
-	segments=*psegments;
-	numsegs=*pnumsegs;
+	int    *index    = *pindex;
+	double *x        = *px;
+	double *y        = *py;
+	int     nods     = *pnods;     ;
+	int    *segments = *psegments;
+	int     numsegs  = *pnumsegs;
 
 	/*initialize newnods : */
@@ -558,5 +548,5 @@
 		riftpairs=rifts1pairs[i];
 		for (j=0;j<rifts1numsegs[i];j++){
-			el2=*(riftpairs+2*j+1);
+			el2=riftpairs[2*j+1];
 			node1=(int)*(riftsegments+3*j+0);
 			node2=(int)*(riftsegments+3*j+1);
@@ -565,6 +555,6 @@
 			for (k=0;k<rifts1numsegs[i];k++){
 				if (*(riftsegments+3*k+2)==el2){
-					node3=(int)*(riftsegments+3*k+0);
-					node4=(int)*(riftsegments+3*k+1);
+					node3=*(riftsegments+3*k+0);
+					node4=*(riftsegments+3*k+1);
 					break;
 				}
@@ -677,5 +667,5 @@
 }/*}}}*/
 /*FUNCTION IsRiftPresent{{{*/
-int IsRiftPresent(int* priftflag,int* pnumrifts, double* segmentmarkerlist,int nsegs){
+int IsRiftPresent(int* priftflag,int* pnumrifts,int* segmentmarkerlist,int nsegs){
 
 	int i;
@@ -686,5 +676,5 @@
 	int numrifts=0;
 
-	double maxmark=1; //default marker for regular segments
+	int maxmark=1; //default marker for regular segments
 
 	/*Any marker >=2 indicates a certain rift: */
@@ -696,5 +686,5 @@
 		}
 	}
-	if (numrifts)riftflag=1;
+	if(numrifts)riftflag=1;
 
 	/*Assign output pointers:*/
@@ -704,5 +694,5 @@
 }/*}}}*/
 /*FUNCTION OrderRifts{{{*/
-int OrderRifts(double** priftstips, double** riftssegments,double** riftspairs,int numrifts,int* riftsnumsegments,double* x,double* y,int nods,int nels){
+int OrderRifts(int** priftstips,int** riftssegments,int** riftspairs,int numrifts,int* riftsnumsegments,double* x,double* y,int nods,int nels){
 
 	int noerr=1;
@@ -710,34 +700,34 @@
 
 	/*intermediary: */
-	double *riftsegments = NULL;
-	double *riftpairs    = NULL;
+	int *riftsegments = NULL;
+	int *riftpairs    = NULL;
 	int numsegs;
 
 	/*ordering and copy: */
-	int    *order             = NULL;
-	double *riftsegments_copy = NULL;
-	double *riftpairs_copy    = NULL;
+	int *order             = NULL;
+	int *riftsegments_copy = NULL;
+	int *riftpairs_copy    = NULL;
 
 	/*node and element manipulation: */
-	int     node1,node2,node3,node4,temp_node,tip1,tip2,node;
-	double  el2;
-	int     already_ordered=0;
+	int node1,node2,node3,node4,temp_node,tip1,tip2,node;
+	int el2;
+	int already_ordered=0;
 
 	/*output: */
-	double* riftstips=NULL;
+	int* riftstips=NULL;
 
 	/*Allocate byproduct of this routine, riftstips: */
-	riftstips=xNew<double>(numrifts*2);
+	riftstips=xNew<int>(numrifts*2);
 
 	/*Go through all rifts: */
 	for (i=0;i<numrifts;i++){
-		riftsegments=riftssegments[i];
-		riftpairs=riftspairs[i];
-		numsegs=riftsnumsegments[i];
+		riftsegments = riftssegments[i];
+		riftpairs    = riftspairs[i];
+		numsegs      = riftsnumsegments[i];
 
 		/*Allocate copy of riftsegments and riftpairs, 
 		 *as well as ordering vector: */
-		riftsegments_copy=xNew<double>(numsegs*3);
-		riftpairs_copy=xNew<double>(numsegs*2);
+		riftsegments_copy=xNew<int>(numsegs*3);
+		riftpairs_copy=xNew<int>(numsegs*2);
 		order=xNew<int>(numsegs);
 
@@ -748,12 +738,12 @@
 		for (j=0;j<numsegs;j++){
 			el2=*(riftpairs+2*j+1);
-			node1=(int)*(riftsegments+3*j+0);
-			node2=(int)*(riftsegments+3*j+1);
+			node1=*(riftsegments+3*j+0);
+			node2=*(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){
-					node3=(int)*(riftsegments+3*k+0);
-					node4=(int)*(riftsegments+3*k+1);
+					node3=*(riftsegments+3*k+0);
+					node4=*(riftsegments+3*k+1);
 					break;
 				}
@@ -796,6 +786,6 @@
 
 		/*Record tips in riftstips: */
-		*(riftstips+2*i+0)=(double)tip1;
-		*(riftstips+2*i+1)=(double)tip2;
+		*(riftstips+2*i+0)=tip1;
+		*(riftstips+2*i+1)=tip2;
 
 		/*We have the two tips for this rift.  Go from tip1 to tip2, and figure out the order in which segments are sequential. 
@@ -804,6 +794,6 @@
 		for (counter=0;counter<numsegs;counter++){
 			for (j=0;j<numsegs;j++){
-				node1=(int)*(riftsegments+3*j+0);
-				node2=(int)*(riftsegments+3*j+1);
+				node1=*(riftsegments+3*j+0);
+				node2=*(riftsegments+3*j+1);
 
 				if ((node1==node) || (node2==node)){
@@ -849,6 +839,6 @@
 
 		xDelete<int>(order);
-		xDelete<double>(riftsegments_copy);
-		xDelete<double>(riftpairs_copy);
+		xDelete<int>(riftsegments_copy);
+		xDelete<int>(riftpairs_copy);
 
 	}
@@ -859,6 +849,6 @@
 }/*}}}*/
 /*FUNCTION PenaltyPairs{{{*/
-int PenaltyPairs(double*** priftspenaltypairs,int** priftsnumpenaltypairs,int numrifts,double** riftssegments,
-		int* riftsnumsegs,double** riftspairs,double* riftstips,double* x,double* y){
+int PenaltyPairs(double*** priftspenaltypairs,int** priftsnumpenaltypairs,int numrifts,int** riftssegments,
+		int* riftsnumsegs,int** riftspairs,int* riftstips,double* x,double* y){
 
 	int noerr=1;
@@ -875,6 +865,6 @@
 	/*intermediary: */
 	int numsegs;
-	double* riftsegments=NULL;
-	double* riftpairs=NULL;
+	int* riftsegments=NULL;
+	int* riftpairs=NULL;
 	int counter;
 	double normal[2];
@@ -980,5 +970,5 @@
 		/*Renormalize normals: */
 		for(j=0;j<counter;j++){
-			double magnitude=sqrt(pow( *(riftpenaltypairs+j*7+4),2) + pow( *(riftpenaltypairs+j*7+5),2) );
+			double magnitude=sqrt(pow( double(riftpenaltypairs[j*7+4]),2) + pow( double(riftpenaltypairs[j*7+5]),2) );
 			*(riftpenaltypairs+j*7+4)=*(riftpenaltypairs+j*7+4)/magnitude;
 			*(riftpenaltypairs+j*7+5)=*(riftpenaltypairs+j*7+5)/magnitude;
@@ -993,23 +983,11 @@
 	*priftsnumpenaltypairs=riftsnumpenaltypairs;
 	return noerr;
-}
-
-/******************************************************************************************************************************
-                                   RemoveCorners
-******************************************************************************************************************************/
-
-int RemoveCornersFromRifts(double** pindex,int* pnel,double** px,double** py,int* pnods, double* segments,double* segmentmarkers,int num_seg){
+}/*}}}*/
+int RemoveCornersFromRifts(int** pindex,int* pnel,double** px,double** py,int* pnods,int* segments,int* segmentmarkers,int num_seg){/*{{{*/
 
 	int noerr=1;
 	int i,j,k;
-	double node1,node2,node3;
+	int node1,node2,node3;
 	int el;
-
-	/*input: */
-	double* index=NULL;
-	int     nel;
-	double* x=NULL;
-	double* y=NULL;
-	int     nods;
 	double  pair[2];
 	int     pair_count=0;
@@ -1017,9 +995,9 @@
 
 	/*Recover input: */
-	index=*pindex;
-	nel=*pnel;
-	x=*px;
-	y=*py;
-	nods=*pnods;
+	int    *index = *pindex;
+	int     nel   = *pnel;
+	double *x     = *px;
+	double *y     = *py;
+	int     nods  = *pnods;
 
 	for (i=0;i<num_seg;i++){
@@ -1083,5 +1061,5 @@
 					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=xReNew<double>(index,nel*3,(nel+2*3));
+					index=xReNew<int>(index,nel*3,(nel+2*3));
 					/*First, reassign element el: */
 					*(index+3*el+0)=node1;
@@ -1098,5 +1076,5 @@
 					/*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+2)==(el+1)){
 							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);
@@ -1121,3 +1099,3 @@
 	*pnods=nods;
 	return noerr;
-}
+}/*}}}*/
Index: /issm/trunk-jpl/src/c/shared/TriMesh/trimesh.h
===================================================================
--- /issm/trunk-jpl/src/c/shared/TriMesh/trimesh.h	(revision 14221)
+++ /issm/trunk-jpl/src/c/shared/TriMesh/trimesh.h	(revision 14222)
@@ -10,25 +10,25 @@
 
 //#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 AssociateSegmentToElement(int** psegments,int nseg,int* index,int nel);
+int OrderSegments(int** psegments,int nseg, int* 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 FindElement(int A,int B,int* index,int nel);
+int SplitMeshForRifts(int* pnel,int** pindex,int* pnods,double** px,double** py,int* pnsegs,int** psegments,int** psegmentmarkerlist);
 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 IsNeighbor(int el1,int el2,int* index);
 int IsOnRift(int el,int nriftsegs,int* riftsegments);
-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 nods,int nel);
-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 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);
+void RiftSegmentsFromSegments(int* pnriftsegs, int** priftsegments, int nel,int* index, int nsegs,int* segments);
+int DetermineGridElementListOnOneSideOfRift(int* pNumGridElementListOnOneSideOfRift, int** pGridElementListOnOneSideOfRift,int segmentnumber, int nriftsegs,int* riftsegments, int node,int* index,int nel);
+int UpdateSegments(int** psegments,int** psegmentmarkerlist, int* pnsegs,int* index, double* x,double* y,int* riftsegments,int nriftsegs,int nods,int nel);
+int FindElement(double A,double B,int* index,int nel);
+int RemoveRifts(int** pindex,double** px,double** py,int* pnods,int** psegments,int* pnumsegs,int numrifts1,int* rifts1numsegs,int** rifts1segments,double** rifts1pairs,int nel);
+int IsRiftPresent(int* priftflag,int* pnumrifts,int* segmentmarkerlist,int nsegs);
+int SplitRiftSegments(int** psegments,int** psegmentmarkerlist, int* pnumsegs, int* pnumrifts,int** priftsnumsegs,int*** priftssegments,int numrifts,int nods,int nels);
+int OrderRifts(int** priftstips,int** riftssegments,int** riftspairs,int numrifts,int* riftsnumsegments,double* x,double* y,int nods,int nels);
+int PenaltyPairs(double*** priftspenaltypairs,int** priftsnumpenaltypairs,int numrifts,int**  riftssegments,
+		int* riftsnumsegments,int** riftspairs,int* riftstips,double* x,double* y);
+int RemoveCornersFromRifts(int** pindex,int* pnel,double** px,double** py,int* pnods,int* segments,int* segmentmarkers,int num_seg);
+int PairRiftElements(int** priftsnumpairs,int*** priftspairs,int numrifts,int* riftsnumsegments,int** riftssegments,double* x,double* y);
 
 #endif  /* _SHARED_TRIMESH_H */