Index: /issm/trunk-jpl/src/c/Makefile.am
===================================================================
--- /issm/trunk-jpl/src/c/Makefile.am	(revision 22506)
+++ /issm/trunk-jpl/src/c/Makefile.am	(revision 22507)
@@ -76,4 +76,6 @@
 					./classes/Numberedcostfunction.cpp\
 					./classes/Misfit.cpp\
+					./classes/Cfsurfacesquare.cpp\
+					./classes/Cfsurfacelogvel.cpp\
 					./classes/Regionaloutput.cpp\
 					./classes/Nodalvalue.cpp\
Index: /issm/trunk-jpl/src/c/classes/Cfsurfacelogvel.cpp
===================================================================
--- /issm/trunk-jpl/src/c/classes/Cfsurfacelogvel.cpp	(revision 22507)
+++ /issm/trunk-jpl/src/c/classes/Cfsurfacelogvel.cpp	(revision 22507)
@@ -0,0 +1,222 @@
+/*!\file Cfsurfacelogvel.cpp
+ * \brief: Cfsurfacelogvel Object
+ */
+
+/*Headers:*/
+/*{{{*/
+#ifdef HAVE_CONFIG_H
+   #include <config.h>
+#else
+#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!"
+#endif
+
+#include "./classes.h"
+#include "./ExternalResults/ExternalResult.h"
+#include "./ExternalResults/Results.h"
+#include "../datastructures/datastructures.h"
+#include "./Elements/Element.h"
+#include "./Elements/Elements.h"
+#include "./FemModel.h"
+#include "../modules/SurfaceAreax/SurfaceAreax.h"
+#include "../classes/Params/Parameters.h"
+#include "../classes/Inputs/Input.h"
+#include "../classes/gauss/Gauss.h"
+/*}}}*/
+		
+/*Cfsurfacelogvel constructors, destructors :*/
+Cfsurfacelogvel::Cfsurfacelogvel(){/*{{{*/
+
+	this->definitionenum = -1;
+	this->name = NULL;
+	this->misfit=0;
+	this->lock=0;
+	this->datatime=0.;
+	this->timepassedflag = false;
+
+}
+/*}}}*/
+Cfsurfacelogvel::Cfsurfacelogvel(char* in_name, int in_definitionenum, IssmDouble in_datatime, bool in_timepassedflag){/*{{{*/
+
+	this->definitionenum=in_definitionenum;
+	
+	this->name		= xNew<char>(strlen(in_name)+1);
+	xMemCpy<char>(this->name,in_name,strlen(in_name)+1);
+
+	this->datatime=in_datatime;
+	this->timepassedflag=in_timepassedflag;
+	
+	this->misfit=0;
+	this->lock=0;
+}
+/*}}}*/
+Cfsurfacelogvel::~Cfsurfacelogvel(){/*{{{*/
+	if(this->name)xDelete(this->name);
+	this->misfit=0;
+	this->lock=0;
+}
+/*}}}*/
+/*Object virtual function resolutoin: */
+Object* Cfsurfacelogvel::copy() {/*{{{*/
+	Cfsurfacelogvel* mf = new Cfsurfacelogvel(this->name,this->definitionenum,this->datatime,this->timepassedflag);
+	mf->misfit=this->misfit;
+	mf->lock=this->lock;
+	return (Object*) mf;
+}
+/*}}}*/
+void Cfsurfacelogvel::DeepEcho(void){/*{{{*/
+	this->Echo();
+}
+/*}}}*/
+void Cfsurfacelogvel::Echo(void){/*{{{*/
+	_printf_(" Cfsurfacelogvel: " << name << " " << this->definitionenum << "\n");
+	_printf_("    datatime: " << datatime << "\n");
+	_printf_("	  timepassedflag: "<<timepassedflag<<"\n");
+}
+/*}}}*/
+int Cfsurfacelogvel::Id(void){/*{{{*/
+	return -1;
+}
+/*}}}*/
+void Cfsurfacelogvel::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){/*{{{*/
+	_error_("not implemented yet!"); 
+} 
+/*}}}*/
+int Cfsurfacelogvel::ObjectEnum(void){/*{{{*/
+	return CfsurfacelogvelEnum;
+}
+/*}}}*/
+/*Definition virtual function resolutoin: */
+int Cfsurfacelogvel::DefinitionEnum(){/*{{{*/
+	return this->definitionenum;
+}
+/*}}}*/
+char* Cfsurfacelogvel::Name(){/*{{{*/
+	char* name2=xNew<char>(strlen(this->name)+1);
+	xMemCpy(name2,this->name,strlen(this->name)+1);
+
+	return name2;
+}
+/*}}}*/
+IssmDouble Cfsurfacelogvel::Response(FemModel* femmodel){/*{{{*/
+		 
+	 /*diverse: */
+	 IssmDouble time;
+	 
+	 /*recover time parameters: */
+	 femmodel->parameters->FindParam(&time,TimeEnum);
+
+/*ELLEN UNFINISHED*/
+		 int i;
+		 IssmDouble J=0.;
+		 IssmDouble J_sum=0.;
+	
+	 if(datatime<=time && !timepassedflag){
+		 for(i=0;i<femmodel->elements->Size();i++){
+			 Element* element=(Element*)femmodel->elements->GetObjectByOffset(i);
+			 J+=this->Cfsurfacelogvel_Calculation(element,definitionenum);
+		 }
+
+		 ISSM_MPI_Allreduce ( (void*)&J,(void*)&J_sum,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,IssmComm::GetComm());
+		 ISSM_MPI_Bcast(&J_sum,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
+		 J=J_sum;
+		
+		 timepassedflag = true;
+		 return J;
+		}
+	 else return J;
+ }
+	/*}}}*/
+IssmDouble Cfsurfacelogvel::Cfsurfacelogvel_Calculation(Element* element, int definitionenum){/*{{{*/
+
+	int        domaintype,numcomponents;
+	IssmDouble Jelem=0.;
+	IssmDouble epsvel=2.220446049250313e-16;
+	IssmDouble meanvel=3.170979198376458e-05; /*1000 m/yr*/
+	IssmDouble velocity_mag,obs_velocity_mag;
+	IssmDouble misfit,Jdet;
+	IssmDouble vx,vy,vxobs,vyobs,weight;
+	IssmDouble* xyz_list = NULL;
+	
+	/*Get basal element*/
+	if(!element->IsOnSurface()) return 0.;
+
+	/*If on water, return 0: */
+	if(!element->IsIceInElement()) return 0.;
+
+	/*Get problem dimension*/
+	element->FindParam(&domaintype,DomainTypeEnum);
+	switch(domaintype){
+		case Domain2DverticalEnum:   numcomponents   = 1; break;
+		case Domain3DEnum:           numcomponents   = 2; break;
+		case Domain2DhorizontalEnum: numcomponents   = 2; break;
+		default: _error_("not supported yet");
+	}
+
+	/*Spawn surface element*/
+	Element* topelement = element->SpawnTopElement();
+
+	/* Get node coordinates*/
+	topelement->GetVerticesCoordinates(&xyz_list);
+	
+	/*Get model values*/
+	Input* vx_input     =topelement->GetInput(VxEnum);                                 _assert_(vx_input);
+	Input* vy_input	  =NULL;
+	if(numcomponents==2){
+	      vy_input    =topelement->GetInput(VyEnum);							              _assert_(vy_input);
+	}
+
+	/*Retrieve all inputs we will be needing: */
+	DatasetInput*    datasetinput = NULL;
+	Input*  tempinput = topelement->GetInput(definitionenum);
+	/*Cast it to a Datasetinput*/
+	if(tempinput->ObjectEnum()!=DatasetInputEnum) _error_("don't know what to do");
+	datasetinput = (DatasetInput*)tempinput;
+
+
+	/* Start  looping on the number of gaussian points: */
+	Gauss* gauss=topelement->NewGauss(2);
+	for(int ig=gauss->begin();ig<gauss->end();ig++){
+
+		gauss->GaussPoint(ig);
+
+		/* Get Jacobian determinant: */
+		topelement->JacobianDeterminant(&Jdet,xyz_list,gauss);
+
+		/*Get all parameters at gaussian point*/
+		datasetinput->GetInputValue(&weight,gauss,WeightsSurfaceObservationEnum);
+		vx_input->GetInputValue(&vx,gauss);
+		datasetinput->GetInputValue(&vxobs,gauss,VxObsEnum);
+		if(numcomponents==2){
+			vy_input->GetInputValue(&vy,gauss);
+			datasetinput->GetInputValue(&vyobs,gauss,VyObsEnum);
+		}
+
+		/*Compute SurfaceLogVelMisfit:
+		 *        *                 [        vel + eps     ] 2
+		 *               * J = 4 \bar{v}^2 | log ( -----------  ) |
+		 *                      *                 [       vel   + eps    ]
+		 *                             *                            obs
+		 *                                    */
+		if(numcomponents==1){
+			velocity_mag    =fabs(vx)+epsvel;
+			obs_velocity_mag=fabs(vxobs)+epsvel;
+		}
+		else{
+			velocity_mag    =sqrt(vx*vx+vy*vy)+epsvel;
+			obs_velocity_mag=sqrt(vxobs*vxobs+vyobs*vyobs)+epsvel;
+		}
+
+		misfit=4*pow(meanvel,2)*pow(log(velocity_mag/obs_velocity_mag),2);
+
+		/*Add to cost function*/
+		Jelem+=misfit*weight*Jdet*gauss->weight;
+
+	}
+
+	/*clean up and Return: */
+	if(domaintype!=Domain2DhorizontalEnum){topelement->DeleteMaterials(); delete topelement;};
+	xDelete<IssmDouble>(xyz_list);
+	delete gauss;
+	return Jelem;
+}/*}}}*/
+
Index: /issm/trunk-jpl/src/c/classes/Cfsurfacelogvel.h
===================================================================
--- /issm/trunk-jpl/src/c/classes/Cfsurfacelogvel.h	(revision 22507)
+++ /issm/trunk-jpl/src/c/classes/Cfsurfacelogvel.h	(revision 22507)
@@ -0,0 +1,46 @@
+/*!\file Cfsurfacelogvel.h
+ * \brief: header file for Cfsurfacelogvel object
+ */
+
+#ifndef _CFSURFACESQUARE_H_
+#define _CFSURFACESQUARE_H_
+
+/*Headers:*/
+#include "./Definition.h"
+#include "./FemModel.h"
+
+IssmDouble OutputDefinitionsResponsex(FemModel* femmodel,int output_enum);
+void  GetVectorFromInputsx( IssmDouble** pvector, int* pvector_size, FemModel* femmodel,int name);
+
+class Cfsurfacelogvel: public Object, public Definition{
+
+	public: 
+
+		int         definitionenum;
+		char*       name;
+		IssmDouble	datatime;
+		bool			timepassedflag;
+		
+		int         lock; // if lock is on, we just return the value stored in "misfit".  this is used so we don't compute misfit past the final_time
+		IssmDouble  misfit; //value carried over in time.
+		
+		/*Cfsurfacelogvel constructors, destructors :*/
+		Cfsurfacelogvel();
+		Cfsurfacelogvel(char* in_name, int in_definitionenum, IssmDouble in_datatime, bool timepassedflag);
+		~Cfsurfacelogvel();
+		
+		/*Object virtual function resolutoin: */
+		Object* copy();
+		void DeepEcho(void);
+		void Echo(void);
+		int Id(void);
+		void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
+		int ObjectEnum(void);
+		
+		/*Definition virtual function resolutoin: */
+		int DefinitionEnum();
+		char* Name();
+		IssmDouble Response(FemModel* femmodel);
+		IssmDouble Cfsurfacelogvel_Calculation(Element* element, int definitionenum);
+};
+#endif  /* _CFSURFACESQUARE_H_ */
Index: /issm/trunk-jpl/src/c/classes/Cfsurfacesquare.cpp
===================================================================
--- /issm/trunk-jpl/src/c/classes/Cfsurfacesquare.cpp	(revision 22507)
+++ /issm/trunk-jpl/src/c/classes/Cfsurfacesquare.cpp	(revision 22507)
@@ -0,0 +1,215 @@
+/*!\file Cfsurfacesquare.cpp
+ * \brief: Cfsurfacesquare Object
+ */
+
+/*Headers:*/
+/*{{{*/
+#ifdef HAVE_CONFIG_H
+   #include <config.h>
+#else
+#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!"
+#endif
+
+#include "./classes.h"
+#include "./ExternalResults/ExternalResult.h"
+#include "./ExternalResults/Results.h"
+#include "../datastructures/datastructures.h"
+#include "./Elements/Element.h"
+#include "./Elements/Elements.h"
+#include "./FemModel.h"
+#include "../modules/SurfaceAreax/SurfaceAreax.h"
+#include "../classes/Params/Parameters.h"
+#include "../classes/Inputs/Input.h"
+#include "../classes/gauss/Gauss.h"
+/*}}}*/
+		
+/*Cfsurfacesquare constructors, destructors :*/
+Cfsurfacesquare::Cfsurfacesquare(){/*{{{*/
+
+	this->definitionenum = -1;
+	this->name = NULL;
+	this->model_enum = UNDEF;
+	this->observation_enum = UNDEF;
+	this->weights_enum = UNDEF;
+	this->misfit=0;
+	this->lock=0;
+	this->datatime=0.;
+	this->timepassedflag = false;
+
+}
+/*}}}*/
+Cfsurfacesquare::Cfsurfacesquare(char* in_name, int in_definitionenum, int in_model_enum, int in_observation_enum, int in_weights_enum, IssmDouble in_datatime, bool in_timepassedflag){/*{{{*/
+
+	this->definitionenum=in_definitionenum;
+	
+	this->name		= xNew<char>(strlen(in_name)+1);
+	xMemCpy<char>(this->name,in_name,strlen(in_name)+1);
+
+	this->model_enum=in_model_enum;
+	this->observation_enum=in_observation_enum;
+	this->weights_enum=in_weights_enum;
+	this->datatime=in_datatime;
+	this->timepassedflag=in_timepassedflag;
+	
+	this->misfit=0;
+	this->lock=0;
+}
+/*}}}*/
+Cfsurfacesquare::~Cfsurfacesquare(){/*{{{*/
+	if(this->name)xDelete(this->name);
+	this->misfit=0;
+	this->lock=0;
+}
+/*}}}*/
+/*Object virtual function resolutoin: */
+Object* Cfsurfacesquare::copy() {/*{{{*/
+	Cfsurfacesquare* mf = new Cfsurfacesquare(this->name,this->definitionenum, this->model_enum,this->observation_enum,this->weights_enum,this->datatime,this->timepassedflag);
+	mf->misfit=this->misfit;
+	mf->lock=this->lock;
+	return (Object*) mf;
+}
+/*}}}*/
+void Cfsurfacesquare::DeepEcho(void){/*{{{*/
+	this->Echo();
+}
+/*}}}*/
+void Cfsurfacesquare::Echo(void){/*{{{*/
+	_printf_(" Cfsurfacesquare: " << name << " " << this->definitionenum << "\n");
+	_printf_("    model_enum: " << model_enum << " " << EnumToStringx(model_enum) << "\n");
+	_printf_("    observation_enum: " << observation_enum << " " << EnumToStringx(observation_enum) << "\n");
+	_printf_("    weights_enum: " << weights_enum << " " << EnumToStringx(weights_enum) << "\n");
+	_printf_("    datatime: " << datatime << "\n");
+	_printf_("	  timepassedflag: "<<timepassedflag<<"\n");
+}
+/*}}}*/
+int Cfsurfacesquare::Id(void){/*{{{*/
+	return -1;
+}
+/*}}}*/
+void Cfsurfacesquare::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){/*{{{*/
+	_error_("not implemented yet!"); 
+} 
+/*}}}*/
+int Cfsurfacesquare::ObjectEnum(void){/*{{{*/
+	return CfsurfacesquareEnum;
+}
+/*}}}*/
+/*Definition virtual function resolutoin: */
+int Cfsurfacesquare::DefinitionEnum(){/*{{{*/
+	return this->definitionenum;
+}
+/*}}}*/
+char* Cfsurfacesquare::Name(){/*{{{*/
+	char* name2=xNew<char>(strlen(this->name)+1);
+	xMemCpy(name2,this->name,strlen(this->name)+1);
+
+	return name2;
+}
+/*}}}*/
+IssmDouble Cfsurfacesquare::Response(FemModel* femmodel){/*{{{*/
+		 
+	 /*diverse: */
+	 IssmDouble time;
+	 
+	 /*recover time parameters: */
+	 femmodel->parameters->FindParam(&time,TimeEnum);
+
+/*ELLEN UNFINISHED*/
+		 int i;
+		 IssmDouble J=0.;
+		 IssmDouble J_sum=0.;
+	
+	 if(datatime<=time && !timepassedflag){
+		 for(i=0;i<femmodel->elements->Size();i++){
+			 Element* element=(Element*)femmodel->elements->GetObjectByOffset(i);
+			 J+=this->Cfsurfacesquare_Calculation(element,model_enum,observation_enum,weights_enum);
+		 }
+
+		 ISSM_MPI_Allreduce ( (void*)&J,(void*)&J_sum,1,ISSM_MPI_DOUBLE,ISSM_MPI_SUM,IssmComm::GetComm());
+		 ISSM_MPI_Bcast(&J_sum,1,ISSM_MPI_DOUBLE,0,IssmComm::GetComm());
+		 J=J_sum;
+		
+		 timepassedflag = true;
+		 return J;
+		}
+	 else return J;
+ }
+	/*}}}*/
+IssmDouble Cfsurfacesquare::Cfsurfacesquare_Calculation(Element* element, int model_enum, int observation_enum, int weights_enum){/*{{{*/
+
+	int        domaintype,numcomponents;
+	IssmDouble Jelem=0.;
+	IssmDouble misfit,Jdet;
+	IssmDouble model,obs,weight;
+	IssmDouble* xyz_list = NULL;
+
+	/*Get basal element*/
+	if(!element->IsOnSurface()) return 0.;
+
+	/*If on water, return 0: */
+	if(!element->IsIceInElement()) return 0.;
+
+	/*Get problem dimension*/
+	element->FindParam(&domaintype,DomainTypeEnum);
+	switch(domaintype){
+		case Domain2DverticalEnum:   numcomponents   = 1; break;
+		case Domain3DEnum:           numcomponents   = 2; break;
+		case Domain2DhorizontalEnum: numcomponents   = 2; break;
+		default: _error_("not supported yet");
+	}
+
+	/*Spawn surface element*/
+	Element* topelement = element->SpawnTopElement();
+
+	/* Get node coordinates*/
+	topelement->GetVerticesCoordinates(&xyz_list);
+
+	/*Retrieve all inputs we will be needing: */
+
+	DatasetInput*    datasetinput = NULL;
+
+	/*Get input if it already exists*/
+	Input*  tempinput = topelement->GetInput(definitionenum);
+	
+	/*Cast it to a Datasetinput*/
+	if(tempinput->ObjectEnum()!=DatasetInputEnum) _error_("don't know what to do");
+	datasetinput = (DatasetInput*)tempinput;
+
+	Input* model_input=topelement->GetInput(model_enum);												_assert_(model_input);
+	//Input* observation_input=topelement->GetInput(observation_enum);								_assert_(observation_input);
+	//Input* weights_input     =topelement->GetInput(weights_enum);									_assert_(weights_input);
+
+	/* Start  looping on the number of gaussian points: */
+	Gauss* gauss=topelement->NewGauss(2);
+	for(int ig=gauss->begin();ig<gauss->end();ig++){
+
+		gauss->GaussPoint(ig);
+
+		/* Get Jacobian determinant: */
+		topelement->JacobianDeterminant(&Jdet,xyz_list,gauss);
+
+		/*Get all parameters at gaussian point*/
+		datasetinput->GetInputValue(&weight,gauss,WeightsSurfaceObservationEnum);
+		model_input->GetInputValue(&model,gauss);
+		datasetinput->GetInputValue(&obs,gauss,SurfaceObservationEnum);
+
+		/*Compute SurfaceAbsVelMisfitEnum:
+		 *        *
+		 *               *      1  [           2              2 ]
+		 *                      * J = --- | (u - u   )  +  (v - v   )  |
+		 *                             *      2  [       obs            obs   ]
+		 *                                    *
+		 *                                           */
+		misfit=0.5*(model-obs)*(model-obs);
+
+		/*Add to cost function*/
+		Jelem+=misfit*weight*Jdet*gauss->weight;
+	}
+
+	/*clean up and Return: */
+	if(domaintype!=Domain2DhorizontalEnum){topelement->DeleteMaterials(); delete topelement;};
+	xDelete<IssmDouble>(xyz_list);
+	delete gauss;
+	return Jelem;
+}/*}}}*/
+
Index: /issm/trunk-jpl/src/c/classes/Cfsurfacesquare.h
===================================================================
--- /issm/trunk-jpl/src/c/classes/Cfsurfacesquare.h	(revision 22507)
+++ /issm/trunk-jpl/src/c/classes/Cfsurfacesquare.h	(revision 22507)
@@ -0,0 +1,51 @@
+/*!\file Cfsurfacesquare.h
+ * \brief: header file for Cfsurfacesquare object
+ */
+
+#ifndef _TIMEMISFIT_H_
+#define _TIMEMISFIT_H_
+
+/*Headers:*/
+#include "./Definition.h"
+#include "./FemModel.h"
+
+IssmDouble OutputDefinitionsResponsex(FemModel* femmodel,int output_enum);
+void  GetVectorFromInputsx( IssmDouble** pvector, int* pvector_size, FemModel* femmodel,int name);
+
+class Cfsurfacesquare: public Object, public Definition{
+
+	public: 
+
+		int         definitionenum;
+		int         local;     
+		int         model_enum;
+		char*       name;
+		int         observation_enum;
+		char*       timeinterpolation;
+		int         weights_enum;
+		IssmDouble	datatime;
+		bool			timepassedflag;
+		
+		int         lock; // if lock is on, we just return the value stored in "misfit".  this is used so we don't compute misfit past the final_time
+		IssmDouble  misfit; //value carried over in time.
+		
+		/*Cfsurfacesquare constructors, destructors :*/
+		Cfsurfacesquare();
+		Cfsurfacesquare(char* in_name, int in_definitionenum, int in_model_enum, int in_observation_enum, int in_weights_enum, IssmDouble in_datatime, bool timepassedflag);
+		~Cfsurfacesquare();
+		
+		/*Object virtual function resolutoin: */
+		Object* copy();
+		void DeepEcho(void);
+		void Echo(void);
+		int Id(void);
+		void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction);
+		int ObjectEnum(void);
+		
+		/*Definition virtual function resolutoin: */
+		int DefinitionEnum();
+		char* Name();
+		IssmDouble Response(FemModel* femmodel);
+		IssmDouble Cfsurfacesquare_Calculation(Element* element, int model_enum, int observation_enum, int weights_enum);
+};
+#endif  /* _TIMEMISFIT_H_ */
Index: /issm/trunk-jpl/src/c/classes/Elements/Element.cpp
===================================================================
--- /issm/trunk-jpl/src/c/classes/Elements/Element.cpp	(revision 22506)
+++ /issm/trunk-jpl/src/c/classes/Elements/Element.cpp	(revision 22507)
@@ -1489,6 +1489,5 @@
     
     /*Intermediaries*/
