Index: /issm/trunk-jpl/src/c/Container/Elements.cpp
===================================================================
--- /issm/trunk-jpl/src/c/Container/Elements.cpp	(revision 13611)
+++ /issm/trunk-jpl/src/c/Container/Elements.cpp	(revision 13612)
@@ -168,6 +168,6 @@
 	int i;
 	
-	int my_rank2;
-	int num_procs2;
+	int my_rank;
+	int num_procs;
 
 	Patch  *patch        = NULL;
@@ -185,7 +185,7 @@
 	int    minrank;
 	
-	/*recover my_rank2:*/
-	my_rank2=IssmComm::GetRank();
-	num_procs2=IssmComm::GetSize();
+	/*recover my_rank:*/
+	my_rank=IssmComm::GetRank();
+	num_procs=IssmComm::GetSize();
 
 	/*Recover parameters: */
@@ -200,13 +200,13 @@
 		/*Get rank of first cpu that has results*/
 		#ifdef _HAVE_MPI_
-		if(this->Size()) rank=my_rank2;
-		else rank=num_procs2;
+		if(this->Size()) rank=my_rank;
+		else rank=num_procs;
 		MPI_Allreduce (&rank,&minrank,1,MPI_INT,MPI_MIN,IssmComm::GetComm());
 		#else
-		minrank=my_rank2;
+		minrank=my_rank;
 		#endif
 
 		/*see what the first element of this partition has in stock (this is common to all partitions)*/
