Index: /issm/trunk/src/c/modules/Solverx/Solverx.cpp
===================================================================
--- /issm/trunk/src/c/modules/Solverx/Solverx.cpp	(revision 5685)
+++ /issm/trunk/src/c/modules/Solverx/Solverx.cpp	(revision 5686)
@@ -4,5 +4,4 @@
 
 #include "./Solverx.h"
-
 #include "../../shared/shared.h"
 #include "../../include/include.h"
@@ -14,6 +13,5 @@
 #endif
 
-
-void	Solverx( Vec* puf, Mat Kff, Vec pf, Vec uf0, char* solver_string){
+void	Solverx(Vec* puf, Mat Kff, Vec pf, Vec uf0,Parameters* parameters){
 
 	/*output: */
@@ -29,9 +27,9 @@
 	PetscTruth flag;
 	int solver_type;
+	char* solver_string=NULL;
 
 	/*First, check that f-set is not NULL, ie model is fully constrained: */
 	if(!Kff){
-		*puf=NULL;
-		return;
+		*puf=NULL; return;
 	}
 
@@ -46,4 +44,5 @@
 
 	/*Before preparing the solver, add options to the options database*/
+	parameters->FindParam(&solver_string,SolverStringEnum);
 	PetscOptionsInsertMultipleString(solver_string);
 
@@ -95,16 +94,13 @@
 		}
 	}
-
 	KSPSolve(ksp,pf,uf);
 	
 	/*Check convergence*/
 	KSPGetIterationNumber(ksp,&iteration_number);
-	if (iteration_number<0){
-		ISSMERROR("%s%i"," Solver diverged at iteration number: ",-iteration_number);
-	}
+	if (iteration_number<0) ISSMERROR("%s%i"," Solver diverged at iteration number: ",-iteration_number);
 
 	/*Free ressources:*/
 	KSPFree(&ksp);
-
+	xfree((void**)&solver_string);
 	
 	/*Assign output pointers:*/
Index: /issm/trunk/src/c/modules/Solverx/Solverx.h
===================================================================
--- /issm/trunk/src/c/modules/Solverx/Solverx.h	(revision 5685)
+++ /issm/trunk/src/c/modules/Solverx/Solverx.h	(revision 5686)
@@ -8,7 +8,6 @@
 #include "../../objects/objects.h"
 
-
 /* local prototypes: */
-void	Solverx( Vec* puf, Mat Kff, Vec pf, Vec uf0, char* solver_string);
+void	Solverx( Vec* puf, Mat Kff, Vec pf, Vec uf0,Parameters* parameters);
 
 #endif  /* _SOLVERX_H */
Index: /issm/trunk/src/c/solvers/solver_adjoint_linear.cpp
===================================================================
--- /issm/trunk/src/c/solvers/solver_adjoint_linear.cpp	(revision 5685)
+++ /issm/trunk/src/c/solvers/solver_adjoint_linear.cpp	(revision 5686)
@@ -8,5 +8,5 @@
 #include "../modules/modules.h"
 
