Index: /issm/trunk/src/c/Makefile.am
===================================================================
--- /issm/trunk/src/c/Makefile.am	(revision 764)
+++ /issm/trunk/src/c/Makefile.am	(revision 765)
@@ -109,4 +109,6 @@
 					./shared/Elements/Paterson.cpp\
 					./shared/Elements/GetElementNodeData.cpp\
+					./shared/String/isdistributed.cpp\
+					./shared/String/sharedstring.h\
 					./toolkits/petsc\
 					./toolkits/petsc/patches\
@@ -376,4 +378,6 @@
 					./shared/Elements/Paterson.cpp\
 					./shared/Elements/GetElementNodeData.cpp\
+					./shared/String/isdistributed.cpp\
+					./shared/String/sharedstring.h\
 					./toolkits/petsc\
 					./toolkits/petsc/patches\
@@ -470,4 +474,5 @@
 					./ModelProcessorx/Prognostic/CreateLoadsPrognostic.cpp\
 					./ModelProcessorx/Prognostic/CreateParametersPrognostic.cpp\
+					./ModelProcessorx/Qmu/CreateParametersQmu.cpp\
 					./Dofx/Dofx.h\
 					./Dofx/Dofx.cpp\
@@ -557,5 +562,6 @@
 bin_PROGRAMS = 
 else 
-bin_PROGRAMS = diagnostic.exe  control.exe thermal.exe prognostic.exe
+dnl bin_PROGRAMS = diagnostic.exe  control.exe thermal.exe prognostic.exe
+bin_PROGRAMS = diagnostic.exe  
 endif
 
Index: /issm/trunk/src/c/ModelProcessorx/Control/CreateParametersControl.cpp
===================================================================
--- /issm/trunk/src/c/ModelProcessorx/Control/CreateParametersControl.cpp	(revision 764)
+++ /issm/trunk/src/c/ModelProcessorx/Control/CreateParametersControl.cpp	(revision 765)
@@ -113,5 +113,5 @@
 
 	count++;
-	param= new Param(count,"velocity_observed",DOUBLEVEC);
+	param= new Param(count,"u_g_obs",DOUBLEVEC);
 	param->SetDoubleVec(u_g_obs,2*model->numberofnodes,2);
 	parameters->AddObject(param);
@@ -121,5 +121,5 @@
 
 	count++;
-	param= new Param(count,"parameter",DOUBLEVEC);
+	param= new Param(count,"param_g",DOUBLEVEC);
 	param->SetDoubleVec(p_g,model->numberofnodes,1);
 	parameters->AddObject(param);
Index: /issm/trunk/src/c/ModelProcessorx/CreateDataSets.cpp
===================================================================
--- /issm/trunk/src/c/ModelProcessorx/CreateDataSets.cpp	(revision 764)
+++ /issm/trunk/src/c/ModelProcessorx/CreateDataSets.cpp	(revision 765)
@@ -39,4 +39,5 @@
 			CreateLoadsDiagnosticHoriz(ploads,model,model_handle);
 			CreateParametersDiagnosticHoriz(pparameters,model,model_handle);
+			if(model->qmu_analysis)CreateParametersQmu(pparameters,model,model_handle);
 				
 		}
@@ -77,4 +78,5 @@
 		CreateLoadsThermal(ploads,model,model_handle);
 		CreateParametersThermal(pparameters,model,model_handle);
+		if(model->qmu_analysis)CreateParametersQmu(pparameters,model,model_handle);
 					
 	}
@@ -92,4 +94,5 @@
 		CreateLoadsPrognostic(ploads,model,model_handle);
 		CreateParametersPrognostic(pparameters,model,model_handle);
+		if(model->qmu_analysis)CreateParametersQmu(pparameters,model,model_handle);
 					
 	}
Index: /issm/trunk/src/c/ModelProcessorx/CreateParameters.cpp
===================================================================
--- /issm/trunk/src/c/ModelProcessorx/CreateParameters.cpp	(revision 764)
+++ /issm/trunk/src/c/ModelProcessorx/CreateParameters.cpp	(revision 765)
@@ -25,8 +25,4 @@
 	int      numberofdofspernode;
 	int      dim;
-	int*  epart=NULL;
-	int*  part=NULL;
-	double*  dpart=NULL;
-	int      elements_width;
 
 
@@ -48,15 +44,4 @@
 	parameters->AddObject(param);
 
-	//qmu analysis?
-	count++;
-	param= new Param(count,"qmu_analysis",INTEGER);
-	param->SetInteger(model->qmu_analysis);
-	parameters->AddObject(param);
-
-	count++;
-	param= new Param(count,"qmu_npart",INTEGER);
-	param->SetInteger(model->qmu_npart);
-	parameters->AddObject(param);
-
 	//dimension 2d or 3d:
 	if (strcmp(model->meshtype,"2d")==0)dim=2;
@@ -217,67 +202,4 @@
 	param->SetInteger(numberofdofspernode);
 	parameters->AddObject(param);
-
-	/*Deal with responses and partition for qmu modeling: */
-	if(model->qmu_analysis){
-		char** descriptors=NULL;
-		char*  descriptor=NULL;
-		char*  tag=NULL;
-
-		descriptors=(char**)xmalloc(model->numberofresponses*sizeof(char*));
-		tag=(char*)xmalloc((strlen("descriptori")+1)*sizeof(char));
-
-		/*Fetch descriptors: */
-		for(i=0;i<model->numberofresponses;i++){
-			sprintf(tag,"%s%i","descriptor",i);
-			ModelFetchData((void**)&descriptor,NULL,NULL,model_handle,tag,"String",NULL);
-			descriptors[i]=descriptor;
-		}
-
-		/*Ok, we have all the descriptors. Build a parameter with it: */
-		count++;
-		param= new Param(count,"descriptors",STRINGARRAY);
-		param->SetStringArray(descriptors,model->numberofresponses);
-		parameters->AddObject(param);
-
-		/*Free data: */
-		xfree((void**)&tag);
-		for(i=0;i<model->numberofresponses;i++){
-			char* descriptor=descriptors[i];
-			xfree((void**)&descriptor);
-		}
-		xfree((void**)&descriptors);
-
-		#ifdef _PARALLEL_
-		/*partition grids in model->qmu_npart parts: */
-	
-		if(strcmp(model->meshtype,"2d")==0){
-			ModelFetchData((void**)&model->elements,NULL,NULL,model_handle,"elements","Matrix","Mat");
-			elements_width=3; //tria elements
-		}
-		else{
-			ModelFetchData((void**)&model->elements2d,NULL,NULL,model_handle,"elements2d","Matrix","Mat");
-			elements_width=6; //penta elements
-		}
-
-		MeshPartitionx(&epart, &part,model->numberofelements,model->numberofnodes,model->elements, model->numberofelements2d,model->numberofnodes2d,model->elements2d,model->numlayers,elements_width, model->meshtype,model->qmu_npart);
-
-		dpart=(double*)xmalloc(model->numberofnodes*sizeof(double));
-		for(i=0;i<model->numberofnodes;i++)dpart[i]=part[i];
-
-		count++;
-		param= new Param(count,"qmu_part",DOUBLEVEC);
-		param->SetDoubleVec(dpart,model->numberofnodes);
-		parameters->AddObject(param);
-
-		/*Free elements and elements2d: */
-		xfree((void**)&model->elements);
-		xfree((void**)&model->elements2d);
-		xfree((void**)&epart);
-		xfree((void**)&part);
-		xfree((void**)&dpart);
-
-		#endif
-	}
-
 	
 	/*All our datasets are already ordered by ids. Set presort flag so that later on, when sorting is requested on these 
Index: /issm/trunk/src/c/ModelProcessorx/DiagnosticHoriz/CreateParametersDiagnosticHoriz.cpp
===================================================================
--- /issm/trunk/src/c/ModelProcessorx/DiagnosticHoriz/CreateParametersDiagnosticHoriz.cpp	(revision 764)
+++ /issm/trunk/src/c/ModelProcessorx/DiagnosticHoriz/CreateParametersDiagnosticHoriz.cpp	(revision 765)
@@ -23,4 +23,5 @@
 	double* vy=NULL;
 	double* vz=NULL;
+	double* ug=NULL;
 
 	/*recover parameters : */