-		if(my_rank2==minrank){
+		if(my_rank==minrank){
 			if(this->Size()==0) _error_("Cannot write results because there is no element??");
 			Element* element=(Element*)this->GetObjectByOffset(0);
@@ -220,5 +220,5 @@
 		if(!numberofresults) return;
 		#ifdef _HAVE_MPI_
-		if(my_rank2!=minrank){
+		if(my_rank!=minrank){
 			resultsenums=xNew<int>(numberofresults);
 			resultssizes=xNew<int>(numberofresults);
@@ -249,5 +249,5 @@
 			/*Serialize and add to results*/
 			vector_serial=vector->ToMPISerial();
-			if(my_rank2==0){
+			if(my_rank==0){
 				/*No need to add this vector for all cpus*/
 				#ifdef _HAVE_ADOLC_
Index: /issm/trunk-jpl/src/c/Container/Nodes.cpp
===================================================================
--- /issm/trunk-jpl/src/c/Container/Nodes.cpp	(revision 13611)
+++ /issm/trunk-jpl/src/c/Container/Nodes.cpp	(revision 13612)
@@ -56,6 +56,6 @@
 void  Nodes::DistributeDofs(int analysis_type,int setenum){
 
-	int num_procs2;
-	int my_rank2;
+	int num_procs;
+	int my_rank;
 
 	int  i;
@@ -67,7 +67,7 @@
 	int  numnodes=0;
 	
-	/*recover my_rank2:*/
-	my_rank2=IssmComm::GetRank();
-	num_procs2=IssmComm::GetSize();
+	/*recover my_rank:*/
+	my_rank=IssmComm::GetRank();
+	num_procs=IssmComm::GetSize();
 
 	/*some check: */
@@ -88,8 +88,8 @@
 	 * cpus by the total last dofs of the previus cpu, starting from 0.
 	 * First: get number of dofs for each cpu*/
-	alldofcount=xNew<int>(num_procs2);
+	alldofcount=xNew<int>(num_procs);
 	#ifdef _HAVE_MPI_
 	MPI_Gather(&dofcount,1,MPI_INT,alldofcount,1,MPI_INT,0,IssmComm::GetComm());
-	MPI_Bcast(alldofcount,num_procs2,MPI_INT,0,IssmComm::GetComm());
+	MPI_Bcast(alldofcount,num_procs,MPI_INT,0,IssmComm::GetComm());
 	#else
 	alldofcount[0]=dofcount;
@@ -98,6 +98,6 @@
 	/* Every cpu should start its own dof count at the end of the dofcount from cpu-1*/
 	dofcount=0;
-	if(my_rank2!=0){
-		for(i=0;i<my_rank2;i++){
+	if(my_rank!=0){
+		for(i=0;i<my_rank;i++){
 			dofcount+=alldofcount[i];
 		}
@@ -152,5 +152,5 @@
 
 	int i;
-	int num_procs2;
+	int num_procs;
 
 	int* ranks=NULL;
@@ -158,6 +158,6 @@
 	int  numnodes;
 
-	/*recover num_procs2: */
-	num_procs2=IssmComm::GetSize();
+	/*recover num_procs: */
+	num_procs=IssmComm::GetSize();
 
 	/*Figure out number of nodes for this analysis: */
@@ -167,5 +167,5 @@
 	ranks=xNew<int>(numnodes);
 	minranks=xNew<int>(numnodes);
-	for(i=0;i<numnodes;i++)ranks[i]=num_procs2; //no cpu can have rank num_procs. This is the maximum limit.
+	for(i=0;i<numnodes;i++)ranks[i]=num_procs; //no cpu can have rank num_procs. This is the maximum limit.
 
 	/*Now go through all our objects and ask them to report to who they belong (which rank): */
@@ -335,9 +335,9 @@
 void   Nodes::Ranks(int* ranks,int analysis_type){
 
-	int my_rank2;
+	int my_rank;
 	int        sid;
 	
-	/*recover my_rank2:*/
-	my_rank2=IssmComm::GetRank();
+	/*recover my_rank:*/
+	my_rank=IssmComm::GetRank();
 
 	/*Go through nodes, and for each object, report it cpu: */
@@ -350,5 +350,5 @@
 			/*Plug rank into ranks, according to sid: */
 			sid=node->Sid();
-			ranks[sid]=my_rank2; 
+			ranks[sid]=my_rank; 
 		}
 	}
Index: /issm/trunk-jpl/src/c/Container/Vertices.cpp
===================================================================
--- /issm/trunk-jpl/src/c/Container/Vertices.cpp	(revision 13611)
+++ /issm/trunk-jpl/src/c/Container/Vertices.cpp	(revision 13612)
@@ -41,6 +41,6 @@
 void  Vertices::DistributePids(int numberofobjects){
 
-	int num_procs2;
-	int my_rank2;
+	int num_procs;
+	int my_rank;
 
 	int  i;
@@ -50,7 +50,7 @@
 	int *alltruepids = NULL;
 	
-	/*recover my_rank2:*/
-	my_rank2=IssmComm::GetRank();
-	num_procs2=IssmComm::GetSize();
+	/*recover my_rank:*/
+	my_rank=IssmComm::GetRank();
+	num_procs=IssmComm::GetSize();
 
 	/*Go through objects, and distribute pids locally, from 0 to numberofpidsperobject*/
@@ -64,8 +64,8 @@
 	 * cpus by the total last pids of the previus cpu, starting from 0.
 	 * First: get number of pids for each cpu*/
-	allpidcount=xNew<int>(num_procs2);
+	allpidcount=xNew<int>(num_procs);
 	#ifdef _HAVE_MPI_
 	MPI_Gather(&pidcount,1,MPI_INT,allpidcount,1,MPI_INT,0,IssmComm::GetComm());
-	MPI_Bcast(allpidcount,num_procs2,MPI_INT,0,IssmComm::GetComm());
+	MPI_Bcast(allpidcount,num_procs,MPI_INT,0,IssmComm::GetComm());
 	#else
 	allpidcount[0]=pidcount;
@@ -74,6 +74,6 @@
 	/* Every cpu should start its own pid count at the end of the pidcount from cpu-1*/
 	pidcount=0;
-	if(my_rank2!=0){
-		for(i=0;i<my_rank2;i++){
+	if(my_rank!=0){
+		for(i=0;i<my_rank;i++){
 			pidcount+=allpidcount[i];
 		}
@@ -115,11 +115,11 @@
 
 	int i;
-	int num_procs2;
+	int num_procs;
 
 	int* ranks=NULL;
 	int* minranks=NULL;
 	
-	/*recover num_procs2:*/
-	num_procs2=IssmComm::GetSize();
+	/*recover num_procs:*/
+	num_procs=IssmComm::GetSize();
 
 	/*Allocate ranks: */
@@ -127,5 +127,5 @@
 	minranks=xNew<int>(numberofobjects);
 
-	for(i=0;i<numberofobjects;i++)ranks[i]=num_procs2; //no cpu can have rank num_procs. This is the maximum limit.
+	for(i=0;i<numberofobjects;i++)ranks[i]=num_procs; //no cpu can have rank num_procs. This is the maximum limit.
 
 	/*Now go through all our objects and ask them to report to who they belong (which rank): */
@@ -184,9 +184,9 @@
 void   Vertices::Ranks(int* ranks){
 
-	int my_rank2;
+	int my_rank;
 	int        sid;
 	
-	/*recover my_rank2:*/
-	my_rank2=IssmComm::GetRank();
+	/*recover my_rank:*/
+	my_rank=IssmComm::GetRank();
 
 	/*Go through a dataset, and for each object, report it cpu: */
@@ -195,6 +195,6 @@
 		Vertex* vertex=(Vertex*)this->GetObjectByOffset(i);
 		sid=vertex->Sid();
-		ranks[sid]=my_rank2; 
-	}
-}
-/*}}}*/
+		ranks[sid]=my_rank; 
+	}
+}
+/*}}}*/
Index: /issm/trunk-jpl/src/c/classes/FemModel.cpp
===================================================================
--- /issm/trunk-jpl/src/c/classes/FemModel.cpp	(revision 13611)
+++ /issm/trunk-jpl/src/c/classes/FemModel.cpp	(revision 13612)
@@ -84,11 +84,11 @@
 	FILE       *petscoptionsfid = NULL;
 	FILE       *output_fid = NULL;
-	int         my_rank2;
-	
-	/*recover my_rank2:*/
-	my_rank2=IssmComm::GetRank();
+	int         my_rank;
+	
+	/*recover my_rank:*/
+	my_rank=IssmComm::GetRank();
 
 	/*Open input file on cpu 0: */
-	if(my_rank2==0) IOMODEL = pfopen(inputfilename ,"rb");
+	if(my_rank==0) IOMODEL = pfopen(inputfilename ,"rb");
 
 	/*Initialize internal data: */
@@ -130,5 +130,5 @@
 	
 	/*Close input file descriptors: */
-	if(my_rank2==0) pfclose(IOMODEL,inputfilename);
+	if(my_rank==0) pfclose(IOMODEL,inputfilename);
 
 	/*Open output file once for all and add output file name and file descriptor to parameters*/
Index: /issm/trunk-jpl/src/c/classes/IoModel.cpp
===================================================================
--- /issm/trunk-jpl/src/c/classes/IoModel.cpp	(revision 13611)
+++ /issm/trunk-jpl/src/c/classes/IoModel.cpp	(revision 13612)
@@ -104,15 +104,15 @@
 void  IoModel::CheckEnumSync(void){
 
-	int my_rank2;
+	int my_rank;
 	int record_enum = 0;
 
-	/*recover my_rank2:*/
-	my_rank2=IssmComm::GetRank();
+	/*recover my_rank:*/
+	my_rank=IssmComm::GetRank();
 
 	/*Check that some fields have been allocated*/
-	_assert_(this->fid || my_rank2);
+	_assert_(this->fid || my_rank);
 
 	/*Go find in the binary file, the position of the data we want to fetch: */
-	if(my_rank2==0){ //cpu 0
+	if(my_rank==0){ //cpu 0
 
 		/*First set FILE* position to the beginning of the file: */
@@ -299,5 +299,5 @@
 void  IoModel::FetchConstants(void){
 
-	int my_rank2;
+	int my_rank;
 	
 	/*record descriptions; */
@@ -314,13 +314,13 @@
 	int   string_size;
 
-	/*recover my_rank2:*/
-	my_rank2=IssmComm::GetRank();
+	/*recover my_rank:*/
+	my_rank=IssmComm::GetRank();
 
 	/*Check that some fields have been allocated*/
-	_assert_(this->fid || my_rank2);
+	_assert_(this->fid || my_rank);
 	_assert_(this->constants);
 
 	/*Go find in the binary file, the position of the data we want to fetch: */
-	if(my_rank2==0){ //cpu 0{{{
+	if(my_rank==0){ //cpu 0{{{
 	
 		/*First set FILE* position to the beginning of the file: */
@@ -540,5 +540,5 @@
 void  IoModel::FetchData(bool* pboolean,int data_enum){
 
-	int my_rank2;
+	int my_rank;
 	
 
@@ -547,6 +547,6 @@
 	int   code;
 	
-	/*recover my_rank2:*/
-	my_rank2=IssmComm::GetRank();
+	/*recover my_rank:*/
+	my_rank=IssmComm::GetRank();
 
 	
@@ -557,5 +557,5 @@
 	
 	/*We have to read a boolean from disk. */
-	if(my_rank2==0){  
+	if(my_rank==0){  
 		if(fread(&booleanint,sizeof(int),1,fid)!=1) _error_("could not read boolean ");
 	}
@@ -573,5 +573,5 @@
 void  IoModel::FetchData(int* pinteger,int data_enum){
 
-	int my_rank2;
+	int my_rank;
 
 	/*output: */
@@ -579,6 +579,6 @@
 	int   code;
 	
-	/*recover my_rank2:*/
-	my_rank2=IssmComm::GetRank();
+	/*recover my_rank:*/
+	my_rank=IssmComm::GetRank();
 	
 	/*Set file pointer to beginning of the data: */
@@ -588,5 +588,5 @@
 	
 	/*We have to read a integer from disk. First read the dimensions of the integer, then the integer: */
-	if(my_rank2==0){  
+	if(my_rank==0){  
 		if(fread(&integer,sizeof(int),1,fid)!=1) _error_("could not read integer ");
 	}
@@ -604,5 +604,5 @@
 
 
-	int my_rank2;
+	int my_rank;
 	
 
@@ -611,6 +611,6 @@
 	int      code;
 	
-	/*recover my_rank2:*/
-	my_rank2=IssmComm::GetRank();
+	/*recover my_rank:*/
+	my_rank=IssmComm::GetRank();
 
 	/*Set file pointer to beginning of the data: */
@@ -620,5 +620,5 @@
 	
 	/*We have to read a scalar from disk. First read the dimensions of the scalar, then the scalar: */
-	if(my_rank2==0){
+	if(my_rank==0){
 		if(fread(&scalar,sizeof(IssmPDouble),1,fid)!=1)_error_("could not read scalar ");
 	}
@@ -635,5 +635,5 @@
 void  IoModel::FetchData(char** pstring,int data_enum){
 
-	int my_rank2;
+	int my_rank;
 	
 
@@ -643,6 +643,6 @@
 	int code=0;
 	
-	/*recover my_rank2:*/
-	my_rank2=IssmComm::GetRank();
+	/*recover my_rank:*/
+	my_rank=IssmComm::GetRank();
 
 	/*Set file pointer to beginning of the data: */
@@ -654,5 +654,5 @@
 	
 	/*We have to read a string from disk. First read the dimensions of the string, then the string: */
-	if(my_rank2==0){  
+	if(my_rank==0){  
 		if(fread(&string_size,sizeof(int),1,fid)!=1) _error_("could not read length of string ");
 	}
@@ -668,5 +668,5 @@
 
 		/*Read string on node 0, then broadcast: */
-		if(my_rank2==0){  
+		if(my_rank==0){  
 			if(fread(string,string_size*sizeof(char),1,fid)!=1)_error_(" could not read string ");
 		}
@@ -688,5 +688,5 @@
 void  IoModel::FetchData(int** pmatrix,int* pM,int* pN,int data_enum){
 
-	int my_rank2;
+	int my_rank;
 	int i,j;
 
@@ -698,6 +698,6 @@
 	int vector_type=0;
 	
-	/*recover my_rank2:*/
-	my_rank2=IssmComm::GetRank();
+	/*recover my_rank:*/
+	my_rank=IssmComm::GetRank();
 
 	/*Set file pointer to beginning of the data: */
@@ -710,5 +710,5 @@
 	/*We have to read a matrix from disk. First read the dimensions of the matrix, then the whole matrix: */
 	/*numberofelements: */
-	if(my_rank2==0){  
+	if(my_rank==0){  
 		if(fread(&M,sizeof(int),1,fid)!=1) _error_("could not read number of rows for matrix ");
 	}
@@ -718,5 +718,5 @@
 	#endif
 
-	if(my_rank2==0){  
+	if(my_rank==0){  
 		if(fread(&N,sizeof(int),1,fid)!=1) _error_("could not read number of columns for matrix ");
 	}
@@ -730,5 +730,5 @@
 
 		/*Read matrix on node 0, then broadcast: */
-		if(my_rank2==0){  
+		if(my_rank==0){  
 			if(fread(matrix,M*N*sizeof(IssmPDouble),1,fid)!=1) _error_("could not read matrix ");
 		}
@@ -764,5 +764,5 @@
 void  IoModel::FetchData(IssmDouble** pmatrix,int* pM,int* pN,int data_enum){
 
-	int my_rank2;
+	int my_rank;
 
 	/*output: */
@@ -772,6 +772,6 @@
 	int vector_type=0;
 	
-	/*recover my_rank2:*/
-	my_rank2=IssmComm::GetRank();
+	/*recover my_rank:*/
+	my_rank=IssmComm::GetRank();
 
 	/*Set file pointer to beginning of the data: */
@@ -783,5 +783,5 @@
 	/*We have to read a matrix from disk. First read the dimensions of the matrix, then the whole matrix: */
 	/*numberofelements: */
-	if(my_rank2==0){  
+	if(my_rank==0){  
 		if(fread(&M,sizeof(int),1,fid)!=1) _error_("could not read number of rows for matrix ");
 	}
@@ -790,5 +790,5 @@
 	#endif
 
-	if(my_rank2==0){  
+	if(my_rank==0){  
 		if(fread(&N,sizeof(int),1,fid)!=1) _error_("could not read number of columns for matrix ");
 	}
@@ -802,5 +802,5 @@
 
 		/*Read matrix on node 0, then broadcast: */
-		if(my_rank2==0){  
+		if(my_rank==0){  
 			if(fread(matrix,M*N*sizeof(IssmPDouble),1,fid)!=1) _error_("could not read matrix ");
 		}
@@ -831,5 +831,5 @@
 void  IoModel::FetchData(char*** pstrings,int* pnumstrings,int data_enum){
 
-	int my_rank2;
+	int my_rank;
 	
 	int i;
@@ -844,6 +844,6 @@
 	int   code;
 	
-	/*recover my_rank2:*/
-	my_rank2=IssmComm::GetRank();
+	/*recover my_rank:*/
+	my_rank=IssmComm::GetRank();
 
 	/*Set file pointer to beginning of the data: */
@@ -853,5 +853,5 @@
 	
 	/*We have to read a bunch of strings from disk. First read the number of strings, and allocate: */
-	if(my_rank2==0){  
+	if(my_rank==0){  
 		if(fread(&numstrings,sizeof(int),1,fid)!=1) _error_("could not read length of string array");
 	}
@@ -868,5 +868,5 @@
 		for(i=0;i<numstrings;i++){
 			
-			if(my_rank2==0){  
+			if(my_rank==0){  
 				if(fread(&string_size,sizeof(int),1,fid)!=1) _error_("could not read length of string ");
 			}
@@ -879,5 +879,5 @@
 
 				/*Read string on node 0, then broadcast: */
-				if(my_rank2==0){  
+				if(my_rank==0){  
 					if(fread(string,string_size*sizeof(char),1,fid)!=1)_error_(" could not read string ");
 				}
@@ -905,5 +905,5 @@
 	int i;
 
-	int my_rank2;
+	int my_rank;
 
 	/*output: */
@@ -918,6 +918,6 @@
 	int     code;
 	
-	/*recover my_rank2:*/
-	my_rank2=IssmComm::GetRank();
+	/*recover my_rank:*/
+	my_rank=IssmComm::GetRank();
 
 	/*Set file pointer to beginning of the data: */
@@ -926,5 +926,5 @@
 	
 	/*Now fetch: */
-	if(my_rank2==0){  
+	if(my_rank==0){  
 		if(fread(&numrecords,sizeof(int),1,fid)!=1) _error_("could not read number of records in matrix array ");
 	}
@@ -949,5 +949,5 @@
 		for(i=0;i<numrecords;i++){
 
-			if(my_rank2==0){  
+			if(my_rank==0){  
 				if(fread(&M,sizeof(int),1,fid)!=1) _error_("could not read number of rows in " << i << "th matrix of matrix array");
 			}
@@ -956,5 +956,5 @@
 			#endif
 
-			if(my_rank2==0){  
+			if(my_rank==0){  
 				if(fread(&N,sizeof(int),1,fid)!=1) _error_("could not read number of columns in " << i << "th matrix of matrix array");
 			}
@@ -968,5 +968,5 @@
 
 				/*Read matrix on node 0, then broadcast: */
-				if(my_rank2==0){  
+				if(my_rank==0){  
 					if(fread(matrix,M*N*sizeof(IssmPDouble),1,fid)!=1) _error_("could not read matrix ");
 				}
@@ -1279,13 +1279,13 @@
 void IoModel::LastIndex(int *pindex){
 
-	int my_rank2;
+	int my_rank;
 	int        lastindex,index;
 	int        record_length;
 	
-	/*recover my_rank2:*/
-	my_rank2=IssmComm::GetRank();
+	/*recover my_rank:*/
+	my_rank=IssmComm::GetRank();
 
 	/*Go find in the binary file, the position of the data we want to fetch: */
-	if(my_rank2==0){
+	if(my_rank==0){
 
 		/*First set FILE* position to the beginning of the file: */
@@ -1318,5 +1318,5 @@
 FILE* IoModel::SetFilePointerToData(int* pcode,int* pvector_type, int data_enum){
 
-	int my_rank2;
+	int my_rank;
 
 	int found         = 0;
@@ -1326,9 +1326,9 @@
 	int vector_type   = 0; //nodal or elementary
 
-	/*recover my_rank2:*/
-	my_rank2=IssmComm::GetRank();
+	/*recover my_rank:*/
+	my_rank=IssmComm::GetRank();
 
 	/*Go find in the binary file, the position of the data we want to fetch: */
-	if(my_rank2==0){
+	if(my_rank==0){
 
 		/*First set FILE* position to the beginning of the file: */
Index: /issm/trunk-jpl/src/c/classes/IssmComm.cpp
===================================================================
--- /issm/trunk-jpl/src/c/classes/IssmComm.cpp	(revision 13611)
+++ /issm/trunk-jpl/src/c/classes/IssmComm.cpp	(revision 13612)
@@ -18,11 +18,11 @@
 }/*}}}*/
 int IssmComm::GetRank(){  /*{{{*/
-	int my_rank2;
+	int my_rank;
 	#ifdef _HAVE_MPI_
-	MPI_Comm_rank(comm,&my_rank2);
+	MPI_Comm_rank(comm,&my_rank);
 	#else
-	my_rank2=0;
+	my_rank=0;
 	#endif
-	return my_rank2;
+	return my_rank;
 
 }/*}}}*/
Index: /issm/trunk-jpl/src/c/classes/Patch.cpp
===================================================================
--- /issm/trunk-jpl/src/c/classes/Patch.cpp	(revision 13611)
+++ /issm/trunk-jpl/src/c/classes/Patch.cpp	(revision 13612)
@@ -111,6 +111,6 @@
 	int         i;
 	int         count;
-	int         my_rank2;
-	int         num_procs2;
+	int         my_rank;
+	int         num_procs;
 	int         total_numrows;
 	int         node_numrows;
@@ -120,7 +120,7 @@
 	#endif
 	
-	/*recover my_rank2:*/
-	my_rank2=IssmComm::GetRank();
-	num_procs2=IssmComm::GetSize();
+	/*recover my_rank:*/
+	my_rank=IssmComm::GetRank();
+	num_procs=IssmComm::GetSize();
 
 	/*First, figure out total number of rows combining all the cpus: */
@@ -136,8 +136,8 @@
 
 	/*Now, allocate buffer to holds all the values, on node 0: */
-	if(my_rank2==0)total_values=xNew<IssmDouble>(this->numcols*total_numrows);
+	if(my_rank==0)total_values=xNew<IssmDouble>(this->numcols*total_numrows);
 
 	/*Start by copying node 0 values onto total_values: */
-	if(my_rank2==0){
+	if(my_rank==0){
 		count=0;
 		xMemCpy<IssmDouble>(total_values+count,this->values,this->numcols*this->numrows);
@@ -147,10 +147,10 @@
 	/*Now, ask other nodes to send their values: */
 	#ifdef _HAVE_MPI_
-	for (i=1;i<num_procs2;i++){
-		if (my_rank2==i){ 
+	for (i=1;i<num_procs;i++){
+		if (my_rank==i){ 
 			MPI_Send(&this->numrows,1,MPI_INT,0,1,IssmComm::GetComm());   
 			if (this->numrows)MPI_Send(this->values,this->numrows*this->numcols,MPI_DOUBLE,0,1,IssmComm::GetComm()); 
 		}
-		if (my_rank2==0){
+		if (my_rank==0){
 			MPI_Recv(&node_numrows,1,MPI_INT,i,1,IssmComm::GetComm(),&status); 
 			if (node_numrows)MPI_Recv(total_values+count,node_numrows*this->numcols,MPI_DOUBLE,i,1,IssmComm::GetComm(),&status);
@@ -162,5 +162,5 @@
 	/*Now, node 0 has total_values, of size total_numrows*this->numcols. Update the fields in the patch, to reflect this new 
 	 * reality. For other cpus, no point in keeping their data anymore: */
-	if(my_rank2==0){
+	if(my_rank==0){
 		this->numrows=total_numrows;
 		xDelete<IssmDouble>(this->values);
Index: /issm/trunk-jpl/src/c/classes/objects/ExternalResults/GenericExternalResult.h
===================================================================
--- /issm/trunk-jpl/src/c/classes/objects/ExternalResults/GenericExternalResult.h	(revision 13611)
+++ /issm/trunk-jpl/src/c/classes/objects/ExternalResults/GenericExternalResult.h	(revision 13612)
@@ -110,14 +110,14 @@
 void WriteData(FILE* fid,bool io_gather){ /*{{{*/
 			
-	int     my_rank2;
+	int     my_rank;
 	int     type;
 	int     size;
 	IssmPDouble  passiveDouble;
 	
-	/*recover my_rank2:*/
-	my_rank2=IssmComm::GetRank();
+	/*recover my_rank:*/
+	my_rank=IssmComm::GetRank();
 
 	/*return if now on cpu 0: */
-	if(my_rank2)return;
+	if(my_rank)return;
 
 	/*use generic part, same for all ResultTypes: */
@@ -205,13 +205,13 @@
 template <> inline void GenericExternalResult<char*>::WriteData(FILE* fid,bool io_gather){ /*{{{*/
 
-	int     my_rank2;
+	int     my_rank;
 	int     type;
 	int     length;
 	
-	/*recover my_rank2:*/
-	my_rank2=IssmComm::GetRank();
+	/*recover my_rank:*/
+	my_rank=IssmComm::GetRank();
 
 	/*return if now on cpu 0: */
-	if(my_rank2)return;
+	if(my_rank)return;
 
 	/*use generic part, same for all ResultTypes: */
@@ -287,5 +287,5 @@
 template <> inline void GenericExternalResult<IssmPDouble*>::WriteData(FILE* fid,bool io_gather){ /*{{{*/
 	
-	int     my_rank2;
+	int     my_rank;
 	int     length;
 	int     type;
@@ -294,10 +294,10 @@
 	IssmPDouble passiveDouble;
 	
-	/*recover my_rank2:*/
-	my_rank2=IssmComm::GetRank();
+	/*recover my_rank:*/
+	my_rank=IssmComm::GetRank();
 
 	if(io_gather){
 		/*we are gathering the data on cpu 0, don't write on other cpus: */
-		if(my_rank2) return;
+		if(my_rank) return;
 	}
 
Index: /issm/trunk-jpl/src/c/classes/objects/IndependentObject.cpp
===================================================================
--- /issm/trunk-jpl/src/c/classes/objects/IndependentObject.cpp	(revision 13611)
+++ /issm/trunk-jpl/src/c/classes/objects/IndependentObject.cpp	(revision 13612)
@@ -82,9 +82,9 @@
 void IndependentObject::FetchIndependent(IoModel* iomodel){
 
-	int my_rank2;
+	int my_rank;
 	FILE* fid=NULL;
 	
-	/*recover my_rank2:*/
-	my_rank2=IssmComm::GetRank();
+	/*recover my_rank:*/
+	my_rank=IssmComm::GetRank();
 
 	#ifdef _HAVE_ADOLC_ //cannot come here unless you are running AD mode, from DeclaredIndependents:
@@ -105,5 +105,5 @@
 
 		/*We have to read a scalar from disk. First read the dimensions of the scalar, then the scalar: */
-		if(my_rank2==0){
+		if(my_rank==0){
 			if(fread(&pscalar,sizeof(IssmPDouble),1,fid)!=1)_error_("could not read scalar ");
 		}
@@ -143,5 +143,5 @@
 		/*We have to read a matrix from disk. First read the dimensions of the matrix, then the whole matrix: */
 		/*numberofelements: */
-		if(my_rank2==0){  
+		if(my_rank==0){  
 			if(fread(&M,sizeof(int),1,fid)!=1) _error_("could not read number of rows for matrix ");
 		}
@@ -150,5 +150,5 @@
 		#endif
 
-		if(my_rank2==0){  
+		if(my_rank==0){  
 			if(fread(&N,sizeof(int),1,fid)!=1) _error_("could not read number of columns for matrix ");
 		}
@@ -163,5 +163,5 @@
 
 			/*Read matrix on node 0, then broadcast: */
-			if(my_rank2==0){  
+			if(my_rank==0){  
 				if(fread(buffer,M*N*sizeof(IssmPDouble),1,fid)!=1) _error_("could not read matrix ");
 				
Index: /issm/trunk-jpl/src/c/classes/objects/Node.cpp
===================================================================
--- /issm/trunk-jpl/src/c/classes/objects/Node.cpp	(revision 13611)
+++ /issm/trunk-jpl/src/c/classes/objects/Node.cpp	(revision 13612)
@@ -979,10 +979,10 @@
 void  Node::SetClone(int* minranks){
 
-	int my_rank2;
+	int my_rank;
 	
-	/*recover my_rank2:*/
-	my_rank2=IssmComm::GetRank();
-
-	if (minranks[sid]==my_rank2){
+	/*recover my_rank:*/
+	my_rank=IssmComm::GetRank();
+
+	if (minranks[sid]==my_rank){
 		indexing.clone=false;
 	}
Index: /issm/trunk-jpl/src/c/classes/objects/Vertex.cpp
===================================================================
--- /issm/trunk-jpl/src/c/classes/objects/Vertex.cpp	(revision 13611)
+++ /issm/trunk-jpl/src/c/classes/objects/Vertex.cpp	(revision 13612)
@@ -178,10 +178,10 @@
 void  Vertex::SetClone(int* minranks){
 
-	int my_rank2;
+	int my_rank;
 	
-	/*recover my_rank2:*/
-	my_rank2=IssmComm::GetRank();
+	/*recover my_rank:*/
+	my_rank=IssmComm::GetRank();
 
-	if (minranks[this->sid]==my_rank2){
+	if (minranks[this->sid]==my_rank){
 		this->clone=false;
 	}
Index: /issm/trunk-jpl/src/c/io/Disk/WriteLockFile.cpp
===================================================================
--- /issm/trunk-jpl/src/c/io/Disk/WriteLockFile.cpp	(revision 13611)
+++ /issm/trunk-jpl/src/c/io/Disk/WriteLockFile.cpp	(revision 13612)
@@ -9,8 +9,8 @@
 
 	int i;
-	int my_rank2;
+	int my_rank;
 
-	/*recover my_rank2:*/
-	my_rank2=IssmComm::GetRank();
+	/*recover my_rank:*/
+	my_rank=IssmComm::GetRank();
 	
 	/* output: */
@@ -18,5 +18,5 @@
 
 	/* Open lock file and write 1 into it: */
-	if(my_rank2==0){
+	if(my_rank==0){
 		fid=fopen(filename,"w");
 		if(fid==NULL) _error_("error message: could not open lock file " << filename);
Index: /issm/trunk-jpl/src/c/io/PrintfFunction.cpp
===================================================================
--- /issm/trunk-jpl/src/c/io/PrintfFunction.cpp	(revision 13611)
+++ /issm/trunk-jpl/src/c/io/PrintfFunction.cpp	(revision 13612)
@@ -16,10 +16,10 @@
 	int   n,size = 100;
 	int   string_size;
-	int   my_rank2;
+	int   my_rank;
 	//variable list of arguments
 	va_list args;
 	
-	/*recover my_rank2:*/
-	my_rank2=IssmComm::GetRank();
+	/*recover my_rank:*/
+	my_rank=IssmComm::GetRank();
 
 	while(true){
@@ -46,5 +46,5 @@
 
 	/*Ok, if we are running in parallel, get node 0 to print*/
-	if(my_rank2==0)_printString_(buffer);
+	if(my_rank==0)_printString_(buffer);
 
 	/*Clean up and return*/
@@ -53,10 +53,10 @@
 }
 int PrintfFunction(const string & message){
-	int  my_rank2;
+	int  my_rank;
 	
-	/*recover my_rank2:*/
-	my_rank2=IssmComm::GetRank();
+	/*recover my_rank:*/
+	my_rank=IssmComm::GetRank();
 
-	if(my_rank2==0){
+	if(my_rank==0){
 		printf("%s\n",message.c_str());
 	}
@@ -64,10 +64,10 @@
 }
 int PrintfFunction2(const string & message){
-	int  my_rank2;
+	int  my_rank;
 
-	/*recover my_rank2:*/
-	my_rank2=IssmComm::GetRank();
+	/*recover my_rank:*/
+	my_rank=IssmComm::GetRank();
 
-	if(my_rank2==0){
+	if(my_rank==0){
 		printf("%s",message.c_str());
 	}
Index: /issm/trunk-jpl/src/c/matlab/io/PrintfFunction.cpp
===================================================================
--- /issm/trunk-jpl/src/c/matlab/io/PrintfFunction.cpp	(revision 13611)
+++ /issm/trunk-jpl/src/c/matlab/io/PrintfFunction.cpp	(revision 13612)
@@ -18,8 +18,8 @@
 	int   n,size = 100;
 	int         string_size;
-	int  my_rank2;
+	int  my_rank;
 	
-	/*recover my_rank2:*/
-	my_rank2=IssmComm::GetRank();
+	/*recover my_rank:*/
+	my_rank=IssmComm::GetRank();
 
 	//variable list of arguments
@@ -53,5 +53,5 @@
 
 	/*Ok, if we are running in parallel, get node 0 to print*/
-	if(my_rank2==0)_printString_(buffer);
+	if(my_rank==0)_printString_(buffer);
 
 	/*Clean up and return*/
Index: /issm/trunk-jpl/src/c/modules/DakotaResponsesx/DakotaResponsesx.cpp
===================================================================
--- /issm/trunk-jpl/src/c/modules/DakotaResponsesx/DakotaResponsesx.cpp	(revision 13611)
+++ /issm/trunk-jpl/src/c/modules/DakotaResponsesx/DakotaResponsesx.cpp	(revision 13612)
@@ -21,5 +21,5 @@
 
 	int        i,j,k;
-	int        my_rank2;
+	int        my_rank;
 	bool       process_units = true;
 
@@ -36,5 +36,5 @@
 	/*retrieve npart: */
 	parameters->FindParam(&npart,QmuNumberofpartitionsEnum);
-	my_rank2=IssmComm::GetRank();
+	my_rank=IssmComm::GetRank();
 
 	/*save the d_responses pointer: */
@@ -57,5 +57,5 @@
 
 			/*Copy onto our dakota responses: */
-			if(my_rank2==0){
+			if(my_rank==0){
 				/*plug response: */
 				for(i=0;i<npart;i++)responses_pointer[i]=qmu_response[i];
@@ -78,5 +78,5 @@
 			Responsex(&femmodel_response,elements,nodes, vertices,loads,materials, parameters,root,process_units,0);//0 is the index for weights
 			
-			if(my_rank2==0){
+			if(my_rank==0){
 				/*plug response: */
 				responses_pointer[0]=femmodel_response;
@@ -97,5 +97,5 @@
 			Responsex(&femmodel_response,elements,nodes, vertices,loads,materials, parameters,root,process_units,0);//0 is the weight index
 
-			if(my_rank2==0){
+			if(my_rank==0){
 				/*plug response: */
 				responses_pointer[0]=femmodel_response;
@@ -110,5 +110,5 @@
 
 	/*Synthesize echo: {{{*/
-	if(my_rank2==0){
+	if(my_rank==0){
 		_printString_("   responses: " << d_numresponses << ": ");
 		for(i=0;i<d_numresponses-1;i++)_printString_(d_responses[i] << "|");
Index: /issm/trunk-jpl/src/c/modules/ElementResponsex/ElementResponsex.cpp
===================================================================
--- /issm/trunk-jpl/src/c/modules/ElementResponsex/ElementResponsex.cpp	(revision 13611)
+++ /issm/trunk-jpl/src/c/modules/ElementResponsex/ElementResponsex.cpp	(revision 13612)
@@ -13,5 +13,5 @@
 	
 
-	int my_rank2;
+	int my_rank;
 	int i;
 
@@ -25,5 +25,5 @@
 	/*retrieve element we are interested in: */
 	parameters->FindParam(&index,IndexEnum);
-	my_rank2=IssmComm::GetRank();
+	my_rank=IssmComm::GetRank();
 
 	/*now, go through our elements, and retrieve the one with this id: index: */
@@ -32,5 +32,5 @@
 		if (element->Id()==index){
 			found=1;
-			cpu_found=my_rank2;
+			cpu_found=my_rank;
 			break;
 		}
@@ -44,5 +44,5 @@
 
 	/*Ok, we found the element, compute responseocity: */
-	if(my_rank2==cpu_found){
+	if(my_rank==cpu_found){
 		element->ElementResponse(&response,response_enum,IuToExtEnum);
 	}
Index: /issm/trunk-jpl/src/c/modules/Krigingx/pKrigingx.cpp
===================================================================
--- /issm/trunk-jpl/src/c/modules/Krigingx/pKrigingx.cpp	(revision 13611)
+++ /issm/trunk-jpl/src/c/modules/Krigingx/pKrigingx.cpp	(revision 13612)
@@ -14,6 +14,6 @@
 int pKrigingx(double** ppredictions,double **perror,double* obs_x, double* obs_y, double* obs_list, int obs_length,double* x_interp,double* y_interp,int n_interp,Options* options){
 
-	int num_procs2;
-	int my_rank2;
+	int num_procs;
+	int my_rank;
 
 	/*output*/
@@ -28,7 +28,7 @@
 	Observations *observations = NULL;
 
-	/*Get my_rank2: */
-	my_rank2=IssmComm::GetRank();
-	num_procs2=IssmComm::GetSize();
+	/*Get my_rank: */
+	my_rank=IssmComm::GetRank();
+	num_procs=IssmComm::GetSize();
 
 	/*Get some Options*/
@@ -59,5 +59,5 @@
 
 		/*partition loop across threads: */
-		for(int idx=my_rank2;idx<n_interp;idx+=num_procs2){
+		for(int idx=my_rank;idx<n_interp;idx+=num_procs){
 			_pprintLine_("      interpolation progress: "<<setw(6)<<setprecision(2)<<double(idx)/double(n_interp)*100<<"%");
 			observations->InterpolationKriging(&predictions[idx],&error[idx],x_interp[idx],y_interp[idx],radius,mindata,maxdata,variogram);
@@ -77,5 +77,5 @@
 
 		/*partition loop across threads: */
-		for(int idx=my_rank2;idx<n_interp;idx+=num_procs2){
+		for(int idx=my_rank;idx<n_interp;idx+=num_procs){
 			_pprintLine_("      interpolation progress: "<<setw(6)<<setprecision(2)<<double(idx)/double(n_interp)*100<<"%");
 			observations->InterpolationNearestNeighbor(&predictions[idx],x_interp[idx],y_interp[idx],radius);
@@ -94,5 +94,5 @@
 
 		/*partition loop across threads: */
-		for(int idx=my_rank2;idx<n_interp;idx+=num_procs2){
+		for(int idx=my_rank;idx<n_interp;idx+=num_procs){
 			_pprintLine_("      interpolation progress: "<<setw(6)<<setprecision(2)<<double(idx)/double(n_interp)*100<<"%");
 			observations->InterpolationIDW(&predictions[idx],x_interp[idx],y_interp[idx],radius,mindata,maxdata,power);
Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/ElementsAndVerticesPartitioning.cpp
===================================================================
--- /issm/trunk-jpl/src/c/modules/ModelProcessorx/ElementsAndVerticesPartitioning.cpp	(revision 13611)
+++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/ElementsAndVerticesPartitioning.cpp	(revision 13612)
@@ -22,6 +22,6 @@
 	int i;
 
-	int my_rank2;
-	int num_procs2;
+	int my_rank;
+	int num_procs;
 	int    numberofelements;
 	int    numberofvertices;
@@ -47,7 +47,7 @@
 	IssmDouble* vertex_pairing=NULL;
 
-	/*Get my_rank2:*/
-	my_rank2=IssmComm::GetRank();
-	num_procs2=IssmComm::GetSize();
+	/*Get my_rank:*/
+	my_rank=IssmComm::GetRank();
+	num_procs=IssmComm::GetSize();
 
 	/*Fetch parameters: */
@@ -77,5 +77,5 @@
 	}
 
-	MeshPartitionx(&epart, &npart,numberofelements,numberofvertices,elements, numberofelements2d,numberofvertices2d,elements2d,numlayers,elements_width, dim,num_procs2);
+	MeshPartitionx(&epart, &npart,numberofelements,numberofvertices,elements, numberofelements2d,numberofvertices2d,elements2d,numlayers,elements_width, dim,num_procs);
 
 	/*Free elements and elements2d: */
@@ -103,5 +103,5 @@
 
 		/*!All elements have been partitioned above, only deal with elements for this cpu: */
-		if(my_rank2==epart[i]){ 
+		if(my_rank==epart[i]){ 
 
 			my_elements[i]=true;
Index: /issm/trunk-jpl/src/c/modules/NodalValuex/NodalValuex.cpp
===================================================================
--- /issm/trunk-jpl/src/c/modules/NodalValuex/NodalValuex.cpp	(revision 13611)
+++ /issm/trunk-jpl/src/c/modules/NodalValuex/NodalValuex.cpp	(revision 13612)
@@ -12,5 +12,5 @@
 void NodalValuex( IssmDouble* pnodalvalue, int natureofdataenum,Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,bool process_units){
 
-	int my_rank2;
+	int my_rank;
 	int i;
 	int index;
@@ -21,6 +21,6 @@
 	int cpu_found;
 
-	/*Get my_rank2:*/
-	my_rank2=IssmComm::GetRank();
+	/*Get my_rank:*/
+	my_rank=IssmComm::GetRank();
 
 	/*retrieve element we are interested in: */
@@ -33,5 +33,5 @@
 		found=element->NodalValue(&value,index,natureofdataenum,process_units);
 		if (found){
-			cpu_found=my_rank2;
+			cpu_found=my_rank;
 			break;
 		}
Index: /issm/trunk-jpl/src/c/modules/OutputResultsx/OutputResultsx.cpp
===================================================================
--- /issm/trunk-jpl/src/c/modules/OutputResultsx/OutputResultsx.cpp	(revision 13611)
+++ /issm/trunk-jpl/src/c/modules/OutputResultsx/OutputResultsx.cpp	(revision 13612)
@@ -18,5 +18,5 @@
 void OutputResultsx(Elements* elements, Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,Results* results){
 
-	int         my_rank2;
+	int         my_rank;
 	FILE       *fid                     = NULL;
 	char       *outputfilename          = NULL;
@@ -30,6 +30,6 @@
 	parameters->FindParam(&dakota_analysis,QmuIsdakotaEnum);
 	
-	/*recover my_rank2:*/
-	my_rank2=IssmComm::GetRank();
+	/*recover my_rank:*/
+	my_rank=IssmComm::GetRank();
 
 	if(dakota_analysis){
@@ -45,5 +45,5 @@
 	/*Results do not include the type of solution being run	. In parallel, we output results to a filename, 
 	 *therefore, we need to include the solutiontype into the filename: */
-	if(my_rank2==0){
+	if(my_rank==0){
 		parameters->FindParam(&solutiontype,SolutionTypeEnum);
 		EnumToStringx(&solutiontypestring,solutiontype);
@@ -63,10 +63,10 @@
 		if(io_gather){
 			/*Just open the file for output on cpu 0. We are gathering the data on cpu 0 from all other cpus: */
-			if(my_rank2==0) fid=pfopen(outputfilename ,"wb");
+			if(my_rank==0) fid=pfopen(outputfilename ,"wb");
 		}
 		else{
 			/*We are opening different  files for output on all cpus. Append the  rank to the filename, and open: */
 			parameters->FindParam(&fid,OutputFilePointerEnum);
-			sprintf(cpu_outputfilename,"%s.%i",outputfilename,my_rank2);
+			sprintf(cpu_outputfilename,"%s.%i",outputfilename,my_rank);
 			fid=pfopen(cpu_outputfilename ,"wb");
 		}
@@ -87,5 +87,5 @@
 	  if((step==1) && (time==0)){
 	  if(io_gather){
-	  if(my_rank2==0) pfclose(fid,outputfilename);
+	  if(my_rank==0) pfclose(fid,outputfilename);
 	  }
 	  else pfclose(fid,cpu_outputfilename);
Index: /issm/trunk-jpl/src/c/modules/ParsePetscOptionsx/ParsePetscOptionsx.cpp
===================================================================
--- /issm/trunk-jpl/src/c/modules/ParsePetscOptionsx/ParsePetscOptionsx.cpp	(revision 13611)
+++ /issm/trunk-jpl/src/c/modules/ParsePetscOptionsx/ParsePetscOptionsx.cpp	(revision 13612)
@@ -23,5 +23,5 @@
 
 	char line [1000];
-	int my_rank2;
+	int my_rank;
 	int i;
 
@@ -35,8 +35,8 @@
 	int   stringlength;
 
-	/*Get my_rank2:*/
-	my_rank2=IssmComm::GetRank();
+	/*Get my_rank:*/
+	my_rank=IssmComm::GetRank();
 
-	if(my_rank2==0){
+	if(my_rank==0){
 
 		/*Now, go through lines and figure out how many analyses we have: */
@@ -100,5 +100,5 @@
  	#ifdef _HAVE_MPI_
 	MPI_Bcast(&numanalyses,1,MPI_INT,0,IssmComm::GetComm());
-	if(my_rank2!=0){
+	if(my_rank!=0){
 		analyses=xNew<IssmPDouble>(numanalyses);
 		strings=xNew<char*>(numanalyses);
@@ -108,13 +108,13 @@
 	for(i=0;i<numanalyses;i++){
 		char* string=strings[i];
-		if(my_rank2==0){
+		if(my_rank==0){
 			if(string==NULL) _error_("PETSc options for analysis " << EnumToStringx(reCast<int>(analyses[i])) << " have been declared but were not found");
 		}
-		if(my_rank2==0)stringlength=(strlen(string)+1)*sizeof(char);
+		if(my_rank==0)stringlength=(strlen(string)+1)*sizeof(char);
 		#ifdef _HAVE_MPI_
 		MPI_Bcast(&stringlength,1,MPI_INT,0,IssmComm::GetComm());
-		if(my_rank2!=0)string=xNew<char>(stringlength);
+		if(my_rank!=0)string=xNew<char>(stringlength);
 		MPI_Bcast(string,stringlength,MPI_CHAR,0,IssmComm::GetComm());
-		if(my_rank2!=0)strings[i]=string;
+		if(my_rank!=0)strings[i]=string;
 		#endif
 	}
Index: /issm/trunk-jpl/src/c/shared/Exceptions/Exceptions.cpp
===================================================================
--- /issm/trunk-jpl/src/c/shared/Exceptions/Exceptions.cpp	(revision 13611)
+++ /issm/trunk-jpl/src/c/shared/Exceptions/Exceptions.cpp	(revision 13612)
@@ -30,12 +30,12 @@
 ErrorException::~ErrorException() throw(){
 	
-	int num_procs2;
+	int num_procs;
 	
-	/*recover num_procs2:*/
-	num_procs2=IssmComm::GetSize();
+	/*recover num_procs:*/
+	num_procs=IssmComm::GetSize();
 
 	/*We want the report only for matlab modules, otherwise we get twice the report
 	 * We assume that if num_procs==1, it is a module (FIXME)*/
-	if(num_procs2==1) this->Report();
+	if(num_procs==1) this->Report();
 }
 
@@ -46,10 +46,10 @@
 void ErrorException::Report() const{
 	
-	int my_rank2;
-	int num_procs2;
+	int my_rank;
+	int num_procs;
 	
-	/*recover my_rank2 and num_procs2:*/
-	my_rank2=IssmComm::GetRank();
-	num_procs2=IssmComm::GetSize();
+	/*recover my_rank and num_procs:*/
+	my_rank=IssmComm::GetRank();
+	num_procs=IssmComm::GetSize();
 
 
@@ -59,11 +59,11 @@
 	}
 	else{
-		if(num_procs2==1){
+		if(num_procs==1){
 			_printLine_("\n??? Error using ==> " << file_name.c_str() << ":" << file_line);
 			_printLine_(function_name.c_str() << " error message: " << what() << "\n");
 		}
 		else{
-			_printLine_("\n[" << my_rank2<< "] ??? Error using ==> " << file_name.c_str() << ":" << file_line);
-			_printLine_("[" << my_rank2 << "] " << function_name.c_str() << " error message: " << what() << "\n");
+			_printLine_("\n[" << my_rank<< "] ??? Error using ==> " << file_name.c_str() << ":" << file_line);
+			_printLine_("[" << my_rank << "] " << function_name.c_str() << " error message: " << what() << "\n");
 		}
 	}
Index: /issm/trunk-jpl/src/c/solutions/DakotaSpawnCore.cpp
===================================================================
--- /issm/trunk-jpl/src/c/solutions/DakotaSpawnCore.cpp	(revision 13611)
+++ /issm/trunk-jpl/src/c/solutions/DakotaSpawnCore.cpp	(revision 13612)
@@ -103,5 +103,5 @@
 
 	int i;
-	int my_rank2;
+	int my_rank;
 
 	/*inputs and outputs: */
@@ -115,6 +115,6 @@
 	int   string_length;
 
-	/*recover my_rank2:*/
-	my_rank2=IssmComm::GetRank();
+	/*recover my_rank:*/
+	my_rank=IssmComm::GetRank();
 
 	/*recover inputs from pointers: */
@@ -128,20 +128,20 @@
 	
 	/*variables:*/
-	if(my_rank2!=0)variables=xNew<double>(numvariables);
+	if(my_rank!=0)variables=xNew<double>(numvariables);
 	MPI_Bcast(variables,numvariables,MPI_DOUBLE,0,IssmComm::GetComm()); 
 
 	/*variables_descriptors: */
-	if(my_rank2!=0){
+	if(my_rank!=0){
 		variables_descriptors=xNew<char*>(numvariables);
 	}
 	for(i=0;i<numvariables;i++){
-		if(my_rank2==0){
+		if(my_rank==0){
 			string=variables_descriptors[i];
 			string_length=(strlen(string)+1)*sizeof(char);
 		}
 		MPI_Bcast(&string_length,1,MPI_INT,0,IssmComm::GetComm()); 
-		if(my_rank2!=0)string=xNew<char>(string_length);
+		if(my_rank!=0)string=xNew<char>(string_length);
 		MPI_Bcast(string,string_length,MPI_CHAR,0,IssmComm::GetComm()); 
-		if(my_rank2!=0)variables_descriptors[i]=string;
+		if(my_rank!=0)variables_descriptors[i]=string;
 	}
 
@@ -160,5 +160,5 @@
 
 	int i;
-	int my_rank2;
+	int my_rank;
 	
 	double  *variables             = NULL;
@@ -172,9 +172,9 @@
 	responses_descriptors=*presponses_descriptors;
 
-	/*recover my_rank2:*/
-	my_rank2=IssmComm::GetRank();
+	/*recover my_rank:*/
+	my_rank=IssmComm::GetRank();
 
 	/*Free variables and variables_descriptors only on cpu !=0*/
-	if(my_rank2!=0){
+	if(my_rank!=0){
 		xDelete<double>(variables);
 		for(i=0;i<numvariables;i++){
Index: /issm/trunk-jpl/src/c/solutions/dakota_core.cpp
===================================================================
--- /issm/trunk-jpl/src/c/solutions/dakota_core.cpp	(revision 13611)
+++ /issm/trunk-jpl/src/c/solutions/dakota_core.cpp	(revision 13612)
@@ -57,5 +57,5 @@
 	#ifdef _HAVE_DAKOTA_ //only works if dakota library has been compiled in.
 	
-	int                my_rank2;
+	int                my_rank;
 	char*              dakota_input_file  = NULL;
 	char*              dakota_output_file = NULL;
@@ -70,8 +70,8 @@
 	femmodel->parameters->FindParam(&dakota_error_file,QmuErrNameEnum);
 	
-	/*recover my_rank2:*/
-	my_rank2=IssmComm::GetRank();
+	/*recover my_rank:*/
+	my_rank=IssmComm::GetRank();
 
-	if(my_rank2==0){
+	if(my_rank==0){
 	
 		// Instantiate/initialize the parallel library and problem description
Index: /issm/trunk-jpl/src/c/toolkits/mpi/patches/DetermineLocalSize.cpp
===================================================================
--- /issm/trunk-jpl/src/c/toolkits/mpi/patches/DetermineLocalSize.cpp	(revision 13611)
+++ /issm/trunk-jpl/src/c/toolkits/mpi/patches/DetermineLocalSize.cpp	(revision 13612)
@@ -19,28 +19,28 @@
 
 	/*from MPI: */
-	int num_procs2;
-	int my_rank2;
+	int num_procs;
+	int my_rank;
 
-	/*recover my_rank2*/
-	MPI_Comm_rank(comm,&my_rank2);
-	MPI_Comm_size(comm,&num_procs2);
+	/*recover my_rank*/
+	MPI_Comm_rank(comm,&my_rank);
+	MPI_Comm_size(comm,&num_procs);
 
 	
 	/*We are  not bound by any library, just use what seems most logical*/
-	num_local_rows=xNew<int>(num_procs2);    
+	num_local_rows=xNew<int>(num_procs);    
 
-	for (i=0;i<num_procs2;i++){
+	for (i=0;i<num_procs;i++){
 		/*Here, we use floor. We under distribute rows. The rows 
 		  left  are then redistributed, therefore resulting in a 
 		  more even distribution.*/
-		num_local_rows[i]=(int)floor((double)global_size/(double)num_procs2); 
+		num_local_rows[i]=(int)floor((double)global_size/(double)num_procs); 
 	}
 	
 	/*There may be some rows left. Distribute evenly.*/ 
-	row_rest=global_size - num_procs2*(int)floor((double)global_size/(double)num_procs2);
+	row_rest=global_size - num_procs*(int)floor((double)global_size/(double)num_procs);
 	for (i=0;i<row_rest;i++){
 		num_local_rows[i]++;
 	}
-	local_size=num_local_rows[my_rank2];
+	local_size=num_local_rows[my_rank];
 	
 	/*free ressources: */
Index: /issm/trunk-jpl/src/c/toolkits/petsc/patches/GetOwnershipBoundariesFromRange.cpp
===================================================================
--- /issm/trunk-jpl/src/c/toolkits/petsc/patches/GetOwnershipBoundariesFromRange.cpp	(revision 13611)
+++ /issm/trunk-jpl/src/c/toolkits/petsc/patches/GetOwnershipBoundariesFromRange.cpp	(revision 13612)
@@ -17,10 +17,10 @@
 
 	/*externals :*/
-	int my_rank2;
-	int num_procs2;
+	int my_rank;
+	int num_procs;
 	
-	/*recover my_rank2 and num_procs2:*/
-	MPI_Comm_size(comm,&num_procs2);
-	MPI_Comm_rank(comm,&my_rank2);
+	/*recover my_rank and num_procs:*/
+	MPI_Comm_size(comm,&num_procs);
+	MPI_Comm_rank(comm,&my_rank);
 
 	/*output: */
@@ -32,5 +32,5 @@
 
 	/*Gather all range values into allranges, for all nodes*/
-	allranges=xNew<int>(num_procs2);
+	allranges=xNew<int>(num_procs);
 	MPI_Allgather(&range,1,MPI_INT,allranges,1,MPI_INT,comm);
 
@@ -38,5 +38,5 @@
 	lower_row=0;
 	upper_row=lower_row+allranges[0];
-	for (i=1;i<=my_rank2;i++){
+	for (i=1;i<=my_rank;i++){
 		lower_row=lower_row+allranges[i-1];
 		upper_row=upper_row+allranges[i];
Index: /issm/trunk-jpl/src/c/toolkits/petsc/patches/MatMultPatch.cpp
===================================================================
--- /issm/trunk-jpl/src/c/toolkits/petsc/patches/MatMultPatch.cpp	(revision 13611)
+++ /issm/trunk-jpl/src/c/toolkits/petsc/patches/MatMultPatch.cpp	(revision 13612)
@@ -50,8 +50,8 @@
 	int result=1;
 	int sumresult;
-	int num_procs2;
+	int num_procs;
 	
-	/*recover num_procs2:*/
-	MPI_Comm_size(comm,&num_procs2);
+	/*recover num_procs:*/
+	MPI_Comm_size(comm,&num_procs);
 
 	MatGetLocalSize(A,&local_m,&local_n);;
@@ -63,5 +63,5 @@
 	MPI_Reduce (&result,&sumresult,1,MPI_INT,MPI_SUM,0,comm );
 	MPI_Bcast(&sumresult,1,MPI_INT,0,comm);                
-	if (sumresult!=num_procs2){
+	if (sumresult!=num_procs){
 		result=0;
 	}
Index: /issm/trunk-jpl/src/c/toolkits/petsc/patches/MatToSerial.cpp
===================================================================
--- /issm/trunk-jpl/src/c/toolkits/petsc/patches/MatToSerial.cpp	(revision 13611)
+++ /issm/trunk-jpl/src/c/toolkits/petsc/patches/MatToSerial.cpp	(revision 13612)
@@ -16,6 +16,6 @@
 
 	int i;
-	int my_rank2;
-	int num_procs2;
+	int my_rank;
+	int num_procs;
 	
 	/*Petsc variables*/
@@ -29,7 +29,7 @@
 	int buffer[3];
 	
-	/*recover my_rank2 and num_procs2:*/
-	MPI_Comm_size(comm,&num_procs2);
-	MPI_Comm_rank(comm,&my_rank2);
+	/*recover my_rank and num_procs:*/
+	MPI_Comm_size(comm,&num_procs);
+	MPI_Comm_rank(comm,&my_rank);
 
 	/*Output*/
@@ -45,5 +45,5 @@
 	
 	/*Local and global allocation*/
-	if (my_rank2==0)outmatrix=xNew<double>(M*N);
+	if (my_rank==0)outmatrix=xNew<double>(M*N);
 	
 	if (range){
@@ -65,7 +65,7 @@
 	 * We send these rows to the matrix on node 0*/
 	
-	for (i=1;i<num_procs2;i++){
-		if (my_rank2==i){ 
-			buffer[0]=my_rank2;
+	for (i=1;i<num_procs;i++){
+		if (my_rank==i){ 
+			buffer[0]=my_rank;
 			buffer[1]=lower_row;
 			buffer[2]=range;
@@ -73,10 +73,10 @@
 			if (range)MPI_Send(local_matrix,N*range,MPI_DOUBLE,0,1,comm); 
 		}
-		if (my_rank2==0){
+		if (my_rank==0){
 			MPI_Recv(buffer,3,MPI_INT,i,1,comm,&status); 
 			if (buffer[2])MPI_Recv(outmatrix+(buffer[1]*N),N*buffer[2],MPI_DOUBLE,i,1,comm,&status);
 		}
 	} 
-	if (my_rank2==0){ 
+	if (my_rank==0){ 
 		//Still have the local_matrix on node 0 to take care of.
 		memcpy(outmatrix,local_matrix,N*range*sizeof(double));
Index: /issm/trunk-jpl/src/c/toolkits/petsc/patches/VecToMPISerial.cpp
===================================================================
--- /issm/trunk-jpl/src/c/toolkits/petsc/patches/VecToMPISerial.cpp	(revision 13611)
+++ /issm/trunk-jpl/src/c/toolkits/petsc/patches/VecToMPISerial.cpp	(revision 13612)
@@ -16,6 +16,6 @@
 	
 	int i;
-	int num_procs2; 
-	int my_rank2;
+	int num_procs; 
+	int my_rank;
 
 	/*Petsc*/
@@ -35,7 +35,7 @@
 	double* gathered_vector=NULL; //Global vector holding the final assembled vector on all nodes.
 	
-	/*recover my_rank2 and num_procs2*/
-	MPI_Comm_size(comm,&num_procs2);
-	MPI_Comm_rank(comm,&my_rank2);
+	/*recover my_rank and num_procs*/
+	MPI_Comm_size(comm,&num_procs);
+	MPI_Comm_rank(comm,&my_rank);
 
 	VecGetSize(vector,&vector_size);
@@ -65,7 +65,7 @@
 	/*Now each node holds its local_vector containing range rows. 
 	 * We send this local_vector  to the gathered_vector on node 0*/
-	for (i=1;i<num_procs2;i++){
-		if (my_rank2==i){ 
-			buffer[0]=my_rank2;
+	for (i=1;i<num_procs;i++){
+		if (my_rank==i){ 
+			buffer[0]=my_rank;
 			buffer[1]=lower_row;
 			buffer[2]=range;
@@ -73,5 +73,5 @@
 			if (range)MPI_Send(local_vector,range,MPI_DOUBLE,0,1,comm); 
 		}
-		if (my_rank2==0){
+		if (my_rank==0){
 			MPI_Recv(buffer,3,MPI_INT,i,1,comm,&status); 
 			if (buffer[2])MPI_Recv(gathered_vector+buffer[1],buffer[2],MPI_DOUBLE,i,1,comm,&status);
@@ -79,5 +79,5 @@
 	}
 
-	if (my_rank2==0){ 
+	if (my_rank==0){ 
 		//Still have the local_vector on node 0 to take care of.
 		if (range)memcpy(gathered_vector+lower_row,local_vector,range*sizeof(double));