-void solver_adjoint_linear(FemModel* fem){
+void solver_adjoint_linear(FemModel* femmodel){
 	/*This is axactly the same solver as solver_linear except that Reduceloadfromgtofx and Mergesolutionfromftogx
 	 * use the flag "true" so that all spc are taken as 0*/
@@ -15,5 +15,4 @@
 	int kflag,pflag;
 	int verbose=0;
-	char* solver_string=NULL;
 
 	/*output: */
@@ -30,36 +29,34 @@
 	/*Recover parameters: */
 	kflag=1; pflag=1;
-	fem->parameters->FindParam(&verbose,VerboseEnum);
-	fem->parameters->FindParam(&solver_string,SolverStringEnum);
+	femmodel->parameters->FindParam(&verbose,VerboseEnum);
 
 	//*Generate system matrices
 	if(verbose)_printf_("   Generating matrices\n");
-	SystemMatricesx(&Kgg, &pg,fem->elements,fem->nodes,fem->vertices,fem->loads,fem->materials,fem->parameters,kflag,pflag);
+	SystemMatricesx(&Kgg, &pg,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,kflag,pflag);
 
 	if(verbose)_printf_("   Generating penalty matrices\n");
 	//*Generate penalty system matrices
-	PenaltySystemMatricesx(Kgg, pg,NULL,fem->elements,fem->nodes,fem->vertices,fem->loads,fem->materials,fem->parameters,kflag,pflag);
+	PenaltySystemMatricesx(Kgg, pg,NULL,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,kflag,pflag);
 
 	/*!Reduce matrix from g to f size:*/
 	if(verbose)_printf_("   reducing matrix from g to f set\n");
-	Reducematrixfromgtofx(&Kff,&Kfs,Kgg,fem->nodesets); MatFree(&Kgg);
+	Reducematrixfromgtofx(&Kff,&Kfs,Kgg,femmodel->nodesets); MatFree(&Kgg);
 
 	/*!Reduce load from g to f size: */
 	if(verbose)_printf_("   reducing load from g to f set\n"); //true means spc = 0
-	Reduceloadfromgtofx(&pf, pg, Kfs, fem->ys, fem->nodesets,true);VecFree(&pg); MatFree(&Kfs);
+	Reduceloadfromgtofx(&pf, pg, Kfs, femmodel->ys, femmodel->nodesets,true);VecFree(&pg); MatFree(&Kfs);
 
 	/*Solve: */
 	if(verbose)_printf_("   solving\n");
-	Solverx(&uf, Kff, pf, NULL, solver_string); MatFree(&Kff); VecFree(&pf);
+	Solverx(&uf, Kff, pf, NULL, femmodel->parameters); MatFree(&Kff); VecFree(&pf);
 
 	//Merge back to g set
 	if(verbose)_printf_("   merging solution from f to g set\n");//true means spc=0
-	Mergesolutionfromftogx(&ug, uf,fem->ys,fem->nodesets,true);VecFree(&uf);
+	Mergesolutionfromftogx(&ug, uf,femmodel->ys,femmodel->nodesets,true);VecFree(&uf);
 
 	//Update inputs using new solution:
-	InputUpdateFromSolutionx( fem->elements,fem->nodes, fem->vertices, fem->loads, fem->materials, fem->parameters,ug);
+	InputUpdateFromSolutionx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,ug);
 
 	/*free ressources: */
-	xfree((void**)&solver_string);
 	VecFree(&ug);
 	VecFree(&uf);
Index: /issm/trunk/src/c/solvers/solver_diagnostic_nonlinear.cpp
===================================================================
--- /issm/trunk/src/c/solvers/solver_diagnostic_nonlinear.cpp	(revision 5685)
+++ /issm/trunk/src/c/solvers/solver_diagnostic_nonlinear.cpp	(revision 5686)
@@ -35,5 +35,4 @@
 	/*parameters:*/
 	int kflag,pflag;
-	char* solver_string=NULL;
 	int verbose=0;
 	int dim;
@@ -41,5 +40,4 @@
 	/*Recover parameters: */
 	kflag=1; pflag=1;
-	femmodel->parameters->FindParam(&solver_string,SolverStringEnum);
 	femmodel->parameters->FindParam(&dim,DimEnum);
 	femmodel->parameters->FindParam(&verbose,VerboseEnum);
@@ -91,5 +89,5 @@
 
 		if(verbose)_printf_("   solving\n");
-		Solverx(&uf, Kff, pf, old_uf, solver_string);
+		Solverx(&uf, Kff, pf, old_uf, femmodel->parameters);
 
 		if(verbose)_printf_("   merging solution from f to g set\n");
@@ -136,5 +134,4 @@
 	VecFree(&old_uf);
 	VecFree(&old_ug);
-	xfree((void**)&solver_string);
 	
 }
Index: /issm/trunk/src/c/solvers/solver_linear.cpp
===================================================================
--- /issm/trunk/src/c/solvers/solver_linear.cpp	(revision 5685)
+++ /issm/trunk/src/c/solvers/solver_linear.cpp	(revision 5686)
@@ -8,10 +8,9 @@
 #include "../modules/modules.h"
 
