Index: /issm/trunk-jpl/src/c/Makefile.am
===================================================================
--- /issm/trunk-jpl/src/c/Makefile.am	(revision 26251)
+++ /issm/trunk-jpl/src/c/Makefile.am	(revision 26252)
@@ -91,4 +91,5 @@
 	./classes/Cfdragcoeffabsgrad.cpp \
 	./classes/Cfsurfacelogvel.cpp \
+	./classes/Cflevelsetmisfit.cpp \
 	./classes/Regionaloutput.cpp \
 	./classes/Nodalvalue.cpp \
Index: /issm/trunk-jpl/src/c/classes/Cflevelsetmisfit.cpp
===================================================================
--- /issm/trunk-jpl/src/c/classes/Cflevelsetmisfit.cpp	(revision 26252)
+++ /issm/trunk-jpl/src/c/classes/Cflevelsetmisfit.cpp	(revision 26252)
@@ -0,0 +1,203 @@
+/*!\file Cflevelsetmisfit.cpp
+ * \brief: Cflevelsetmisfit 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/gauss/Gauss.h"
+#include "./Inputs/DatasetInput.h"
+/*}}}*/
+
+/*Cflevelsetmisfit constructors, destructors :*/
+Cflevelsetmisfit::Cflevelsetmisfit(){/*{{{*/
+
+	this->definitionenum = -1;
+	this->name = NULL;
+	this->model_enum = UNDEF;
+	this->observation_enum = UNDEF;
+	this->weights_enum = UNDEF;
+	this->misfit=0;
+	this->datatime=0.;
+	this->timepassedflag = false;
+}
+/*}}}*/
+Cflevelsetmisfit::Cflevelsetmisfit(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;
+}
+/*}}}*/
+Cflevelsetmisfit::~Cflevelsetmisfit(){/*{{{*/
+	if(this->name)xDelete(this->name);
+	this->misfit=0;
+}
+/*}}}*/
+/*Object virtual function resolutoin: */
+Object* Cflevelsetmisfit::copy() {/*{{{*/
+	Cflevelsetmisfit* mf = new Cflevelsetmisfit(this->name,this->definitionenum, this->model_enum,this->observation_enum,this->weights_enum,this->datatime,this->timepassedflag);
+	mf->misfit=this->misfit;
+	return (Object*) mf;
+}
+/*}}}*/
+void Cflevelsetmisfit::DeepEcho(void){/*{{{*/
+	this->Echo();
+}
+/*}}}*/
+void Cflevelsetmisfit::Echo(void){/*{{{*/
+	_printf_(" Cflevelsetmisfit: " << 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 Cflevelsetmisfit::Id(void){/*{{{*/
+	return -1;
+}
+/*}}}*/
+void Cflevelsetmisfit::Marshall(MarshallHandle* marshallhandle){/*{{{*/
+	_error_("not implemented yet!"); 
+} 
+/*}}}*/
+int Cflevelsetmisfit::ObjectEnum(void){/*{{{*/
+	return CflevelsetmisfitEnum;
+}
+/*}}}*/
+/*Definition virtual function resolutoin: */
+int Cflevelsetmisfit::DefinitionEnum(){/*{{{*/
+	return this->definitionenum;
+}
+/*}}}*/
+char* Cflevelsetmisfit::Name(){/*{{{*/
+	char* name2=xNew<char>(strlen(this->name)+1);
+	xMemCpy(name2,this->name,strlen(this->name)+1);
+
+	return name2;
+}
+/*}}}*/
+IssmDouble Cflevelsetmisfit::Response(FemModel* femmodel){/*{{{*/
+	 /*diverse: */
+	 IssmDouble time;
+
+	 /*recover time parameters: */
+	 femmodel->parameters->FindParam(&time,TimeEnum);
+
+	 IssmDouble J=0.;
+	 IssmDouble J_sum=0.;
+
+	 if(datatime<=time && !timepassedflag){
+		 for(Object* & object : femmodel->elements->objects){
+			 Element* element=xDynamicCast<Element*>(object);
+			 J+=this->Cflevelsetmisfit_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 Cflevelsetmisfit::Cflevelsetmisfit_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 modelLevel,obsLevel;
+	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 = topelement->GetDatasetInput(definitionenum); _assert_(datasetinput);
+	Input        *model_input  = topelement->GetInput(model_enum);            _assert_(model_input);
+
+	/* Start  looping on the number of gaussian points: */
+	Gauss* gauss=topelement->NewGauss(2);
+	while(gauss->next()){
+
+		/* Get Jacobian determinant: */
+		topelement->JacobianDeterminant(&Jdet,xyz_list,gauss);
+
+		/*Get all parameters at gaussian point*/
+		datasetinput->GetInputValue(&weight,gauss,WeightsLevelsetObservationEnum);
+		model_input->GetInputValue(&model,gauss);
+		datasetinput->GetInputValue(&obs,gauss,LevelsetObservationEnum);
+
+		/*Compute Levelset misfit:
+		 *  J = || H(\phi) - H(\phi_obs)||^2
+		 *                                           */
+//		modelLevel = this->Heaviside(model);
+//		obsLevel = this->Heaviside(obs);
+		modelLevel = model;
+		obsLevel = obs;
+
+		misfit=0.5*(modelLevel-obsLevel)*(modelLevel-obsLevel);
+
+//		if (modelLevel*obsLevel<0.0) {
+		/*Add to cost function*/
+			Jelem+=misfit*weight*Jdet*gauss->weight;
+//		}
+	}
+
+	/*clean up and Return: */
+	if(topelement->IsSpawnedElement()){topelement->DeleteMaterials(); delete topelement;};
+	xDelete<IssmDouble>(xyz_list);
+	delete gauss;
+	return Jelem;
+}/*}}}*/
+IssmDouble Cflevelsetmisfit::Heaviside(IssmDouble x){/*{{{*/
+	if (x>0) return 1.;
+	else if (x<0) return -1.;
+	else return 0.;
+}
+	/*}}}*/
Index: /issm/trunk-jpl/src/c/classes/Cflevelsetmisfit.h
===================================================================
--- /issm/trunk-jpl/src/c/classes/Cflevelsetmisfit.h	(revision 26252)
+++ /issm/trunk-jpl/src/c/classes/Cflevelsetmisfit.h	(revision 26252)
@@ -0,0 +1,51 @@
+/*!\file Cflevelsetmisfit.h
+ * \brief: header file for Cflevelsetmisfit object
+ */
+
+#ifndef _CFLEVELSETMISFIT_H_
+#define _CFLEVELSETMISFIT_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 Cflevelsetmisfit: 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;
+		
+		IssmDouble  misfit; //value carried over in time.
+		
+		/*Cflevelsetmisfit constructors, destructors :*/
+		Cflevelsetmisfit();
+		Cflevelsetmisfit(char* in_name, int in_definitionenum, int in_model_enum, int in_observation_enum, int in_weights_enum, IssmDouble in_datatime, bool timepassedflag);
+		~Cflevelsetmisfit();
+		
+		/*Object virtual function resolutoin: */
+		Object* copy();
+		void DeepEcho(void);
+		void Echo(void);
+		int Id(void);
+		void Marshall(MarshallHandle* marshallhandle);
+		int ObjectEnum(void);
+		
+		/*Definition virtual function resolutoin: */
+		int DefinitionEnum();
+		char* Name();
+		IssmDouble Response(FemModel* femmodel);
+		IssmDouble Cflevelsetmisfit_Calculation(Element* element, int model_enum, int observation_enum, int weights_enum);
+		IssmDouble Heaviside(IssmDouble x);
+};
+#endif  /* _CFLEVELSETMISFIT_H_ */
Index: /issm/trunk-jpl/src/c/classes/classes.h
===================================================================
--- /issm/trunk-jpl/src/c/classes/classes.h	(revision 26251)
+++ /issm/trunk-jpl/src/c/classes/classes.h	(revision 26252)
@@ -26,4 +26,5 @@
 #include "./Cfdragcoeffabsgrad.h"
 #include "./Cfsurfacelogvel.h"
+#include "./Cflevelsetmisfit.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 26251)
+++ /issm/trunk-jpl/src/c/modules/ModelProcessorx/CreateOutputDefinitions.cpp	(revision 26252)
@@ -170,5 +170,5 @@
 				int*         cfsurfacesquare_weights_N_s				= NULL;
 				char**       cfsurfacesquare_weights_string_s		= NULL;
-				int*	 cfsurfacesquare_datatime_s				= NULL;
+				IssmDouble*	 cfsurfacesquare_datatime_s				= NULL;
 
 				/*Fetch name, model_string, observation, observation_string, etc ... (see src/m/classes/cfsurfacesquare.m): */
@@ -241,5 +241,5 @@
 				xDelete<int>(cfsurfacesquare_weights_N_s);
 				xDelete<char*>(cfsurfacesquare_weights_string_s);
-				xDelete<int>(cfsurfacesquare_datatime_s);
+				xDelete<IssmDouble>(cfsurfacesquare_datatime_s);
 				/*}}}*/
 			}
@@ -323,5 +323,5 @@
 				int*         cfsurfacelogvel_weights_N				= NULL;
 				char**       cfsurfacelogvel_weightstring		= NULL;
-				int*				cfsurfacelogvel_datatime				= NULL;
+				IssmDouble*  cfsurfacelogvel_datatime				= NULL;
 
 				/*Fetch name, modeltring, observation, observationtring, etc ... (see src/m/classes/cfsurfacelogvel.m): */
@@ -399,5 +399,92 @@
 				xDelete<int>(cfsurfacelogvel_weights_N);
 				xDelete<char*>(cfsurfacelogvel_weightstring);
-				xDelete<int>(cfsurfacelogvel_datatime);
+				xDelete<IssmDouble>(cfsurfacelogvel_datatime);
+				/*}}}*/
+			}
+			else if (output_definition_enums[i]==CflevelsetmisfitEnum){
+				/*Deal with cflevelsetmisfit: {{{*/
+
+				/*cflevelsetmisfit variables: */
+				int          num_cflevelsetmisfits;
+				char**       cflevelsetmisfit_name_s						= NULL;    
+				char**		 cflevelsetmisfit_definitionstring_s		= NULL;    
+				char**       cflevelsetmisfit_model_string_s			= NULL;
+				IssmDouble** cflevelsetmisfit_observation_s			= NULL;
+				char**		 cflevelsetmisfit_observation_string_s	= NULL;
+				int*         cflevelsetmisfit_observation_M_s			= NULL;
+				int*         cflevelsetmisfit_observation_N_s			= NULL;
+				IssmDouble** cflevelsetmisfit_weights_s					= NULL;
+				int*         cflevelsetmisfit_weights_M_s				= NULL;
+				int*         cflevelsetmisfit_weights_N_s				= NULL;
+				char**       cflevelsetmisfit_weights_string_s		= NULL;
+				IssmDouble*	 cflevelsetmisfit_datatime_s				= NULL;
+
+				/*Fetch name, model_string, observation, observation_string, etc ... (see src/m/classes/cflevelsetmisfit.m): */
+				iomodel->FetchMultipleData(&cflevelsetmisfit_name_s,&num_cflevelsetmisfits,                                                        "md.cflevelsetmisfit.name");
+				iomodel->FetchMultipleData(&cflevelsetmisfit_definitionstring_s,&num_cflevelsetmisfits,                                            "md.cflevelsetmisfit.definitionstring");
+				iomodel->FetchMultipleData(&cflevelsetmisfit_model_string_s,&num_cflevelsetmisfits,                                                "md.cflevelsetmisfit.model_string");
+				iomodel->FetchMultipleData(&cflevelsetmisfit_observation_s,&cflevelsetmisfit_observation_M_s,&cflevelsetmisfit_observation_N_s,&num_cflevelsetmisfits, "md.cflevelsetmisfit.observation");
+				iomodel->FetchMultipleData(&cflevelsetmisfit_observation_string_s,&num_cflevelsetmisfits,                                          "md.cflevelsetmisfit.observation_string");
+				iomodel->FetchMultipleData(&cflevelsetmisfit_weights_s,&cflevelsetmisfit_weights_M_s,&cflevelsetmisfit_weights_N_s,&num_cflevelsetmisfits,             "md.cflevelsetmisfit.weights");
+				iomodel->FetchMultipleData(&cflevelsetmisfit_weights_string_s,&num_cflevelsetmisfits,                                              "md.cflevelsetmisfit.weights_string");
+				iomodel->FetchMultipleData(&cflevelsetmisfit_datatime_s,&num_cflevelsetmisfits,																	 "md.cflevelsetmisfit.datatime");
+
+				for(j=0;j<num_cflevelsetmisfits;j++){
+					int obs_vector_type=0;
+					if ((cflevelsetmisfit_observation_M_s[j]==iomodel->numberofvertices) || (cflevelsetmisfit_observation_M_s[j]==iomodel->numberofvertices+1)){
+						obs_vector_type=1;
+					}
+					else if ((cflevelsetmisfit_observation_M_s[j]==iomodel->numberofelements) || (cflevelsetmisfit_observation_M_s[j]==iomodel->numberofelements+1)){
+						obs_vector_type=2;
+					}
+					else
+					 _error_("cflevelsetmisfit observation size not supported yet");
+
+					int weight_vector_type=0;
+					if ((cflevelsetmisfit_weights_M_s[j]==iomodel->numberofvertices) || (cflevelsetmisfit_weights_M_s[j]==iomodel->numberofvertices+1)){
+						weight_vector_type=1;
+					}
+					else if ((cflevelsetmisfit_weights_M_s[j]==iomodel->numberofelements) || (cflevelsetmisfit_weights_M_s[j]==iomodel->numberofelements+1)){
+						weight_vector_type=2;
+					}
+					else
+					 _error_("cflevelsetmisfit weight size not supported yet");
+
+					/*First create a cflevelsetmisfit object for that specific string (cflevelsetmisfit_model_string_s[j]):*/
+					output_definitions->AddObject(new Cflevelsetmisfit(cflevelsetmisfit_name_s[j],StringToEnumx(cflevelsetmisfit_definitionstring_s[j]),StringToEnumx(cflevelsetmisfit_model_string_s[j]),StringToEnumx(cflevelsetmisfit_observation_string_s[j]),StringToEnumx(cflevelsetmisfit_weights_string_s[j]),cflevelsetmisfit_datatime_s[j],false));
+
+					/*Now, for this particular cflevelsetmisfit object, make sure we plug into the elements: the observation, and the weights.*/
+					for(Object* & object : elements->objects){
+						Element* element=xDynamicCast<Element*>(object);
+						element->DatasetInputAdd(StringToEnumx(cflevelsetmisfit_definitionstring_s[j]),cflevelsetmisfit_observation_s[j],inputs,iomodel,cflevelsetmisfit_observation_M_s[j],cflevelsetmisfit_observation_N_s[j],obs_vector_type,StringToEnumx(cflevelsetmisfit_observation_string_s[j]),7,LevelsetObservationEnum);
+						element->DatasetInputAdd(StringToEnumx(cflevelsetmisfit_definitionstring_s[j]),cflevelsetmisfit_weights_s[j],inputs,iomodel,cflevelsetmisfit_weights_M_s[j],cflevelsetmisfit_weights_N_s[j],weight_vector_type,StringToEnumx(cflevelsetmisfit_weights_string_s[j]),7,WeightsLevelsetObservationEnum);
+					}
+				}
+
+				  /*Free ressources:*/
+				for(j=0;j<num_cflevelsetmisfits;j++){
+					char* string=NULL;
+					IssmDouble* matrix = NULL;
+
+					string = cflevelsetmisfit_definitionstring_s[j];		xDelete<char>(string);
+					string = cflevelsetmisfit_observation_string_s[j];	xDelete<char>(string);
+					string = cflevelsetmisfit_model_string_s[j];			xDelete<char>(string);
+					string = cflevelsetmisfit_weights_string_s[j];		xDelete<char>(string);
+					string = cflevelsetmisfit_name_s[j];    xDelete<char>(string);
+					matrix = cflevelsetmisfit_observation_s[j]; xDelete<IssmDouble>(matrix);
+					matrix = cflevelsetmisfit_weights_s[j]; xDelete<IssmDouble>(matrix);
+				}
+				xDelete<char*>(cflevelsetmisfit_name_s);
+				xDelete<char*>(cflevelsetmisfit_model_string_s);
+				xDelete<char*>(cflevelsetmisfit_definitionstring_s);
+				xDelete<IssmDouble*>(cflevelsetmisfit_observation_s);
+				xDelete<char*>(cflevelsetmisfit_observation_string_s);
+				xDelete<int>(cflevelsetmisfit_observation_M_s);
+				xDelete<int>(cflevelsetmisfit_observation_N_s);
+				xDelete<IssmDouble*>(cflevelsetmisfit_weights_s);
+				xDelete<int>(cflevelsetmisfit_weights_M_s);
+				xDelete<int>(cflevelsetmisfit_weights_N_s);
+				xDelete<char*>(cflevelsetmisfit_weights_string_s);
+				xDelete<IssmDouble>(cflevelsetmisfit_datatime_s);
 				/*}}}*/
 			}
Index: /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h
===================================================================
--- /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h	(revision 26251)
+++ /issm/trunk-jpl/src/c/shared/Enum/EnumDefinitions.h	(revision 26252)
@@ -707,4 +707,5 @@
 	LevelsetfunctionSlopeXEnum,
 	LevelsetfunctionSlopeYEnum,
+	LevelsetObservationEnum,
 	LoadingforceXEnum,
 	LoadingforceYEnum,
@@ -712,4 +713,5 @@
 	MaskOceanLevelsetEnum,
 	MaskIceLevelsetEnum,
+	MaskIceRefLevelsetEnum,
 	MasstransportSpcthicknessEnum,
 	MaterialsRheologyBEnum,
@@ -1012,4 +1014,5 @@
 	WaterfractionEnum,
 	WaterheightEnum,
+	WeightsLevelsetObservationEnum,
 	WeightsSurfaceObservationEnum,
 	OldAccumulatedDeltaBottomPressureEnum,
@@ -1157,4 +1160,5 @@
 	CfsurfacelogvelEnum,
 	CfsurfacesquareEnum,
+	CflevelsetmisfitEnum,
 	ChannelEnum,
 	ChannelAreaEnum,
Index: /issm/trunk-jpl/src/m/classes/cflevelsetmisfit.m
===================================================================
--- /issm/trunk-jpl/src/m/classes/cflevelsetmisfit.m	(revision 26252)
+++ /issm/trunk-jpl/src/m/classes/cflevelsetmisfit.m	(revision 26252)
@@ -0,0 +1,103 @@
+%MISFIT class definition
+%
+%   Usage:
+%      cflevelsetmisfit=cflevelsetmisfit();
+%      cflevelsetmisfit=cflevelsetmisfit('name','CalvingFrontPosition',...
+%                    'definitionstring','Outputdefinition1',... 
+%							'model_string','MaskIceLevelset',...
+%                    'observation_string','LevelsetObservations',...
+%                    'observation',md.mask.ice_levelset,...
+%                    'weights',ones(md.mesh.numberofvertices,1),...
+%                    'weights_string','WeightsLevelsetObservations',...
+%							'datatime',time);
+%
+%
+
+classdef cflevelsetmisfit
+	properties (SetAccess=public)
+		%cflevelsetmisfit
+		name               = '';
+		definitionstring   = ''; %string that identifies this output definition uniquely, from 'Outputdefinition[1-100]'
+		model_string       = ''; %string for field that is modeled
+		observation        = NaN; %observed field that we compare the model against
+		observation_string = ''; %string for observed field.
+		weights            = NaN; %weight coefficients for every vertex
+		weights_string     = ''; %string to identify this particular set of weights
+		datatime				 = 0; %time in years from start that the data is from 
+		cumulated          = NaN; %do we cumulate cflevelsetmisfit through time?
+	end
+	
+	methods
+		function self = extrude(self,md) % {{{
+			if ~isnan(self.weights)
+				self.weights=project3d(md,'vector',self.weights,'type','node');
+			end
+			if ~isnan(self.observation)
+				self.observation=project3d(md,'vector',self.observation,'type','node');
+			end
+		end % }}}
+		function self = cflevelsetmisfit(varargin) % {{{
+			if nargin==0,
+				self=setdefaultparameters(self);
+			else
+				%use provided options to change fields
+				options=pairoptions(varargin{:});
+
+				%get name
+				self.name=getfieldvalue(options,'name','');
+				self.definitionstring=getfieldvalue(options,'definitionstring');
+				self.model_string=getfieldvalue(options,'model_string');
+				self.observation=getfieldvalue(options,'observation',NaN);
+				self.observation_string=getfieldvalue(options,'observation_string');
+				self.weights=getfieldvalue(options,'weights',NaN);
+				self.weights_string=getfieldvalue(options,'weights_string','');
+				self.datatime = getfieldvalue(options, 'datatime');
+
+			end
+		end % }}}
+		function self = setdefaultparameters(self) % {{{
+			self.datatime = 0;
+		end % }}}
+		function md = checkconsistency(self,md,solution,analyses) % {{{
+
+			if ~ischar(self.name),
+				error('cflevelsetmisfit error message: ''name'' field should be a string!');
+			end
+			OutputdefinitionStringArray={};
+			for i=1:100
+				OutputdefinitionStringArray{i}=strcat('Outputdefinition',num2str(i));
+			end
+			md = checkfield(md,'fieldname','self.definitionstring','field',self.definitionstring,'values',OutputdefinitionStringArray);
+
+			md = checkfield(md,'fieldname','self.observation','field',self.observation,'timeseries',1,'NaN',1,'Inf',1);
+			md = checkfield(md,'fieldname','self.weights','field',self.weights,'timeseries',1,'NaN',1,'Inf',1);
+			md = checkfield(md,'fieldname','self.datatime','field',self.datatime,'<=',md.timestepping.final_time);
+
+		end % }}}
+		function md = disp(self) % {{{
+		
+			disp(sprintf('   TimeMisfit:\n'));
+
+			fielddisplay(self,'name','identifier for this cflevelsetmisfit response');
+			fielddisplay(self,'definitionstring','string that identifies this output definition uniquely, from ''Outputdefinition[1-10]''');
+			fielddisplay(self,'model_string','string for field that is modeled');
+			fielddisplay(self,'observation','observed field that we compare the model against');
+			fielddisplay(self,'observation_string','observation string');
+			fielddisplay(self,'weights','weights (at vertices) to apply to the cflevelsetmisfit');
+			fielddisplay(self,'weights_string','string for weights for identification purposes');
+			fielddisplay(self,'datatime','time to compare data to model for misfit');
+
+		end % }}}
+		function md = marshall(self,prefix,md,fid) % {{{
+
+		WriteData(fid,prefix,'data',self.name,'name','md.cflevelsetmisfit.name','format','String');
+		WriteData(fid,prefix,'data',self.definitionstring,'name','md.cflevelsetmisfit.definitionstring','format','String');
+		WriteData(fid,prefix,'data',self.model_string,'name','md.cflevelsetmisfit.model_string','format','String');
+		WriteData(fid,prefix,'data',self.observation,'name','md.cflevelsetmisfit.observation','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1,'yts',md.constants.yts);
+		WriteData(fid,prefix,'data',self.observation_string,'name','md.cflevelsetmisfit.observation_string','format','String');
+		WriteData(fid,prefix,'data',self.weights,'name','md.cflevelsetmisfit.weights','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1,'yts',md.constants.yts);
+		WriteData(fid,prefix,'data',self.weights_string,'name','md.cflevelsetmisfit.weights_string','format','String');
+		WriteData(fid,prefix,'data',round(self.datatime*md.constants.yts),'name','md.cflevelsetmisfit.datatime','format','Double');
+		end % }}}
+	end
+end
Index: /issm/trunk-jpl/src/m/classes/cfsurfacelogvel.m
===================================================================
--- /issm/trunk-jpl/src/m/classes/cfsurfacelogvel.m	(revision 26251)
+++ /issm/trunk-jpl/src/m/classes/cfsurfacelogvel.m	(revision 26252)
@@ -101,5 +101,5 @@
 		WriteData(fid,prefix,'data',self.weights,'name','md.cfsurfacelogvel.weights','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1,'yts',md.constants.yts);
 		WriteData(fid,prefix,'data',self.weights_string,'name','md.cfsurfacelogvel.weights_string','format','String');
-		WriteData(fid,prefix,'data',round(self.datatime*md.constants.yts),'name','md.cfsurfacelogvel.datatime','format','Integer');
+		WriteData(fid,prefix,'data',round(self.datatime*md.constants.yts),'name','md.cfsurfacelogvel.datatime','format','Double');
 		end % }}}
 	end
Index: /issm/trunk-jpl/src/m/classes/cfsurfacesquare.m
===================================================================
--- /issm/trunk-jpl/src/m/classes/cfsurfacesquare.m	(revision 26251)
+++ /issm/trunk-jpl/src/m/classes/cfsurfacesquare.m	(revision 26252)
@@ -98,5 +98,5 @@
 		WriteData(fid,prefix,'data',self.weights,'name','md.cfsurfacesquare.weights','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1,'yts',md.constants.yts);
 		WriteData(fid,prefix,'data',self.weights_string,'name','md.cfsurfacesquare.weights_string','format','String');
-		WriteData(fid,prefix,'data',round(self.datatime*md.constants.yts),'name','md.cfsurfacesquare.datatime','format','Integer');
+		WriteData(fid,prefix,'data',round(self.datatime*md.constants.yts),'name','md.cfsurfacesquare.datatime','format','Double');
 		end % }}}
 	end