-    int        i,t;
-    IssmDouble time;
+    int i,t;
     
     /*Branch on type of vector: nodal or elementary: */
@@ -1598,4 +1597,179 @@
             DoubleArrayInput* arrayinput=new DoubleArrayInput(vector_enum,layers,N);
             this->inputs->AddInput(arrayinput);
+            xDelete<IssmDouble>(layers);
+        }
+        else _error_("element vector is either numberofelements or numberofelements+1 long. Field provided (" << EnumToStringx(vector_enum) << ") is " << M << " long");
+    }
+    else _error_("Cannot add input for vector type " << vector_type << " (not supported)");
+}
+/*}}}*/
+void       Element::DatasetInputAdd(int enum_type,IssmDouble* vector,IoModel* iomodel,int M,int N,int vector_type,int vector_enum,int code,int input_enum){/*{{{*/
+    /*enum_type: the name of the DatasetInput (eg Outputdefinition1)
+	  * vector: information being stored (eg observations)
+	  * vector_type: is if by element or by vertex
+	  * vector_enum: is the name of the vector being stored
+	  * code: what type of data is in the vector (booleans, ints, doubles)
+	  */
+    
+	 /*Intermediaries*/
+    int					i,t;
+	 DatasetInput*		datasetinput = NULL;
+
+	 /*Get input if it already exists*/
+	 Input*  tempinput = GetInput(enum_type);
+	 if(tempinput){
+		 /*Cast it to a Datasetinput*/
+		 if(tempinput->ObjectEnum()!=DatasetInputEnum) _error_("don't know what to do");
+		 datasetinput = (DatasetInput*)tempinput;
+	 }
+	 else{
+		 datasetinput=new DatasetInput(enum_type);
+	   this->inputs->AddInput(datasetinput);
+	}
+
+
+    /*Branch on type of vector: nodal or elementary: */
+    if(vector_type==1){ //nodal vector
+        
+        int         numvertices = this->GetNumberOfVertices();
+        int        *vertexids   = xNew<int>(numvertices);
+        IssmDouble *values      = xNew<IssmDouble>(numvertices);
+        
+        /*Recover vertices ids needed to initialize inputs*/
+        _assert_(iomodel->elements);
+        for(i=0;i<numvertices;i++){
+            vertexids[i]=reCast<int>(iomodel->elements[numvertices*this->Sid()+i]); //ids for vertices are in the elements array from Matlab
+        }
+        
+        /*Are we in transient or static? */
+		  if(M==1){
+			  values[0]=vector[0];
+				switch(this->ObjectEnum()){
+                    case TriaEnum:  datasetinput->AddInput(new TriaInput(vector_enum,values,P0Enum),input_enum); break;
+                    case PentaEnum: datasetinput->AddInput(new PentaInput(vector_enum,values,P0Enum),input_enum); break;
+                    case TetraEnum: datasetinput->AddInput(new TetraInput(vector_enum,values,P0Enum),input_enum); break;
+                    default: _error_("Not implemented yet");
+				} 
+		  }
+		  else if(M==iomodel->numberofvertices){
+            for(i=0;i<numvertices;i++) values[i]=vector[vertexids[i]-1];
+				switch(this->ObjectEnum()){
+                    case TriaEnum:  datasetinput->AddInput(new TriaInput(vector_enum,values,P1Enum),input_enum); break;
+                    case PentaEnum: datasetinput->AddInput(new PentaInput(vector_enum,values,P1Enum),input_enum); break;
+                    case TetraEnum: datasetinput->AddInput(new TetraInput(vector_enum,values,P1Enum),input_enum); break;
+                    default: _error_("Not implemented yet");
+				}  }
+        else if(M==iomodel->numberofvertices+1){
+            /*create transient input: */
+            IssmDouble* times = xNew<IssmDouble>(N);
+            for(t=0;t<N;t++) times[t] = vector[(M-1)*N+t];
+            TransientInput* transientinput=new TransientInput(vector_enum,times,N);
+            for(t=0;t<N;t++){
+                for(i=0;i<numvertices;i++) values[i]=vector[N*(vertexids[i]-1)+t];
+                switch(this->ObjectEnum()){
+                    case TriaEnum:  transientinput->AddTimeInput(new TriaInput( vector_enum,values,P1Enum)); break;
+                    case PentaEnum: transientinput->AddTimeInput(new PentaInput(vector_enum,values,P1Enum)); break;
+                    case TetraEnum: transientinput->AddTimeInput(new TetraInput(vector_enum,values,P1Enum)); break;
+                    default: _error_("Not implemented yet");
+                }
+            }
+            datasetinput->AddInput(transientinput,input_enum);
+            xDelete<IssmDouble>(times);
+        }
+        else if(M==iomodel->numberofelements){
+
+			  /*This is a Patch!*/
+			  xDelete<IssmDouble>(values);
+			  values = xNew<IssmDouble>(N);
+			  for(int j=0;j<N;j++) values[j]=vector[this->Sid()*N+j];
+
+			  if     (N==this->GetNumberOfNodes(P1Enum)   ){
+				  switch(this->ObjectEnum()){
+					  case TriaEnum:  datasetinput->AddInput(new TriaInput(vector_enum,values,P1Enum),input_enum); break;
+					  case PentaEnum: datasetinput->AddInput(new PentaInput(vector_enum,values,P1Enum),input_enum); break;
+					  case TetraEnum: datasetinput->AddInput(new TetraInput(vector_enum,values,P1Enum),input_enum); break;
+					  default: _error_("Not implemented yet");
+				  }
+			  }
+			  else if(N==this->GetNumberOfNodes(P0Enum)   ){
+				  switch(this->ObjectEnum()){
+					  case TriaEnum:  datasetinput->AddInput(new TriaInput(vector_enum,values,P0Enum),input_enum); break;
+					  case PentaEnum: datasetinput->AddInput(new PentaInput(vector_enum,values,P0Enum),input_enum); break;
+					  case TetraEnum: datasetinput->AddInput(new TetraInput(vector_enum,values,P0Enum),input_enum); break;
+					  default: _error_("Not implemented yet");
+				  }	  
+			  }
+			  else if(N==this->GetNumberOfNodes(P1xP2Enum)){
+				  switch(this->ObjectEnum()){
+					  case TriaEnum:  datasetinput->AddInput(new TriaInput(vector_enum,values,P1xP2Enum),input_enum); break;
+					  case PentaEnum: datasetinput->AddInput(new PentaInput(vector_enum,values,P1xP2Enum),input_enum); break;
+					  case TetraEnum: datasetinput->AddInput(new TetraInput(vector_enum,values,P1xP2Enum),input_enum); break;
+					  default: _error_("Not implemented yet");
+				  }
+			  }
+			  else if(N==this->GetNumberOfNodes(P1xP3Enum)) {
+				 switch(this->ObjectEnum()){
+					  case TriaEnum:  datasetinput->AddInput(new TriaInput(vector_enum,values,P1xP3Enum),input_enum); break;
+					  case PentaEnum: datasetinput->AddInput(new PentaInput(vector_enum,values,P1xP3Enum),input_enum); break;
+					  case TetraEnum: datasetinput->AddInput(new TetraInput(vector_enum,values,P1xP3Enum),input_enum); break;
+					  default: _error_("Not implemented yet");
+				  }
+			  }
+			  else _error_("Patch interpolation not supported yet");
+
+		  }
+		  else{
+			  _error_("nodal vector is either numberofvertices or numberofvertices+1 long. Field provided (" << EnumToStringx(vector_enum) << ") is " << M << " long");
+		  }
+        
+        xDelete<IssmDouble>(values);
+        xDelete<int>(vertexids);
+    }
+    else if(vector_type==2){ //element vector
+        
+        IssmDouble value;
+        
+        /*Are we in transient or static? */
+        if(M==iomodel->numberofelements){
+            if (code==5){ //boolean
+                datasetinput->AddInput(new BoolInput(vector_enum,reCast<bool>(vector[this->Sid()])),input_enum);
+            }
+            else if (code==6){ //integer
+                datasetinput->AddInput(new IntInput(vector_enum,reCast<int>(vector[this->Sid()])),input_enum);
+            }
+            else if (code==7){ //IssmDouble
+                datasetinput->AddInput(new DoubleInput(vector_enum,vector[this->Sid()]),input_enum);
+            }
+            else _error_("could not recognize nature of vector from code " << code);
+        }
+        else if(M==iomodel->numberofelements+1){
+            /*create transient input: */
+            IssmDouble* times = xNew<IssmDouble>(N);
+            for(t=0;t<N;t++) times[t] = vector[(M-1)*N+t];
+            TransientInput* transientinput=new TransientInput(vector_enum,times,N);
+            TriaInput* bof=NULL;
+            for(t=0;t<N;t++){
+                value=vector[N*this->Sid()+t];
+                switch(this->ObjectEnum()){
+                    case TriaEnum:  transientinput->AddTimeInput(new TriaInput( vector_enum,&value,P0Enum)); break;
+                    case PentaEnum: transientinput->AddTimeInput(new PentaInput(vector_enum,&value,P0Enum)); break;
+                    case TetraEnum: transientinput->AddTimeInput(new TetraInput(vector_enum,&value,P0Enum)); break;
+                    default: _error_("Not implemented yet");
+                }
+            }
+            datasetinput->AddInput(transientinput,input_enum);
+            xDelete<IssmDouble>(times);
+        }
+        else _error_("element vector is either numberofelements or numberofelements+1 long. Field provided (" << EnumToStringx(vector_enum) << ") is " << M << " long");
+    }
+    else if(vector_type==3){ //element vector
+        
+        /*For right now we are static */
+        if(M==iomodel->numberofelements){
+            /*create transient input: */
+            IssmDouble* layers = xNewZeroInit<IssmDouble>(N);;
+            for(t=0;t<N;t++) layers[t] = vector[N*this->Sid()+t];
+            DoubleArrayInput* arrayinput=new DoubleArrayInput(vector_enum,layers,N);
+            datasetinput->AddInput(arrayinput,input_enum);
             xDelete<IssmDouble>(layers);
         }
Index: /issm/trunk-jpl/src/c/classes/Elements/Element.h
===================================================================
--- /issm/trunk-jpl/src/c/classes/Elements/Element.h	(revision 22506)
+++ /issm/trunk-jpl/src/c/classes/Elements/Element.h	(revision 22507)
@@ -122,4 +122,5 @@
 		void               InputChangeName(int enum_type,int enum_type_old);
 		void               InputCreate(IssmDouble* vector,IoModel* iomodel,int M,int N,int vector_type,int vector_enum,int code);
+		void					 DatasetInputAdd(int enum_type,IssmDouble* vector,IoModel* iomodel,int M,int N,int vector_type,int vector_enum,int code,int input_enum);
 		void               InputDuplicate(int original_enum,int new_enum);
 		void               InputUpdateFromConstant(IssmDouble constant, int name);
Index: /issm/trunk-jpl/src/c/classes/classes.h
===================================================================
--- /issm/trunk-jpl/src/c/classes/classes.h	(revision 22506)
+++ /issm/trunk-jpl/src/c/classes/classes.h	(revision 22507)
@@ -20,4 +20,6 @@
 #include "./Nodalvalue.h"
 #include "./Numberedcostfunction.h"
+#include "./Cfsurfacesquare.h"
+#include "./Cfsurfacelogvel.h"
 #include "./Masscon.h"
 #include "./Massconaxpby.h"
Index: /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateOutputDefinitions.cpp
===================================================================
--- /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateOutputDefinitions.cpp	(revision 22506)
+++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateOutputDefinitions.cpp	(revision 22507)
@@ -65,5 +65,5 @@
 			else if (output_definition_enums[i]==MisfitEnum){
 				/*Deal with misfits: {{{*/
-				
+			
 				/*misfit variables: */
 				int          nummisfits;
@@ -157,4 +157,193 @@
 				/*}}}*/
 			}
+			else if (output_definition_enums[i]==CfsurfacesquareEnum){
+				/*Deal with cfsurfacesquare: {{{*/
+				
+				/*cfsurfacesquare variables: */
+				int          num_cfsurfacesquares;
+				char**       cfsurfacesquare_name_s						= NULL;    
+				char**		 cfsurfacesquare_definitionstring_s		= NULL;    
+				char**       cfsurfacesquare_model_string_s			= NULL;
+				IssmDouble** cfsurfacesquare_observation_s			= NULL;
+				char**		 cfsurfacesquare_observation_string_s	= NULL;
+				int*         cfsurfacesquare_observation_M_s			= NULL;
+				int*         cfsurfacesquare_observation_N_s			= NULL;
+				IssmDouble** cfsurfacesquare_weights_s					= NULL;
+				int*         cfsurfacesquare_weights_M_s				= NULL;
+				int*         cfsurfacesquare_weights_N_s				= NULL;
+				char**       cfsurfacesquare_weights_string_s		= NULL;
+				int*	 cfsurfacesquare_datatime_s				= NULL;
+
+				/*Fetch name, model_string, observation, observation_string, etc ... (see src/m/classes/cfsurfacesquare.m): */
+				iomodel->FetchMultipleData(&cfsurfacesquare_name_s,&num_cfsurfacesquares,                                                        "md.cfsurfacesquare.name");
+				iomodel->FetchMultipleData(&cfsurfacesquare_definitionstring_s,&num_cfsurfacesquares,                                            "md.cfsurfacesquare.definitionstring");
+				iomodel->FetchMultipleData(&cfsurfacesquare_model_string_s,&num_cfsurfacesquares,                                                "md.cfsurfacesquare.model_string");
+				iomodel->FetchMultipleData(&cfsurfacesquare_observation_s,&cfsurfacesquare_observation_M_s,&cfsurfacesquare_observation_N_s,&num_cfsurfacesquares, "md.cfsurfacesquare.observation");
+				iomodel->FetchMultipleData(&cfsurfacesquare_observation_string_s,&num_cfsurfacesquares,                                          "md.cfsurfacesquare.observation_string");
+				iomodel->FetchMultipleData(&cfsurfacesquare_weights_s,&cfsurfacesquare_weights_M_s,&cfsurfacesquare_weights_N_s,&num_cfsurfacesquares,             "md.cfsurfacesquare.weights");
+				iomodel->FetchMultipleData(&cfsurfacesquare_weights_string_s,&num_cfsurfacesquares,                                              "md.cfsurfacesquare.weights_string");
+				iomodel->FetchMultipleData(&cfsurfacesquare_datatime_s,&num_cfsurfacesquares,																	 "md.cfsurfacesquare.datatime");
+
+				for(j=0;j<num_cfsurfacesquares;j++){
+
+					int obs_vector_type=0;
+					if ((cfsurfacesquare_observation_M_s[j]==iomodel->numberofvertices) || (cfsurfacesquare_observation_M_s[j]==iomodel->numberofvertices+1)){
+						obs_vector_type=1;
+					}
+					else if ((cfsurfacesquare_observation_M_s[j]==iomodel->numberofelements) || (cfsurfacesquare_observation_M_s[j]==iomodel->numberofelements+1)){
+						obs_vector_type=2;
+					}
+					else
+					 _error_("cfsurfacesquare observation size not supported yet");
+
+					int weight_vector_type=0;
+					if ((cfsurfacesquare_weights_M_s[j]==iomodel->numberofvertices) || (cfsurfacesquare_weights_M_s[j]==iomodel->numberofvertices+1)){
+						weight_vector_type=1;
+					}
+					else if ((cfsurfacesquare_weights_M_s[j]==iomodel->numberofelements) || (cfsurfacesquare_weights_M_s[j]==iomodel->numberofelements+1)){
+						weight_vector_type=2;
+					}
+					else
+					 _error_("cfsurfacesquare weight size not supported yet");
+
+					/*First create a cfsurfacesquare object for that specific string (cfsurfacesquare_model_string_s[j]):*/
+					output_definitions->AddObject(new Cfsurfacesquare(cfsurfacesquare_name_s[j],StringToEnumx(cfsurfacesquare_definitionstring_s[j]),StringToEnumx(cfsurfacesquare_model_string_s[j]),StringToEnumx(cfsurfacesquare_observation_string_s[j]),StringToEnumx(cfsurfacesquare_weights_string_s[j]),cfsurfacesquare_datatime_s[j],false));
+
+					/*Now, for this particular cfsurfacesquare object, make sure we plug into the elements: the observation, and the weights.*/
+					for(int k=0;k<elements->Size();k++){
+
+						Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(k));
+						
+						element->DatasetInputAdd(StringToEnumx(cfsurfacesquare_definitionstring_s[j]),cfsurfacesquare_observation_s[j], iomodel,cfsurfacesquare_observation_M_s[j],cfsurfacesquare_observation_N_s[j],obs_vector_type,StringToEnumx(cfsurfacesquare_observation_string_s[j]),7,SurfaceObservationEnum);
+						element->DatasetInputAdd(StringToEnumx(cfsurfacesquare_definitionstring_s[j]),cfsurfacesquare_weights_s[j], iomodel,cfsurfacesquare_weights_M_s[j],cfsurfacesquare_weights_N_s[j],weight_vector_type,StringToEnumx(cfsurfacesquare_weights_string_s[j]),7,WeightsSurfaceObservationEnum);
+
+					}
+
+				}
+
+				/*Free ressources:*/
+				for(j=0;j<num_cfsurfacesquares;j++){
+					char* string=NULL;
+					IssmDouble* matrix = NULL;
+
+					string = cfsurfacesquare_definitionstring_s[j];		xDelete<char>(string);
+					string = cfsurfacesquare_observation_string_s[j];	xDelete<char>(string);
+					string = cfsurfacesquare_model_string_s[j];			xDelete<char>(string);
+					string = cfsurfacesquare_weights_string_s[j];		xDelete<char>(string);
+					string = cfsurfacesquare_name_s[j];    xDelete<char>(string);
+					matrix = cfsurfacesquare_observation_s[j]; xDelete<IssmDouble>(matrix);
+					matrix = cfsurfacesquare_weights_s[j]; xDelete<IssmDouble>(matrix);
+				}
+				xDelete<char*>(cfsurfacesquare_name_s);
+				xDelete<char*>(cfsurfacesquare_model_string_s);
+				xDelete<char*>(cfsurfacesquare_definitionstring_s);
+				xDelete<IssmDouble*>(cfsurfacesquare_observation_s);
+				xDelete<char*>(cfsurfacesquare_observation_string_s);
+				xDelete<int>(cfsurfacesquare_observation_M_s);
+				xDelete<int>(cfsurfacesquare_observation_N_s);
+				xDelete<IssmDouble*>(cfsurfacesquare_weights_s);
+				xDelete<int>(cfsurfacesquare_weights_M_s);
+				xDelete<int>(cfsurfacesquare_weights_N_s);
+				xDelete<char*>(cfsurfacesquare_weights_string_s);
+				xDelete<int>(cfsurfacesquare_datatime_s);
+				/*}}}*/
+			}
+			else if (output_definition_enums[i]==CfsurfacelogvelEnum){
+				/*Deal with cfsurfacelogvel: {{{*/
+				
+				/*cfsurfacelogvel variables: */
+				int          num_cfsurfacelogvels;
+				char**       cfsurfacelogvel_name						= NULL;    
+				char**		 cfsurfacelogvel_definitionstring		= NULL;    
+				IssmDouble** cfsurfacelogvel_vxobs			= NULL;
+				IssmDouble** cfsurfacelogvel_vyobs			= NULL;
+				char**		 cfsurfacelogvel_vxobs_string	= NULL;
+				char**		 cfsurfacelogvel_vyobs_string	= NULL;
+				int*         cfsurfacelogvel_observation_M			= NULL;
+				int*         cfsurfacelogvel_observation_N			= NULL;
+				IssmDouble** cfsurfacelogvel_weights					= NULL;
+				int*         cfsurfacelogvel_weights_M				= NULL;
+				int*         cfsurfacelogvel_weights_N				= NULL;
+				char**       cfsurfacelogvel_weightstring		= NULL;
+				int*				cfsurfacelogvel_datatime				= NULL;
+
+				/*Fetch name, modeltring, observation, observationtring, etc ... (see src/m/classes/cfsurfacelogvel.m): */
+				iomodel->FetchMultipleData(&cfsurfacelogvel_name,&num_cfsurfacelogvels,                                                        "md.cfsurfacelogvel.name");
+				iomodel->FetchMultipleData(&cfsurfacelogvel_definitionstring,&num_cfsurfacelogvels,                                            "md.cfsurfacelogvel.definitionstring");
+				iomodel->FetchMultipleData(&cfsurfacelogvel_vxobs,&cfsurfacelogvel_observation_M,&cfsurfacelogvel_observation_N,&num_cfsurfacelogvels, "md.cfsurfacelogvel.vxobs");
+				iomodel->FetchMultipleData(&cfsurfacelogvel_vxobs_string,&num_cfsurfacelogvels,                                          "md.cfsurfacelogvel.vxobs_string");
+				iomodel->FetchMultipleData(&cfsurfacelogvel_vyobs,&cfsurfacelogvel_observation_M,&cfsurfacelogvel_observation_N,&num_cfsurfacelogvels, "md.cfsurfacelogvel.vyobs");
+				iomodel->FetchMultipleData(&cfsurfacelogvel_vyobs_string,&num_cfsurfacelogvels,                                          "md.cfsurfacelogvel.vyobs_string");			iomodel->FetchMultipleData(&cfsurfacelogvel_weights,&cfsurfacelogvel_weights_M,&cfsurfacelogvel_weights_N,&num_cfsurfacelogvels,             "md.cfsurfacelogvel.weights");
+				iomodel->FetchMultipleData(&cfsurfacelogvel_weightstring,&num_cfsurfacelogvels,                                              "md.cfsurfacelogvel.weights_string");
+				_printf_("Num with weight string: "<<num_cfsurfacelogvels<<"\n");
+				iomodel->FetchMultipleData(&cfsurfacelogvel_datatime,&num_cfsurfacelogvels,																	 "md.cfsurfacelogvel.datatime");
+
+				for(j=0;j<num_cfsurfacelogvels;j++){
+
+					int obs_vector_type=0;
+					if ((cfsurfacelogvel_observation_M[j]==iomodel->numberofvertices) || (cfsurfacelogvel_observation_M[j]==iomodel->numberofvertices+1)){
+						obs_vector_type=1;
+					}
+					else if ((cfsurfacelogvel_observation_M[j]==iomodel->numberofelements) || (cfsurfacelogvel_observation_M[j]==iomodel->numberofelements+1)){
+						obs_vector_type=2;
+					}
+					else
+					 _error_("cfsurfacelogvel observation size not supported yet");
+
+					int weight_vector_type=0;
+					if ((cfsurfacelogvel_weights_M[j]==iomodel->numberofvertices) || (cfsurfacelogvel_weights_M[j]==iomodel->numberofvertices+1)){
+						weight_vector_type=1;
+					}
+					else if ((cfsurfacelogvel_weights_M[j]==iomodel->numberofelements) || (cfsurfacelogvel_weights_M[j]==iomodel->numberofelements+1)){
+						weight_vector_type=2;
+					}
+					else
+					 _error_("cfsurfacelogvel weight size not supported yet");
+
+					/*First create a cfsurfacelogvel object for that specific string (cfsurfacelogvel_modeltring[j]):*/
+					output_definitions->AddObject(new Cfsurfacelogvel(cfsurfacelogvel_name[j],StringToEnumx(cfsurfacelogvel_definitionstring[j]),cfsurfacelogvel_datatime[j],false));
+
+					/*Now, for this particular cfsurfacelogvel object, make sure we plug into the elements: the observation, and the weights.*/
+					for(int k=0;k<elements->Size();k++){
+
+						Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(k));
+						
+						element->DatasetInputAdd(StringToEnumx(cfsurfacelogvel_definitionstring[j]),cfsurfacelogvel_vxobs[j], iomodel,cfsurfacelogvel_observation_M[j],cfsurfacelogvel_observation_N[j],obs_vector_type,StringToEnumx(cfsurfacelogvel_vxobs_string[j]),7,VxObsEnum);
+							element->DatasetInputAdd(StringToEnumx(cfsurfacelogvel_definitionstring[j]),cfsurfacelogvel_vyobs[j], iomodel,cfsurfacelogvel_observation_M[j],cfsurfacelogvel_observation_N[j],obs_vector_type,StringToEnumx(cfsurfacelogvel_vyobs_string[j]),7,VyObsEnum);
+						element->DatasetInputAdd(StringToEnumx(cfsurfacelogvel_definitionstring[j]),cfsurfacelogvel_weights[j], iomodel,cfsurfacelogvel_weights_M[j],cfsurfacelogvel_weights_N[j],weight_vector_type,StringToEnumx(cfsurfacelogvel_weightstring[j]),7,WeightsSurfaceObservationEnum);
+
+					}
+
+				}
+
+				/*Free ressources:*/
+				for(j=0;j<num_cfsurfacelogvels;j++){
+					char* string=NULL;
+					IssmDouble* matrix = NULL;
+
+					string = cfsurfacelogvel_definitionstring[j];		xDelete<char>(string);
+					string = cfsurfacelogvel_vxobs_string[j];	xDelete<char>(string);
+					string = cfsurfacelogvel_vyobs_string[j];	xDelete<char>(string);
+					string = cfsurfacelogvel_weightstring[j];		xDelete<char>(string);
+					string = cfsurfacelogvel_name[j];    xDelete<char>(string);
+					matrix = cfsurfacelogvel_weights[j]; xDelete<IssmDouble>(matrix);
+					matrix = cfsurfacelogvel_vxobs[j]; xDelete<IssmDouble>(matrix);
+					matrix = cfsurfacelogvel_vyobs[j]; xDelete<IssmDouble>(matrix);
+				}
+				xDelete<char*>(cfsurfacelogvel_name);
+				xDelete<char*>(cfsurfacelogvel_definitionstring);
+				xDelete<int>(cfsurfacelogvel_observation_M);
+				xDelete<IssmDouble*>(cfsurfacelogvel_vxobs);
+				xDelete<IssmDouble*>(cfsurfacelogvel_vyobs);
+				xDelete<char*>(cfsurfacelogvel_vxobs_string);
+				xDelete<char*>(cfsurfacelogvel_vyobs_string);
+				xDelete<int>(cfsurfacelogvel_observation_N);
+				xDelete<IssmDouble*>(cfsurfacelogvel_weights);
+				xDelete<int>(cfsurfacelogvel_weights_M);
+				xDelete<int>(cfsurfacelogvel_weights_N);
+				xDelete<char*>(cfsurfacelogvel_weightstring);
+				xDelete<int>(cfsurfacelogvel_datatime);
+				/*}}}*/
+			}
 			else if (output_definition_enums[i]==NodalvalueEnum){
 				/*Deal with nodal values: {{{*/
Index: /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h
===================================================================
--- /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h	(revision 22506)
+++ /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h	(revision 22507)
@@ -759,4 +759,6 @@
 	VyObsEnum,
 	NumberedcostfunctionEnum,
+	CfsurfacesquareEnum,
+	CfsurfacelogvelEnum,
 	/*}}}*/
 	/*Relaxation{{{*/
Index: /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp
===================================================================
--- /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp	(revision 22506)
+++ /issm/trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp	(revision 22507)
@@ -753,4 +753,6 @@
 		case VyObsEnum : return "VyObs";
 		case NumberedcostfunctionEnum : return "Numberedcostfunction";
+		case CfsurfacesquareEnum : return "Cfsurfacesquare";
+		case CfsurfacelogvelEnum : return "Cfsurfacelogvel";
 		case AbsoluteEnum : return "Absolute";
 		case IncrementalEnum : return "Incremental";
Index: /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp
===================================================================
--- /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp	(revision 22506)
+++ /issm/trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp	(revision 22507)
@@ -771,4 +771,6 @@
 	      else if (strcmp(name,"VyObs")==0) return VyObsEnum;
 	      else if (strcmp(name,"Numberedcostfunction")==0) return NumberedcostfunctionEnum;
+	      else if (strcmp(name,"Cfsurfacesquare")==0) return CfsurfacesquareEnum;
+	      else if (strcmp(name,"Cfsurfacelogvel")==0) return CfsurfacelogvelEnum;
 	      else if (strcmp(name,"Absolute")==0) return AbsoluteEnum;
 	      else if (strcmp(name,"Incremental")==0) return IncrementalEnum;
@@ -873,10 +875,10 @@
 	      else if (strcmp(name,"SealevelriseNumRequestedOutputs")==0) return SealevelriseNumRequestedOutputsEnum;
 	      else if (strcmp(name,"LoveNfreq")==0) return LoveNfreqEnum;
-	      else if (strcmp(name,"LoveFrequencies")==0) return LoveFrequenciesEnum;
-	      else if (strcmp(name,"LoveShNmax")==0) return LoveShNmaxEnum;
          else stage=8;
    }
    if(stage==8){
-	      if (strcmp(name,"LoveShNmin")==0) return LoveShNminEnum;
+	      if (strcmp(name,"LoveFrequencies")==0) return LoveFrequenciesEnum;
+	      else if (strcmp(name,"LoveShNmax")==0) return LoveShNmaxEnum;
+	      else if (strcmp(name,"LoveShNmin")==0) return LoveShNminEnum;
 	      else if (strcmp(name,"LoveG0")==0) return LoveG0Enum;
 	      else if (strcmp(name,"LoveR0")==0) return LoveR0Enum;
@@ -996,10 +998,10 @@
 	      else if (strcmp(name,"TriaInput")==0) return TriaInputEnum;
 	      else if (strcmp(name,"Tetra")==0) return TetraEnum;
-	      else if (strcmp(name,"TetraInput")==0) return TetraInputEnum;
-	      else if (strcmp(name,"Penta")==0) return PentaEnum;
          else stage=9;
    }
    if(stage==9){
-	      if (strcmp(name,"PentaInput")==0) return PentaInputEnum;
+	      if (strcmp(name,"TetraInput")==0) return TetraInputEnum;
+	      else if (strcmp(name,"Penta")==0) return PentaEnum;
+	      else if (strcmp(name,"PentaInput")==0) return PentaInputEnum;
 	      else if (strcmp(name,"Vertex")==0) return VertexEnum;
 	      else if (strcmp(name,"VertexPId")==0) return VertexPIdEnum;
@@ -1119,10 +1121,10 @@
 	      else if (strcmp(name,"P1xP4")==0) return P1xP4Enum;
 	      else if (strcmp(name,"P2xP4")==0) return P2xP4Enum;
-	      else if (strcmp(name,"P1P1")==0) return P1P1Enum;
-	      else if (strcmp(name,"P1P1GLS")==0) return P1P1GLSEnum;
          else stage=10;
    }
    if(stage==10){
-	      if (strcmp(name,"MINI")==0) return MINIEnum;
+	      if (strcmp(name,"P1P1")==0) return P1P1Enum;
+	      else if (strcmp(name,"P1P1GLS")==0) return P1P1GLSEnum;
+	      else if (strcmp(name,"MINI")==0) return MINIEnum;
 	      else if (strcmp(name,"MINIcondensed")==0) return MINIcondensedEnum;
 	      else if (strcmp(name,"TaylorHood")==0) return TaylorHoodEnum;