-void solver_linear(FemModel* fem){
+void solver_linear(FemModel* femmodel){
 
 	/*parameters:*/
 	int kflag,pflag;
 	int verbose=0;
-	char* solver_string=NULL;
 
 	/*output: */
@@ -28,36 +27,34 @@
 	/*Recover parameters: */
 	kflag=1; pflag=1;
-	fem->parameters->FindParam(&verbose,VerboseEnum);
-	fem->parameters->FindParam(&solver_string,SolverStringEnum);
+	femmodel->parameters->FindParam(&verbose,VerboseEnum);
 
 	//*Generate system matrices
 	if(verbose)_printf_("   Generating matrices\n");
-	SystemMatricesx(&Kgg, &pg,fem->elements,fem->nodes,fem->vertices,fem->loads,fem->materials,fem->parameters,kflag,pflag);
+	SystemMatricesx(&Kgg, &pg,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,kflag,pflag);
 
 	if(verbose)_printf_("   Generating penalty matrices\n");
 	//*Generate penalty system matrices
-	PenaltySystemMatricesx(Kgg, pg,NULL,fem->elements,fem->nodes,fem->vertices,fem->loads,fem->materials,fem->parameters,kflag,pflag);
+	PenaltySystemMatricesx(Kgg, pg,NULL,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,kflag,pflag);
 
 	/*!Reduce matrix from g to f size:*/
 	if(verbose)_printf_("   reducing matrix from g to f set\n");
-	Reducematrixfromgtofx(&Kff,&Kfs,Kgg,fem->nodesets); MatFree(&Kgg);
+	Reducematrixfromgtofx(&Kff,&Kfs,Kgg,femmodel->nodesets); MatFree(&Kgg);
 
 	/*!Reduce load from g to f size: */
 	if(verbose)_printf_("   reducing load from g to f set\n");
-	Reduceloadfromgtofx(&pf, pg, Kfs, fem->ys, fem->nodesets);VecFree(&pg); MatFree(&Kfs);
+	Reduceloadfromgtofx(&pf, pg, Kfs, femmodel->ys, femmodel->nodesets);VecFree(&pg); MatFree(&Kfs);
 
 	/*Solve: */
 	if(verbose)_printf_("   solving\n");
-	Solverx(&uf, Kff, pf, NULL, solver_string); MatFree(&Kff); VecFree(&pf);
+	Solverx(&uf, Kff, pf, NULL, femmodel->parameters); MatFree(&Kff); VecFree(&pf);
 
 	//Merge back to g set
 	if(verbose)_printf_("   merging solution from f to g set\n");
-	Mergesolutionfromftogx(&ug, uf,fem->ys,fem->nodesets);VecFree(&uf);
+	Mergesolutionfromftogx(&ug, uf,femmodel->ys,femmodel->nodesets);VecFree(&uf);
 
 	//Update inputs using new solution:
-	InputUpdateFromSolutionx( fem->elements,fem->nodes, fem->vertices, fem->loads, fem->materials, fem->parameters,ug);
+	InputUpdateFromSolutionx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,ug);
 
 	/*free ressources: */
-	xfree((void**)&solver_string);
 	VecFree(&ug);
 	VecFree(&uf);
Index: /issm/trunk/src/c/solvers/solver_thermal_nonlinear.cpp
===================================================================
--- /issm/trunk/src/c/solvers/solver_thermal_nonlinear.cpp	(revision 5685)
+++ /issm/trunk/src/c/solvers/solver_thermal_nonlinear.cpp	(revision 5686)
@@ -8,5 +8,5 @@
 #include "../modules/modules.h"
 
-void solver_thermal_nonlinear(FemModel* fem){
+void solver_thermal_nonlinear(FemModel* femmodel){
 
 	/*solution : */
@@ -34,5 +34,4 @@
 	/*parameters:*/
 	int kflag,pflag;
-	char* solver_string=NULL;
 	int verbose=0;
 	bool lowmem=0;
@@ -41,8 +40,7 @@
 	kflag=1; pflag=1;
 
-	fem->parameters->FindParam(&solver_string,SolverStringEnum);
-	fem->parameters->FindParam(&verbose,VerboseEnum);
-	fem->parameters->FindParam(&lowmem,LowmemEnum);
-	fem->parameters->FindParam(&min_thermal_constraints,MinThermalConstraintsEnum);
+	femmodel->parameters->FindParam(&verbose,VerboseEnum);
+	femmodel->parameters->FindParam(&lowmem,LowmemEnum);
+	femmodel->parameters->FindParam(&min_thermal_constraints,MinThermalConstraintsEnum);
 
 	count=1;
@@ -54,5 +52,5 @@
 
 		if(count==1) reset_penalties=1; else reset_penalties=0;
-		InputUpdateFromConstantx( fem->elements,fem->nodes, fem->vertices, fem->loads, fem->materials, fem->parameters,reset_penalties,ResetPenaltiesEnum);
+		InputUpdateFromConstantx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,reset_penalties,ResetPenaltiesEnum);
 
 		//*Generate system matrices
@@ -61,5 +59,5 @@
 			/*Compute Kgg_nopenalty and pg_nopenalty once for all: */
 			if (count==1){
-				SystemMatricesx(&Kgg_nopenalty, &pg_nopenalty,fem->elements,fem->nodes,fem->vertices,fem->loads,fem->materials,fem->parameters,kflag,pflag);
+				SystemMatricesx(&Kgg_nopenalty, &pg_nopenalty,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,kflag,pflag);
 			}
 
@@ -69,14 +67,14 @@
 
 			//apply penalties each time
-			PenaltySystemMatricesx(Kgg, pg,&melting_offset,fem->elements,fem->nodes,fem->vertices,fem->loads,fem->materials,fem->parameters,kflag,pflag);
+			PenaltySystemMatricesx(Kgg, pg,&melting_offset,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,kflag,pflag);
 		}
 		else{
-			SystemMatricesx(&Kgg, &pg,fem->elements,fem->nodes,fem->vertices,fem->loads,fem->materials,fem->parameters,kflag,pflag);
+			SystemMatricesx(&Kgg, &pg,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,kflag,pflag);
 			//apply penalties
-			PenaltySystemMatricesx(Kgg, pg,&melting_offset,fem->elements,fem->nodes,fem->vertices,fem->loads,fem->materials,fem->parameters,kflag,pflag);
+			PenaltySystemMatricesx(Kgg, pg,&melting_offset,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,kflag,pflag);
 		}
 
 		/*!Reduce matrix from g to f size:*/
-		Reducematrixfromgtofx(&Kff,&Kfs,Kgg,fem->nodesets);
+		Reducematrixfromgtofx(&Kff,&Kfs,Kgg,femmodel->nodesets);
 
 		/*Free ressources: */
@@ -84,5 +82,5 @@
 	
 		if(verbose)_printf_("   reducing load from g to f set\n");
-		Reduceloadfromgtofx(&pf, pg, Kfs, fem->ys, fem->nodesets);
+		Reduceloadfromgtofx(&pf, pg, Kfs, femmodel->ys, femmodel->nodesets);
 
 		//no need for pg and Kfs anymore 
@@ -93,5 +91,5 @@
 		if(verbose)_printf_("%s\n","solving");
 		VecFree(&tf);
-		Solverx(&tf, Kff, pf,tf_old, solver_string);
+		Solverx(&tf, Kff, pf,tf_old, femmodel->parameters);
 		VecFree(&tf_old); VecDuplicatePatch(&tf_old,tf);
 	
@@ -100,13 +98,13 @@
 
 		if(verbose)_printf_("   merging solution from f to g set\n");
-		Mergesolutionfromftogx(&tg, tf,fem->ys,fem->nodesets);
+		Mergesolutionfromftogx(&tg, tf,femmodel->ys,femmodel->nodesets);
 
 		//Update inputs using new solution:
 		if (verbose) _printf_("   updating inputs\n");
-		InputUpdateFromSolutionx(fem->elements,fem->nodes, fem->vertices, fem->loads, fem->materials, fem->parameters,tg);
+		InputUpdateFromSolutionx(femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,tg);
 
 		//Deal with penalty loads
 		if(verbose)_printf_("   penalty constraints\n");
-		PenaltyConstraintsx(&constraints_converged, &num_unstable_constraints, fem->elements,fem->nodes,fem->vertices,fem->loads,fem->materials,fem->parameters);
+		PenaltyConstraintsx(&constraints_converged, &num_unstable_constraints, femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters);
 
 		if (!converged){
@@ -120,5 +118,5 @@
 
 	//add melting_offset to inputs:
-	InputUpdateFromConstantx( fem->elements,fem->nodes, fem->vertices, fem->loads, fem->materials, fem->parameters,melting_offset,MeltingOffsetEnum);
+	InputUpdateFromConstantx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,melting_offset,MeltingOffsetEnum);
 
 	/*Free ressources: */
@@ -128,4 +126,3 @@
 	VecFree(&tf);
 	VecFree(&tf_old);
-	xfree((void**)&solver_string);
 }