@@ -37,24 +38,13 @@
 	ModelFetchData((void**)&vz,NULL,NULL,model_handle,"vz","Matrix","Mat");
 
-	if(vx) for(i=0;i<model->numberofnodes;i++)vx[i]=vx[i]/model->yts;
-	if(vy) for(i=0;i<model->numberofnodes;i++)vy[i]=vy[i]/model->yts;
-	if(vz) for(i=0;i<model->numberofnodes;i++)vz[i]=vz[i]/model->yts;
+	ug=(double*)xcalloc(model->numberofnodes*3,sizeof(double));
+
+	if(vx) for(i=0;i<model->numberofnodes;i++)ug[3*i+0]=vx[i]/model->yts;
+	if(vy) for(i=0;i<model->numberofnodes;i++)ug[3*i+1]=vy[i]/model->yts;
+	if(vz) for(i=0;i<model->numberofnodes;i++)ug[3*i+2]=vz[i]/model->yts;
 
 	count++;
-	param= new Param(count,"vx",DOUBLEVEC);
-	if(vx) param->SetDoubleVec(vx,model->numberofnodes);
-	else param->SetDoubleVec(vx,0);
-	parameters->AddObject(param);
-
-	count++;
-	param= new Param(count,"vy",DOUBLEVEC);
-	if(vy) param->SetDoubleVec(vy,model->numberofnodes);
-	else param->SetDoubleVec(vy,0);
-	parameters->AddObject(param);
-
-	count++;
-	param= new Param(count,"vz",DOUBLEVEC);
-	if(vz) param->SetDoubleVec(vz,model->numberofnodes);
-	else param->SetDoubleVec(vz,0);
+	param= new Param(count,"u_g",DOUBLEVEC);
+	param->SetDoubleVec(ug,3*model->numberofnodes,3);
 	parameters->AddObject(param);
 
@@ -62,4 +52,5 @@
 	xfree((void**)&vy);
 	xfree((void**)&vz);
+	xfree((void**)&ug);
 	
 	/*Assign output pointer: */
Index: /issm/trunk/src/c/ModelProcessorx/Melting/CreateParametersMelting.cpp
===================================================================
--- /issm/trunk/src/c/ModelProcessorx/Melting/CreateParametersMelting.cpp	(revision 764)
+++ /issm/trunk/src/c/ModelProcessorx/Melting/CreateParametersMelting.cpp	(revision 765)
@@ -40,5 +40,5 @@
 
 		count++;
-		param= new Param(count,"melting",DOUBLEVEC);
+		param= new Param(count,"m_g",DOUBLEVEC);
 		if(melting) param->SetDoubleVec(melting,model->numberofnodes);
 		else param->SetDoubleVec(melting,0);
Index: /issm/trunk/src/c/ModelProcessorx/Model.cpp
===================================================================
--- /issm/trunk/src/c/ModelProcessorx/Model.cpp	(revision 764)
+++ /issm/trunk/src/c/ModelProcessorx/Model.cpp	(revision 765)
@@ -39,4 +39,5 @@
 	model->solverstring=NULL;
 	model->numberofresponses=0;
+	model->numberofvariables=0;
 	model->qmu_npart=0;
 	model->numberofelements=0;