Index: /issm/trunk/src/mex/Solver/Solver.cpp
===================================================================
--- /issm/trunk/src/mex/Solver/Solver.cpp	(revision 5685)
+++ /issm/trunk/src/mex/Solver/Solver.cpp	(revision 5686)
@@ -37,10 +37,8 @@
 		FetchData(&pf,PF);
 		FetchData(&uf0,UF0);
-	}
-
-	/*Run solver code: */
-	if (strcmp(solver_string,matlabstring)!=0){
 		/*Petsc solver: */
-		Solverx(&uf, Kff, pf, uf0, solver_string);
+		Solverx(&uf, Kff, pf, uf0, parameters);
+		/*Write output*/
+		WriteData(UF,uf);
 	}
 	else{
@@ -51,15 +49,10 @@
 	}
 
-	/*write output datasets if running Petsc solver: */
-	if (strcmp(solver_string,matlabstring)!=0) WriteData(UF,uf);
-
 	/*Free ressources: */
-	if (strcmp(solver_string,matlabstring)!=0){
-		MatFree(&Kff);
-		VecFree(&pf);
-		VecFree(&uf0);
-		VecFree(&uf);
-		delete parameters;
-	}
+	MatFree(&Kff);
+	VecFree(&pf);
+	VecFree(&uf0);
+	VecFree(&uf);
+	delete parameters;
 	xfree((void**)&solver_string);
 
@@ -71,5 +64,5 @@
 {
 	_printf_("\n");
-	_printf_("   usage: [uf] = %s(Kff,pf,uf0,solver_string);\n",__FUNCT__);
+	_printf_("   usage: [uf] = %s(Kff,pf,uf0,parameters);\n",__FUNCT__);
 	_printf_("\n");
 }