@@ -384,4 +385,5 @@
 	/*qmu: */
 	if(model->qmu_analysis){
+		ModelFetchData((void**)&model->numberofvariables,NULL,NULL,model_handle,"numberofvariables","Integer",NULL);
 		ModelFetchData((void**)&model->numberofresponses,NULL,NULL,model_handle,"numberofresponses","Integer",NULL);
 		ModelFetchData((void**)&model->qmu_npart,NULL,NULL,model_handle,"npart","Integer",NULL);
Index: /issm/trunk/src/c/ModelProcessorx/Model.h
===================================================================
--- /issm/trunk/src/c/ModelProcessorx/Model.h	(revision 764)
+++ /issm/trunk/src/c/ModelProcessorx/Model.h	(revision 765)
@@ -58,4 +58,5 @@
 	/*qmu: */
 	int      numberofresponses;
+	int      numberofvariables;
 	int      qmu_npart;
 
@@ -237,4 +238,7 @@
 	void    CreateParametersPrognostic(DataSet** pparameters,Model* model,ConstDataHandle model_handle);
 
+	/*qmu: */
+	void CreateParametersQmu(DataSet** pparameters,Model* model,ConstDataHandle model_handle);
+
 
 #endif  /* _MODEL_H */
Index: /issm/trunk/src/c/ModelProcessorx/Prognostic/CreateParametersPrognostic.cpp
===================================================================
--- /issm/trunk/src/c/ModelProcessorx/Prognostic/CreateParametersPrognostic.cpp	(revision 764)
+++ /issm/trunk/src/c/ModelProcessorx/Prognostic/CreateParametersPrognostic.cpp	(revision 765)
@@ -23,4 +23,5 @@
 	double* vy=NULL;
 	double* vz=NULL;
+	double* u_g=NULL;
 	double* pressure=NULL;
 	double* thickness=NULL;
@@ -38,29 +39,20 @@
 	ModelFetchData((void**)&vz,NULL,NULL,model_handle,"vz","Matrix","Mat");
 
-	if(vx) for(i=0;i<model->numberofnodes;i++)vx[i]=vx[i]/model->yts;
-	if(vy) for(i=0;i<model->numberofnodes;i++)vy[i]=vy[i]/model->yts;
-	if(vz) for(i=0;i<model->numberofnodes;i++)vz[i]=vz[i]/model->yts;
+	u_g=(double*)xcalloc(model->numberofnodes*3,sizeof(double));
+
+	if(vx) for(i=0;i<model->numberofnodes;i++)u_g[3*i+0]=vx[i]/model->yts;
+	if(vy) for(i=0;i<model->numberofnodes;i++)u_g[3*i+1]=vy[i]/model->yts;
+	if(vz) for(i=0;i<model->numberofnodes;i++)u_g[3*i+2]=vz[i]/model->yts;
 
 	count++;
-	param= new Param(count,"vx",DOUBLEVEC);
-	if(vx) param->SetDoubleVec(vx,model->numberofnodes);
-	else param->SetDoubleVec(vx,0);
+	param= new Param(count,"u_g",DOUBLEVEC);
+	param->SetDoubleVec(u_g,3*model->numberofnodes,3);
 	parameters->AddObject(param);
 
-	count++;
-	param= new Param(count,"vy",DOUBLEVEC);
-	if(vy) param->SetDoubleVec(vy,model->numberofnodes);
-	else param->SetDoubleVec(vy,0);
-	parameters->AddObject(param);
-
-	count++;
-	param= new Param(count,"vz",DOUBLEVEC);
-	if(vz) param->SetDoubleVec(vz,model->numberofnodes);
-	else param->SetDoubleVec(vz,0);
-	parameters->AddObject(param);
 
 	xfree((void**)&vx);
 	xfree((void**)&vy);
 	xfree((void**)&vz);
+	xfree((void**)&u_g);
 	
 	/*Get thickness: */
@@ -68,7 +60,7 @@
 	
 	count++;
-	param= new Param(count,"thickness",DOUBLEVEC);
-	if(thickness) param->SetDoubleVec(thickness,model->numberofnodes);
-	else param->SetDoubleVec(thickness,0);
+	param= new Param(count,"h_g",DOUBLEVEC);
+	if(thickness) param->SetDoubleVec(thickness,model->numberofnodes,1);
+	else param->SetDoubleVec(thickness,0,0);
 	parameters->AddObject(param);
 
@@ -80,7 +72,7 @@
 	
 	count++;
-	param= new Param(count,"melting",DOUBLEVEC);
-	if(melting) param->SetDoubleVec(melting,model->numberofnodes);
-	else param->SetDoubleVec(melting,0);
+	param= new Param(count,"m_g",DOUBLEVEC);
+	if(melting) param->SetDoubleVec(melting,model->numberofnodes,1);
+	else param->SetDoubleVec(melting,0,1);
 	parameters->AddObject(param);
 
@@ -92,7 +84,7 @@
 	
 	count++;
-	param= new Param(count,"accumulation",DOUBLEVEC);
-	if(accumulation) param->SetDoubleVec(accumulation,model->numberofnodes);
-	else param->SetDoubleVec(accumulation,0);
+	param= new Param(count,"a_g",DOUBLEVEC);
+	if(accumulation) param->SetDoubleVec(accumulation,model->numberofnodes,1);
+	else param->SetDoubleVec(accumulation,0,0);
 	parameters->AddObject(param);
 
Index: /issm/trunk/src/c/ModelProcessorx/Qmu/CreateParametersQmu.cpp
===================================================================
--- /issm/trunk/src/c/ModelProcessorx/Qmu/CreateParametersQmu.cpp	(revision 765)
+++ /issm/trunk/src/c/ModelProcessorx/Qmu/CreateParametersQmu.cpp	(revision 765)
@@ -0,0 +1,158 @@
+/*!\file: CreateParametersQmu.cpp
+ * \brief general driver for creating parameters dataset
+ */ 
+
+#undef __FUNCT__ 
+#define __FUNCT__ "CreateParametersQmu"
+
+#include "../../DataSet/DataSet.h"
+#include "../../toolkits/toolkits.h"
+#include "../../EnumDefinitions/EnumDefinitions.h"
+#include "../../objects/objects.h"
+#include "../../shared/shared.h"
+#include "../../MeshPartitionx/MeshPartitionx.h"
+#include "../Model.h"
+
+void CreateParametersQmu(DataSet** pparameters,Model* model,ConstDataHandle model_handle){
+	
+	int i;
+	
+	DataSet* parameters = NULL;
+	Param*   param = NULL;
+	int      count;
+	
+	int*     epart=NULL;
+	int*     part=NULL;
+	double*  dpart=NULL;
+	int      elements_width;
+
+	char**  responsedescriptors=NULL;
+	char**  variabledescriptors=NULL;
+	char*   descriptor=NULL;
+	char*   tag=NULL;
+	double* dakota_parameter=NULL;
+
+	/*recover parameters : */
+	parameters=*pparameters;
+
+	count=parameters->Size();
+
+	//qmu analysis?
+	count++;
+	param= new Param(count,"qmu_analysis",INTEGER);
+	param->SetInteger(model->qmu_analysis);
+	parameters->AddObject(param);
+
+	count++;
+	param= new Param(count,"qmu_npart",INTEGER);
+	param->SetInteger(model->qmu_npart);
+	parameters->AddObject(param);
+
+	/*Deal with variables for qmu modeling: */
+	variabledescriptors=(char**)xmalloc(model->numberofvariables*sizeof(char*));
+	tag=(char*)xmalloc((strlen("variabledescriptori")+1)*sizeof(char));
+
+	/*Fetch descriptors: */
+	for(i=0;i<model->numberofvariables;i++){
+		sprintf(tag,"%s%i","variabledescriptor",i);
+		ModelFetchData((void**)&descriptor,NULL,NULL,model_handle,tag,"String",NULL);
+		variabledescriptors[i]=descriptor;
+	}
+
+	/*Ok, we have all the variable descriptors. Build a parameter with it: */
+	count++;
+	param= new Param(count,"variabledescriptors",STRINGARRAY);
+	param->SetStringArray(variabledescriptors,model->numberofvariables);
+	parameters->AddObject(param);
+
+	xfree((void**)&tag);
+
+	/*Deal with responses and partition for qmu modeling: */
+	responsedescriptors=(char**)xmalloc(model->numberofresponses*sizeof(char*));
+	tag=(char*)xmalloc((strlen("responsedescriptori")+1)*sizeof(char));
+
+	/*Fetch descriptors: */
+	for(i=0;i<model->numberofresponses;i++){
+		sprintf(tag,"%s%i","responsedescriptor",i);
+		ModelFetchData((void**)&descriptor,NULL,NULL,model_handle,tag,"String",NULL);
+		responsedescriptors[i]=descriptor;
+	}
+
+	/*Ok, we have all the response descriptors. Build a parameter with it: */
+	count++;
+	param= new Param(count,"responsedescriptors",STRINGARRAY);
+	param->SetStringArray(responsedescriptors,model->numberofresponses);
+	parameters->AddObject(param);
+
+	
+	#ifdef _PARALLEL_
+	/*partition grids in model->qmu_npart parts: */
+
+	if(strcmp(model->meshtype,"2d")==0){
+		ModelFetchData((void**)&model->elements,NULL,NULL,model_handle,"elements","Matrix","Mat");
+		elements_width=3; //tria elements
+	}
+	else{
+		ModelFetchData((void**)&model->elements2d,NULL,NULL,model_handle,"elements2d","Matrix","Mat");
+		elements_width=6; //penta elements
+	}
+
+	MeshPartitionx(&epart, &part,model->numberofelements,model->numberofnodes,model->elements, model->numberofelements2d,model->numberofnodes2d,model->elements2d,model->numlayers,elements_width, model->meshtype,model->qmu_npart);
+
+	dpart=(double*)xmalloc(model->numberofnodes*sizeof(double));
+	for(i=0;i<model->numberofnodes;i++)dpart[i]=part[i];
+
+	count++;
+	param= new Param(count,"qmu_part",DOUBLEVEC);
+	param->SetDoubleVec(dpart,model->numberofnodes,1);
+	parameters->AddObject(param);
+	#endif
+
+	/*Ok, now if any of the variables input from Dakota are distributed, we are going to need the parameters: */
+	for(i=0;i<model->numberofvariables;i++){
+
+		descriptor=variabledescriptors[i];
+
+		if ((strcmp(descriptor,"thickness")==0) ||
+			(strcmp(descriptor,"drag")     ==0)
+			){
+
+			//Fetch data: 
+			ModelFetchData((void**)&dakota_parameter,NULL,NULL,model_handle,descriptor,"Matrix","Mat");
+
+			//Add parameter
+			count++;
+			param= new Param(count,descriptor,DOUBLEVEC);
+			param->SetDoubleVec(dakota_parameter,model->numberofnodes,1);
+			parameters->AddObject(param);
+
+			//free data
+			xfree((void**)&dakota_parameter);
+
+		}
+	}
+
+	/*Free data: */
+	xfree((void**)&tag);
+	for(i=0;i<model->numberofresponses;i++){
+		char* descriptor=responsedescriptors[i];
+		xfree((void**)&descriptor);
+	}
+	xfree((void**)&responsedescriptors);
+
+	for(i=0;i<model->numberofvariables;i++){
+		char* descriptor=variabledescriptors[i];
+		xfree((void**)&descriptor);
+	}
+	xfree((void**)&variabledescriptors);
+
+	xfree((void**)&model->elements);
+	xfree((void**)&model->elements2d);
+	xfree((void**)&epart);
+	xfree((void**)&part);
+	xfree((void**)&dpart);
+
+
+	/*Assign output pointer: */
+	*pparameters=parameters;
+}
Index: /issm/trunk/src/c/ModelProcessorx/Thermal/CreateParametersThermal.cpp
===================================================================
--- /issm/trunk/src/c/ModelProcessorx/Thermal/CreateParametersThermal.cpp	(revision 764)
+++ /issm/trunk/src/c/ModelProcessorx/Thermal/CreateParametersThermal.cpp	(revision 765)
@@ -23,4 +23,5 @@
 	double* vy=NULL;
 	double* vz=NULL;
+	double* u_g=NULL;
 	double* pressure=NULL;
 	double* temperature=NULL;
@@ -36,24 +37,13 @@
 	ModelFetchData((void**)&vz,NULL,NULL,model_handle,"vz","Matrix","Mat");
 
-	if(vx) for(i=0;i<model->numberofnodes;i++)vx[i]=vx[i]/model->yts;
-	if(vy) for(i=0;i<model->numberofnodes;i++)vy[i]=vy[i]/model->yts;
-	if(vz) for(i=0;i<model->numberofnodes;i++)vz[i]=vz[i]/model->yts;
+	u_g=(double*)xcalloc(model->numberofnodes*3,sizeof(double));
+
+	if(vx) for(i=0;i<model->numberofnodes;i++)u_g[3*i+0]=vx[i]/model->yts;
+	if(vy) for(i=0;i<model->numberofnodes;i++)u_g[3*i+1]=vy[i]/model->yts;
+	if(vz) for(i=0;i<model->numberofnodes;i++)u_g[3*i+2]=vz[i]/model->yts;
 
 	count++;
-	param= new Param(count,"vx",DOUBLEVEC);
-	if(vx) param->SetDoubleVec(vx,model->numberofnodes);
-	else param->SetDoubleVec(vx,0);
-	parameters->AddObject(param);
-
-	count++;
-	param= new Param(count,"vy",DOUBLEVEC);
-	if(vy) param->SetDoubleVec(vy,model->numberofnodes);
-	else param->SetDoubleVec(vy,0);
-	parameters->AddObject(param);
-
-	count++;
-	param= new Param(count,"vz",DOUBLEVEC);
-	if(vz) param->SetDoubleVec(vz,model->numberofnodes);
-	else param->SetDoubleVec(vz,0);
+	param= new Param(count,"u_g",DOUBLEVEC);
+	param->SetDoubleVec(u_g,3*model->numberofnodes,3);
 	parameters->AddObject(param);
 
@@ -61,4 +51,5 @@
 	xfree((void**)&vy);
 	xfree((void**)&vz);
+	xfree((void**)&u_g);
 	
 	/*Get pressure: */
@@ -66,7 +57,7 @@
 	
 	count++;
-	param= new Param(count,"pressure",DOUBLEVEC);
-	if(pressure) param->SetDoubleVec(pressure,model->numberofnodes);
-	else param->SetDoubleVec(pressure,0);
+	param= new Param(count,"p_g",DOUBLEVEC);
+	if(pressure) param->SetDoubleVec(pressure,model->numberofnodes,1);
+	else param->SetDoubleVec(pressure,0,0);
 	parameters->AddObject(param);
 
@@ -74,5 +65,5 @@
 	xfree((void**)&pressure);
 
-	/* get initial temperature if transient*/
+	/* get initial temperature and melting if transient*/
 	if(strcmp(model->sub_analysis_type,"transient")==0){
 
@@ -81,5 +72,5 @@
 
 		count++;
-		param= new Param(count,"temperature",DOUBLEVEC);
+		param= new Param(count,"t_g",DOUBLEVEC);
 		if(temperature) param->SetDoubleVec(temperature,model->numberofnodes);
 		else throw ErrorException(__FUNCT__,exprintf("Missing initial temperature"));
Index: /issm/trunk/src/c/ProcessParamsx/ProcessParamsx.cpp
===================================================================
--- /issm/trunk/src/c/ProcessParamsx/ProcessParamsx.cpp	(revision 764)
+++ /issm/trunk/src/c/ProcessParamsx/ProcessParamsx.cpp	(revision 765)
@@ -1,4 +1,8 @@
 /*!\file ProcessParamsx
- * \brief: process parameters using partitioning vector
+ * \brief: process parameters using partitioning vector. 
+ * Go through all parameters in the 'parameters' dataset. For each parameter that holds a doublevec (ie, a double* vector synchronized across 
+ * the MPI ring of a cluster), partition the vector so that the new node partitioning decided in ModelProcessor is applied. Otherwise, 
+ * parameters coming directly from Matlab would be serially partitioned, which means could not be recognized by each individual node or element. 
+ * The partition needs to be the parallel partitionting.
  */
 
@@ -11,273 +15,61 @@
 #include "../include/macros.h"
 #include "../toolkits/toolkits.h"
+#include "../DataSet/DataSet.h"
 #include "../EnumDefinitions/EnumDefinitions.h"
 
 void ProcessParamsx( DataSet* parameters, Vec  part){
 
-	int i;
 	
 	double* partition=NULL;
 	Param*  param=NULL;
 
-	/*diagnostic: */
-	double* vx=NULL;
-	double* vy=NULL;
-	double* vz=NULL;
-		
-	double* u_g=NULL;
-	
-	/*control: */
-	Vec     vec_vx_obs=NULL;
-	Vec     vec_vy_obs=NULL;
-	Vec     vec_control_parameter=NULL;
-
-	double* vx_obs=NULL;
-	double* vy_obs=NULL;
-	double* control_parameter=NULL;
-	double* param_g=NULL; 
-
-	double* u_g_obs=NULL;
-
-	/*thermal*/ 
-	double* pressure=NULL; 
-	double* temperature=NULL; 
-	double* melting=NULL; 
-	
-	double* p_g=NULL; 
-	double* t_g=NULL; 
-	double* m_g=NULL;
-
-	/*prognostic: */
-	double* a_g=NULL;
-	double* h_g=NULL;
-	double* accumulation=NULL;
-	double* thickness=NULL;
-
 	/*diverse: */
 	int     numberofnodes;
-	int     analysis_type;
-	int     sub_analysis_type;
-	int     count;
+	int i,j,k;
+	int ndof;
 
-	parameters->FindParam((void*)&analysis_type,"analysis_type");
-	parameters->FindParam((void*)&sub_analysis_type,"sub_analysis_type");
-	count=parameters->Size();
-		
+	/*processing of parameters: */
+	double* parameter=NULL;
+	double* new_parameter=NULL;
+
+	/*Some parameters needed: */
 	parameters->FindParam((void*)&numberofnodes,"numberofnodes");
 
-	/*First serialize partition vector: */
+	/*serialize partition vector: */
 	if(part)VecToMPISerial(&partition,part);
-	
-	if (   (analysis_type==ControlAnalysisEnum()) ||  
-		   (analysis_type==DiagnosticAnalysisEnum()) || 
-		   (analysis_type==ThermalAnalysisEnum()) ||
-		   (analysis_type==PrognosticAnalysisEnum()) 
-		   ){
 
-		parameters->FindParam((void*)&vx,"vx");
-		parameters->FindParam((void*)&vy,"vy");
-		parameters->FindParam((void*)&vz,"vz");
+	for(i=0;i<parameters->Size();i++){
 
-		if(numberofnodes){
-			u_g=(double*)xcalloc(numberofnodes*3,sizeof(double));
+		Param* param=(Param*)parameters->GetObjectByOffset(i);
 
-			if(vx){
-				for(i=0;i<numberofnodes;i++){
-					u_g[(int)(3*partition[i]+0)]=vx[i];  
+		if (param->GetType()==DOUBLEVEC){
+
+			ndof=param->GetNdof();
+
+			if (ndof!=0){ /*ok, we are dealing with a parameter that needs to be repartitioned, for ndof degrees of freedom: */
+
+				new_parameter=(double*)xcalloc(numberofnodes*ndof,sizeof(double));
+				param->GetParameterValue(&parameter);
+
+				for(j=0;j<ndof;j++){
+
+					for(k=0;k<numberofnodes;k++){
+					
+						new_parameter[(int)(ndof*partition[k]+j)]=parameter[ndof*k+j];
+
+					}
+
 				}
+			
+				
+				/*Now, replace old parameter with new parameter: */
+				param->SetDoubleVec(new_parameter,ndof*numberofnodes,ndof);
+
+				/*Free ressources: */
+				xfree((void**)&new_parameter);
+
 			}
-			if(vy){
-				for(i=0;i<numberofnodes;i++){
-					u_g[(int)(3*partition[i]+1)]=vy[i];  
-				}
-			}
-			if(vz){
-				for(i=0;i<numberofnodes;i++){
-					u_g[(int)(3*partition[i]+2)]=vz[i];  
-				}
-			}
-
-			/*Now, create new parameters: */
-			count++;
-			param= new Param(count,"u_g",DOUBLEVEC);
-			param->SetDoubleVec(u_g,3*numberofnodes);
-			parameters->AddObject(param);
-
-			/*erase old parameters: */
-			param=(Param*)parameters->FindParamObject("vx");
-			parameters->DeleteObject((Object*)param);
-
-			param=(Param*)parameters->FindParamObject("vy");
-			parameters->DeleteObject((Object*)param);
-
-			param=(Param*)parameters->FindParamObject("vz");
-			parameters->DeleteObject((Object*)param);
 		}
 	}
 
-	if(analysis_type==ControlAnalysisEnum()){
-
-		parameters->FindParam((void*)&vx_obs,"vx_obs");
-		parameters->FindParam((void*)&vy_obs,"vy_obs");
-		parameters->FindParam((void*)&control_parameter,"control_parameter");
-
-		/*Now, from vx_obs and vy_obs, build u_g_obs, correctly partitioned: */
-
-		u_g_obs=(double*)xcalloc(numberofnodes*2,sizeof(double));
-		param_g=(double*)xcalloc(numberofnodes*2,sizeof(double));
-
-		for(i=0;i<numberofnodes;i++){
-			u_g_obs[(int)(2*partition[i]+0)]=vx_obs[i];  
-			u_g_obs[(int)(2*partition[i]+1)]=vy_obs[i];  
-			param_g[(int)(2*partition[i]+0)]=control_parameter[i];
-		}
-
-		/*Now, create new parameters: */
-		count++;
-		param= new Param(count,"u_g_obs",DOUBLEVEC);
-		param->SetDoubleVec(u_g_obs,2*numberofnodes);
-		parameters->AddObject(param);
-
-		count++;
-		param= new Param(count,"param_g",DOUBLEVEC);
-		param->SetDoubleVec(param_g,2*numberofnodes);
-		parameters->AddObject(param);
-
-		/*erase old parameter: */
-		param=(Param*)parameters->FindParamObject("vx_obs");
-		parameters->DeleteObject((Object*)param);
-
-		param=(Param*)parameters->FindParamObject("vy_obs");
-		parameters->DeleteObject((Object*)param);
-
-		param=(Param*)parameters->FindParamObject("control_parameter");
-		parameters->DeleteObject((Object*)param);
-	}
-
-	if(analysis_type==ThermalAnalysisEnum()){
-
-		parameters->FindParam((void*)&pressure,"pressure");
-
-		/*Now, from temperature and melting, build t_g and m_g, correctly partitioned: */ 
-		p_g=(double*)xcalloc(numberofnodes,sizeof(double));
-
-		for(i=0;i<numberofnodes;i++){ 
-			p_g[(int)(partition[i])]= pressure[i];  
-		} 
-
-		/*Now, create new parameter: */ 
-		count++;
-		param= new Param(count,"p_g",DOUBLEVEC);
-		param->SetDoubleVec(p_g,numberofnodes);
-		parameters->AddObject(param);
-
-		/*erase old parameter: */ 
-		param=(Param*)parameters->FindParamObject("pressure");
-		parameters->DeleteObject((Object*)param);
-
-		if (sub_analysis_type==TransientAnalysisEnum()){
-
-			parameters->FindParam((void*)&temperature,"temperature"); 
-
-			/*Now, from temperature , build t_g , correctly partitioned: */ 
-			t_g=(double*)xcalloc(numberofnodes,sizeof(double)); 
-
-			for(i=0;i<numberofnodes;i++){ 
-				t_g[(int)(partition[i])]=temperature[i]; 
-			} 
-
-			/*Now, create new parameter: */ 
-			count++; 
-			param= new Param(count,"t_g",DOUBLEVEC); 
-			param->SetDoubleVec(t_g,numberofnodes); 
-			parameters->AddObject(param); 
-
-			/*erase old parameter: */ 
-			param=(Param*)parameters->FindParamObject("temperature"); 
-			parameters->DeleteObject((Object*)param); 
-		}
-	}
-
-	if(analysis_type==MeltingAnalysisEnum() && sub_analysis_type==TransientAnalysisEnum()){
-
-		parameters->FindParam((void*)&melting,"melting"); 
-
-		/*Now, from melting , build m_g , correctly partitioned: */ 
-		m_g=(double*)xcalloc(numberofnodes,sizeof(double)); 
-
-		for(i=0;i<numberofnodes;i++){ 
-			m_g[(int)(partition[i])]=melting[i]; 
-		} 
-
-		/*Now, create new parameter: */ 
-		count++; 
-		param= new Param(count,"m_g",DOUBLEVEC); 
-		param->SetDoubleVec(m_g,numberofnodes); 
-		parameters->AddObject(param); 
-
-		/*erase old parameter: */ 
-		param=(Param*)parameters->FindParamObject("melting"); 
-		parameters->DeleteObject((Object*)param); 
-	}
-
-	if(analysis_type==PrognosticAnalysisEnum()){
-
-		parameters->FindParam((void*)&melting,"melting");
-		parameters->FindParam((void*)&thickness,"thickness");
-		parameters->FindParam((void*)&accumulation,"accumulation");
-		
-		/*Now, from melting accumulation and thickness, build m_g, h_g, correctly partitioned: */
-		m_g=(double*)xcalloc(numberofnodes,sizeof(double));
-		h_g=(double*)xcalloc(numberofnodes,sizeof(double));
-		a_g=(double*)xcalloc(numberofnodes,sizeof(double));
-
-		for(i=0;i<numberofnodes;i++){
-			m_g[(int)(partition[i])]= melting[i];  
-			h_g[(int)(partition[i])]= thickness[i];  
-			a_g[(int)(partition[i])]= accumulation[i];  
-		}
-
-		/*Now, create new parameter: */
-		count++;
-		param= new Param(count,"m_g",DOUBLEVEC);
-		param->SetDoubleVec(m_g,numberofnodes);
-		parameters->AddObject(param);
-
-		count++;
-		param= new Param(count,"h_g",DOUBLEVEC);
-		param->SetDoubleVec(h_g,numberofnodes);
-		parameters->AddObject(param);
-
-		count++;
-		param= new Param(count,"a_g",DOUBLEVEC);
-		param->SetDoubleVec(a_g,numberofnodes);
-		parameters->AddObject(param);
-
-		/*erase old parameter: */
-		param=(Param*)parameters->FindParamObject("melting");
-		parameters->DeleteObject((Object*)param);
-		
-		param=(Param*)parameters->FindParamObject("thickness");
-		parameters->DeleteObject((Object*)param);
-
-		param=(Param*)parameters->FindParamObject("accumulation");
-		parameters->DeleteObject((Object*)param);
-	}
-	xfree((void**)&partition);
-	
-	xfree((void**)&vx);
-	xfree((void**)&vy);
-	xfree((void**)&vz);
-	xfree((void**)&u_g);
-
-	xfree((void**)&vx_obs);
-	xfree((void**)&vy_obs);
-	xfree((void**)&param_g);
-	xfree((void**)&pressure);
-	xfree((void**)&control_parameter);
-	xfree((void**)&u_g_obs);
-	xfree((void**)&p_g); 
-	xfree((void**)&a_g); 
-	xfree((void**)&h_g); 
-	xfree((void**)&m_g); 
 }
Index: /issm/trunk/src/c/objects/Param.cpp
===================================================================
--- /issm/trunk/src/c/objects/Param.cpp	(revision 764)
+++ /issm/trunk/src/c/objects/Param.cpp	(revision 765)
@@ -125,5 +125,5 @@
 		
 		case DOUBLEVEC:
-			printf("   double vector. size: %i\n",M);
+			printf("   double vector. size: %i ndof: %i\n",M,ndof);
 			for(i=0;i<M;i++)printf("%g\n",doublevec[i]);
 			break;
@@ -178,4 +178,5 @@
 	memcpy(marshalled_dataset,&name,sizeof(name));marshalled_dataset+=sizeof(name);
 	memcpy(marshalled_dataset,&type,sizeof(type));marshalled_dataset+=sizeof(type);
+	memcpy(marshalled_dataset,&ndof,sizeof(ndof));marshalled_dataset+=sizeof(ndof);
 
 	switch(type){
@@ -265,4 +266,5 @@
 		sizeof(name)+
 		sizeof(type)+
+		sizeof(ndof)+
 		sizeof(int); //sizeof(int) for enum type
 
@@ -333,4 +335,5 @@
 	memcpy(&name,marshalled_dataset,sizeof(name));marshalled_dataset+=sizeof(name);
 	memcpy(&type,marshalled_dataset,sizeof(type));marshalled_dataset+=sizeof(type);
+	memcpy(&ndof,marshalled_dataset,sizeof(ndof));marshalled_dataset+=sizeof(ndof);
 
 
@@ -575,4 +578,8 @@
 }
 
+int   Param::GetNdof(){
+	return ndof;
+}
+
 int   Param::GetN(){
 	return N;
@@ -589,6 +596,21 @@
 		memcpy(doublevec,value,M*sizeof(double));
 	}
-
-}
+	ndof=0; //this vector will not be repartitioned.
+
+}
+
+#undef __FUNCT__
+#define __FUNCT__ "SetDoubleVec"
+void  Param::SetDoubleVec(double* value,int size, int numberofdofs){
+	if (type!=DOUBLEVEC) throw ErrorException(__FUNCT__,exprintf("%s%i"," trying to set doublevecfor type",type));
+	
+	M=size;
+	if(M){
+		doublevec=(double*)xmalloc(M*sizeof(double));
+		memcpy(doublevec,value,M*sizeof(double));
+	}
+	ndof=numberofdofs;
+}
+
 
 #undef __FUNCT__
Index: /issm/trunk/src/c/objects/Param.h
===================================================================
--- /issm/trunk/src/c/objects/Param.h	(revision 764)
+++ /issm/trunk/src/c/objects/Param.h	(revision 765)
@@ -30,4 +30,5 @@
 		int M; //dimensions of vectors and matrices
 		int N;
+		int ndof;
 
 	public:
@@ -47,4 +48,5 @@
 		void  SetDouble(double value);
 		void  SetDoubleVec(double* value,int size);
+		void  SetDoubleVec(double* value,int size,int ndof);
 		void  SetVec(Vec value);
 		void  SetInteger(int value);
@@ -59,4 +61,5 @@
 		int   GetM();
 		int   GetN();
+		int   GetNdof();
 		Object* copy();
 
Index: /issm/trunk/src/c/objects/ParameterInputs.cpp
===================================================================
--- /issm/trunk/src/c/objects/ParameterInputs.cpp	(revision 764)
+++ /issm/trunk/src/c/objects/ParameterInputs.cpp	(revision 765)
@@ -270,2 +270,75 @@
 	return ug;
 }
+
+#undef __FUNCT__
+#define __FUNCT__ "ParameterInputs::UpdateFromDakota"
+void ParameterInputs::UpdateFromDakota(double* variables,char** variables_descriptors,int numvariables,DataSet* parameters,double* qmu_part,int qmu_npart){
+
+	/*Go through all dakota descriptors, ex: "rho_ice","thermal_conductivity","thickness1","thickness2", etc ..., and 
+	 * for each descriptor, take the variable value and plug it into the inputs: */
+
+	int     i,j,k;
+	int     found;
+
+	double* distributed_values=NULL;
+	char*   root=NULL; //root name of distributed variable, ex: thickness, drag, etc ...
+	double* parameter=NULL;
+	int     numberofnodes;
+
+	char*   descriptor=NULL;
+
+	/*retrive some necessary parameters first: */
+	found=parameters->FindParam((void*)&numberofnodes,"numberofnodes");
+	if(!found)throw ErrorException(__FUNCT__,"coud not find numberofnodes in parameters dataset!");
+
+	for(i=0;i<numvariables;i++){
+	
+		descriptor=variables_descriptors[i];
+
+		/*From descriptor, figure out if the variable is distributed (distributed implies there is a numeric value at the 
+		 * end of the descriptor, for ex: thickness1, thickness10, etc .... If it is distributed, the next qmu_npart (number 
+		 * of partitions in the distributed variable) variable are the values for each partition of the distributed variable: */
+		if (!isdistributed(&root,descriptor)){
+			
+			/*Ok, variable is not distributed, just add it to inputs: */
+			this->Add(descriptor,variables[i]);
+		}
+		else{
+			
+			/*Ok, variable is distributed. Root name of variable is also known. Now, allocate distributed_values and fill the 
+			 * distributed_values with the next qmu_npart variables: */
+
+			distributed_values=(double*)xmalloc(qmu_npart*sizeof(double));
+			for(j=0;j<qmu_npart;j++){
+				distributed_values[j]=variables[i+j];
+			}
+
+			/*Now, pick up the parameter corresponding to root: */
+			found=parameters->FindParam((void*)&parameter,root);
+			if(!found)throw ErrorException(__FUNCT__,exprintf("%s%s%s"," could not find parameter ",root," for Dakota input update"));
+			
+			/*We've got the parameter, we need to update it using qmu_part (a partitioning vector), and the distributed_values: */
+			for(k=0;k<numberofnodes;k++){
+				parameter[k]=parameter[k]*distributed_values[(int)qmu_part[k]];
+			}
+
+			/*Add parameter to inputs: */
+			this->Add("root",parameter,1,numberofnodes);
+
+			/*increment i to skip the distributed values just collected: */
+			i+=qmu_npart;
+
+			/*Free allocations: */
+			xfree((void**)&parameter);
+			xfree((void**)&distributed_values);
+			xfree((void**)&root);
+
+		}
+	}
+
+	/*Free ressources:*/
+	xfree((void**)&distributed_values);
+	xfree((void**)&root);
+	xfree((void**)&parameter);
+
+}
Index: /issm/trunk/src/c/objects/ParameterInputs.h
===================================================================
--- /issm/trunk/src/c/objects/ParameterInputs.h	(revision 764)
+++ /issm/trunk/src/c/objects/ParameterInputs.h	(revision 765)
@@ -38,4 +38,6 @@
 		void Init( void* data_handle);
 		void purge(char* name);
+		void UpdateFromDakota(double* variables,char** variables_descriptors,int numvariables,DataSet* parameters, double* qmu_part,int qmu_npart);
+
 };
 
Index: /issm/trunk/src/c/parallel/SpawnCore.cpp
===================================================================
--- /issm/trunk/src/c/parallel/SpawnCore.cpp	(revision 764)
+++ /issm/trunk/src/c/parallel/SpawnCore.cpp	(revision 765)
@@ -36,9 +36,12 @@
 	extern int my_rank;
 	
+	
 	/*synchronize all cpus, as CPU 0 is probably late (it is starting the entire dakota strategy!) : */
 	MPI_Barrier(MPI_COMM_WORLD);
 
-	/*First off, recover the responses descriptors for the response functions: */
-	param=(Param*)femmodels[0].parameters->FindParamObject("descriptors");
+	/*First off, recover the response descriptors for the response functions: */
+	param=(Param*)femmodels[0].parameters->FindParamObject("responsedescriptors");
+	if(!param)throw ErrorException(__FUNCT__," could not find response descriptors!");
+
 	numresponses=param->GetM();
 	param->GetParameterValue(&responses_descriptors);
@@ -47,8 +50,7 @@
 	femmodels[0].parameters->FindParam((void*)&qmu_npart,"qmu_npart");
 	femmodels[0].parameters->FindParam((void*)&qmu_part,"qmu_part");
-
 	#ifdef _DEBUG_
 	for(i=0;i<numresponses;i++){
-		PetscSynchronizedPrintf(MPI_COMM_WORLD,"descriptor %i: %s\n",i,responses_descriptors[i]);
+		PetscSynchronizedPrintf(MPI_COMM_WORLD,"response descriptor %i: %s\n",i,responses_descriptors[i]);
 		PetscSynchronizedFlush(MPI_COMM_WORLD);
 	}
@@ -89,24 +91,45 @@
 	#endif
 
+
 	_printf_("initialize results:\n");
 	results=new DataSet(ResultsEnum());
 
 	/*Modify core inputs to reflect the dakota variables inputs: */
-	//inputs->UpdateFromDakota(variables,variables_descriptors,numvariables,qmu_part,qmu_npart);
+	inputs->UpdateFromDakota(variables,variables_descriptors,numvariables,femmodels[0].parameters,qmu_part,qmu_npart); //femmodel #0 is the one holding the parameters for Dakota.
+	
 
 	/*Run the analysis core solution sequence, with the updated inputs: */
 	if(analysis_type==DiagnosticAnalysisEnum()){
-
+			
 		_printf_("Starting diagnostic core\n");
 		diagnostic_core(results,femmodels,inputs);
 
 	}
-	else{
-		throw ErrorException(__FUNCT__,exprintf("%s%i%s%i%s"," analysis_type ",analysis_type," and sub_analysis_type ",sub_analysis_type," not supported yet!"));
+	else if(analysis_type==ThermalAnalysisEnum()){
+		
+		_printf_("Starting thermal core\n");
+		thermal_core(results,femmodels,inputs);
+
 	}
+	else if(analysis_type==PrognosticAnalysisEnum()){
+
+		_printf_("Starting prognostic core\n");
+		prognostic_core(results,femmodels,inputs);
+
+	}
+	else if(analysis_type==TransientAnalysisEnum()){
+
+		_printf_("Starting transient core\n");
+		throw ErrorException(__FUNCT__,"not supported yet!");
+
+	}
+	else throw ErrorException(__FUNCT__,exprintf("%s%i%s%i%s"," analysis_type ",analysis_type," and sub_analysis_type ",sub_analysis_type," not supported yet!"));
+	
+		
 
 	/*Now process the outputs, before computing the dakota responses: */
 	_printf_("process results:\n");
 	ProcessResults(&results,femmodels,analysis_type); 
+	
 
 	/*compute responses on cpu 0: dummy for now! */
Index: /issm/trunk/src/c/parallel/prognostic.cpp
===================================================================
--- /issm/trunk/src/c/parallel/prognostic.cpp	(revision 764)
+++ /issm/trunk/src/c/parallel/prognostic.cpp	(revision 765)
@@ -33,4 +33,5 @@
 	Vec     h_g=NULL;
 	Vec     u_g=NULL;
+	Vec u_g=NULL;
 	double* u_g_serial=NULL;
 	double* h_g_initial=NULL;
Index: /issm/trunk/src/c/parallel/thermal.cpp
===================================================================
--- /issm/trunk/src/c/parallel/thermal.cpp	(revision 764)
+++ /issm/trunk/src/c/parallel/thermal.cpp	(revision 765)
@@ -91,4 +91,5 @@
 	//erase velocities and pressure embedded in parameters
 	param=(Param*)femmodels[0].parameters->FindParamObject("u_g");
+	param=(Param*)femmodels[0].parameters->FindParamObject("velocity");
 	femmodels[0].parameters->DeleteObject((Object*)param);
 	param=(Param*)femmodels[0].parameters->FindParamObject("p_g");
Index: /issm/trunk/src/c/shared/String/isdistributed.cpp
===================================================================
--- /issm/trunk/src/c/shared/String/isdistributed.cpp	(revision 764)
+++ /issm/trunk/src/c/shared/String/isdistributed.cpp	(revision 765)
@@ -12,7 +12,11 @@
 #endif
 
+#include "stdio.h"
+#include <string.h>
+#include <ctype.h>
+#include "../Alloc/alloc.h"
+
 #undef __FUNCT__ 
 #define __FUNCT__ "isdistributed"
-
 int isdistributed(char** proot,char* name){
 
Index: /issm/trunk/src/m/classes/@model/model.m
===================================================================
--- /issm/trunk/src/m/classes/@model/model.m	(revision 764)
+++ /issm/trunk/src/m/classes/@model/model.m	(revision 765)
@@ -268,4 +268,5 @@
 	md.qmu_analysis=0;
 	md.iresp=1;
+	md.ivar=1;
 	md.npart=0;
 
Index: /issm/trunk/src/m/classes/public/displayqmu.m
===================================================================
--- /issm/trunk/src/m/classes/public/displayqmu.m	(revision 764)
+++ /issm/trunk/src/m/classes/public/displayqmu.m	(revision 765)
@@ -85,3 +85,2 @@
 if isempty(md.dakotadat), disp(sprintf('         dakotadat: N/A')); else disp(sprintf('         dakotadat:    [%ix%i]    (can be accessed by typing md.dakotadat)',size(md.dakotadat)));end
 disp(sprintf('         npart   : %i (number of partitions for semi-descrete qmu)',md.npart));
-disp(sprintf('         numrifts: %i (number of rifts for semi-descrete qmu)',md.numrifts));
Index: /issm/trunk/src/m/classes/public/marshall.m
===================================================================
--- /issm/trunk/src/m/classes/public/marshall.m	(revision 764)
+++ /issm/trunk/src/m/classes/public/marshall.m	(revision 765)
@@ -159,9 +159,60 @@
 WriteData(fid,md.qmu_analysis,'Integer','qmu_analysis');
 if md.qmu_analysis,
-	responses=md.responses(md.iresp).rf;
-	WriteData(fid,numel(responses),'Integer','numberofresponses');
-	for i=1:numel(responses),
-		WriteData(fid,responses(i).descriptor,'String',['descriptor' num2str(i-1)]);
-	end
+	%recover variables for corresponding analysis
+	variables=md.variables(md.ivar);
+
+	%count how many variables we have
+	numvariables=0;
+	variable_fieldnames=fieldnames(variables);
+	for i=1:length(variable_fieldnames),
+		field_name=variable_fieldnames{i};
+		fieldvariables=variables.(field_name);
+		numvariables=numvariables+numel(variables.(field_name));
+	end
+	%write number of variables to disk
+	WriteData(fid,numvariables,'Integer','numberofvariables');
+
+	%now, for each variable, write descriptor
+	count=0;
+	for i=1:length(variable_fieldnames),
+		field_name=variable_fieldnames{i};
+		fieldvariables=variables.(field_name);
+		for j=1:length(fieldvariables),
+			descriptor=fieldvariables(j).descriptor;
+			WriteData(fid,descriptor,'String',['variabledescriptor' num2str(count)]);
+			count=count+1;
+		end
+	end
+	
+	%deal with responses
+
+	%recover responses for corresponding analysis
+	responses=md.responses(md.iresp);
+
+	%count how many responses we have
+	numresponses=0;
+	response_fieldnames=fieldnames(responses);
+	for i=1:length(response_fieldnames),
+		field_name=response_fieldnames{i};
+		fieldresponses=responses.(field_name);
+		numresponses=numresponses+numel(responses.(field_name));
+	end
+	%write number of responses to disk
+	WriteData(fid,numresponses,'Integer','numberofresponses');
+
+	%now, for each response, write descriptor
+	count=0;
+	for i=1:length(response_fieldnames),
+		field_name=response_fieldnames{i};
+		fieldresponses=responses.(field_name);
+		for j=1:length(fieldresponses),
+			descriptor=fieldresponses(j).descriptor;
+			WriteData(fid,descriptor,'String',['responsedescriptor' num2str(count)]);
+			count=count+1;
+		end
+	end
+	
+	
+	%write npart to disk
 	WriteData(fid,md.npart,'Integer','npart');
 end
Index: /issm/trunk/src/m/classes/public/qmuparallel.m
===================================================================
--- /issm/trunk/src/m/classes/public/qmuparallel.m	(revision 764)
+++ /issm/trunk/src/m/classes/public/qmuparallel.m	(revision 765)
@@ -37,2 +37,5 @@
 	return;
 end
+
+%reset qmu_analysis counter
+md.qmu_analysis=0;
Index: /issm/trunk/src/m/solutions/dakota/qmuin.m
===================================================================
--- /issm/trunk/src/m/solutions/dakota/qmuin.m	(revision 764)
+++ /issm/trunk/src/m/solutions/dakota/qmuin.m	(revision 765)
@@ -82,4 +82,5 @@
 cd ../
 
-%keep iresp for response function handling in marshall routine.
+%keep ivar iresp for variable and response function handling in marshall routine.
 md.iresp=iresp;
+md.ivar=ivar;