Index: ../trunk-jpl/src/m/classes/initialization.m
===================================================================
--- ../trunk-jpl/src/m/classes/initialization.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/initialization.m	(revision 19040)
@@ -18,35 +18,35 @@
 		watercolumn   = NaN;
 	end
 	methods
-		function createxml(obj,fid) % {{{
+		function createxml(self,fid) % {{{
 			fprintf(fid, '\n\n');
 			fprintf(fid, '%s\n', '<!-- initialization -->');
 			fprintf(fid,'%s\n%s\n%s\n','<frame key="1" label="Initial field values">','<section name="initialization" />');                    
 
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="vx" type="',class(obj.vx),'" default="',obj.vx,'">','     <section name="initialization" />','     <help> x component of velocity [m/yr] </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="vy" type="',class(obj.vy),'" default="',obj.vy,'">','     <section name="initialization" />','     <help> y component of velocity [m/yr] </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="vz" type="',class(obj.vz),'" default="',obj.vz,'">','     <section name="initialization" />','     <help> z component of velocity [m/yr] </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="vel" type="',class(obj.vel),'" default="',obj.vel,'">','     <section name="initialization" />','     <help> velocity norm [m/yr] </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="pressure" type="',class(obj.pressure),'" default="',obj.pressure,'">','     <section name="initialization" />','     <help> pressure field [Pa] </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="temperature" type="',class(obj.temperature),'" default="',obj.temperature,'">','     <section name="initialization" />','     <help> fraction of water in the ice </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="waterfraction" type="',class(obj.waterfraction),'" default="',obj.waterfraction,'">','     <section name="initialization" />','     <help> ice thickness [m] </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="sediment_head" type="',class(obj.sediment_head),'" default="',obj.sediment_head,'">','     <section name="initialization" />','     <help> sediment water head of subglacial system [m] </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="epl_head" type="',class(obj.epl_head),'" default="',obj.epl_head,'">','     <section name="initialization" />','     <help> epl water head of subglacial system [m] </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','<parameter key ="watercolumn" type="',class(obj.watercolumn),'" default="',obj.watercolumn,'">','     <section name="initialization" />','     <help> thickness of subglacial water [m] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="vx" type="',class(self.vx),'" default="',self.vx,'">','     <section name="initialization" />','     <help> x component of velocity [m/yr] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="vy" type="',class(self.vy),'" default="',self.vy,'">','     <section name="initialization" />','     <help> y component of velocity [m/yr] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="vz" type="',class(self.vz),'" default="',self.vz,'">','     <section name="initialization" />','     <help> z component of velocity [m/yr] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="vel" type="',class(self.vel),'" default="',self.vel,'">','     <section name="initialization" />','     <help> velocity norm [m/yr] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="pressure" type="',class(self.pressure),'" default="',self.pressure,'">','     <section name="initialization" />','     <help> pressure field [Pa] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="temperature" type="',class(self.temperature),'" default="',self.temperature,'">','     <section name="initialization" />','     <help> fraction of water in the ice </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="waterfraction" type="',class(self.waterfraction),'" default="',self.waterfraction,'">','     <section name="initialization" />','     <help> ice thickness [m] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="sediment_head" type="',class(self.sediment_head),'" default="',self.sediment_head,'">','     <section name="initialization" />','     <help> sediment water head of subglacial system [m] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="epl_head" type="',class(self.epl_head),'" default="',self.epl_head,'">','     <section name="initialization" />','     <help> epl water head of subglacial system [m] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','<parameter key ="watercolumn" type="',class(self.watercolumn),'" default="',self.watercolumn,'">','     <section name="initialization" />','     <help> thickness of subglacial water [m] </help>','</parameter>');
 			fprintf(fid,'%s\n%s\n','</frame>');
 		end % }}}
-		function obj = initialization(varargin) % {{{
+		function self = initialization(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 			if ismember(StressbalanceAnalysisEnum(),analyses)
 				if ~(isnan(md.initialization.vx) | isnan(md.initialization.vy)),
 					md = checkfield(md,'fieldname','initialization.vx','NaN',1,'size',[md.mesh.numberofvertices 1]);
@@ -97,36 +97,36 @@
 				end
 			end
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   initial field values:'));
 
-			fielddisplay(obj,'vx','x component of velocity [m/yr]');
-			fielddisplay(obj,'vy','y component of velocity [m/yr]');
-			fielddisplay(obj,'vz','z component of velocity [m/yr]');
-			fielddisplay(obj,'vel','velocity norm [m/yr]');
-			fielddisplay(obj,'pressure','pressure field [Pa]');
-			fielddisplay(obj,'temperature','temperature [K]');
-			fielddisplay(obj,'waterfraction','fraction of water in the ice');
-			fielddisplay(obj,'sediment_head','sediment water head of subglacial system [m]');
-			fielddisplay(obj,'epl_head','epl water head of subglacial system [m]');
-			fielddisplay(obj,'epl_thickness','epl layer thickness [m]');
-			fielddisplay(obj,'watercolumn','thickness of subglacial water [m]');
+			fielddisplay(self,'vx','x component of velocity [m/yr]');
+			fielddisplay(self,'vy','y component of velocity [m/yr]');
+			fielddisplay(self,'vz','z component of velocity [m/yr]');
+			fielddisplay(self,'vel','velocity norm [m/yr]');
+			fielddisplay(self,'pressure','pressure field [Pa]');
+			fielddisplay(self,'temperature','temperature [K]');
+			fielddisplay(self,'waterfraction','fraction of water in the ice');
+			fielddisplay(self,'sediment_head','sediment water head of subglacial system [m]');
+			fielddisplay(self,'epl_head','epl water head of subglacial system [m]');
+			fielddisplay(self,'epl_thickness','epl layer thickness [m]');
+			fielddisplay(self,'watercolumn','thickness of subglacial water [m]');
 
 		end % }}}
-		function marshall(obj,md,fid) % {{{
+		function marshall(self,md,fid) % {{{
 
 			yts=365.0*24.0*3600.0;
 
-			WriteData(fid,'data',obj.vx,'format','DoubleMat','mattype',1,'enum',VxEnum,'scale',1./yts);
-			WriteData(fid,'data',obj.vy,'format','DoubleMat','mattype',1,'enum',VyEnum,'scale',1./yts);
-			WriteData(fid,'data',obj.vz,'format','DoubleMat','mattype',1,'enum',VzEnum,'scale',1./yts);
-			WriteData(fid,'data',obj.pressure,'format','DoubleMat','mattype',1,'enum',PressureEnum);
-			WriteData(fid,'data',obj.temperature,'format','DoubleMat','mattype',1,'enum',TemperatureEnum);
-			WriteData(fid,'data',obj.waterfraction,'format','DoubleMat','mattype',1,'enum',WaterfractionEnum);
-			WriteData(fid,'data',obj.sediment_head,'format','DoubleMat','mattype',1,'enum',SedimentHeadEnum);
-			WriteData(fid,'data',obj.epl_head,'format','DoubleMat','mattype',1,'enum',EplHeadEnum);
-			WriteData(fid,'data',obj.epl_thickness,'format','DoubleMat','mattype',1,'enum',HydrologydcEplThicknessEnum);
-			WriteData(fid,'data',obj.watercolumn,'format','DoubleMat','mattype',1,'enum',WatercolumnEnum);
+			WriteData(fid,'data',self.vx,'format','DoubleMat','mattype',1,'enum',VxEnum,'scale',1./yts);
+			WriteData(fid,'data',self.vy,'format','DoubleMat','mattype',1,'enum',VyEnum,'scale',1./yts);
+			WriteData(fid,'data',self.vz,'format','DoubleMat','mattype',1,'enum',VzEnum,'scale',1./yts);
+			WriteData(fid,'data',self.pressure,'format','DoubleMat','mattype',1,'enum',PressureEnum);
+			WriteData(fid,'data',self.temperature,'format','DoubleMat','mattype',1,'enum',TemperatureEnum);
+			WriteData(fid,'data',self.waterfraction,'format','DoubleMat','mattype',1,'enum',WaterfractionEnum);
+			WriteData(fid,'data',self.sediment_head,'format','DoubleMat','mattype',1,'enum',SedimentHeadEnum);
+			WriteData(fid,'data',self.epl_head,'format','DoubleMat','mattype',1,'enum',EplHeadEnum);
+			WriteData(fid,'data',self.epl_thickness,'format','DoubleMat','mattype',1,'enum',HydrologydcEplThicknessEnum);
+			WriteData(fid,'data',self.watercolumn,'format','DoubleMat','mattype',1,'enum',WatercolumnEnum);
 
 			if md.thermal.isenthalpy,
 				tpmp = md.materials.meltingpoint - md.materials.beta*md.initialization.pressure;
Index: ../trunk-jpl/src/m/classes/radaroverlay.m
===================================================================
--- ../trunk-jpl/src/m/classes/radaroverlay.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/radaroverlay.m	(revision 19040)
@@ -10,23 +10,23 @@
 		y   = NaN;
 	end
 	methods
-		function obj = radaroverlay(varargin) % {{{
+		function self = radaroverlay(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   radaroverlay parameters:'));
 
-			fielddisplay(obj,'pwr','radar power image (matrix)');
-			fielddisplay(obj,'x','corresponding x coordinates [m]');
-			fielddisplay(obj,'y','corresponding y coordinates [m]');
+			fielddisplay(self,'pwr','radar power image (matrix)');
+			fielddisplay(self,'x','corresponding x coordinates [m]');
+			fielddisplay(self,'y','corresponding y coordinates [m]');
 
 		end % }}}
 	end
Index: ../trunk-jpl/src/m/classes/pairoptions.m
===================================================================
--- ../trunk-jpl/src/m/classes/pairoptions.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/pairoptions.m	(revision 19040)
@@ -10,24 +10,24 @@
 		list         = cell(0,3);
 	end
 	methods
-		function obj = pairoptions(varargin) % {{{
+		function self = pairoptions(varargin) % {{{
 
 			%get calling function name
 			a=dbstack;
 			if length(a)>1,
-				obj.functionname=a(2).file(1:end-2);
+				self.functionname=a(2).file(1:end-2);
 			else
-				obj.functionname='';
+				self.functionname='';
 			end
 
 			%initialize list
 			if nargin==0,
 				%Do nothing,
 			else
-				obj=buildlist(obj,varargin{:});
+				self=buildlist(self,varargin{:});
 			end
 		end % }}}
-		function obj = buildlist(obj,varargin) % {{{
+		function self = buildlist(self,varargin) % {{{
 		%BUILDLIST - build list of obj from input
 
 			%check length of input
@@ -37,36 +37,36 @@
 			numoptions = (nargin-1)/2;
 
 			%Allocate memory
-			obj.list=cell(numoptions,3);
+			self.list=cell(numoptions,3);
 
 			%go through varargin and build list of obj
 			for i=1:numoptions,
 				if ischar(varargin{2*i-1}),
-					obj.list{i,1}=varargin{2*i-1};
-					obj.list{i,2}=varargin{2*i};
-					obj.list{i,3}=false; %used?
+					self.list{i,1}=varargin{2*i-1};
+					self.list{i,2}=varargin{2*i};
+					self.list{i,3}=false; %used?
 				else
 					%option is not a string, ignore it
 					disp(['WARNING: option number ' num2str(i) ' is not a string, it will be ignored']);
-					obj.list(i,:)=[];
+					self.list(i,:)=[];
 					continue
 				end
 			end
 		end % }}}
-		function obj = addfield(obj,field,value) % {{{
+		function self = addfield(self,field,value) % {{{
 			if ischar(field),
-				obj.list{end+1,1} = field;
-				obj.list{end,2}   = value;
-				obj.list{end,3}   = false;
+				self.list{end+1,1} = field;
+				self.list{end,2}   = value;
+				self.list{end,3}   = false;
 			end
 		end % }}}
-		function obj = addfielddefault(obj,field,value) % {{{
+		function self = addfielddefault(self,field,value) % {{{
 		%ADDFIELDDEFAULT - add a field to an options list if it does not exist
 			if ischar(field),
-				if ~exist(obj,field),
-					obj.list{end+1,1} = field;
-					obj.list{end,2}   = value;
-					obj.list{end,3}   = true;  %It is a default so user will not be notified if not used
+				if ~exist(self,field),
+					self.list{end+1,1} = field;
+					self.list{end,2}   = value;
+					self.list{end,3}   = true;  %It is a default so user will not be notified if not used
 				end
 			end
 		end % }}}
@@ -83,73 +83,73 @@
 				end
 			end
 		end % }}}
-		function obj = changefieldvalue(obj,field,newvalue) % {{{
+		function self = changefieldvalue(self,field,newvalue) % {{{
 		%CHANGEOPTIONVALUE - change the value of an option in an option list
 
 			%track occurrence of field
-			lines=find(strcmpi(obj.list(:,1),field));
+			lines=find(strcmpi(self.list(:,1),field));
 
 			%replace value
 			if isempty(lines),
 				%add new field if not found
-				obj=addfield(obj,field,newvalue);
-				obj.list{end,3}=true; % do not notify user if unused
+				self=addfield(self,field,newvalue);
+				self.list{end,3}=true; % do not notify user if unused
 			else
 				for i=1:length(lines),
-					obj.list{lines(i),2}=newvalue;
+					self.list{lines(i),2}=newvalue;
 				end
 			end
 		end % }}}
-		function obj = deleteduplicates(obj,warn) % {{{
+		function self = deleteduplicates(self,warn) % {{{
 		%DELETEDUPLICATES - delete duplicates in an option list
 
 			%track the first occurrence of each option
-			[dummy lines]=unique(obj.list(:,1),'first');
+			[dummy lines]=unique(self.list(:,1),'first');
 			clear dummy
 
 			%warn user if requested
 			if warn,
-				numoptions=size(obj.list,1);
+				numoptions=size(self.list,1);
 				for i=1:numoptions,
 					if ~ismember(i,lines),
-						disp(['WARNING: option ' obj.list{i,1} ' appeared more than once. Only its first occurrence will be kept'])
+						disp(['WARNING: option ' self.list{i,1} ' appeared more than once. Only its first occurrence will be kept'])
 					end
 				end
 			end
 
 			%remove duplicates from the options list
-			obj.list=obj.list(lines,:);
+			self.list=self.list(lines,:);
 		end % }}}
-		function displayunused(obj) % {{{
+		function displayunused(self) % {{{
 			%DISPLAYUNUSED - display unused options
 
-			numoptions=size(obj.list,1);
+			numoptions=size(self.list,1);
 			for i=1:numoptions,
-				if ~obj.list{i,3},
-					disp(['WARNING: option ' obj.list{i,1} ' was not used'])
+				if ~self.list{i,3},
+					disp(['WARNING: option ' self.list{i,1} ' was not used'])
 				end
 			end
 		end % }}}
-		function disp(obj) % {{{
-			disp(sprintf('   functionname: %s',obj.functionname));
-			if ~isempty(obj.list),
-				disp(sprintf('   list: (%ix%i)\n',size(obj.list,1),size(obj.list,2)));
-				for i=1:size(obj.list,1),
-					if ischar(obj.list{i,2}),
-						disp(sprintf('     field: %-10s value: ''%s''',obj.list{i,1},obj.list{i,2}));
-					elseif isnumeric(obj.list{i,2}) & length(obj.list{i,2})==1,
-						disp(sprintf('     field: %-10s value: %g',obj.list{i,1},obj.list{i,2}));
-					elseif isnumeric(obj.list{i,2}) & length(obj.list{i,2})==2,
-						disp(sprintf('     field: %-10s value: [%g %g]',obj.list{i,1},obj.list{i,2}));
+		function disp(self) % {{{
+			disp(sprintf('   functionname: %s',self.functionname));
+			if ~isempty(self.list),
+				disp(sprintf('   list: (%ix%i)\n',size(self.list,1),size(self.list,2)));
+				for i=1:size(self.list,1),
+					if ischar(self.list{i,2}),
+						disp(sprintf('     field: %-10s value: ''%s''',self.list{i,1},self.list{i,2}));
+					elseif isnumeric(self.list{i,2}) & length(self.list{i,2})==1,
+						disp(sprintf('     field: %-10s value: %g',self.list{i,1},self.list{i,2}));
+					elseif isnumeric(self.list{i,2}) & length(self.list{i,2})==2,
+						disp(sprintf('     field: %-10s value: [%g %g]',self.list{i,1},self.list{i,2}));
 					else
-						disp(sprintf('     field: %-10s value: (%ix%i)',obj.list{i,1},size(obj.list{i,2},1),size(obj.list{i,2},2)));
+						disp(sprintf('     field: %-10s value: (%ix%i)',self.list{i,1},size(self.list{i,2},1),size(self.list{i,2},2)));
 					end
 				end
 			else
 				disp(sprintf('   list: empty'));
 			end
 		end % }}}
-		function bool = exist(obj,field) % {{{
+		function bool = exist(self,field) % {{{
 		%EXIST - check if the option exists
 
 			%some argument checking: 
@@ -161,15 +161,15 @@
 			end
 
 			%Recover option
-			pos=find(strcmpi(field,obj.list(:,1)));
+			pos=find(strcmpi(field,self.list(:,1)));
 			if ~isempty(pos),
 				bool=true;
-				obj.list{pos,3}   = true;  %It is a default so user will not be notified if not used
+				self.list{pos,3}   = true;  %It is a default so user will not be notified if not used
 			else
 				bool=false;
 			end
 		end % }}}
-		function num = fieldoccurrences(obj,field), % {{{
+		function num = fieldoccurrences(self,field), % {{{
 		%FIELDOCCURRENCES - get number of occurrence of a field
 
 			%check input 
@@ -178,13 +178,13 @@
 			end
 
 			%get number of occurrence
-			num=sum(strcmpi(field,obj.list(:,1)));
+			num=sum(strcmpi(field,self.list(:,1)));
 		end % }}}
-		function value = getfieldvalue(obj,field,varargin), % {{{
+		function value = getfieldvalue(self,field,varargin), % {{{
 		%GETOPTION - get the value of an option
 		%
 		%   Usage:
-		%      value=getfieldvalue(obj,field,varargin)
+		%      value=getfieldvalue(self,field,varargin)
 		%
 		%   Find an option value from a field. A default option
 		%   can be given in input if the field does not exist
@@ -204,10 +204,10 @@
 			end
 
 			%Recover option
-			pos=find(strcmpi(obj.list(:,1),field));
+			pos=find(strcmpi(self.list(:,1),field));
 			if ~isempty(pos),
-				value=obj.list{pos(1),2}; % ignore extra entry
-				obj.list{pos(1),3}=true;  % option used
+				value=self.list{pos(1),2}; % ignore extra entry
+				self.list{pos(1),3}=true;  % option used
 				return;
 			end
 
@@ -218,23 +218,23 @@
 				error(['error message: field ' field ' has not been provided by user (and no default value has been specified)'])
 			end
 		end % }}}
-		function obj = removefield(obj,field,warn)% {{{
+		function self = removefield(self,field,warn)% {{{
 		%REMOVEFIELD - delete a field in an option list
 		%
 		%   Usage:
-		%      obj=removefield(obj,field,warn)
+		%      self=removefield(self,field,warn)
 		%
 		%   if warn==1 display an info message to warn user that
 		%   some of his options have been removed.
 
 			%check is field exist
-			if exist(obj,field),
+			if exist(self,field),
 
 				%find where the field is located
-				lines=find(~strcmpi(obj.list(:,1),field));
+				lines=find(~strcmpi(self.list(:,1),field));
 
 				%remove duplicates from the options list
-				obj.list=obj.list(lines,:);
+				self.list=self.list(lines,:);
 
 				%warn user if requested
 				if warn
@@ -242,11 +242,11 @@
 				end
 			end
 		end % }}}
-		function marshall(obj,fid,firstindex)% {{{
+		function marshall(self,fid,firstindex)% {{{
 
-			for i=1:size(obj.list,1),
-				name  = obj.list{i,1};
-				value = obj.list{i,2};
+			for i=1:size(self.list,1),
+				name  = self.list{i,1};
+				value = self.list{i,2};
 
 				%Write option name
 				WriteData(fid,'enum',(firstindex-1)+2*i-1,'data',name,'format','String');
Index: ../trunk-jpl/src/m/classes/toolkits.m
===================================================================
--- ../trunk-jpl/src/m/classes/toolkits.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/toolkits.m	(revision 19040)
@@ -1,7 +1,7 @@
 %TOOLKITS class definition
 %
 %   Usage:
-%      obj=toolkits();
+%      self=toolkits();
 
 classdef toolkits < dynamicprops
     properties (SetAccess=public) 
@@ -9,17 +9,17 @@
 		 %The other properties are dynamic
 	 end
 	 methods
-		 function obj = toolkits(varargin) % {{{
+		 function self = toolkits(varargin) % {{{
 			 switch nargin
 				 case 0
-					 obj=setdefaultparameters(obj);
+					 self=setdefaultparameters(self);
 				 case 1
-					 obj=structtoobj(obj,varargin{1});
+					 self=structtoobj(self,varargin{1});
 				 otherwise
 					 error('constructor not supported');
 				 end
 			 end % }}}
-		 function obj = addoptions(obj,analysis,varargin) % {{{
+		 function self = addoptions(self,analysis,varargin) % {{{
 		 % Usage example:
 		 %    md.toolkits=addoptions(md.toolkits,StressbalanceAnalysisEnum(),FSoptions());
 		 %    md.toolkits=addoptions(md.toolkits,StressbalanceAnalysisEnum());
@@ -28,48 +28,48 @@
 			 analysis=EnumToString(analysis);
 
 			 %Create dynamic property if property does not exist yet
-			 if ~ismember(analysis,properties(obj)),
-				 obj.addprop(analysis);
+			 if ~ismember(analysis,properties(self)),
+				 self.addprop(analysis);
 			 end
 
 			 %Add toolkits options to analysis
-			 if nargin==3, obj.(analysis) = varargin{1}; end
+			 if nargin==3, self.(analysis) = varargin{1}; end
 		 end
 		 %}}}
-		 function obj = setdefaultparameters(obj) % {{{
+		 function self = setdefaultparameters(self) % {{{
 
 			 %default toolkits: 
 			 if IssmConfig('_HAVE_PETSC_'),
 				 %MUMPS is the default toolkits
 				 if IssmConfig('_HAVE_MUMPS_'),
-					 obj.DefaultAnalysis           = mumpsoptions();
+					 self.DefaultAnalysis           = mumpsoptions();
 				 else
-					 obj.DefaultAnalysis           = iluasmoptions(); 
+					 self.DefaultAnalysis           = iluasmoptions(); 
 				 end
 			 else
 				 if IssmConfig('_HAVE_MUMPS_'),
-					 obj.DefaultAnalysis           = issmmumpssolver(); 
+					 self.DefaultAnalysis           = issmmumpssolver(); 
 				 elseif IssmConfig('_HAVE_GSL_'),
-					 obj.DefaultAnalysis           = issmgslsolver(); 
+					 self.DefaultAnalysis           = issmgslsolver(); 
 				 else 
 					 error('Need at least Mumps or Gsl to define an issm solver type');
 				 end
 			 end
 
 		 end % }}}
-		 function disp(obj) % {{{
-			 analyses=properties(obj);
+		 function disp(self) % {{{
+			 analyses=properties(self);
 			 disp(sprintf('List of toolkits options per analysis:\n'));
 			 for i=1:numel(analyses),
 				 analysis=analyses{i};
 				 disp([analysis ':']);
-				 disp(obj.(analysis));
+				 disp(self.(analysis));
 			 end
 		 end % }}}
-		 function md = checkconsistency(obj,md,solution,analyses) % {{{
-			 analyses=properties(obj);
+		 function md = checkconsistency(self,md,solution,analyses) % {{{
+			 analyses=properties(self);
 			 for i=1:numel(analyses),
-				 if isempty(fieldnames(obj.(analyses{i})))
+				 if isempty(fieldnames(self.(analyses{i})))
 					 md = checkmessage(md,['md.toolkits.' analyses{i} ' is empty']);
 				 end
 			 end
Index: ../trunk-jpl/src/m/classes/frictionwaterlayer.m
===================================================================
--- ../trunk-jpl/src/m/classes/frictionwaterlayer.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/frictionwaterlayer.m	(revision 19040)
@@ -11,20 +11,20 @@
 		water_layer = NaN;
 	end
 	methods
-		function obj = frictionwaterlayer(varargin) % {{{
+		function self = frictionwaterlayer(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				case 1
 					obj=structtoobj(frictionwaterlayer(),varargin{1});
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 			%Early return
 			if ~ismember(StressbalanceAnalysisEnum(),analyses) & ~ismember(ThermalAnalysisEnum(),analyses), return; end
@@ -35,20 +35,20 @@
 			md = checkfield(md,'fieldname','thermal.spctemperature','timeseries',1,'>=',0.);
 
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('Basal shear stress parameters: tau_b = coefficient^2 * Neff ^r * |u_b|^(s-1) * u_b * 1/f(T)\n(effective stress Neff=rho_ice*g*thickness+rho_water*g*(bed+water_layer), r=q/p and s=1/p)'));
-			fielddisplay(obj,'coefficient','frictiontemp coefficient [SI]');
-			fielddisplay(obj,'p','p exponent');
-			fielddisplay(obj,'q','q exponent');
-			fielddisplay(obj,'water_layer','water thickness at the base of the ice (m)');
+			fielddisplay(self,'coefficient','frictiontemp coefficient [SI]');
+			fielddisplay(self,'p','p exponent');
+			fielddisplay(self,'q','q exponent');
+			fielddisplay(self,'water_layer','water thickness at the base of the ice (m)');
 		end % }}}
-		function marshall(obj,md,fid) % {{{
+		function marshall(self,md,fid) % {{{
 
 			WriteData(fid,'enum',FrictionLawEnum,'data',5,'format','Integer');
-			WriteData(fid,'class','friction','object',obj,'fieldname','coefficient','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
-			WriteData(fid,'class','friction','object',obj,'fieldname','p','format','DoubleMat','mattype',2);
-			WriteData(fid,'class','friction','object',obj,'fieldname','q','format','DoubleMat','mattype',2);
-			WriteData(fid,'class','friction','object',obj,'fieldname','water_layer','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
+			WriteData(fid,'class','friction','object',self,'fieldname','coefficient','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
+			WriteData(fid,'class','friction','object',self,'fieldname','p','format','DoubleMat','mattype',2);
+			WriteData(fid,'class','friction','object',self,'fieldname','q','format','DoubleMat','mattype',2);
+			WriteData(fid,'class','friction','object',self,'fieldname','water_layer','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
 		end % }}}
 	end
 end
Index: ../trunk-jpl/src/m/classes/SMB.m
===================================================================
--- ../trunk-jpl/src/m/classes/SMB.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/SMB.m	(revision 19040)
@@ -8,13 +8,13 @@
 		mass_balance = NaN;
 	end
 	methods
-        function createxml(obj,fid) % {{{
+        function createxml(self,fid) % {{{
             fprintf(fid, '\n\n');
             fprintf(fid, '%s\n', '<!-- surfaceforcings(SMB) -->');
-			 fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','<parameter key ="mass_balance" type="',class(obj.mass_balance),'" default="',obj.mass_balance,'">','     <section name="surfaceforcings(SMB)" />','     <help> surface mass balance [m/yr ice eq] </help>','</parameter>');
+			 fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','<parameter key ="mass_balance" type="',class(self.mass_balance),'" default="',self.mass_balance,'">','     <section name="surfaceforcings(SMB)" />','     <help> surface mass balance [m/yr ice eq] </help>','</parameter>');
            
         end % }}}
-		function obj = SMB(varargin) % {{{
+		function self = SMB(varargin) % {{{
 			switch nargin
 				case 0
 				otherwise
@@ -34,7 +34,7 @@
 			end
 
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 			if ismember(MasstransportAnalysisEnum(),analyses),
 				md = checkfield(md,'fieldname','surfaceforcings.mass_balance','timeseries',1,'NaN',1);
@@ -43,16 +43,16 @@
 				md = checkfield(md,'fieldname','surfaceforcings.mass_balance','size',[md.mesh.numberofvertices 1],'NaN',1);
 			end
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   surface forcings parameters:'));
-			fielddisplay(obj,'mass_balance','surface mass balance [m/yr ice eq]');
+			fielddisplay(self,'mass_balance','surface mass balance [m/yr ice eq]');
 		end % }}}
-		function marshall(obj,md,fid) % {{{
+		function marshall(self,md,fid) % {{{
 
 			yts=365.0*24.0*3600.0;
 
 			WriteData(fid,'enum',SurfaceforcingsEnum(),'data',SMBEnum(),'format','Integer');
-			WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','mass_balance','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
+			WriteData(fid,'object',self,'class','surfaceforcings','fieldname','mass_balance','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
 		end % }}}
 	end
 end
Index: ../trunk-jpl/src/m/classes/debug.m
===================================================================
--- ../trunk-jpl/src/m/classes/debug.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/debug.m	(revision 19040)
@@ -10,7 +10,7 @@
 		profiling = false;
 	end
 	methods
-        function createxml(obj,fid) % {{{
+        function createxml(self,fid) % {{{
             fprintf(fid, '\n\n');
             fprintf(fid, '%s\n', '<!-- Debug -->');
             
@@ -19,30 +19,30 @@
             fprintf(fid,'%s\n','       <option value="0" type="string" default="true"> </option>');
             fprintf(fid,'%s\n%s\n','       <option value="1" type="string" default="false"> </option>','</parameter>');
           
-            fprintf(fid,'%s%s%s\n%s\n%s%s%s\n%s\n%s\n',    '<parameter key ="gprof" type="',              class(obj.gprof),'" optional="false">',              '     <section name="debug" />','        <option value="',convert2str(obj.gprof),'" type="string" default="true"></option>','     <help> use gnu-profiler to find out where the time is spent </help>','</parameter>');
-            fprintf(fid,'%s%s%s\n%s\n%s%s%s\n%s\n',    '<parameter key ="profiling" type="',              class(obj.profiling),'" optional="false">',              '     <section name="debug" />','        <option value="',convert2str(obj.profiling),'" type="string" default="true"></option>','     <help> enables profiling (memory, flops, time) </help>','</parameter>');
+            fprintf(fid,'%s%s%s\n%s\n%s%s%s\n%s\n%s\n',    '<parameter key ="gprof" type="',              class(self.gprof),'" optional="false">',              '     <section name="debug" />','        <option value="',convert2str(self.gprof),'" type="string" default="true"></option>','     <help> use gnu-profiler to find out where the time is spent </help>','</parameter>');
+            fprintf(fid,'%s%s%s\n%s\n%s%s%s\n%s\n',    '<parameter key ="profiling" type="',              class(self.profiling),'" optional="false">',              '     <section name="debug" />','        <option value="',convert2str(self.profiling),'" type="string" default="true"></option>','     <help> enables profiling (memory, flops, time) </help>','</parameter>');
         end % }}}
-		function obj = debug(varargin) % {{{
+		function self = debug(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				otherwise
 					error('constructor not supported');
 				end
 			end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   debug parameters:'));
 
-			fielddisplay(obj,'valgrind','use Valgrind to debug (0 or 1)');
-			fielddisplay(obj,'gprof','use gnu-profiler to find out where the time is spent');
-			fielddisplay(obj,'profiling','enables profiling (memory, flops, time)');
+			fielddisplay(self,'valgrind','use Valgrind to debug (0 or 1)');
+			fielddisplay(self,'gprof','use gnu-profiler to find out where the time is spent');
+			fielddisplay(self,'profiling','enables profiling (memory, flops, time)');
 
 		end % }}}
-		function marshall(obj,md,fid) % {{{
-			WriteData(fid,'object',obj,'fieldname','profiling','format','Boolean');
+		function marshall(self,md,fid) % {{{
+			WriteData(fid,'object',self,'fieldname','profiling','format','Boolean');
 		end % }}}
 	end
 end
Index: ../trunk-jpl/src/m/classes/massfluxatgate.m
===================================================================
--- ../trunk-jpl/src/m/classes/massfluxatgate.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/massfluxatgate.m	(revision 19040)
@@ -15,54 +15,54 @@
 		segments        = NaN;
 	end
 	methods
-		function obj = massfluxatgate(varargin) % {{{
+		function self = massfluxatgate(varargin) % {{{
 			if nargin==0,
-				obj=setdefaultparameters(obj);
+				self=setdefaultparameters(self);
 			else
 				%use provided options to change fields
 				options=pairoptions(varargin{:});
 
 				%get name
-				obj.name=getfieldvalue(options,'name','');
-				obj.definitionenum=getfieldvalue(options,'definitionenum');
-				obj.profilename=getfieldvalue(options,'profilename');
+				self.name=getfieldvalue(options,'name','');
+				self.definitionenum=getfieldvalue(options,'definitionenum');
+				self.profilename=getfieldvalue(options,'profilename');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 			
-			if ~ischar(obj.name),
+			if ~ischar(self.name),
 				error('massfluxatgate error message: ''name'' field should be a string!');
 			end
-			if ~ischar(obj.profilename),
+			if ~ischar(self.profilename),
 				error('massfluxatgate error message: ''profilename'' field should be a string!');
 			end
 			
-			md = checkfield(md,'field',obj.definitionenum,'values',[Outputdefinition1Enum():Outputdefinition100Enum()]);
+			md = checkfield(md,'field',self.definitionenum,'values',[Outputdefinition1Enum():Outputdefinition100Enum()]);
 
 			%check the profilename points to a file!: 
-			if exist(obj.profilename,'file')~=2,
+			if exist(self.profilename,'file')~=2,
 				error('massfluxatgate error message: file name for profile corresponding to gate does not point to a legitimate file on disk!');
 			end
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   Massfluxatgate:\n'));
 
-			fielddisplay(obj,'name','identifier for this massfluxatgate response');
-			fielddisplay(obj,'profilename','name of file (shapefile or argus file) defining a profile (or gate)');
-			fielddisplay(obj,'definitionenum','enum that identifies this output definition uniquely, from Outputdefinition[1-10]Enum');
+			fielddisplay(self,'name','identifier for this massfluxatgate response');
+			fielddisplay(self,'profilename','name of file (shapefile or argus file) defining a profile (or gate)');
+			fielddisplay(self,'definitionenum','enum that identifies this output definition uniquely, from Outputdefinition[1-10]Enum');
 			
 		end % }}}
-		function marshall(obj,md,fid) % {{{
+		function marshall(self,md,fid) % {{{
 
 		%before marshalling, we need to create the segments out of the profilename: 
-		obj.segments=MeshProfileIntersection(md.mesh.elements,md.mesh.x,md.mesh.y,obj.profilename);
+		self.segments=MeshProfileIntersection(md.mesh.elements,md.mesh.x,md.mesh.y,self.profilename);
 
 		%ok, marshall name and segments: 
-		WriteData(fid,'object',obj,'fieldname','name','format','String');
-		WriteData(fid,'object',obj,'fieldname','definitionenum','format','Integer');
-		WriteData(fid,'object',obj,'fieldname','segments','format','DoubleMat','mattype',1);
+		WriteData(fid,'object',self,'fieldname','name','format','String');
+		WriteData(fid,'object',self,'fieldname','definitionenum','format','Integer');
+		WriteData(fid,'object',self,'fieldname','segments','format','DoubleMat','mattype',1);
 
 		end % }}}
 	end
Index: ../trunk-jpl/src/m/classes/m1qn3inversion.m
===================================================================
--- ../trunk-jpl/src/m/classes/m1qn3inversion.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/m1qn3inversion.m	(revision 19040)
@@ -26,12 +26,12 @@
 
 	end
 	methods
-		function obj = m1qn3inversion(varargin) % {{{
+		function self = m1qn3inversion(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				case 1
-					obj=structtoobj(m1qn3inversion(),varargin{1});
+					self=structtoobj(m1qn3inversion(),varargin{1});
 				otherwise
 					error('constructor not supported');
 			end
@@ -60,10 +60,10 @@
 			self.gttol = 1e-4;
 
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 			%Early return
-			if ~obj.iscontrol, return; end
+			if ~self.iscontrol, return; end
 
 			if ~IssmConfig('_HAVE_M1QN3_'),
 				md = checkmessage(md,['M1QN3 has not been installed, ISSM needs to be reconfigured and recompiled with M1QN3']);
@@ -96,25 +96,25 @@
 				end
 			end
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   m1qn3inversion parameters:'));
-			fielddisplay(obj,'iscontrol','is inversion activated?');
-			fielddisplay(obj,'incomplete_adjoint','1: linear viscosity, 0: non-linear viscosity');
-			fielddisplay(obj,'control_parameters','ex: {''FrictionCoefficient''}, or {''MaterialsRheologyBbar''}');
-			fielddisplay(obj,'control_scaling_factors','order of magnitude of each control (useful for multi-parameter optimization)');
-			fielddisplay(obj,'maxsteps','maximum number of iterations (gradient computation)');
-			fielddisplay(obj,'maxiter','maximum number of Function evaluation (forward run)');
-			fielddisplay(obj,'dxmin','convergence criterion: two points less than dxmin from eachother (sup-norm) are considered identical');
-			fielddisplay(obj,'gttol','convergence criterion: ||g(X)||/||g(X0)|| (g(X0): gradient at initial guess X0)');
-			fielddisplay(obj,'cost_functions','indicate the type of response for each optimization step');
-			fielddisplay(obj,'cost_functions_coefficients','cost_functions_coefficients applied to the misfit of each vertex and for each control_parameter');
-			fielddisplay(obj,'min_parameters','absolute minimum acceptable value of the inversed parameter on each vertex');
-			fielddisplay(obj,'max_parameters','absolute maximum acceptable value of the inversed parameter on each vertex');
-			fielddisplay(obj,'vx_obs','observed velocity x component [m/yr]');
-			fielddisplay(obj,'vy_obs','observed velocity y component [m/yr]');
-			fielddisplay(obj,'vel_obs','observed velocity magnitude [m/yr]');
-			fielddisplay(obj,'thickness_obs','observed thickness [m]');
-			fielddisplay(obj,'surface_obs','observed surface elevation [m]');
+			fielddisplay(self,'iscontrol','is inversion activated?');
+			fielddisplay(self,'incomplete_adjoint','1: linear viscosity, 0: non-linear viscosity');
+			fielddisplay(self,'control_parameters','ex: {''FrictionCoefficient''}, or {''MaterialsRheologyBbar''}');
+			fielddisplay(self,'control_scaling_factors','order of magnitude of each control (useful for multi-parameter optimization)');
+			fielddisplay(self,'maxsteps','maximum number of iterations (gradient computation)');
+			fielddisplay(self,'maxiter','maximum number of Function evaluation (forward run)');
+			fielddisplay(self,'dxmin','convergence criterion: two points less than dxmin from eachother (sup-norm) are considered identical');
+			fielddisplay(self,'gttol','convergence criterion: ||g(X)||/||g(X0)|| (g(X0): gradient at initial guess X0)');
+			fielddisplay(self,'cost_functions','indicate the type of response for each optimization step');
+			fielddisplay(self,'cost_functions_coefficients','cost_functions_coefficients applied to the misfit of each vertex and for each control_parameter');
+			fielddisplay(self,'min_parameters','absolute minimum acceptable value of the inversed parameter on each vertex');
+			fielddisplay(self,'max_parameters','absolute maximum acceptable value of the inversed parameter on each vertex');
+			fielddisplay(self,'vx_obs','observed velocity x component [m/yr]');
+			fielddisplay(self,'vy_obs','observed velocity y component [m/yr]');
+			fielddisplay(self,'vel_obs','observed velocity magnitude [m/yr]');
+			fielddisplay(self,'thickness_obs','observed thickness [m]');
+			fielddisplay(self,'surface_obs','observed surface elevation [m]');
 			disp('Available cost functions:');
 			disp('   101: SurfaceAbsVelMisfit');
 			disp('   102: SurfaceRelVelMisfit');
@@ -126,45 +126,45 @@
 			disp('   502: RheologyBbarAbsGradient');
 			disp('   503: ThicknessAbsGradient');
 		end % }}}
-		function marshall(obj,md,fid) % {{{
+		function marshall(self,md,fid) % {{{
 
 			yts=365.0*24.0*3600.0;
 
-			WriteData(fid,'object',obj,'class','inversion','fieldname','iscontrol','format','Boolean');
+			WriteData(fid,'object',self,'class','inversion','fieldname','iscontrol','format','Boolean');
 			WriteData(fid,'enum',InversionTypeEnum(),'data',2,'format','Integer');
-			if ~obj.iscontrol, return; end
-			WriteData(fid,'object',obj,'class','inversion','fieldname','incomplete_adjoint','format','Boolean');
-			WriteData(fid,'object',obj,'class','inversion','fieldname','control_scaling_factors','format','DoubleMat','mattype',3);
-			WriteData(fid,'object',obj,'class','inversion','fieldname','maxsteps','format','Integer');
-			WriteData(fid,'object',obj,'class','inversion','fieldname','maxiter','format','Integer');
-			WriteData(fid,'object',obj,'class','inversion','fieldname','dxmin','format','Double');
-			WriteData(fid,'object',obj,'class','inversion','fieldname','gttol','format','Double');
-			WriteData(fid,'object',obj,'class','inversion','fieldname','cost_functions_coefficients','format','DoubleMat','mattype',1);
-			WriteData(fid,'object',obj,'class','inversion','fieldname','min_parameters','format','DoubleMat','mattype',3);
-			WriteData(fid,'object',obj,'class','inversion','fieldname','max_parameters','format','DoubleMat','mattype',3);
-			WriteData(fid,'object',obj,'class','inversion','fieldname','vx_obs','format','DoubleMat','mattype',1,'scale',1./yts);
-			WriteData(fid,'object',obj,'class','inversion','fieldname','vy_obs','format','DoubleMat','mattype',1,'scale',1./yts);
-			WriteData(fid,'object',obj,'class','inversion','fieldname','vz_obs','format','DoubleMat','mattype',1,'scale',1./yts);
-			if(numel(obj.thickness_obs)==md.mesh.numberofelements),
+			if ~self.iscontrol, return; end
+			WriteData(fid,'object',self,'class','inversion','fieldname','incomplete_adjoint','format','Boolean');
+			WriteData(fid,'object',self,'class','inversion','fieldname','control_scaling_factors','format','DoubleMat','mattype',3);
+			WriteData(fid,'object',self,'class','inversion','fieldname','maxsteps','format','Integer');
+			WriteData(fid,'object',self,'class','inversion','fieldname','maxiter','format','Integer');
+			WriteData(fid,'object',self,'class','inversion','fieldname','dxmin','format','Double');
+			WriteData(fid,'object',self,'class','inversion','fieldname','gttol','format','Double');
+			WriteData(fid,'object',self,'class','inversion','fieldname','cost_functions_coefficients','format','DoubleMat','mattype',1);
+			WriteData(fid,'object',self,'class','inversion','fieldname','min_parameters','format','DoubleMat','mattype',3);
+			WriteData(fid,'object',self,'class','inversion','fieldname','max_parameters','format','DoubleMat','mattype',3);
+			WriteData(fid,'object',self,'class','inversion','fieldname','vx_obs','format','DoubleMat','mattype',1,'scale',1./yts);
+			WriteData(fid,'object',self,'class','inversion','fieldname','vy_obs','format','DoubleMat','mattype',1,'scale',1./yts);
+			WriteData(fid,'object',self,'class','inversion','fieldname','vz_obs','format','DoubleMat','mattype',1,'scale',1./yts);
+			if(numel(self.thickness_obs)==md.mesh.numberofelements),
 				mattype=2;
 			else
 				mattype=1;
 			end
-			WriteData(fid,'object',obj,'class','inversion','fieldname','thickness_obs','format','DoubleMat','mattype',mattype);
-			WriteData(fid,'object',obj,'class','inversion','fieldname','surface_obs','format','DoubleMat','mattype',mattype);
+			WriteData(fid,'object',self,'class','inversion','fieldname','thickness_obs','format','DoubleMat','mattype',mattype);
+			WriteData(fid,'object',self,'class','inversion','fieldname','surface_obs','format','DoubleMat','mattype',mattype);
 
 			%process control parameters
-			num_control_parameters=numel(obj.control_parameters);
+			num_control_parameters=numel(self.control_parameters);
 			data=zeros(1,num_control_parameters);
 			for i=1:num_control_parameters,
-				data(i)=StringToEnum(obj.control_parameters{i});
+				data(i)=StringToEnum(self.control_parameters{i});
 			end
 			WriteData(fid,'data',data,'enum',InversionControlParametersEnum(),'format','DoubleMat','mattype',3);
 			WriteData(fid,'data',num_control_parameters,'enum',InversionNumControlParametersEnum(),'format','Integer');
 
 			%process cost functions
-			num_cost_functions=size(obj.cost_functions,2);
-			data=marshallcostfunctions(obj.cost_functions);
+			num_cost_functions=size(self.cost_functions,2);
+			data=marshallcostfunctions(self.cost_functions);
 			WriteData(fid,'data',data,'enum',InversionCostFunctionsEnum(),'format','DoubleMat','mattype',3);
 			WriteData(fid,'data',num_cost_functions,'enum',InversionNumCostFunctionsEnum(),'format','Integer');
 		end % }}}
Index: ../trunk-jpl/src/m/classes/thermal.m
===================================================================
--- ../trunk-jpl/src/m/classes/thermal.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/thermal.m	(revision 19040)
@@ -17,12 +17,12 @@
 		requested_outputs = {};
 	end
 	methods
-        function createxml(obj,fid) % {{{
+        function createxml(self,fid) % {{{
             fprintf(fid, '<!-- thermal -->\n');            
                     
             % thermal solution parameters
             fprintf(fid,'%s\n%s\n%s\n','<frame key="1" label="Thermal solution parameters">','<section name="thermal" />');                    
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="spctemperature" type="',class(obj.spctemperature),'" default="',convert2str(obj.spctemperature),'">','     <section name="thermal" />','     <help> temperature constraints (NaN means no constraint) [K] </help>','  </parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="spctemperature" type="',class(self.spctemperature),'" default="',convert2str(self.spctemperature),'">','     <section name="thermal" />','     <help> temperature constraints (NaN means no constraint) [K] </help>','  </parameter>');
                 
             % penalty_threshold drop-down (0, 1, or 2)
             fprintf(fid,'%s\n%s\n%s\n%s\n','  <parameter key ="penalty_threshold" type="alternative"  optional="false">','     <section name="thermal" />','     <help> 0: no, 1: artificial_diffusivity, 2: SUPG </help>');
@@ -30,21 +30,21 @@
             fprintf(fid,'%s\n','       <option value="1" type="string" default="false"> </option>');
             fprintf(fid,'%s\n%s\n','       <option value="2" type="string" default="false"> </option>','</parameter>');
 
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="stabilization" type="',class(obj.stabilization),'" default="',convert2str(obj.stabilization),'">','     <section name="thermal" />','     <help> maximum number of non linear iterations </help>','  </parameter>');
-				fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="reltol" type="',class(obj.reltol),'" default="',convert2str(obj.reltol),'">','     <section name="steadystate" />','     <help> relative tolerance criterion [K] </help>','  </parameter>');
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="maxiter" type="',class(obj.maxiter),'" default="',convert2str(obj.maxiter),'">','     <section name="thermal" />','     <help> stabilize unstable thermal constraints that keep zigzagging after n iteration (default is 0, no stabilization) </help>','  </parameter>');
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="penalty_lock" type="',class(obj.penalty_lock),'" default="',convert2str(obj.penalty_lock),'">','     <section name="thermal" />','     <help> threshold to declare convergence of thermal solution (default is 0)  </help>','  </parameter>');
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="penalty_factor" type="',class(obj.penalty_factor),'" default="',convert2str(obj.penalty_factor),'">','     <section name="thermal" />','     <help> scaling exponent (default is 3) </help>','  </parameter>');
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="isenthalpy" type="',class(obj.isenthalpy),'" default="',convert2str(obj.isenthalpy),'">','     <section name="thermal" />','     <help> use an enthalpy formulation to include temperate ice (default is 0) </help>','  </parameter>');
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="isdynamicbasalspc" type="',class(obj.isdynamicbasalspc),'" default="',convert2str(obj.isdynamicbasalspc),'">','     <section name="thermal" />','     <help> enable dynamic setting of basal forcing. recommended for enthalpy formulation (default is 0)  </help>','  </parameter>');
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="requested_outputs" type="',class(obj.requested_outputs),'" default="',convert2str(obj.requested_outputs),'">','     <section name="thermal" />','     <help> additional outputs requested </help>','  </parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="stabilization" type="',class(self.stabilization),'" default="',convert2str(self.stabilization),'">','     <section name="thermal" />','     <help> maximum number of non linear iterations </help>','  </parameter>');
+				fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="reltol" type="',class(self.reltol),'" default="',convert2str(self.reltol),'">','     <section name="steadystate" />','     <help> relative tolerance criterion [K] </help>','  </parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="maxiter" type="',class(self.maxiter),'" default="',convert2str(self.maxiter),'">','     <section name="thermal" />','     <help> stabilize unstable thermal constraints that keep zigzagging after n iteration (default is 0, no stabilization) </help>','  </parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="penalty_lock" type="',class(self.penalty_lock),'" default="',convert2str(self.penalty_lock),'">','     <section name="thermal" />','     <help> threshold to declare convergence of thermal solution (default is 0)  </help>','  </parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="penalty_factor" type="',class(self.penalty_factor),'" default="',convert2str(self.penalty_factor),'">','     <section name="thermal" />','     <help> scaling exponent (default is 3) </help>','  </parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="isenthalpy" type="',class(self.isenthalpy),'" default="',convert2str(self.isenthalpy),'">','     <section name="thermal" />','     <help> use an enthalpy formulation to include temperate ice (default is 0) </help>','  </parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="isdynamicbasalspc" type="',class(self.isdynamicbasalspc),'" default="',convert2str(self.isdynamicbasalspc),'">','     <section name="thermal" />','     <help> enable dynamic setting of basal forcing. recommended for enthalpy formulation (default is 0)  </help>','  </parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="requested_outputs" type="',class(self.requested_outputs),'" default="',convert2str(self.requested_outputs),'">','     <section name="thermal" />','     <help> additional outputs requested </help>','  </parameter>');
             fprintf(fid,'%s\n%s\n','</frame>');    
         
         end % }}}
-		function obj = thermal(varargin) % {{{
+		function self = thermal(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				otherwise
 					error('constructor not supported');
 			end
@@ -58,33 +58,33 @@
 			end
 
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 			%Number of unstable constraints acceptable
-			obj.penalty_threshold=0;
+			self.penalty_threshold=0;
 
 			%Type of stabilization used
-			obj.stabilization=1;
+			self.stabilization=1;
 
 			%Relative tolerance for the enthalpy convergence
-			obj.reltol=0.01;
+			self.reltol=0.01;
 
 			%Maximum number of iterations
-			obj.maxiter=100;
+			self.maxiter=100;
 
 			%factor used to compute the values of the penalties: kappa=max(stiffness matrix)*10^penalty_factor
-			obj.penalty_factor=3;
+			self.penalty_factor=3;
 
 			%Should we use cold ice (default) or enthalpy formulation
-			obj.isenthalpy=0;
+			self.isenthalpy=0;
 
 			%will basal boundary conditions be set dynamically
-			obj.isdynamicbasalspc=0;
+			self.isdynamicbasalspc=0;
 
 			%default output
-			obj.requested_outputs={'default'};
+			self.requested_outputs={'default'};
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 			%Early return
 			if (~ismember(ThermalAnalysisEnum(),analyses) & ~ismember(EnthalpyAnalysisEnum(),analyses)) | (solution==TransientSolutionEnum() & md.transient.isthermal==0), return; end
@@ -107,38 +107,38 @@
 
 		 md = checkfield(md,'fieldname','thermal.requested_outputs','stringrow',1);
     end % }}} 
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   Thermal solution parameters:'));
 
-			fielddisplay(obj,'spctemperature','temperature constraints (NaN means no constraint) [K]');
-			fielddisplay(obj,'stabilization','0: no, 1: artificial_diffusivity, 2: SUPG');
-			fielddisplay(obj,'reltol','relative tolerance convergence criterion for enthalpy');
-			fielddisplay(obj,'maxiter','maximum number of non linear iterations');
-			fielddisplay(obj,'penalty_lock','stabilize unstable thermal constraints that keep zigzagging after n iteration (default is 0, no stabilization)');
-			fielddisplay(obj,'penalty_threshold','threshold to declare convergence of thermal solution (default is 0)');
-			fielddisplay(obj,'penalty_factor','scaling exponent (default is 3)');
-			fielddisplay(obj,'isenthalpy','use an enthalpy formulation to include temperate ice (default is 0)');
-			fielddisplay(obj,'isdynamicbasalspc',['enable dynamic setting of basal forcing. required for enthalpy formulation (default is 0)']);
-			fielddisplay(obj,'requested_outputs','additional outputs requested');
+			fielddisplay(self,'spctemperature','temperature constraints (NaN means no constraint) [K]');
+			fielddisplay(self,'stabilization','0: no, 1: artificial_diffusivity, 2: SUPG');
+			fielddisplay(self,'reltol','relative tolerance convergence criterion for enthalpy');
+			fielddisplay(self,'maxiter','maximum number of non linear iterations');
+			fielddisplay(self,'penalty_lock','stabilize unstable thermal constraints that keep zigzagging after n iteration (default is 0, no stabilization)');
+			fielddisplay(self,'penalty_threshold','threshold to declare convergence of thermal solution (default is 0)');
+			fielddisplay(self,'penalty_factor','scaling exponent (default is 3)');
+			fielddisplay(self,'isenthalpy','use an enthalpy formulation to include temperate ice (default is 0)');
+			fielddisplay(self,'isdynamicbasalspc',['enable dynamic setting of basal forcing. required for enthalpy formulation (default is 0)']);
+			fielddisplay(self,'requested_outputs','additional outputs requested');
 
 		end % }}}
-		function marshall(obj,md,fid) % {{{
-			WriteData(fid,'object',obj,'fieldname','spctemperature','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
-			WriteData(fid,'object',obj,'fieldname','penalty_threshold','format','Integer');
-			WriteData(fid,'object',obj,'fieldname','stabilization','format','Integer');
-			WriteData(fid,'object',obj,'fieldname','reltol','format','Double');
-			WriteData(fid,'object',obj,'fieldname','maxiter','format','Integer');
-			WriteData(fid,'object',obj,'fieldname','penalty_lock','format','Integer');
-			WriteData(fid,'object',obj,'fieldname','penalty_factor','format','Double');
-			WriteData(fid,'object',obj,'fieldname','isenthalpy','format','Boolean');
-			WriteData(fid,'object',obj,'fieldname','isdynamicbasalspc','format','Boolean');
+		function marshall(self,md,fid) % {{{
+			WriteData(fid,'object',self,'fieldname','spctemperature','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
+			WriteData(fid,'object',self,'fieldname','penalty_threshold','format','Integer');
+			WriteData(fid,'object',self,'fieldname','stabilization','format','Integer');
+			WriteData(fid,'object',self,'fieldname','reltol','format','Double');
+			WriteData(fid,'object',self,'fieldname','maxiter','format','Integer');
+			WriteData(fid,'object',self,'fieldname','penalty_lock','format','Integer');
+			WriteData(fid,'object',self,'fieldname','penalty_factor','format','Double');
+			WriteData(fid,'object',self,'fieldname','isenthalpy','format','Boolean');
+			WriteData(fid,'object',self,'fieldname','isdynamicbasalspc','format','Boolean');
 
 			%process requested outputs
-			outputs = obj.requested_outputs;
+			outputs = self.requested_outputs;
 			pos  = find(ismember(outputs,'default'));
 			if ~isempty(pos),
 				outputs(pos) = [];                         %remove 'default' from outputs
-				outputs      = [outputs defaultoutputs(obj,md)]; %add defaults
+				outputs      = [outputs defaultoutputs(self,md)]; %add defaults
 			end
 			WriteData(fid,'data',outputs,'enum',ThermalRequestedOutputsEnum(),'format','StringArray');
         	end % }}}
Index: ../trunk-jpl/src/m/classes/miscellaneous.m
===================================================================
--- ../trunk-jpl/src/m/classes/miscellaneous.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/miscellaneous.m	(revision 19040)
@@ -10,43 +10,43 @@
 		dummy = struct();
 	end
 	methods
-        function createxml(obj,fid) % {{{
+        function createxml(self,fid) % {{{
             fprintf(fid, '<!-- miscellaneous -->\n');            
                     
             % miscellaneous solution parameters
             fprintf(fid,'%s\n%s\n%s\n','<frame key="1" label="miscellaneous parameters">','<section name="miscellaneous" />');                    
-                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="notes" type="',class(obj.notes),'" default="',convert2str(obj.notes),'">','     <section name="miscellaneous" />','     <help> notes in a cell of strings </help>','  </parameter>');
-                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="name" type="',class(obj.name),'" default="',convert2str(obj.name),'">','     <section name="miscellaneous" />','     <help> model name </help>','  </parameter>');
-                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="dummy" type="',class(obj.dummy),'" default="',convert2str(obj.dummy),'">','     <section name="miscellaneous" />','     <help> empty field to store some data </help>','  </parameter>');
+                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="notes" type="',class(self.notes),'" default="',convert2str(self.notes),'">','     <section name="miscellaneous" />','     <help> notes in a cell of strings </help>','  </parameter>');
+                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="name" type="',class(self.name),'" default="',convert2str(self.name),'">','     <section name="miscellaneous" />','     <help> model name </help>','  </parameter>');
+                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="dummy" type="',class(self.dummy),'" default="',convert2str(self.dummy),'">','     <section name="miscellaneous" />','     <help> empty field to store some data </help>','  </parameter>');
             fprintf(fid,'%s\n%s\n','</frame>');    
         
         end % }}}        
-		function obj = miscellaneous(varargin) % {{{
+		function self = miscellaneous(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 			md = checkfield(md,'fieldname','miscellaneous.name','empty',1);
 
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   miscellaneous parameters:'));
 
-			fielddisplay(obj,'notes','notes in a cell of strings');
-			fielddisplay(obj,'name','model name');
-			fielddisplay(obj,'dummy','empty field to store some data');
+			fielddisplay(self,'notes','notes in a cell of strings');
+			fielddisplay(self,'name','model name');
+			fielddisplay(self,'dummy','empty field to store some data');
 
 		end % }}}
-		function marshall(obj,md,fid) % {{{
-			WriteData(fid,'object',obj,'fieldname','name','format','String');
+		function marshall(self,md,fid) % {{{
+			WriteData(fid,'object',self,'fieldname','name','format','String');
 		end % }}}
 	end
 end
Index: ../trunk-jpl/src/m/classes/mesh3dtetras.m
===================================================================
--- ../trunk-jpl/src/m/classes/mesh3dtetras.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/mesh3dtetras.m	(revision 19040)
@@ -61,56 +61,56 @@
 		end% }}}
 	end
 	methods
-		function createxml(obj,fid) % {{{
+		function createxml(self,fid) % {{{
 			fprintf(fid, '<!-- 3D Tetra Mesh -->\n');
 
 			% Elements and verticies of the original 2d mesh
 			fprintf(fid,'%s\n%s\n%s\n','       <frame key="1" label="Elements and vertices of the orginal 2d mesh">','       <section name="mesh3dprisms" />');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','          <parameter key ="numberofelements2d" type="',class(obj.numberofelements2d),'" default="',convert2str(obj.numberofelements2d),'">','              <help> number of elements </help>','          </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','          <parameter key ="numberofvertices2d" type="',class(obj.numberofvertices2d),'" default="',convert2str(obj.numberofvertices2d),'">','              <help> number of vertices </help>','          </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','          <parameter key ="elements2d" type="',class(obj.elements2d),'" default="',convert2str(obj.elements2d),'">','              <help> vertex indices of the mesh elements </help>','          </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="x2d" type="',class(obj.x2d),'" default="',convert2str(obj.x2d),'">','     <section name="mesh3dprisms" />','     <help> vertices x coordinate [m] </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="y2d" type="',class(obj.y2d),'" default="',convert2str(obj.y2d),'">','     <section name="mesh3dprisms" />','     <help> vertices y coordinate [m] </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','          <parameter key ="numberofelements2d" type="',class(self.numberofelements2d),'" default="',convert2str(self.numberofelements2d),'">','              <help> number of elements </help>','          </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','          <parameter key ="numberofvertices2d" type="',class(self.numberofvertices2d),'" default="',convert2str(self.numberofvertices2d),'">','              <help> number of vertices </help>','          </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','          <parameter key ="elements2d" type="',class(self.elements2d),'" default="',convert2str(self.elements2d),'">','              <help> vertex indices of the mesh elements </help>','          </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="x2d" type="',class(self.x2d),'" default="',convert2str(self.x2d),'">','     <section name="mesh3dprisms" />','     <help> vertices x coordinate [m] </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="y2d" type="',class(self.y2d),'" default="',convert2str(self.y2d),'">','     <section name="mesh3dprisms" />','     <help> vertices y coordinate [m] </help>','  </parameter>');
 			fprintf(fid,'%s\n%s\n','       </frame>');
 
 			% Elements and vertices of the extruded 3d mesh
 			fprintf(fid,'%s\n%s\n%s\n','       <frame key="2" label="Elements and vertices of the orginal 3d mesh">','       <section name="mesh3dprisms" />');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','          <parameter key ="numberofelements" type="',class(obj.numberofelements),'" default="',convert2str(obj.numberofelements),'">','              <help> number of elements </help>','          </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','          <parameter key ="numberofvertices" type="',class(obj.numberofvertices),'" default="',convert2str(obj.numberofvertices),'">','              <help> number of vertices </help>','          </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','          <parameter key ="elements" type="',class(obj.elements),'" default="',convert2str(obj.elements),'">','              <help> vertex indices of the mesh elements </help>','          </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="x" type="',class(obj.x),'" default="',convert2str(obj.x),'">','     <section name="mesh3dprisms" />','     <help> vertices x coordinate [m] </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="y" type="',class(obj.y),'" default="',convert2str(obj.y),'">','     <section name="mesh3dprisms" />','     <help> vertices y coordinate [m] </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="z" type="',class(obj.y),'" default="',convert2str(obj.y),'">','     <section name="mesh3dprisms" />','     <help> vertices z coordinate [m] </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','          <parameter key ="numberofelements" type="',class(self.numberofelements),'" default="',convert2str(self.numberofelements),'">','              <help> number of elements </help>','          </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','          <parameter key ="numberofvertices" type="',class(self.numberofvertices),'" default="',convert2str(self.numberofvertices),'">','              <help> number of vertices </help>','          </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','          <parameter key ="elements" type="',class(self.elements),'" default="',convert2str(self.elements),'">','              <help> vertex indices of the mesh elements </help>','          </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="x" type="',class(self.x),'" default="',convert2str(self.x),'">','     <section name="mesh3dprisms" />','     <help> vertices x coordinate [m] </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="y" type="',class(self.y),'" default="',convert2str(self.y),'">','     <section name="mesh3dprisms" />','     <help> vertices y coordinate [m] </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="z" type="',class(self.y),'" default="',convert2str(self.y),'">','     <section name="mesh3dprisms" />','     <help> vertices z coordinate [m] </help>','  </parameter>');
 			fprintf(fid,'%s\n%s\n','       </frame>');
 
 			% properties
 			fprintf(fid,'%s\n%s\n%s\n','<frame key="3" label="Properties">','<section name="mesh3dprisms" />');             
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="numberoflayers" type="',class(obj.numberoflayers),'" default="',convert2str(obj.numberoflayers),'">','     <section name="mesh3dprisms" />','     <help> number of extrusion layers </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="vertexonbase" type="',class(obj.vertexonbase),'" default="',convert2str(obj.vertexonbase),'">','     <section name="mesh3dprisms" />','     <help> lower vertices flags list </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="elementontbase" type="',class(obj.elementontbase),'" default="',convert2str(obj.elementontbase),'">','     <section name="mesh3dprisms" />','     <help> lower elements flags list </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="vertexonsurface" type="',class(obj.vertexonsurface),'" default="',convert2str(obj.vertexonsurface),'">','     <section name="mesh3dprisms" />','     <help> upper vertices flags list </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="elementontsurface" type="',class(obj.elementontsurface),'" default="',convert2str(obj.elementontsurface),'">','     <section name="mesh3dprisms" />','     <help> upper elements flags list </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="uppervertex" type="',class(obj.uppervertex),'" default="',convert2str(obj.uppervertex),'">','     <section name="mesh3dprisms" />','     <help> upper vertex list (NaN for vertex on the upper surface) </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="upperelements" type="',class(obj.upperelements),'" default="',convert2str(obj.upperelements),'">','     <section name="mesh3dprisms" />','     <help> upper element list (NaN for element on the upper layer) </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="lowervertex" type="',class(obj.lowervertex),'" default="',convert2str(obj.lowervertex),'">','     <section name="mesh3dprisms" />','     <help> lower vertex list (NaN for vertex on the lower surface) </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="lowerelements" type="',class(obj.lowerelements),'" default="',convert2str(obj.lowerelements),'">','     <section name="mesh3dprisms" />','     <help> element list (NaN for element on the lower layer) </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="vertexonboundary" type="',class(obj.vertexonboundary),'" default="',convert2str(obj.vertexonboundary),'">','     <section name="mesh3dprisms" />','     <help> vertices on the boundary of the domain flag list </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="vertexconnectivity" type="',class(obj.vertexconnectivity),'" default="',convert2str(obj.vertexconnectivity),'">','     <section name="mesh3dprisms" />','     <help> list of vertices connected to vertex_i </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="elementconnectivity" type="',class(obj.elementconnectivity),'" default="',convert2str(obj.elementconnectivity),'">','     <section name="mesh3dprisms" />','     <help> average number of vertices connected to one vertex </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="average_vertex_connectivity" type="',class(obj.average_vertex_connectivity),'" default="',convert2str(obj.average_vertex_connectivity),'">','     <section name="mesh3dprisms" />','     <help> average number of vertices connected to one vertex </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="numberoflayers" type="',class(self.numberoflayers),'" default="',convert2str(self.numberoflayers),'">','     <section name="mesh3dprisms" />','     <help> number of extrusion layers </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="vertexonbase" type="',class(self.vertexonbase),'" default="',convert2str(self.vertexonbase),'">','     <section name="mesh3dprisms" />','     <help> lower vertices flags list </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="elementontbase" type="',class(self.elementontbase),'" default="',convert2str(self.elementontbase),'">','     <section name="mesh3dprisms" />','     <help> lower elements flags list </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="vertexonsurface" type="',class(self.vertexonsurface),'" default="',convert2str(self.vertexonsurface),'">','     <section name="mesh3dprisms" />','     <help> upper vertices flags list </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="elementontsurface" type="',class(self.elementontsurface),'" default="',convert2str(self.elementontsurface),'">','     <section name="mesh3dprisms" />','     <help> upper elements flags list </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="uppervertex" type="',class(self.uppervertex),'" default="',convert2str(self.uppervertex),'">','     <section name="mesh3dprisms" />','     <help> upper vertex list (NaN for vertex on the upper surface) </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="upperelements" type="',class(self.upperelements),'" default="',convert2str(self.upperelements),'">','     <section name="mesh3dprisms" />','     <help> upper element list (NaN for element on the upper layer) </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="lowervertex" type="',class(self.lowervertex),'" default="',convert2str(self.lowervertex),'">','     <section name="mesh3dprisms" />','     <help> lower vertex list (NaN for vertex on the lower surface) </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="lowerelements" type="',class(self.lowerelements),'" default="',convert2str(self.lowerelements),'">','     <section name="mesh3dprisms" />','     <help> element list (NaN for element on the lower layer) </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="vertexonboundary" type="',class(self.vertexonboundary),'" default="',convert2str(self.vertexonboundary),'">','     <section name="mesh3dprisms" />','     <help> vertices on the boundary of the domain flag list </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="vertexconnectivity" type="',class(self.vertexconnectivity),'" default="',convert2str(self.vertexconnectivity),'">','     <section name="mesh3dprisms" />','     <help> list of vertices connected to vertex_i </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="elementconnectivity" type="',class(self.elementconnectivity),'" default="',convert2str(self.elementconnectivity),'">','     <section name="mesh3dprisms" />','     <help> average number of vertices connected to one vertex </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="average_vertex_connectivity" type="',class(self.average_vertex_connectivity),'" default="',convert2str(self.average_vertex_connectivity),'">','     <section name="mesh3dprisms" />','     <help> average number of vertices connected to one vertex </help>','  </parameter>');
 			fprintf(fid,'%s\n%s\n','</frame>');
 
 			% Extracted model
 			fprintf(fid,'%s\n%s\n%s\n','<frame key="4" label="Extracted Model">','<section name="mesh3dprisms" />'); 
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="extractedvertices" type="',class(obj.extractedvertices),'" default="',convert2str(obj.extractedvertices),'">','     <section name="mesh3dprisms" />','     <help> vertices extracted from the model </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="extractedelements" type="',class(obj.extractedelements),'" default="',convert2str(obj.extractedelements),'">','     <section name="mesh3dprisms" />','     <help> elements extracted from the model </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="extractedvertices" type="',class(self.extractedvertices),'" default="',convert2str(self.extractedvertices),'">','     <section name="mesh3dprisms" />','     <help> vertices extracted from the model </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="extractedelements" type="',class(self.extractedelements),'" default="',convert2str(self.extractedelements),'">','     <section name="mesh3dprisms" />','     <help> elements extracted from the model </help>','  </parameter>');
 			fprintf(fid,'%s\n%s\n','</frame>');
 
 			% Projection
 			fprintf(fid,'%s\n%s\n%s\n','<frame key="5" label="Projection">','<section name="mesh3dprisms" />'); 
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="lat" type="',class(obj.lat),'" default="',convert2str(obj.lat),'">','     <section name="mesh3dprisms" />','     <help> vertices latitude [degrees] </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="long" type="',class(obj.long),'" default="',convert2str(obj.long),'">','     <section name="mesh3dprisms" />','     <help> verticies longitude [degrees] </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','  <parameter key ="epsg" type="',class(obj.epsg),'" default="',convert2str(obj.epsg),'">','     <section name="mesh3dprisms" />','     <help> Indicate epsg ''n'' or ''s'' </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="lat" type="',class(self.lat),'" default="',convert2str(self.lat),'">','     <section name="mesh3dprisms" />','     <help> vertices latitude [degrees] </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="long" type="',class(self.long),'" default="',convert2str(self.long),'">','     <section name="mesh3dprisms" />','     <help> verticies longitude [degrees] </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','  <parameter key ="epsg" type="',class(self.epsg),'" default="',convert2str(self.epsg),'">','     <section name="mesh3dprisms" />','     <help> Indicate epsg ''n'' or ''s'' </help>','  </parameter>');
 			fprintf(fid,'%s\n%s\n','</frame>');
 
 		end % }}}cd
@@ -132,16 +132,16 @@
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 			%the connectivity is the averaged number of nodes linked to a
 			%given node through an edge. This connectivity is used to initially
 			%allocate memory to the stiffness matrix. A value of 16 seems to
 			%give a good memory/time ration. This value can be checked in
 			%trunk/test/Miscellaneous/runme.m
-			obj.average_vertex_connectivity=25;
+			self.average_vertex_connectivity=25;
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 			md = checkfield(md,'fieldname','mesh.x','NaN',1,'size',[md.mesh.numberofvertices 1]);
 			md = checkfield(md,'fieldname','mesh.y','NaN',1,'size',[md.mesh.numberofvertices 1]);
@@ -160,74 +160,74 @@
 			md = checkfield(md,'fieldname','mesh.z','<=',md.geometry.surface+10^-10,'message','''mesh.z'' higher than surface elevation');
 			md = checkfield(md,'fieldname','mesh.average_vertex_connectivity','>=',24,'message','''mesh.average_vertex_connectivity'' should be at least 24 in 3d');
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   3D tetra Mesh:')); 
 
 			disp(sprintf('\n      Elements and vertices of the original 2d mesh:'));
-			fielddisplay(obj,'numberofelements2d','number of elements');
-			fielddisplay(obj,'numberofvertices2d','number of vertices');
-			fielddisplay(obj,'elements2d','vertex indices of the mesh elements');
-			fielddisplay(obj,'x2d','vertices x coordinate [m]');
-			fielddisplay(obj,'y2d','vertices y coordinate [m]');
+			fielddisplay(self,'numberofelements2d','number of elements');
+			fielddisplay(self,'numberofvertices2d','number of vertices');
+			fielddisplay(self,'elements2d','vertex indices of the mesh elements');
+			fielddisplay(self,'x2d','vertices x coordinate [m]');
+			fielddisplay(self,'y2d','vertices y coordinate [m]');
 
 			disp(sprintf('\n      Elements and vertices of the extruded 3d mesh:'));
-			fielddisplay(obj,'numberofelements','number of elements');
-			fielddisplay(obj,'numberofvertices','number of vertices');
-			fielddisplay(obj,'elements','vertex indices of the mesh elements');
-			fielddisplay(obj,'x','vertices x coordinate [m]');
-			fielddisplay(obj,'y','vertices y coordinate [m]');
-			fielddisplay(obj,'z','vertices z coordinate [m]');
+			fielddisplay(self,'numberofelements','number of elements');
+			fielddisplay(self,'numberofvertices','number of vertices');
+			fielddisplay(self,'elements','vertex indices of the mesh elements');
+			fielddisplay(self,'x','vertices x coordinate [m]');
+			fielddisplay(self,'y','vertices y coordinate [m]');
+			fielddisplay(self,'z','vertices z coordinate [m]');
 
 			disp(sprintf('\n      Properties:'));
-			fielddisplay(obj,'numberoflayers','number of extrusion layers');
-			fielddisplay(obj,'vertexonbase','lower vertices flags list');
-			fielddisplay(obj,'vertexonsurface','upper vertices flags list');
-			fielddisplay(obj,'uppervertex','upper vertex list (NaN for vertex on the upper surface)');
-			fielddisplay(obj,'upperelements','upper element list (NaN for element on the upper layer)');
-			fielddisplay(obj,'lowervertex','lower vertex list (NaN for vertex on the lower surface)');
-			fielddisplay(obj,'lowerelements','lower element list (NaN for element on the lower layer');
-			fielddisplay(obj,'vertexonboundary','vertices on the boundary of the domain flag list');
+			fielddisplay(self,'numberoflayers','number of extrusion layers');
+			fielddisplay(self,'vertexonbase','lower vertices flags list');
+			fielddisplay(self,'vertexonsurface','upper vertices flags list');
+			fielddisplay(self,'uppervertex','upper vertex list (NaN for vertex on the upper surface)');
+			fielddisplay(self,'upperelements','upper element list (NaN for element on the upper layer)');
+			fielddisplay(self,'lowervertex','lower vertex list (NaN for vertex on the lower surface)');
+			fielddisplay(self,'lowerelements','lower element list (NaN for element on the lower layer');
+			fielddisplay(self,'vertexonboundary','vertices on the boundary of the domain flag list');
 
-			fielddisplay(obj,'vertexconnectivity','list of vertices connected to vertex_i');
-			fielddisplay(obj,'elementconnectivity','list of vertices connected to element_i');
-			fielddisplay(obj,'average_vertex_connectivity','average number of vertices connected to one vertex');
+			fielddisplay(self,'vertexconnectivity','list of vertices connected to vertex_i');
+			fielddisplay(self,'elementconnectivity','list of vertices connected to element_i');
+			fielddisplay(self,'average_vertex_connectivity','average number of vertices connected to one vertex');
 
 			disp(sprintf('\n      Extracted model:'));
-			fielddisplay(obj,'extractedvertices','vertices extracted from the model');
-			fielddisplay(obj,'extractedelements','elements extracted from the model');
+			fielddisplay(self,'extractedvertices','vertices extracted from the model');
+			fielddisplay(self,'extractedelements','elements extracted from the model');
 
 			disp(sprintf('\n      Projection:'));
-			fielddisplay(obj,'lat','vertices latitude [degrees]');
-			fielddisplay(obj,'long','vertices longitude [degrees]');
-			fielddisplay(obj,'epsg','EPSG code (ex: 3413 for UPS Greenland, 3031 for UPS Antarctica)');
+			fielddisplay(self,'lat','vertices latitude [degrees]');
+			fielddisplay(self,'long','vertices longitude [degrees]');
+			fielddisplay(self,'epsg','EPSG code (ex: 3413 for UPS Greenland, 3031 for UPS Antarctica)');
 		end % }}}
-		function marshall(obj,md,fid) % {{{
-			WriteData(fid,'enum',DomainTypeEnum(),'data',StringToEnum(['Domain' domaintype(obj)]),'format','Integer');
-			WriteData(fid,'enum',DomainDimensionEnum(),'data',dimension(obj),'format','Integer');
-			WriteData(fid,'enum',MeshElementtypeEnum(),'data',StringToEnum(elementtype(obj)),'format','Integer');
-			WriteData(fid,'object',obj,'class','mesh','fieldname','x','format','DoubleMat','mattype',1);
-			WriteData(fid,'object',obj,'class','mesh','fieldname','y','format','DoubleMat','mattype',1);
-			WriteData(fid,'object',obj,'class','mesh','fieldname','z','format','DoubleMat','mattype',1);
-			WriteData(fid,'object',obj,'class','mesh','fieldname','elements','format','DoubleMat','mattype',2);
-			WriteData(fid,'object',obj,'class','mesh','fieldname','numberoflayers','format','Integer');
-			WriteData(fid,'object',obj,'class','mesh','fieldname','numberofelements','format','Integer');
-			WriteData(fid,'object',obj,'class','mesh','fieldname','numberofvertices','format','Integer');
-			WriteData(fid,'object',obj,'class','mesh','fieldname','vertexonbase','format','BooleanMat','mattype',1);
-			WriteData(fid,'object',obj,'class','mesh','fieldname','vertexonsurface','format','BooleanMat','mattype',1);
-			WriteData(fid,'object',obj,'class','mesh','fieldname','lowerelements','format','DoubleMat','mattype',2);
-			WriteData(fid,'object',obj,'class','mesh','fieldname','upperelements','format','DoubleMat','mattype',2);
-			WriteData(fid,'object',obj,'class','mesh','fieldname','average_vertex_connectivity','format','Integer');
-			WriteData(fid,'object',obj,'class','mesh','fieldname','elements2d','format','DoubleMat','mattype',3);
-			WriteData(fid,'object',obj,'class','mesh','fieldname','numberofvertices2d','format','Integer');
-			WriteData(fid,'object',obj,'class','mesh','fieldname','numberofelements2d','format','Integer');
+		function marshall(self,md,fid) % {{{
+			WriteData(fid,'enum',DomainTypeEnum(),'data',StringToEnum(['Domain' domaintype(self)]),'format','Integer');
+			WriteData(fid,'enum',DomainDimensionEnum(),'data',dimension(self),'format','Integer');
+			WriteData(fid,'enum',MeshElementtypeEnum(),'data',StringToEnum(elementtype(self)),'format','Integer');
+			WriteData(fid,'object',self,'class','mesh','fieldname','x','format','DoubleMat','mattype',1);
+			WriteData(fid,'object',self,'class','mesh','fieldname','y','format','DoubleMat','mattype',1);
+			WriteData(fid,'object',self,'class','mesh','fieldname','z','format','DoubleMat','mattype',1);
+			WriteData(fid,'object',self,'class','mesh','fieldname','elements','format','DoubleMat','mattype',2);
+			WriteData(fid,'object',self,'class','mesh','fieldname','numberoflayers','format','Integer');
+			WriteData(fid,'object',self,'class','mesh','fieldname','numberofelements','format','Integer');
+			WriteData(fid,'object',self,'class','mesh','fieldname','numberofvertices','format','Integer');
+			WriteData(fid,'object',self,'class','mesh','fieldname','vertexonbase','format','BooleanMat','mattype',1);
+			WriteData(fid,'object',self,'class','mesh','fieldname','vertexonsurface','format','BooleanMat','mattype',1);
+			WriteData(fid,'object',self,'class','mesh','fieldname','lowerelements','format','DoubleMat','mattype',2);
+			WriteData(fid,'object',self,'class','mesh','fieldname','upperelements','format','DoubleMat','mattype',2);
+			WriteData(fid,'object',self,'class','mesh','fieldname','average_vertex_connectivity','format','Integer');
+			WriteData(fid,'object',self,'class','mesh','fieldname','elements2d','format','DoubleMat','mattype',3);
+			WriteData(fid,'object',self,'class','mesh','fieldname','numberofvertices2d','format','Integer');
+			WriteData(fid,'object',self,'class','mesh','fieldname','numberofelements2d','format','Integer');
 		end % }}}
-		function t = domaintype(obj) % {{{
+		function t = domaintype(self) % {{{
 			t = '3D';
 		end % }}}
-		function d = dimension(obj) % {{{
+		function d = dimension(self) % {{{
 			d = 3;
 		end % }}}
-		function s = elementtype(obj) % {{{
+		function s = elementtype(self) % {{{
 			s = 'Tetra';
 		end % }}}
 	end
Index: ../trunk-jpl/src/m/classes/linearbasalforcings.m
===================================================================
--- ../trunk-jpl/src/m/classes/linearbasalforcings.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/linearbasalforcings.m	(revision 19040)
@@ -12,17 +12,17 @@
 		geothermalflux            = NaN;
 	end
 	methods
-     function createxml(obj,fid) % {{{
+     function createxml(self,fid) % {{{
             fprintf(fid, '\n\n');
             fprintf(fid, '%s\n', '<!-- basalforcings -->');
-			 fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="melting_rate" type="',            class(obj.melting_rate),'" default="',              num2str(obj.melting_rate),'">',              '     <section name="basalforcings" />','     <help> basal melting rate (positive if melting) [m/yr] </help>','</parameter>');
-             fprintf(fid,'%s%s%s%s%s\n%s\n%s\n',        '<parameter key ="geothermalflux" type="',          class(obj.geothermalflux),'" default="',            num2str(obj.geothermalflux),'">',            '     <section name="basalforcings" />','     <help> geothermal heat flux [W/m^2] </help>','</parameter>');
+			 fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="melting_rate" type="',            class(self.melting_rate),'" default="',              num2str(self.melting_rate),'">',              '     <section name="basalforcings" />','     <help> basal melting rate (positive if melting) [m/yr] </help>','</parameter>');
+             fprintf(fid,'%s%s%s%s%s\n%s\n%s\n',        '<parameter key ="geothermalflux" type="',          class(self.geothermalflux),'" default="',            num2str(self.geothermalflux),'">',            '     <section name="basalforcings" />','     <help> geothermal heat flux [W/m^2] </help>','</parameter>');
              
         end % }}}
-		function obj = linearbasalforcings(varargin) % {{{
+		function self = linearbasalforcings(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				case 1
 					obj=structtoobj(linearbasalforcings(),varargin{1});
 				otherwise
@@ -37,15 +37,15 @@
 			end
 
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 			%default values for melting parameterization
-			obj.deepwater_melting_rate = 50;
-			obj.deepwater_elevation    = -800;
-			obj.upperwater_elevation   = -400;
+			self.deepwater_melting_rate = 50;
+			self.deepwater_elevation    = -800;
+			self.upperwater_elevation   = -400;
 
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 			if ismember(MasstransportAnalysisEnum(),analyses) & ~(solution==TransientSolutionEnum() & md.transient.ismasstransport==0),
 				md = checkfield(md,'fieldname','basalforcings.groundedice_melting_rate','NaN',1,'timeseries',1);
@@ -67,17 +67,17 @@
 				md = checkfield(md,'fieldname','basalforcings.geothermalflux','NaN',1,'timeseries',1,'>=',0);
 			end
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   basal forcings parameters:'));
 
-			fielddisplay(obj,'groundedice_melting_rate','basal melting rate (positive if melting) [m/yr]');
-			fielddisplay(obj,'deepwater_melting_rate','basal melting rate (positive if melting applied for floating ice whith base < deepwater_elevation) [m/yr]');
-			fielddisplay(obj,'deepwater_elevation','elevation of ocean deepwater [m]');
-			fielddisplay(obj,'upperwater_elevation','elevation of ocean upperwater [m]');
-			fielddisplay(obj,'geothermalflux','geothermal heat flux [W/m^2]');
+			fielddisplay(self,'groundedice_melting_rate','basal melting rate (positive if melting) [m/yr]');
+			fielddisplay(self,'deepwater_melting_rate','basal melting rate (positive if melting applied for floating ice whith base < deepwater_elevation) [m/yr]');
+			fielddisplay(self,'deepwater_elevation','elevation of ocean deepwater [m]');
+			fielddisplay(self,'upperwater_elevation','elevation of ocean upperwater [m]');
+			fielddisplay(self,'geothermalflux','geothermal heat flux [W/m^2]');
 
 		end % }}}
-		function marshall(obj,md,fid) % {{{
+		function marshall(self,md,fid) % {{{
 
 			yts=365.0*24.0*3600.0;
 
@@ -87,11 +87,11 @@
 			floatingice_melting_rate(pos)=md.basalforcings.deepwater_melting_rate*(md.geometry.base(pos)-md.basalforcings.upperwater_elevation)/(md.basalforcings.deepwater_elevation-md.basalforcings.upperwater_elevation);
 			WriteData(fid,'enum',BasalforcingsEnum(),'data',LinearFloatingMeltRateEnum(),'format','Integer');
 			WriteData(fid,'data',floatingice_melting_rate,'format','DoubleMat','enum',BasalforcingsFloatingiceMeltingRateEnum(),'mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1)
-			WriteData(fid,'object',obj,'fieldname','groundedice_melting_rate','format','DoubleMat','enum',BasalforcingsGroundediceMeltingRateEnum(),'mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1)
-			WriteData(fid,'object',obj,'fieldname','geothermalflux','enum',BasalforcingsGeothermalfluxEnum(),'format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
-			WriteData(fid,'object',obj,'fieldname','deepwater_melting_rate','format','Double','enum',BasalforcingsDeepwaterMeltingRateEnum(),'scale',1./yts)
-			WriteData(fid,'object',obj,'fieldname','deepwater_elevation','format','Double','enum',BasalforcingsDeepwaterElevationEnum())
-			WriteData(fid,'object',obj,'fieldname','upperwater_elevation','format','Double','enum',BasalforcingsUpperwaterElevationEnum())
+			WriteData(fid,'object',self,'fieldname','groundedice_melting_rate','format','DoubleMat','enum',BasalforcingsGroundediceMeltingRateEnum(),'mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1)
+			WriteData(fid,'object',self,'fieldname','geothermalflux','enum',BasalforcingsGeothermalfluxEnum(),'format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
+			WriteData(fid,'object',self,'fieldname','deepwater_melting_rate','format','Double','enum',BasalforcingsDeepwaterMeltingRateEnum(),'scale',1./yts)
+			WriteData(fid,'object',self,'fieldname','deepwater_elevation','format','Double','enum',BasalforcingsDeepwaterElevationEnum())
+			WriteData(fid,'object',self,'fieldname','upperwater_elevation','format','Double','enum',BasalforcingsUpperwaterElevationEnum())
 		end % }}}
 	end
 end
Index: ../trunk-jpl/src/m/classes/steadystate.m
===================================================================
--- ../trunk-jpl/src/m/classes/steadystate.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/steadystate.m	(revision 19040)
@@ -10,41 +10,41 @@
 		requested_outputs = {};
 	end
 	methods
-        function createxml(obj,fid) % {{{
+        function createxml(self,fid) % {{{
             fprintf(fid, '<!-- steadystate -->\n');            
                     
             % steadystate solution parameters
             fprintf(fid,'%s\n%s\n%s\n','<frame key="1" label="steadystate solution parameters">','<section name="steadystate" />');                    
-                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="reltol" type="',class(obj.reltol),'" default="',convert2str(obj.reltol),'">','     <section name="steadystate" />','     <help> relative tolerance criterion [K] </help>','  </parameter>');
-                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="maxiter" type="',class(obj.maxiter),'" default="',convert2str(obj.maxiter),'">','     <section name="steadystate" />','     <help> maximum number of iterations </help>','  </parameter>');
-                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="requested_outputs" type="',class(obj.requested_outputs),'" default="',convert2str(obj.requested_outputs),'">','     <section name="steadystate" />','     <help> additional requested outputs </help>','  </parameter>');
+                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="reltol" type="',class(self.reltol),'" default="',convert2str(self.reltol),'">','     <section name="steadystate" />','     <help> relative tolerance criterion [K] </help>','  </parameter>');
+                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="maxiter" type="',class(self.maxiter),'" default="',convert2str(self.maxiter),'">','     <section name="steadystate" />','     <help> maximum number of iterations </help>','  </parameter>');
+                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="requested_outputs" type="',class(self.requested_outputs),'" default="',convert2str(self.requested_outputs),'">','     <section name="steadystate" />','     <help> additional requested outputs </help>','  </parameter>');
             fprintf(fid,'%s\n%s\n','</frame>');    
         
         end % }}}
-		function obj = steadystate(varargin) % {{{
+		function self = steadystate(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 			%maximum of steady state iterations
-			obj.maxiter=100;
+			self.maxiter=100;
 
 			%Relative tolerance for the steadystate convertgence
-			obj.reltol=0.01;
+			self.reltol=0.01;
 
 			%default output
-			obj.requested_outputs={'default'};
+			self.requested_outputs={'default'};
 		end % }}}
 		function list=defaultoutputs(self,md) % {{{
 
 			list =  [md.stressbalance.defaultoutputs(md) md.thermal.defaultoutputs(md)];
 
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 			%Early return
 			if solution~=SteadystateSolutionEnum(), return; end;
@@ -58,24 +58,24 @@
 				md = checkmessage(md,['for a steadystate computation, stressbalance.reltol (relative convergence criterion) must be defined!']);
 			end
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   steadystate solution parameters:'));
 
-			fielddisplay(obj,'reltol','relative tolerance criterion');
-			fielddisplay(obj,'maxiter','maximum number of iterations');
-			fielddisplay(obj,'requested_outputs','additional requested outputs');
+			fielddisplay(self,'reltol','relative tolerance criterion');
+			fielddisplay(self,'maxiter','maximum number of iterations');
+			fielddisplay(self,'requested_outputs','additional requested outputs');
 
 		end % }}}
-		function marshall(obj,md,fid) % {{{
-			WriteData(fid,'object',obj,'fieldname','reltol','format','Double');
-			WriteData(fid,'object',obj,'fieldname','maxiter','format','Integer');
+		function marshall(self,md,fid) % {{{
+			WriteData(fid,'object',self,'fieldname','reltol','format','Double');
+			WriteData(fid,'object',self,'fieldname','maxiter','format','Integer');
 
 			%process requested outputs
-			outputs = obj.requested_outputs;
+			outputs = self.requested_outputs;
 			pos  = find(ismember(outputs,'default'));
 			if ~isempty(pos),
 				outputs(pos) = [];                         %remove 'default' from outputs
-				outputs      = [outputs defaultoutputs(obj,md)]; %add defaults
+				outputs      = [outputs defaultoutputs(self,md)]; %add defaults
 			end
 			WriteData(fid,'data',outputs,'enum',SteadystateRequestedOutputsEnum,'format','StringArray');
 		end % }}}
Index: ../trunk-jpl/src/m/classes/misfit.m
===================================================================
--- ../trunk-jpl/src/m/classes/misfit.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/misfit.m	(revision 19040)
@@ -27,67 +27,67 @@
 	end
 	
 	methods
-		function obj = misfit(varargin) % {{{
+		function self = misfit(varargin) % {{{
 			if nargin==0,
-				obj=setdefaultparameters(obj);
+				self=setdefaultparameters(self);
 			else
 				%use provided options to change fields
 				options=pairoptions(varargin{:});
 
 				%get name
-				obj.name=getfieldvalue(options,'name','');
-				obj.definitionenum=getfieldvalue(options,'definitionenum');
-				obj.model_enum=getfieldvalue(options,'model_enum');
-				obj.observation=getfieldvalue(options,'observation',NaN);
-				obj.observation_enum=getfieldvalue(options,'observation_enum');
-				obj.timeinterpolation=getfieldvalue(options,'timeinterpolation','nearestneighbor');
-				obj.weights=getfieldvalue(options,'weights',NaN);
-				obj.weights_enum=getfieldvalue(options,'weights_enum',NaN);
+				self.name=getfieldvalue(options,'name','');
+				self.definitionenum=getfieldvalue(options,'definitionenum');
+				self.model_enum=getfieldvalue(options,'model_enum');
+				self.observation=getfieldvalue(options,'observation',NaN);
+				self.observation_enum=getfieldvalue(options,'observation_enum');
+				self.timeinterpolation=getfieldvalue(options,'timeinterpolation','nearestneighbor');
+				self.weights=getfieldvalue(options,'weights',NaN);
+				self.weights_enum=getfieldvalue(options,'weights_enum',NaN);
 
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
-			obj.timeinterpolation='nearestneighbor';
+		function self = setdefaultparameters(self) % {{{
+			self.timeinterpolation='nearestneighbor';
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
-			if ~ischar(obj.name),
+			if ~ischar(self.name),
 				error('misfit error message: ''name'' field should be a string!');
 			end
-			md = checkfield(md,'fieldname','obj.definitionenum','field',obj.definitionenum,'values',[Outputdefinition1Enum,Outputdefinition2Enum,Outputdefinition3Enum,Outputdefinition4Enum,Outputdefinition5Enum,Outputdefinition6Enum,Outputdefinition7Enum,Outputdefinition8Enum,Outputdefinition9Enum,Outputdefinition10Enum]);
+			md = checkfield(md,'fieldname','self.definitionenum','field',self.definitionenum,'values',[Outputdefinition1Enum,Outputdefinition2Enum,Outputdefinition3Enum,Outputdefinition4Enum,Outputdefinition5Enum,Outputdefinition6Enum,Outputdefinition7Enum,Outputdefinition8Enum,Outputdefinition9Enum,Outputdefinition10Enum]);
 
-			if ~ischar(obj.timeinterpolation),
+			if ~ischar(self.timeinterpolation),
 				error('misfit error message: ''timeinterpolation'' field should be a string!');
 			end
-			md = checkfield(md,'fieldname','obj.observation','field',obj.observation,'timeseries',1,'NaN',1);
-			md = checkfield(md,'fieldname','obj.timeinterpolation','field',obj.timeinterpolation,'values',{'nearestneighbor'});
-			md = checkfield(md,'fieldname','obj.weights','field',obj.weights,'timeseries',1,'NaN',1);
+			md = checkfield(md,'fieldname','self.observation','field',self.observation,'timeseries',1,'NaN',1);
+			md = checkfield(md,'fieldname','self.timeinterpolation','field',self.timeinterpolation,'values',{'nearestneighbor'});
+			md = checkfield(md,'fieldname','self.weights','field',self.weights,'timeseries',1,'NaN',1);
 
 		end % }}}
-		function md = disp(obj) % {{{
+		function md = disp(self) % {{{
 		
 			disp(sprintf('   Misfit:\n'));
 
-			fielddisplay(obj,'name','identifier for this misfit response');
-			fielddisplay(obj,'definitionenum','enum that identifies this output definition uniquely, from Outputdefinition[1-10]Enum');
-			fielddisplay(obj,'model_enum','enum for field that is modeled');
-			fielddisplay(obj,'observation','observed field that we compare the model against');
-			fielddisplay(obj,'observation_enum','observation enum');
-			fielddisplay(obj,'timeinterpolation','interpolation routine used to interpolate misfit between two time steps (default is ''nearestneighbor''');
-			fielddisplay(obj,'weights','weights (at vertices) to apply to the misfit');
-			fielddisplay(obj,'weights_enum','enum for weights for identification purposes');
+			fielddisplay(self,'name','identifier for this misfit response');
+			fielddisplay(self,'definitionenum','enum that identifies this output definition uniquely, from Outputdefinition[1-10]Enum');
+			fielddisplay(self,'model_enum','enum for field that is modeled');
+			fielddisplay(self,'observation','observed field that we compare the model against');
+			fielddisplay(self,'observation_enum','observation enum');
+			fielddisplay(self,'timeinterpolation','interpolation routine used to interpolate misfit between two time steps (default is ''nearestneighbor''');
+			fielddisplay(self,'weights','weights (at vertices) to apply to the misfit');
+			fielddisplay(self,'weights_enum','enum for weights for identification purposes');
 
 		end % }}}
-		function md = marshall(obj,md,fid) % {{{
+		function md = marshall(self,md,fid) % {{{
 
-		WriteData(fid,'object',obj,'fieldname','name','format','String');
-		WriteData(fid,'object',obj,'fieldname','definitionenum','format','Integer');
-		WriteData(fid,'object',obj,'fieldname','model_enum','format','Integer');
-		WriteData(fid,'object',obj,'fieldname','observation','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
-		WriteData(fid,'object',obj,'fieldname','observation_enum','format','Integer');
-		WriteData(fid,'object',obj,'fieldname','timeinterpolation','format','String');
-		WriteData(fid,'object',obj,'fieldname','weights','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
-		WriteData(fid,'object',obj,'fieldname','weights_enum','format','Integer');
+		WriteData(fid,'object',self,'fieldname','name','format','String');
+		WriteData(fid,'object',self,'fieldname','definitionenum','format','Integer');
+		WriteData(fid,'object',self,'fieldname','model_enum','format','Integer');
+		WriteData(fid,'object',self,'fieldname','observation','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
+		WriteData(fid,'object',self,'fieldname','observation_enum','format','Integer');
+		WriteData(fid,'object',self,'fieldname','timeinterpolation','format','String');
+		WriteData(fid,'object',self,'fieldname','weights','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
+		WriteData(fid,'object',self,'fieldname','weights_enum','format','Integer');
 
 		end % }}}
 	end
Index: ../trunk-jpl/src/m/classes/matseaice.m
===================================================================
--- ../trunk-jpl/src/m/classes/matseaice.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/matseaice.m	(revision 19040)
@@ -17,10 +17,10 @@
 		time_relaxation_damage  = 0.;
 	end
 	methods
-		function obj = matseaice(varargin) % {{{
+		function self = matseaice(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				case 1
 					inputstruct=varargin{1};
 					list1 = properties('matseaice');
@@ -28,49 +28,49 @@
 					for i=1:length(list1)
 						fieldname = list1{i};
 						if ismember(fieldname,list2),
-							obj.(fieldname) = inputstruct.(fieldname);
+							self.(fieldname) = inputstruct.(fieldname);
 						end
 					end
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 			%Ice density
-			obj.rho_ice = 917.; %kg/m^3
+			self.rho_ice = 917.; %kg/m^3
 
 			%poisson modulus
-			obj.poisson=0.3;
+			self.poisson=0.3;
 
 			%Young modulus
-			obj.young_modulus=9.e+9;
+			self.young_modulus=9.e+9;
 
 			%ridging exponent
-			obj.ridging_exponent=-20.;
+			self.ridging_exponent=-20.;
 
 			%Cohesion (Weiss 2007)
-			obj.cohesion = 40.e+3; %40 kPa
+			self.cohesion = 40.e+3; %40 kPa
 
 			%internal_friction_coef 
-			obj.internal_friction_coef=0.7;
+			self.internal_friction_coef=0.7;
 
 			%compression_coef (Bouillon and Rampal 2014)
-			obj.compression_coef=5./2;
+			self.compression_coef=5./2;
 
 			%traction_coef (Bouillon and Rampal 2014)
-			obj.traction_coef=5./6.;
+			self.traction_coef=5./6.;
 
 			%Time relaxation stress
 			%1e20 for the elastic case (perfect memory of the stress), equal to the timestep for the viscous case (no memory of the stress)
-			obj.time_relaxation_stress=1.e+20;
+			self.time_relaxation_stress=1.e+20;
 
 			%Time relaxation damage
 			%1e20 for the brittle case (perfect memory of the damage), equal to the timestep for the plastic case (no memory of the damage)
-			obj.time_relaxation_damage=1.e+20;
+			self.time_relaxation_damage=1.e+20;
 
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 			md = checkfield(md,'fieldname','materials.rho_ice','NaN',1,'>',0,'numel',1);
 			md = checkfield(md,'fieldname','materials.poisson','NaN',1,'>',0,'<',.5,'numel',1);
 			md = checkfield(md,'fieldname','materials.young_modulus','NaN',1,'>',0,'numel',1);
@@ -81,31 +81,31 @@
 			md = checkfield(md,'fieldname','materials.traction_coef','NaN',1,'>',0,'<',1,'numel',1);
 			md = checkfield(md,'fieldname','materials.time_relaxation_stress','NaN',1,'>',md.timestepping.time_step,'numel',1);
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   Sea Ice Material:'));
-			fielddisplay(obj,'rho_ice','ice density [kg/m^3]');
-			fielddisplay(obj,'poisson','poisson ratio for undamaged ice [no unit]');
-			fielddisplay(obj,'young_modulus','Young modulus for undamaged ice [Pa]');
-			fielddisplay(obj,'ridging_exponent','Riging exponent (c, Hibler parameter) [no unit]');
-			fielddisplay(obj,'cohesion','cohesion (C) [Pa]');
-			fielddisplay(obj,'internal_friction_coef','Mohr-Coulomb internal friction coefficient (mu=tan(phi)) [no unit]');
-			fielddisplay(obj,'compression_coef','Ratio between cutoff compressive strength and the cohesion [no unit]');
-			fielddisplay(obj,'traction_coef','Ratio between cutoff tensile strength and Mohr-Coulomb tensile strength [no unit]');
-			fielddisplay(obj,'time_relaxation_stress','Relaxation time for stress (1e+20: elastic, dt: viscous) [s]');
-			fielddisplay(obj,'time_relaxation_damage','Relaxation time for damage (1e+20: brittle, dt: plastic) [s]');
+			fielddisplay(self,'rho_ice','ice density [kg/m^3]');
+			fielddisplay(self,'poisson','poisson ratio for undamaged ice [no unit]');
+			fielddisplay(self,'young_modulus','Young modulus for undamaged ice [Pa]');
+			fielddisplay(self,'ridging_exponent','Riging exponent (c, Hibler parameter) [no unit]');
+			fielddisplay(self,'cohesion','cohesion (C) [Pa]');
+			fielddisplay(self,'internal_friction_coef','Mohr-Coulomb internal friction coefficient (mu=tan(phi)) [no unit]');
+			fielddisplay(self,'compression_coef','Ratio between cutoff compressive strength and the cohesion [no unit]');
+			fielddisplay(self,'traction_coef','Ratio between cutoff tensile strength and Mohr-Coulomb tensile strength [no unit]');
+			fielddisplay(self,'time_relaxation_stress','Relaxation time for stress (1e+20: elastic, dt: viscous) [s]');
+			fielddisplay(self,'time_relaxation_damage','Relaxation time for damage (1e+20: brittle, dt: plastic) [s]');
 		end % }}}
-		function marshall(obj,md,fid) % {{{
+		function marshall(self,md,fid) % {{{
 			WriteData(fid,'enum',MaterialsEnum(),'data',MatseaiceEnum(),'format','Integer');
-			WriteData(fid,'object',obj,'class','materials','fieldname','rho_ice','format','Double');
-			WriteData(fid,'object',obj,'class','materials','fieldname','poisson','format','Double');
-			WriteData(fid,'object',obj,'class','materials','fieldname','young_modulus','format','Double');
-			WriteData(fid,'object',obj,'class','materials','fieldname','ridging_exponent','format','Double');
-			WriteData(fid,'object',obj,'class','materials','fieldname','cohesion','format','Double');
-			WriteData(fid,'object',obj,'class','materials','fieldname','internal_friction_coef','format','Double');
-			WriteData(fid,'object',obj,'class','materials','fieldname','compression_coef','format','Double');
-			WriteData(fid,'object',obj,'class','materials','fieldname','traction_coef','format','Double');
-			WriteData(fid,'object',obj,'class','materials','fieldname','time_relaxation_stress','format','Double');
-			WriteData(fid,'object',obj,'class','materials','fieldname','time_relaxation_damage','format','Double');
+			WriteData(fid,'object',self,'class','materials','fieldname','rho_ice','format','Double');
+			WriteData(fid,'object',self,'class','materials','fieldname','poisson','format','Double');
+			WriteData(fid,'object',self,'class','materials','fieldname','young_modulus','format','Double');
+			WriteData(fid,'object',self,'class','materials','fieldname','ridging_exponent','format','Double');
+			WriteData(fid,'object',self,'class','materials','fieldname','cohesion','format','Double');
+			WriteData(fid,'object',self,'class','materials','fieldname','internal_friction_coef','format','Double');
+			WriteData(fid,'object',self,'class','materials','fieldname','compression_coef','format','Double');
+			WriteData(fid,'object',self,'class','materials','fieldname','traction_coef','format','Double');
+			WriteData(fid,'object',self,'class','materials','fieldname','time_relaxation_stress','format','Double');
+			WriteData(fid,'object',self,'class','materials','fieldname','time_relaxation_damage','format','Double');
 		end % }}}
 	end
 end
Index: ../trunk-jpl/src/m/classes/autodiff.m
===================================================================
--- ../trunk-jpl/src/m/classes/autodiff.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/autodiff.m	(revision 19040)
@@ -19,46 +19,46 @@
 		end
 		%}}}
 	methods
-     	function createxml(obj,fid) % {{{
+     	function createxml(self,fid) % {{{
             fprintf(fid, '<!-- autodiff -->\n');            
                     
             % automatic differentiation parameters 
             fprintf(fid,'%s\n%s\n%s\n','<frame key="1" label="automatic differentiation parameters">','<section name="autodiff" />');                    
-                fprintf(fid,'%s%s%s\n%s\n%s%s%s\n%s\n%s\n','  <parameter key ="isautodiff" type="',class(obj.isautodiff),'" optional="false">','     <section name="autodiff" />','         <option value="',convert2str(obj.isautodiff),'" type="string" default="true"></option>','     <help> indicates if the automatic differentiation is activated </help>','  </parameter>');
+                fprintf(fid,'%s%s%s\n%s\n%s%s%s\n%s\n%s\n','  <parameter key ="isautodiff" type="',class(self.isautodiff),'" optional="false">','     <section name="autodiff" />','         <option value="',convert2str(self.isautodiff),'" type="string" default="true"></option>','     <help> indicates if the automatic differentiation is activated </help>','  </parameter>');
              
-                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="dependents" type="',class(obj.dependents),'" default="',convert2str(obj.dependents),'">','     <section name="autodiff" />','     <help> list of dependent variables </help>','  </parameter>');
-                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="independents" type="',class(obj.independents),'" default="',convert2str(obj.independents),'">','     <section name="autodiff" />','     <help> list of independent variables </help>','  </parameter>');
-                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="driver" type="',class(obj.driver),'" default="',convert2str(obj.driver),'">','     <section name="autodiff" />','     <help> ADOLC driver (''fos_forward'' or ''fov_forward'') </help>','  </parameter>');
-                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="obufsize" type="',class(obj.obufsize),'" default="',convert2str(obj.obufsize),'">','     <section name="autodiff" />','     <help> Number of operations per buffer (==OBUFSIZE in usrparms.h)  </help>','  </parameter>');
-                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="lbufsize" type="',class(obj.lbufsize),'" default="',convert2str(obj.lbufsize),'">','     <section name="autodiff" />','     <help> Number of locations per buffer (==LBUFSIZE in usrparms.h) </help>','  </parameter>');
-                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="cbufsize" type="',class(obj.cbufsize),'" default="',convert2str(obj.cbufsize),'">','     <section name="autodiff" />','     <help> Number of values per buffer (==CBUFSIZE in usrparms.h) </help>','  </parameter>');
-                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="tbufsize" type="',class(obj.tbufsize),'" default="',convert2str(obj.tbufsize),'">','     <section name="autodiff" />','     <help> Number of taylors per buffer (&amp;lt;=TBUFSIZE in usrparms.h) </help>','  </parameter>');
-                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="gcTriggerRatio" type="',class(obj.gcTriggerRatio),'" default="',convert2str(obj.gcTriggerRatio),'">','     <section name="autodiff" />','     <help> free location block sorting/consolidation triggered if the ratio between allocated and used locations exceeds gcTriggerRatio </help>','  </parameter>');
-                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="gcTriggerRatio" type="',class(obj.gcTriggerRatio),'" default="',convert2str(obj.gcTriggerRatio),'">','     <section name="autodiff" />','     <help> free location block sorting/consolidation triggered if the allocated locations exceed gcTriggerMaxSize </help>','  </parameter>');
+                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="dependents" type="',class(self.dependents),'" default="',convert2str(self.dependents),'">','     <section name="autodiff" />','     <help> list of dependent variables </help>','  </parameter>');
+                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="independents" type="',class(self.independents),'" default="',convert2str(self.independents),'">','     <section name="autodiff" />','     <help> list of independent variables </help>','  </parameter>');
+                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="driver" type="',class(self.driver),'" default="',convert2str(self.driver),'">','     <section name="autodiff" />','     <help> ADOLC driver (''fos_forward'' or ''fov_forward'') </help>','  </parameter>');
+                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="obufsize" type="',class(self.obufsize),'" default="',convert2str(self.obufsize),'">','     <section name="autodiff" />','     <help> Number of operations per buffer (==OBUFSIZE in usrparms.h)  </help>','  </parameter>');
+                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="lbufsize" type="',class(self.lbufsize),'" default="',convert2str(self.lbufsize),'">','     <section name="autodiff" />','     <help> Number of locations per buffer (==LBUFSIZE in usrparms.h) </help>','  </parameter>');
+                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="cbufsize" type="',class(self.cbufsize),'" default="',convert2str(self.cbufsize),'">','     <section name="autodiff" />','     <help> Number of values per buffer (==CBUFSIZE in usrparms.h) </help>','  </parameter>');
+                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="tbufsize" type="',class(self.tbufsize),'" default="',convert2str(self.tbufsize),'">','     <section name="autodiff" />','     <help> Number of taylors per buffer (&amp;lt;=TBUFSIZE in usrparms.h) </help>','  </parameter>');
+                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="gcTriggerRatio" type="',class(self.gcTriggerRatio),'" default="',convert2str(self.gcTriggerRatio),'">','     <section name="autodiff" />','     <help> free location block sorting/consolidation triggered if the ratio between allocated and used locations exceeds gcTriggerRatio </help>','  </parameter>');
+                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="gcTriggerRatio" type="',class(self.gcTriggerRatio),'" default="',convert2str(self.gcTriggerRatio),'">','     <section name="autodiff" />','     <help> free location block sorting/consolidation triggered if the allocated locations exceed gcTriggerMaxSize </help>','  </parameter>');
             
             fprintf(fid,'%s\n%s\n','</frame>');    
         
         end % }}}
-		function obj = autodiff(varargin) % {{{
+		function self = autodiff(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
-		obj.obufsize     = 524288;
-		obj.lbufsize     = 524288;
-		obj.cbufsize     = 524288;
-		obj.tbufsize     = 524288;
-		obj.gcTriggerRatio=2.0;
-		obj.gcTriggerMaxSize=65536;
+		function self = setdefaultparameters(self) % {{{
+		self.obufsize     = 524288;
+		self.lbufsize     = 524288;
+		self.cbufsize     = 524288;
+		self.tbufsize     = 524288;
+		self.gcTriggerRatio=2.0;
+		self.gcTriggerMaxSize=65536;
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 			%Early return 
-			if ~obj.isautodiff, return; end
+			if ~self.isautodiff, return; end
 
 			%Driver value:
 			md = checkfield(md,'fieldname','autodiff.driver','values',{'fos_forward','fov_forward','fov_forward_all','fos_reverse','fov_reverse','fov_reverse_all'});
@@ -72,51 +72,51 @@
 			md = checkfield(md,'fieldname','autodiff.gcTriggerMaxSize','>=',65536);
 
 			%go through our dependents and independents and check consistency: 
-			for i=1:numel(obj.dependents),
-				dep=obj.dependents{i};
+			for i=1:numel(self.dependents),
+				dep=self.dependents{i};
 				md=checkconsistency(dep,md,solution,analyses);
 			end
-			for i=1:numel(obj.independents),
-				indep=obj.independents{i};
-				md=checkconsistency(indep,md,i,solution,analyses,obj.driver);
+			for i=1:numel(self.independents),
+				indep=self.independents{i};
+				md=checkconsistency(indep,md,i,solution,analyses,self.driver);
 			end
 
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   automatic differentiation parameters:'));
-			fielddisplay(obj,'isautodiff','indicates if the automatic differentiation is activated');
-			fielddisplay(obj,'dependents','list of dependent variables');
-			fielddisplay(obj,'independents','list of independent variables');
-			fielddisplay(obj,'driver','ADOLC driver (''fos_forward'' or ''fov_forward'')');
-			fielddisplay(obj,'obufsize','Number of operations per buffer (==OBUFSIZE in usrparms.h)');
-			fielddisplay(obj,'lbufsize','Number of locations per buffer (==LBUFSIZE in usrparms.h)');
-			fielddisplay(obj,'cbufsize','Number of values per buffer (==CBUFSIZE in usrparms.h)');
-			fielddisplay(obj,'tbufsize','Number of taylors per buffer (<=TBUFSIZE in usrparms.h)');
-			fielddisplay(obj,'gcTriggerRatio','free location block sorting/consolidation triggered if the ratio between allocated and used locations exceeds gcTriggerRatio');
-			fielddisplay(obj,'gcTriggerMaxSize','free location block sorting/consolidation triggered if the allocated locations exceed gcTriggerMaxSize');
+			fielddisplay(self,'isautodiff','indicates if the automatic differentiation is activated');
+			fielddisplay(self,'dependents','list of dependent variables');
+			fielddisplay(self,'independents','list of independent variables');
+			fielddisplay(self,'driver','ADOLC driver (''fos_forward'' or ''fov_forward'')');
+			fielddisplay(self,'obufsize','Number of operations per buffer (==OBUFSIZE in usrparms.h)');
+			fielddisplay(self,'lbufsize','Number of locations per buffer (==LBUFSIZE in usrparms.h)');
+			fielddisplay(self,'cbufsize','Number of values per buffer (==CBUFSIZE in usrparms.h)');
+			fielddisplay(self,'tbufsize','Number of taylors per buffer (<=TBUFSIZE in usrparms.h)');
+			fielddisplay(self,'gcTriggerRatio','free location block sorting/consolidation triggered if the ratio between allocated and used locations exceeds gcTriggerRatio');
+			fielddisplay(self,'gcTriggerMaxSize','free location block sorting/consolidation triggered if the allocated locations exceed gcTriggerMaxSize');
 		end % }}}
-		function marshall(obj,md,fid) % {{{
+		function marshall(self,md,fid) % {{{
 
-			WriteData(fid,'object',obj,'fieldname','isautodiff','format','Boolean');
-			WriteData(fid,'object',obj,'fieldname','driver','format','String');
+			WriteData(fid,'object',self,'fieldname','isautodiff','format','Boolean');
+			WriteData(fid,'object',self,'fieldname','driver','format','String');
 
 			%early return
-			if ~obj.isautodiff,
+			if ~self.isautodiff,
 				WriteData(fid,'data',false,'enum',AutodiffMassFluxSegmentsPresentEnum(),'format','Boolean');
 				WriteData(fid,'data',false,'enum',AutodiffKeepEnum(),'format','Boolean');
 				return;
 			end
 
 			%buffer sizes {{{
-			WriteData(fid,'object',obj,'fieldname','obufsize','format','Double');
-			WriteData(fid,'object',obj,'fieldname','lbufsize','format','Double');
-			WriteData(fid,'object',obj,'fieldname','cbufsize','format','Double');
-			WriteData(fid,'object',obj,'fieldname','tbufsize','format','Double');
-			WriteData(fid,'object',obj,'fieldname','gcTriggerRatio','format','Double');
-			WriteData(fid,'object',obj,'fieldname','gcTriggerMaxSize','format','Double');
+			WriteData(fid,'object',self,'fieldname','obufsize','format','Double');
+			WriteData(fid,'object',self,'fieldname','lbufsize','format','Double');
+			WriteData(fid,'object',self,'fieldname','cbufsize','format','Double');
+			WriteData(fid,'object',self,'fieldname','tbufsize','format','Double');
+			WriteData(fid,'object',self,'fieldname','gcTriggerRatio','format','Double');
+			WriteData(fid,'object',self,'fieldname','gcTriggerMaxSize','format','Double');
 			%}}}
 			%process dependent variables {{{
-			num_dependent_objects=numel(obj.dependents);
+			num_dependent_objects=numel(self.dependents);
 			WriteData(fid,'data',num_dependent_objects,'enum',AutodiffNumDependentObjectsEnum(),'format','Integer');
 
 			if(num_dependent_objects),
@@ -125,7 +125,7 @@
 				indices=zeros(num_dependent_objects,1);
 
 				for i=1:num_dependent_objects,
-					dep=obj.dependents{i};
+					dep=self.dependents{i};
 
 					names{i}=dep.name;
 					types(i)=dep.typetoscalar();
@@ -137,7 +137,7 @@
 			end
 			%}}}
 			%process independent variables {{{
-			num_independent_objects=numel(obj.independents);
+			num_independent_objects=numel(self.independents);
 			WriteData(fid,'data',num_independent_objects,'enum',AutodiffNumIndependentObjectsEnum(),'format','Integer');
 
 			if(num_independent_objects),
@@ -145,7 +145,7 @@
 				types=zeros(num_independent_objects,1);
 
 				for i=1:num_independent_objects,
-					indep=obj.independents{i};
+					indep=self.independents{i};
 
 					names(i)=StringToEnum(indep.name);
 					types(i)=indep.typetoscalar();
@@ -155,11 +155,11 @@
 			end
 			%}}}
 			%if driver is fos_forward, build index:  {{{
-			if strcmpi(obj.driver,'fos_forward'),
+			if strcmpi(self.driver,'fos_forward'),
 				index=0;
 
 				for i=1:num_independent_objects,
-					indep=obj.independents{i};
+					indep=self.independents{i};
 					if ~isnan(indep.fos_forward_index),
 						index=index+indep.fos_forward_index;
 						break;
@@ -176,11 +176,11 @@
 			end
 			%}}}
 			%if driver is fos_reverse, build index:  {{{
-			if strcmpi(obj.driver,'fos_reverse'),
+			if strcmpi(self.driver,'fos_reverse'),
 				index=0;
 
 				for i=1:num_dependent_objects,
-					dep=obj.dependents{i};
+					dep=self.dependents{i};
 					if ~isnan(dep.fos_reverse_index),
 						index=index+dep.fos_reverse_index;
 						break;
@@ -197,11 +197,11 @@
 			end
 			%}}}
 			%if driver is fov_forward, build indices:  {{{
-			if strcmpi(obj.driver,'fov_forward'),
+			if strcmpi(self.driver,'fov_forward'),
 				indices=0;
 
 				for i=1:num_independent_objects,
-					indep=obj.independents{i};
+					indep=self.independents{i};
 					if ~isempty(indep.fos_forward_index),
 						indices=indices+indep.fov_forward_indices;
 						break;
@@ -220,7 +220,7 @@
 			%deal with mass fluxes:  {{{
 			mass_flux_segments=cell(0,1);
 			for i=1:num_dependent_objects,
-				dep=obj.dependents{i};
+				dep=self.dependents{i};
 				if strcmpi(dep.name,'MassFlux'),
 					mass_flux_segments{end+1,1}=dep.segments;
 				end
@@ -243,10 +243,10 @@
 			% mode as described in the Section 4 and Section 5. 
 			%
 
-			if length(obj.driver)<=3,
+			if length(self.driver)<=3,
 				keep=false; %there is no "_reverse" string within the driver string: 
 			else
-				if strncmpi(obj.driver(4:end),'_reverse',8),
+				if strncmpi(self.driver(4:end),'_reverse',8),
 					keep=true;
 				else
 					keep=false;
Index: ../trunk-jpl/src/m/classes/qmu.m
===================================================================
--- ../trunk-jpl/src/m/classes/qmu.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/qmu.m	(revision 19040)
@@ -23,47 +23,47 @@
 		vertex_weight               = NaN;
 	end
 	methods
-        function createxml(obj,fid) % {{{
+        function createxml(self,fid) % {{{
             fprintf(fid, '<!-- qmu -->\n');            
                     
             % qmu solution parameters
             fprintf(fid,'%s\n%s\n%s\n','<frame key="1" label="qmu parameters">','<section name="qmu" />');                    
-                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="isdakota" type="',class(obj.isdakota),'" default="',convert2str(obj.isdakota),'">','     <section name="qmu" />','     <help> is qmu analysis activated? </help>','  </parameter>');
-                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="variables" type="',class(obj.variables),'" default="',convert2str(obj.variables),'">','     <section name="qmu" />','     <help> (arrays of each variable class) </help>','  </parameter>');
-                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="responses" type="',class(obj.responses),'" default="',convert2str(obj.responses),'">','     <section name="qmu" />','     <help> (arrays of each response class) </help>','  </parameter>');
+                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="isdakota" type="',class(self.isdakota),'" default="',convert2str(self.isdakota),'">','     <section name="qmu" />','     <help> is qmu analysis activated? </help>','  </parameter>');
+                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="variables" type="',class(self.variables),'" default="',convert2str(self.variables),'">','     <section name="qmu" />','     <help> (arrays of each variable class) </help>','  </parameter>');
+                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="responses" type="',class(self.responses),'" default="',convert2str(self.responses),'">','     <section name="qmu" />','     <help> (arrays of each response class) </help>','  </parameter>');
                 
-                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="numberofresponses" type="',class(obj.numberofresponses),'" default="',convert2str(obj.numberofresponses),'">','     <section name="qmu" />','     <help> number of responses </help>','  </parameter>');
-                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="params" type="',class(obj.params),'" default="',convert2str(obj.params),'">','     <section name="qmu" />','     <help> (array of method-independent parameters)  </help>','  </parameter>');
-                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="results" type="',class(obj.results),'" default="',convert2str(obj.results),'">','     <section name="qmu" />','     <help> (information from dakota files) </help>','  </parameter>');
+                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="numberofresponses" type="',class(self.numberofresponses),'" default="',convert2str(self.numberofresponses),'">','     <section name="qmu" />','     <help> number of responses </help>','  </parameter>');
+                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="params" type="',class(self.params),'" default="',convert2str(self.params),'">','     <section name="qmu" />','     <help> (array of method-independent parameters)  </help>','  </parameter>');
+                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="results" type="',class(self.results),'" default="',convert2str(self.results),'">','     <section name="qmu" />','     <help> (information from dakota files) </help>','  </parameter>');
                 
-                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="partition" type="',class(obj.partition),'" default="',convert2str(obj.partition),'">','     <section name="qmu" />','     <help> user provided mesh partitioning, defaults to metis if not specified </help>','  </parameter>');
-                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="numberofpartitions" type="',class(obj.numberofpartitions),'" default="',convert2str(obj.numberofpartitions),'">','     <section name="qmu" />','     <help> number of partitions for semi-discrete qmu  </help>','  </parameter>');
-                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="variabledescriptors" type="',class(obj.variabledescriptors),'" default="',convert2str(obj.variabledescriptors),'">','     <section name="qmu" />','     <help>  </help>','  </parameter>');
+                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="partition" type="',class(self.partition),'" default="',convert2str(self.partition),'">','     <section name="qmu" />','     <help> user provided mesh partitioning, defaults to metis if not specified </help>','  </parameter>');
+                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="numberofpartitions" type="',class(self.numberofpartitions),'" default="',convert2str(self.numberofpartitions),'">','     <section name="qmu" />','     <help> number of partitions for semi-discrete qmu  </help>','  </parameter>');
+                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="variabledescriptors" type="',class(self.variabledescriptors),'" default="',convert2str(self.variabledescriptors),'">','     <section name="qmu" />','     <help>  </help>','  </parameter>');
             
-                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="responsedescriptors" type="',class(obj.responsedescriptors),'" default="',convert2str(obj.responsedescriptors),'">','     <section name="qmu" />','     <help> use an enthalpy formulation to include temperate ice (default is 0) </help>','  </parameter>');
-                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="method" type="',class(obj.method),'" default="',convert2str(obj.method),'">','     <section name="qmu" />','     <help> array of dakota_method class </help>','  </parameter>');
-                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="mass_flux_profile_directory" type="',class(obj.mass_flux_profile_directory),'" default="',convert2str(obj.mass_flux_profile_directory),'">','     <section name="qmu" />','     <help> directory for mass flux profiles </help>','  </parameter>');
+                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="responsedescriptors" type="',class(self.responsedescriptors),'" default="',convert2str(self.responsedescriptors),'">','     <section name="qmu" />','     <help> use an enthalpy formulation to include temperate ice (default is 0) </help>','  </parameter>');
+                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="method" type="',class(self.method),'" default="',convert2str(self.method),'">','     <section name="qmu" />','     <help> array of dakota_method class </help>','  </parameter>');
+                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="mass_flux_profile_directory" type="',class(self.mass_flux_profile_directory),'" default="',convert2str(self.mass_flux_profile_directory),'">','     <section name="qmu" />','     <help> directory for mass flux profiles </help>','  </parameter>');
                 
-                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="mass_flux_profiles" type="',class(obj.mass_flux_profiles),'" default="',convert2str(obj.mass_flux_profiles),'">','     <section name="qmu" />','     <help>  </help>','  </parameter>');
-                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="mass_flux_segments" type="',class(obj.mass_flux_segments),'" default="',convert2str(obj.mass_flux_segments),'">','     <section name="qmu" />','     <help>  </help>','  </parameter>');
-                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="adjacency" type="',class(obj.adjacency),'" default="',convert2str(obj.adjacency),'">','     <section name="qmu" />','     <help> additional outputs requested </help>','  </parameter>');
-                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="vertex_weight" type="',class(obj.vertex_weight),'" default="',convert2str(obj.vertex_weight),'">','     <section name="qmu" />','     <help> weight applied to each mesh vertex </help>','  </parameter>');
+                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="mass_flux_profiles" type="',class(self.mass_flux_profiles),'" default="',convert2str(self.mass_flux_profiles),'">','     <section name="qmu" />','     <help>  </help>','  </parameter>');
+                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="mass_flux_segments" type="',class(self.mass_flux_segments),'" default="',convert2str(self.mass_flux_segments),'">','     <section name="qmu" />','     <help>  </help>','  </parameter>');
+                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="adjacency" type="',class(self.adjacency),'" default="',convert2str(self.adjacency),'">','     <section name="qmu" />','     <help> additional outputs requested </help>','  </parameter>');
+                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="vertex_weight" type="',class(self.vertex_weight),'" default="',convert2str(self.vertex_weight),'">','     <section name="qmu" />','     <help> weight applied to each mesh vertex </help>','  </parameter>');
             
             fprintf(fid,'%s\n%s\n','</frame>');    
         
         end % }}}        
-		function obj = qmu(varargin) % {{{
+		function self = qmu(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 			%Early return
 			if ~md.qmu.isdakota, return; end
@@ -89,14 +89,14 @@
 				end
 			end
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   qmu parameters:'));
 
-			fielddisplay(obj,'isdakota','is qmu analysis activated?');
-			for i=1:numel(obj.variables)
+			fielddisplay(self,'isdakota','is qmu analysis activated?');
+			for i=1:numel(self.variables)
 				disp(sprintf('         variables%s:  (arrays of each variable class)',...
-					string_dim(obj.variables,i)));
-				fnames=fieldnames(obj.variables(i));
+					string_dim(self.variables,i)));
+				fnames=fieldnames(self.variables(i));
 				maxlen=0;
 				for j=1:numel(fnames)
 					maxlen=max(maxlen,length(fnames{j}));
@@ -104,13 +104,13 @@
 
 				for j=1:numel(fnames)
 					disp(sprintf(['            %-' num2str(maxlen+1) 's:    [%ix%i]    ''%s'''],...
-						fnames{j},size(obj.variables.(fnames{j})),class(obj.variables.(fnames{j}))));
+						fnames{j},size(self.variables.(fnames{j})),class(self.variables.(fnames{j}))));
 				end
 			end
-			for i=1:numel(obj.responses)
+			for i=1:numel(self.responses)
 				disp(sprintf('         responses%s:  (arrays of each response class)',...
-					string_dim(obj.responses,i)));
-				fnames=fieldnames(obj.responses(i));
+					string_dim(self.responses,i)));
+				fnames=fieldnames(self.responses(i));
 				maxlen=0;
 				for j=1:numel(fnames)
 					maxlen=max(maxlen,length(fnames{j}));
@@ -118,20 +118,20 @@
 
 				for j=1:numel(fnames)
 					disp(sprintf(['            %-' num2str(maxlen+1) 's:    [%ix%i]    ''%s'''],...
-						fnames{j},size(obj.responses.(fnames{j})),class(obj.responses.(fnames{j}))));
+						fnames{j},size(self.responses.(fnames{j})),class(self.responses.(fnames{j}))));
 				end
 			end
-			fielddisplay(obj,'numberofresponses','number of responses') 
-			for i=1:numel(obj.method);
-				if strcmp(class(obj.method(i)),'dakota_method')
+			fielddisplay(self,'numberofresponses','number of responses') 
+			for i=1:numel(self.method);
+				if strcmp(class(self.method(i)),'dakota_method')
 					disp(sprintf('            method%s :    ''%s''',...
-						string_dim(obj.method,i),obj.method(i).method));
+						string_dim(self.method,i),self.method(i).method));
 				end
 			end
-			for i=1:numel(obj.params)
+			for i=1:numel(self.params)
 				disp(sprintf('         params%s:  (array of method-independent parameters)',...
-					string_dim(obj.params,i)));
-				fnames=fieldnames(obj.params(i));
+					string_dim(self.params,i)));
+				fnames=fieldnames(self.params(i));
 				maxlen=0;
 				for j=1:numel(fnames)
 					maxlen=max(maxlen,length(fnames{j}));
@@ -139,13 +139,13 @@
 
 				for j=1:numel(fnames)
 					disp(sprintf(['            %-' num2str(maxlen+1) 's: %s'],...
-						fnames{j},any2str(obj.params(i).(fnames{j}))));
+						fnames{j},any2str(self.params(i).(fnames{j}))));
 				end
 			end
-			for i=1:numel(obj.results)
+			for i=1:numel(self.results)
 				disp(sprintf('         results%s:  (information from dakota files)',...
-					string_dim(obj.results,i)));
-				fnames=fieldnames(obj.results(i));
+					string_dim(self.results,i)));
+				fnames=fieldnames(self.results(i));
 				maxlen=0;
 				for j=1:numel(fnames)
 					maxlen=max(maxlen,length(fnames{j}));
@@ -153,34 +153,34 @@
 
 				for j=1:numel(fnames)
 					disp(sprintf(['            %-' num2str(maxlen+1) 's:    [%ix%i]    ''%s'''],...
-						fnames{j},size(obj.results.(fnames{j})),class(obj.results.(fnames{j}))));
+						fnames{j},size(self.results.(fnames{j})),class(self.results.(fnames{j}))));
 				end
 			end
-			fielddisplay(obj,'partition','user provided mesh partitioning, defaults to metis if not specified') 
-			fielddisplay(obj,'numberofpartitions','number of partitions for semi-discrete qmu') 
-			fielddisplay(obj,'variabledescriptors','');
-			fielddisplay(obj,'responsedescriptors','');
-			fielddisplay(obj,'method','array of dakota_method class');
-			fielddisplay(obj,'mass_flux_profile_directory','directory for mass flux profiles');
-			fielddisplay(obj,'mass_flux_profiles','list of mass_flux profiles');
-			fielddisplay(obj,'mass_flux_segments','');
-			fielddisplay(obj,'adjacency','');
-			fielddisplay(obj,'vertex_weight','weight applied to each mesh vertex');
+			fielddisplay(self,'partition','user provided mesh partitioning, defaults to metis if not specified') 
+			fielddisplay(self,'numberofpartitions','number of partitions for semi-discrete qmu') 
+			fielddisplay(self,'variabledescriptors','');
+			fielddisplay(self,'responsedescriptors','');
+			fielddisplay(self,'method','array of dakota_method class');
+			fielddisplay(self,'mass_flux_profile_directory','directory for mass flux profiles');
+			fielddisplay(self,'mass_flux_profiles','list of mass_flux profiles');
+			fielddisplay(self,'mass_flux_segments','');
+			fielddisplay(self,'adjacency','');
+			fielddisplay(self,'vertex_weight','weight applied to each mesh vertex');
 
 		end % }}}
-		function marshall(obj,md,fid) % {{{
-			WriteData(fid,'object',obj,'fieldname','isdakota','format','Boolean');
-			if ~obj.isdakota, 
+		function marshall(self,md,fid) % {{{
+			WriteData(fid,'object',self,'fieldname','isdakota','format','Boolean');
+			if ~self.isdakota, 
 				WriteData(fid,'data',false,'enum',QmuMassFluxSegmentsPresentEnum,'format','Boolean');
 				return; 
 			end
-			WriteData(fid,'object',obj,'fieldname','partition','format','DoubleMat','mattype',2);
-			WriteData(fid,'object',obj,'fieldname','numberofpartitions','format','Integer');
-			WriteData(fid,'object',obj,'fieldname','numberofresponses','format','Integer');
-			WriteData(fid,'object',obj,'fieldname','variabledescriptors','format','StringArray');
-			WriteData(fid,'object',obj,'fieldname','responsedescriptors','format','StringArray');
-			if ~isempty(obj.mass_flux_segments), 
-				WriteData(fid,'data',obj.mass_flux_segments,'enum',MassFluxSegmentsEnum,'format','MatArray');
+			WriteData(fid,'object',self,'fieldname','partition','format','DoubleMat','mattype',2);
+			WriteData(fid,'object',self,'fieldname','numberofpartitions','format','Integer');
+			WriteData(fid,'object',self,'fieldname','numberofresponses','format','Integer');
+			WriteData(fid,'object',self,'fieldname','variabledescriptors','format','StringArray');
+			WriteData(fid,'object',self,'fieldname','responsedescriptors','format','StringArray');
+			if ~isempty(self.mass_flux_segments), 
+				WriteData(fid,'data',self.mass_flux_segments,'enum',MassFluxSegmentsEnum,'format','MatArray');
 				flag=true; 
 			else 
 				flag=false; 
Index: ../trunk-jpl/src/m/classes/matice.m
===================================================================
--- ../trunk-jpl/src/m/classes/matice.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/matice.m	(revision 19040)
@@ -29,31 +29,31 @@
 
 	end
 	methods
-		function createxml(obj,fid) % {{{
+		function createxml(self,fid) % {{{
 			fprintf(fid, '\n\n');
 			fprintf(fid, '<!-- materials -->\n');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="rho_ice" type="',class(obj.rho_ice),'" default="',convert2str(obj.rho_ice),'">','     <section name="materials" />','     <help> ice density [kg/m^3] </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="rho_water" type="',class(obj.rho_water),'" default="',convert2str(obj.rho_water),'">','     <section name="materials" />','     <help> ocean water density [kg/m^3] </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="rho_freshwater" type="',class(obj.rho_freshwater),'" default="',convert2str(obj.rho_freshwater),'">','     <section name="materials" />','     <help> fresh water density [kg/m^3] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="rho_ice" type="',class(self.rho_ice),'" default="',convert2str(self.rho_ice),'">','     <section name="materials" />','     <help> ice density [kg/m^3] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="rho_water" type="',class(self.rho_water),'" default="',convert2str(self.rho_water),'">','     <section name="materials" />','     <help> ocean water density [kg/m^3] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="rho_freshwater" type="',class(self.rho_freshwater),'" default="',convert2str(self.rho_freshwater),'">','     <section name="materials" />','     <help> fresh water density [kg/m^3] </help>','</parameter>');
 
 
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="mu_water" type="',class(obj.mu_water),'" default="',convert2str(obj.mu_water),'">','     <section name="materials" />','     <help> water viscosity [N s/m^2] </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="heatcapacity" type="',class(obj.heatcapacity),'" default="',convert2str(obj.heatcapacity),'">','     <section name="materials" />','     <help> heat capacity [J/kg/K] </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="latentheat" type="',class(obj.latentheat),'" default="',convert2str(obj.latentheat),'">','     <section name="materials" />','     <help> latent heat of fusion [J/kg] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="mu_water" type="',class(self.mu_water),'" default="',convert2str(self.mu_water),'">','     <section name="materials" />','     <help> water viscosity [N s/m^2] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="heatcapacity" type="',class(self.heatcapacity),'" default="',convert2str(self.heatcapacity),'">','     <section name="materials" />','     <help> heat capacity [J/kg/K] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="latentheat" type="',class(self.latentheat),'" default="',convert2str(self.latentheat),'">','     <section name="materials" />','     <help> latent heat of fusion [J/kg] </help>','</parameter>');
 
 
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="thermalconductivity" type="',class(obj.thermalconductivity),'" default="',convert2str(obj.thermalconductivity),'">','     <section name="materials" />','     <help> ice thermal conductivity [W/m/K] </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="temperateiceconductivity" type="',class(obj.temperateiceconductivity),'" default="',convert2str(obj.temperateiceconductivity),'">','     <section name="materials" />','     <help> temperate ice thermal conductivity [W/m/K] </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="meltingpoint" type="',class(obj.meltingpoint),'" default="',convert2str(obj.meltingpoint),'">','     <section name="materials" />','     <help> melting point of ice at 1atm in K </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="thermalconductivity" type="',class(self.thermalconductivity),'" default="',convert2str(self.thermalconductivity),'">','     <section name="materials" />','     <help> ice thermal conductivity [W/m/K] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="temperateiceconductivity" type="',class(self.temperateiceconductivity),'" default="',convert2str(self.temperateiceconductivity),'">','     <section name="materials" />','     <help> temperate ice thermal conductivity [W/m/K] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="meltingpoint" type="',class(self.meltingpoint),'" default="',convert2str(self.meltingpoint),'">','     <section name="materials" />','     <help> melting point of ice at 1atm in K </help>','</parameter>');
 
 
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="beta" type="',class(obj.beta),'" default="',convert2str(obj.beta),'">','     <section name="materials" />','     <help> rate of change of melting point with pressure [K/Pa] </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="mixed_layer_capacity" type="',class(obj.mixed_layer_capacity),'" default="',convert2str(obj.mixed_layer_capacity),'">','     <section name="materials" />','     <help> mixed layer capacity [W/kg/K] </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="thermal_exchange_velocity" type="',class(obj.thermal_exchange_velocity),'" default="',convert2str(obj.thermal_exchange_velocity),'">','     <section name="materials" />','     <help> thermal exchange velocity [m/s] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="beta" type="',class(self.beta),'" default="',convert2str(self.beta),'">','     <section name="materials" />','     <help> rate of change of melting point with pressure [K/Pa] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="mixed_layer_capacity" type="',class(self.mixed_layer_capacity),'" default="',convert2str(self.mixed_layer_capacity),'">','     <section name="materials" />','     <help> mixed layer capacity [W/kg/K] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="thermal_exchange_velocity" type="',class(self.thermal_exchange_velocity),'" default="',convert2str(self.thermal_exchange_velocity),'">','     <section name="materials" />','     <help> thermal exchange velocity [m/s] </help>','</parameter>');
 
 
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="rheology_B" type="',class(obj.rheology_B),'" default="',convert2str(obj.rheology_B),'">','     <section name="materials" />','     <help> flow law parameter [Pa/s^(1/n)] </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="rheology_n" type="',class(obj.rheology_n),'" default="',convert2str(obj.rheology_n),'">','     <section name="materials" />','     <help> Glens flow law exponent </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="rheology_B" type="',class(self.rheology_B),'" default="',convert2str(self.rheology_B),'">','     <section name="materials" />','     <help> flow law parameter [Pa/s^(1/n)] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="rheology_n" type="',class(self.rheology_n),'" default="',convert2str(self.rheology_n),'">','     <section name="materials" />','     <help> Glens flow law exponent </help>','</parameter>');
 
 			% rheology_law drop-down
 			fprintf(fid,'%s\n%s\n%s\n%s\n','<parameter key ="rheology_law" type="alternative" optional="false">','     <section name="materials" />','     <help> law for the temperature dependance of the rheology: "None", "Paterson",  "Arrhenius" or "LliboutryDuval" </help>');
@@ -63,17 +63,17 @@
 			fprintf(fid,'%s\n%s\n','       <option value="LliboutryDuval" type="string" default="false"> </option>','</parameter>');
 
 
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="lithosphere_shear_modulus" type="',class(obj.lithosphere_shear_modulus),'" default="',convert2str(obj.lithosphere_shear_modulus),'">','     <section name="materials" />','     <help> Lithosphere shear modulus [Pa] </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="lithosphere_density" type="',class(obj.lithosphere_density),'" default="',convert2str(obj.lithosphere_density),'">','     <section name="materials" />','     <help> Lithosphere density [g/cm^-3] </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="mantle_shear_modulus" type="',class(obj.mantle_shear_modulus),'" default="',convert2str(obj.mantle_shear_modulus),'">','     <section name="materials" />','     <help> Mantle shear modulus [Pa] </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="mantle_density" type="',class(obj.mantle_density),'" default="',convert2str(obj.mantle_density),'">','     <section name="materials" />','     <help> Mantle density [g/cm^-3] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="lithosphere_shear_modulus" type="',class(self.lithosphere_shear_modulus),'" default="',convert2str(self.lithosphere_shear_modulus),'">','     <section name="materials" />','     <help> Lithosphere shear modulus [Pa] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="lithosphere_density" type="',class(self.lithosphere_density),'" default="',convert2str(self.lithosphere_density),'">','     <section name="materials" />','     <help> Lithosphere density [g/cm^-3] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="mantle_shear_modulus" type="',class(self.mantle_shear_modulus),'" default="',convert2str(self.mantle_shear_modulus),'">','     <section name="materials" />','     <help> Mantle shear modulus [Pa] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="mantle_density" type="',class(self.mantle_density),'" default="',convert2str(self.mantle_density),'">','     <section name="materials" />','     <help> Mantle density [g/cm^-3] </help>','</parameter>');
 
 
 		end % }}}
-		function obj = matice(varargin) % {{{
+		function self = matice(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				case 1
 					inputstruct=varargin{1};
 					list1 = properties('matice');
@@ -81,63 +81,63 @@
 					for i=1:length(list1)
 						fieldname = list1{i};
 						if ismember(fieldname,list2),
-							obj.(fieldname) = inputstruct.(fieldname);
+							self.(fieldname) = inputstruct.(fieldname);
 						end
 					end
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 			%ice density (kg/m^3)
-			obj.rho_ice=917.;
+			self.rho_ice=917.;
 
 			%ocean water density (kg/m^3)
-			obj.rho_water=1023.;
+			self.rho_water=1023.;
 
 			%fresh water density (kg/m^3)
-			obj.rho_freshwater=1000.;
+			self.rho_freshwater=1000.;
 
 			%water viscosity (N.s/m^2)
-			obj.mu_water=0.001787;  
+			self.mu_water=0.001787;  
 
 			%ice heat capacity cp (J/kg/K)
-			obj.heatcapacity=2093.;
+			self.heatcapacity=2093.;
 
 			%ice latent heat of fusion L (J/kg)
-			obj.latentheat=3.34*10^5;
+			self.latentheat=3.34*10^5;
 
 			%ice thermal conductivity (W/m/K)
-			obj.thermalconductivity=2.4;
+			self.thermalconductivity=2.4;
 			
 			%wet ice thermal conductivity (W/m/K)
-			obj.temperateiceconductivity=.24;
+			self.temperateiceconductivity=.24;
 
 			%the melting point of ice at 1 atmosphere of pressure in K
-			obj.meltingpoint=273.15;
+			self.meltingpoint=273.15;
 
 			%rate of change of melting point with pressure (K/Pa)
-			obj.beta=9.8*10^-8;
+			self.beta=9.8*10^-8;
 
 			%mixed layer (ice-water interface) heat capacity (J/kg/K)
-			obj.mixed_layer_capacity=3974.;
+			self.mixed_layer_capacity=3974.;
 
 			%thermal exchange velocity (ice-water interface) (m/s)
-			obj.thermal_exchange_velocity=1.00*10^-4;
+			self.thermal_exchange_velocity=1.00*10^-4;
 
 			%Rheology law: what is the temperature dependence of B with T
 			%available: none, paterson and arrhenius
-			obj.rheology_law='Paterson';
+			self.rheology_law='Paterson';
 
 			% GIA:
-			obj.lithosphere_shear_modulus  = 6.7*10^10;  % (Pa)
-			obj.lithosphere_density        = 3.32;       % (g/cm^-3)
-			obj.mantle_shear_modulus       = 1.45*10^11; % (Pa)
-			obj.mantle_density             = 3.34;       % (g/cm^-3)
+			self.lithosphere_shear_modulus  = 6.7*10^10;  % (Pa)
+			self.lithosphere_density        = 3.32;       % (g/cm^-3)
+			self.mantle_shear_modulus       = 1.45*10^11; % (Pa)
+			self.mantle_density             = 3.34;       % (g/cm^-3)
 
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 			md = checkfield(md,'fieldname','materials.rho_ice','>',0);
 			md = checkfield(md,'fieldname','materials.rho_water','>',0);
 			md = checkfield(md,'fieldname','materials.rho_freshwater','>',0);
@@ -154,51 +154,51 @@
 			end
 
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   Materials:'));
 
-			fielddisplay(obj,'rho_ice','ice density [kg/m^3]');
-			fielddisplay(obj,'rho_water','ocean water density [kg/m^3]');
-			fielddisplay(obj,'rho_freshwater','fresh water density [kg/m^3]');
-			fielddisplay(obj,'mu_water','water viscosity [N s/m^2]');
-			fielddisplay(obj,'heatcapacity','heat capacity [J/kg/K]');
-			fielddisplay(obj,'thermalconductivity',['ice thermal conductivity [W/m/K]']);
-			fielddisplay(obj,'temperateiceconductivity','temperate ice thermal conductivity [W/m/K]');
-			fielddisplay(obj,'meltingpoint','melting point of ice at 1atm in K');
-			fielddisplay(obj,'latentheat','latent heat of fusion [J/kg]');
-			fielddisplay(obj,'beta','rate of change of melting point with pressure [K/Pa]');
-			fielddisplay(obj,'mixed_layer_capacity','mixed layer capacity [W/kg/K]');
-			fielddisplay(obj,'thermal_exchange_velocity','thermal exchange velocity [m/s]');
-			fielddisplay(obj,'rheology_B','flow law parameter [Pa/s^(1/n)]');
-			fielddisplay(obj,'rheology_n','Glen''s flow law exponent');
-			fielddisplay(obj,'rheology_law',['law for the temperature dependance of the rheology: ''None'', ''Cuffey'', ''Paterson'', ''Arrhenius'' or ''LliboutryDuval''']);
-			fielddisplay(obj,'lithosphere_shear_modulus','Lithosphere shear modulus [Pa]');
-			fielddisplay(obj,'lithosphere_density','Lithosphere density [g/cm^-3]');
-			fielddisplay(obj,'mantle_shear_modulus','Mantle shear modulus [Pa]');
-			fielddisplay(obj,'mantle_density','Mantle density [g/cm^-3]');
+			fielddisplay(self,'rho_ice','ice density [kg/m^3]');
+			fielddisplay(self,'rho_water','ocean water density [kg/m^3]');
+			fielddisplay(self,'rho_freshwater','fresh water density [kg/m^3]');
+			fielddisplay(self,'mu_water','water viscosity [N s/m^2]');
+			fielddisplay(self,'heatcapacity','heat capacity [J/kg/K]');
+			fielddisplay(self,'thermalconductivity',['ice thermal conductivity [W/m/K]']);
+			fielddisplay(self,'temperateiceconductivity','temperate ice thermal conductivity [W/m/K]');
+			fielddisplay(self,'meltingpoint','melting point of ice at 1atm in K');
+			fielddisplay(self,'latentheat','latent heat of fusion [J/kg]');
+			fielddisplay(self,'beta','rate of change of melting point with pressure [K/Pa]');
+			fielddisplay(self,'mixed_layer_capacity','mixed layer capacity [W/kg/K]');
+			fielddisplay(self,'thermal_exchange_velocity','thermal exchange velocity [m/s]');
+			fielddisplay(self,'rheology_B','flow law parameter [Pa/s^(1/n)]');
+			fielddisplay(self,'rheology_n','Glen''s flow law exponent');
+			fielddisplay(self,'rheology_law',['law for the temperature dependance of the rheology: ''None'', ''Cuffey'', ''Paterson'', ''Arrhenius'' or ''LliboutryDuval''']);
+			fielddisplay(self,'lithosphere_shear_modulus','Lithosphere shear modulus [Pa]');
+			fielddisplay(self,'lithosphere_density','Lithosphere density [g/cm^-3]');
+			fielddisplay(self,'mantle_shear_modulus','Mantle shear modulus [Pa]');
+			fielddisplay(self,'mantle_density','Mantle density [g/cm^-3]');
 		end % }}}
-		function marshall(obj,md,fid) % {{{
+		function marshall(self,md,fid) % {{{
 			WriteData(fid,'enum',MaterialsEnum(),'data',MaticeEnum(),'format','Integer');
-			WriteData(fid,'object',obj,'class','materials','fieldname','rho_ice','format','Double');
-			WriteData(fid,'object',obj,'class','materials','fieldname','rho_water','enum',MaterialsRhoSeawaterEnum(),'format','Double');
-			WriteData(fid,'object',obj,'class','materials','fieldname','rho_freshwater','format','Double');
-			WriteData(fid,'object',obj,'class','materials','fieldname','mu_water','format','Double');
-			WriteData(fid,'object',obj,'class','materials','fieldname','heatcapacity','format','Double');
-			WriteData(fid,'object',obj,'class','materials','fieldname','latentheat','format','Double');
-			WriteData(fid,'object',obj,'class','materials','fieldname','thermalconductivity','format','Double');
-			WriteData(fid,'object',obj,'class','materials','fieldname','temperateiceconductivity','format','Double');
-			WriteData(fid,'object',obj,'class','materials','fieldname','meltingpoint','format','Double');
-			WriteData(fid,'object',obj,'class','materials','fieldname','beta','format','Double');
-			WriteData(fid,'object',obj,'class','materials','fieldname','mixed_layer_capacity','format','Double');
-			WriteData(fid,'object',obj,'class','materials','fieldname','thermal_exchange_velocity','format','Double');
-			WriteData(fid,'object',obj,'class','materials','fieldname','rheology_B','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
-			WriteData(fid,'object',obj,'class','materials','fieldname','rheology_n','format','DoubleMat','mattype',2);
-			WriteData(fid,'data',StringToEnum(obj.rheology_law),'enum',MaterialsRheologyLawEnum(),'format','Integer');
+			WriteData(fid,'object',self,'class','materials','fieldname','rho_ice','format','Double');
+			WriteData(fid,'object',self,'class','materials','fieldname','rho_water','enum',MaterialsRhoSeawaterEnum(),'format','Double');
+			WriteData(fid,'object',self,'class','materials','fieldname','rho_freshwater','format','Double');
+			WriteData(fid,'object',self,'class','materials','fieldname','mu_water','format','Double');
+			WriteData(fid,'object',self,'class','materials','fieldname','heatcapacity','format','Double');
+			WriteData(fid,'object',self,'class','materials','fieldname','latentheat','format','Double');
+			WriteData(fid,'object',self,'class','materials','fieldname','thermalconductivity','format','Double');
+			WriteData(fid,'object',self,'class','materials','fieldname','temperateiceconductivity','format','Double');
+			WriteData(fid,'object',self,'class','materials','fieldname','meltingpoint','format','Double');
+			WriteData(fid,'object',self,'class','materials','fieldname','beta','format','Double');
+			WriteData(fid,'object',self,'class','materials','fieldname','mixed_layer_capacity','format','Double');
+			WriteData(fid,'object',self,'class','materials','fieldname','thermal_exchange_velocity','format','Double');
+			WriteData(fid,'object',self,'class','materials','fieldname','rheology_B','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
+			WriteData(fid,'object',self,'class','materials','fieldname','rheology_n','format','DoubleMat','mattype',2);
+			WriteData(fid,'data',StringToEnum(self.rheology_law),'enum',MaterialsRheologyLawEnum(),'format','Integer');
 
-			WriteData(fid,'object',obj,'class','materials','fieldname','lithosphere_shear_modulus','format','Double');
-			WriteData(fid,'object',obj,'class','materials','fieldname','lithosphere_density','format','Double','scale',10^3);
-			WriteData(fid,'object',obj,'class','materials','fieldname','mantle_shear_modulus','format','Double');
-			WriteData(fid,'object',obj,'class','materials','fieldname','mantle_density','format','Double','scale',10^3);
+			WriteData(fid,'object',self,'class','materials','fieldname','lithosphere_shear_modulus','format','Double');
+			WriteData(fid,'object',self,'class','materials','fieldname','lithosphere_density','format','Double','scale',10^3);
+			WriteData(fid,'object',self,'class','materials','fieldname','mantle_shear_modulus','format','Double');
+			WriteData(fid,'object',self,'class','materials','fieldname','mantle_density','format','Double','scale',10^3);
 		end % }}}
 	end
 end
Index: ../trunk-jpl/src/m/classes/frictiontemp.m
===================================================================
--- ../trunk-jpl/src/m/classes/frictiontemp.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/frictiontemp.m	(revision 19040)
@@ -11,24 +11,24 @@
 		q           = NaN;
 	end
 	methods
-		function obj = frictiontemp(varargin) % {{{
+		function self = frictiontemp(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				case 1
 					obj=structtoobj(frictiontemp(),varargin{1});
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 			%By default gamma = 1;
-			obj.gamma = 1;
+			self.gamma = 1;
 
 
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 			%Early return
 			if ~ismember(StressbalanceAnalysisEnum(),analyses) & ~ismember(ThermalAnalysisEnum(),analyses), return; end
@@ -41,20 +41,20 @@
 			%Check that temperature is provided
 			md = checkfield(md,'fieldname','initialization.temperature','NaN',1,'size',[md.mesh.numberofvertices 1]);
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('Basal shear stress parameters: tau_b = coefficient^2 * Neff ^r * |u_b|^(s-1) * u_b * 1/f(T)\n(effective stress Neff=rho_ice*g*thickness+rho_water*g*bed, r=q/p and s=1/p)'));
-			fielddisplay(obj,'gamma','submelt sliding parameter f(T) = exp((T-Tpmp)/gamma)');
-			fielddisplay(obj,'coefficient','frictiontemp coefficient [SI]');
-			fielddisplay(obj,'p','p exponent');
-			fielddisplay(obj,'q','q exponent');
+			fielddisplay(self,'gamma','submelt sliding parameter f(T) = exp((T-Tpmp)/gamma)');
+			fielddisplay(self,'coefficient','frictiontemp coefficient [SI]');
+			fielddisplay(self,'p','p exponent');
+			fielddisplay(self,'q','q exponent');
 		end % }}}
-		function marshall(obj,md,fid) % {{{
+		function marshall(self,md,fid) % {{{
 
 			WriteData(fid,'enum',FrictionLawEnum,'data',4,'format','Integer');
-			WriteData(fid,'class','friction','object',obj,'fieldname','gamma','format','Double');
-			WriteData(fid,'class','friction','object',obj,'fieldname','coefficient','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
-			WriteData(fid,'class','friction','object',obj,'fieldname','p','format','DoubleMat','mattype',2);
-			WriteData(fid,'class','friction','object',obj,'fieldname','q','format','DoubleMat','mattype',2);
+			WriteData(fid,'class','friction','object',self,'fieldname','gamma','format','Double');
+			WriteData(fid,'class','friction','object',self,'fieldname','coefficient','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
+			WriteData(fid,'class','friction','object',self,'fieldname','p','format','DoubleMat','mattype',2);
+			WriteData(fid,'class','friction','object',self,'fieldname','q','format','DoubleMat','mattype',2);
 		end % }}}
 	end
 end
Index: ../trunk-jpl/src/m/classes/verbose.m
===================================================================
--- ../trunk-jpl/src/m/classes/verbose.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/verbose.m	(revision 19040)
@@ -37,21 +37,21 @@
 	end
 	%}}}
 	methods
-        function createxml(obj,fid) % {{{
-            fprintf(fid, '\n\n');
-            fprintf(fid, '%s\n', '<!-- verbose -->');
-             
-             fprintf(fid,'%s%s%s\n%s\n%s%s%s\n%s\n%s\n',    '<parameter key ="mprocessor" type="',              class(obj.mprocessor),'" optional="false">',              '     <section name="verbose" />','        <option value="',convert2str(obj.mprocessor),'" type="string" default="true"></option>','     <help>  </help>','</parameter>');
-             fprintf(fid,'%s%s%s\n%s\n%s%s%s\n%s\n%s\n',    '<parameter key ="module" type="',              class(obj.module),'" optional="false">',              '     <section name="verbose" />','        <option value="',convert2str(obj.module),'" type="string" default="true"></option>','     <help>  </help>','</parameter>');
-             fprintf(fid,'%s%s%s\n%s\n%s%s%s\n%s\n%s\n',    '<parameter key ="solution" type="',              class(obj.solution),'" optional="false">',              '     <section name="verbose" />','        <option value="',convert2str(obj.solution),'" type="string" default="true"></option>','     <help>  </help>','</parameter>');
-             fprintf(fid,'%s%s%s\n%s\n%s%s%s\n%s\n%s\n',    '<parameter key ="solver" type="',              class(obj.solver),'" optional="false">',              '     <section name="verbose" />','        <option value="',convert2str(obj.solver),'" type="string" default="true"></option>','     <help>  </help>','</parameter>');
-             fprintf(fid,'%s%s%s\n%s\n%s%s%s\n%s\n%s\n',    '<parameter key ="convergence" type="',              class(obj.convergence),'" optional="false">',              '     <section name="verbose" />','        <option value="',convert2str(obj.convergence),'" type="string" default="true"></option>','     <help>  </help>','</parameter>');
-             fprintf(fid,'%s%s%s\n%s\n%s%s%s\n%s\n%s\n',    '<parameter key ="control" type="',              class(obj.control),'" optional="false">',              '     <section name="verbose" />','        <option value="',convert2str(obj.control),'" type="string" default="true"></option>','     <help>  </help>','</parameter>');
-             fprintf(fid,'%s%s%s\n%s\n%s%s%s\n%s\n%s\n',    '<parameter key ="qmu" type="',              class(obj.qmu),'" optional="false">',              '     <section name="verbose" />','        <option value="',convert2str(obj.qmu),'" type="string" default="true"></option>','     <help>  </help>','</parameter>');
-             fprintf(fid,'%s%s%s\n%s\n%s%s%s\n%s\n',    '<parameter key ="autodiff" type="',              class(obj.autodiff),'" optional="false">',              '     <section name="verbose" />','        <option value="',convert2str(obj.autodiff),'" type="string" default="true"></option>','     <help>  </help>','</parameter>');
-             
-             
-        end % }}}
+		function createxml(self,fid) % {{{
+			fprintf(fid, '\n\n');
+			fprintf(fid, '%s\n', '<!-- verbose -->');
+
+			fprintf(fid,'%s%s%s\n%s\n%s%s%s\n%s\n%s\n',    '<parameter key ="mprocessor" type="',              class(self.mprocessor),'" optional="false">',              '     <section name="verbose" />','        <option value="',convert2str(self.mprocessor),'" type="string" default="true"></option>','     <help>  </help>','</parameter>');
+			fprintf(fid,'%s%s%s\n%s\n%s%s%s\n%s\n%s\n',    '<parameter key ="module" type="',              class(self.module),'" optional="false">',              '     <section name="verbose" />','        <option value="',convert2str(self.module),'" type="string" default="true"></option>','     <help>  </help>','</parameter>');
+			fprintf(fid,'%s%s%s\n%s\n%s%s%s\n%s\n%s\n',    '<parameter key ="solution" type="',              class(self.solution),'" optional="false">',              '     <section name="verbose" />','        <option value="',convert2str(self.solution),'" type="string" default="true"></option>','     <help>  </help>','</parameter>');
+			fprintf(fid,'%s%s%s\n%s\n%s%s%s\n%s\n%s\n',    '<parameter key ="solver" type="',              class(self.solver),'" optional="false">',              '     <section name="verbose" />','        <option value="',convert2str(self.solver),'" type="string" default="true"></option>','     <help>  </help>','</parameter>');
+			fprintf(fid,'%s%s%s\n%s\n%s%s%s\n%s\n%s\n',    '<parameter key ="convergence" type="',              class(self.convergence),'" optional="false">',              '     <section name="verbose" />','        <option value="',convert2str(self.convergence),'" type="string" default="true"></option>','     <help>  </help>','</parameter>');
+			fprintf(fid,'%s%s%s\n%s\n%s%s%s\n%s\n%s\n',    '<parameter key ="control" type="',              class(self.control),'" optional="false">',              '     <section name="verbose" />','        <option value="',convert2str(self.control),'" type="string" default="true"></option>','     <help>  </help>','</parameter>');
+			fprintf(fid,'%s%s%s\n%s\n%s%s%s\n%s\n%s\n',    '<parameter key ="qmu" type="',              class(self.qmu),'" optional="false">',              '     <section name="verbose" />','        <option value="',convert2str(self.qmu),'" type="string" default="true"></option>','     <help>  </help>','</parameter>');
+			fprintf(fid,'%s%s%s\n%s\n%s%s%s\n%s\n',    '<parameter key ="autodiff" type="',              class(self.autodiff),'" optional="false">',              '     <section name="verbose" />','        <option value="',convert2str(self.autodiff),'" type="string" default="true"></option>','     <help>  </help>','</parameter>');
+
+
+		end % }}}
 		function verbose=verbose(varargin) % {{{
 
 			switch(nargin),
@@ -122,7 +122,7 @@
 
 		end
 		%}}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 		end % }}}
 		function disp(verbose) % {{{
@@ -141,8 +141,8 @@
 
 		end
 		%}}}
-		function marshall(obj,md,fid) % {{{
-			WriteData(fid,'data',VerboseToBinary(obj),'enum',VerboseEnum(),'format','Integer');
+		function marshall(self,md,fid) % {{{
+			WriteData(fid,'data',VerboseToBinary(self),'enum',VerboseEnum(),'format','Integer');
 		end % }}}
 	end
 end
Index: ../trunk-jpl/src/m/classes/massconaxpby.m
===================================================================
--- ../trunk-jpl/src/m/classes/massconaxpby.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/massconaxpby.m	(revision 19040)
@@ -22,60 +22,60 @@
 	end
 	
 	methods
-		function obj = massconaxpby(varargin) % {{{
+		function self = massconaxpby(varargin) % {{{
 			if nargin==0,
-				obj=setdefaultparameters(obj);
+				self=setdefaultparameters(self);
 			else
 				%use provided options to change fields
 				options=pairoptions(varargin{:});
 
 				%get names
-				obj.name=getfieldvalue(options,'name','');
-				obj.definitionenum=getfieldvalue(options,'definitionenum');
-				obj.namex=getfieldvalue(options,'namex');
-				obj.namey=getfieldvalue(options,'namey');
+				self.name=getfieldvalue(options,'name','');
+				self.definitionenum=getfieldvalue(options,'definitionenum');
+				self.namex=getfieldvalue(options,'namex');
+				self.namey=getfieldvalue(options,'namey');
 
 				%get multiplicators: 
-				obj.alpha=getfieldvalue(options,'alpha');
-				obj.beta=getfieldvalue(options,'beta');
+				self.alpha=getfieldvalue(options,'alpha');
+				self.beta=getfieldvalue(options,'beta');
 
 
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
-			if ~ischar(obj.name), error('masscon error message: ''name'' field should be a string!'); end
-			if ~ischar(obj.namex), error('masscon error message: ''namex'' field should be a string!'); end
-			if ~ischar(obj.namey), error('masscon error message: ''namey'' field should be a string!'); end
+			if ~ischar(self.name), error('masscon error message: ''name'' field should be a string!'); end
+			if ~ischar(self.namex), error('masscon error message: ''namex'' field should be a string!'); end
+			if ~ischar(self.namey), error('masscon error message: ''namey'' field should be a string!'); end
 			
-			md = checkfield(md,'fieldname','obj.definitionenum','field',obj.definitionenum,'values',[Outputdefinition1Enum,Outputdefinition2Enum,Outputdefinition3Enum,Outputdefinition4Enum,Outputdefinition5Enum,Outputdefinition6Enum,Outputdefinition7Enum,Outputdefinition8Enum,Outputdefinition9Enum,Outputdefinition10Enum]);
+			md = checkfield(md,'fieldname','self.definitionenum','field',self.definitionenum,'values',[Outputdefinition1Enum,Outputdefinition2Enum,Outputdefinition3Enum,Outputdefinition4Enum,Outputdefinition5Enum,Outputdefinition6Enum,Outputdefinition7Enum,Outputdefinition8Enum,Outputdefinition9Enum,Outputdefinition10Enum]);
 
-			md = checkfield(md,'fieldname','obj.alpha','field',obj.alpha,'NaN',1,'size',[1 1]);
-			md = checkfield(md,'fieldname','obj.betaa','field',obj.beta,'NaN',1,'size',[1 1]);
+			md = checkfield(md,'fieldname','self.alpha','field',self.alpha,'NaN',1,'size',[1 1]);
+			md = checkfield(md,'fieldname','self.betaa','field',self.beta,'NaN',1,'size',[1 1]);
 
 		end % }}}
-		function md = disp(obj) % {{{
+		function md = disp(self) % {{{
 		
 			disp(sprintf('   Misfit:\n'));
 
-			fielddisplay(obj,'name','name');
-			fielddisplay(obj,'definitionenum','enum that identifies this output definition uniquely, from Outputdefinition[1-10]Enum');
-			fielddisplay(obj,'namex','identifier for the first masscon');
-			fielddisplay(obj,'alpha','first masscon multiplicator');
-			fielddisplay(obj,'namey','identifier for the second masscon');
-			fielddisplay(obj,'beta','second masscon multiplicator');
+			fielddisplay(self,'name','name');
+			fielddisplay(self,'definitionenum','enum that identifies this output definition uniquely, from Outputdefinition[1-10]Enum');
+			fielddisplay(self,'namex','identifier for the first masscon');
+			fielddisplay(self,'alpha','first masscon multiplicator');
+			fielddisplay(self,'namey','identifier for the second masscon');
+			fielddisplay(self,'beta','second masscon multiplicator');
 
 		end % }}}
-		function md = marshall(obj,md,fid) % {{{
+		function md = marshall(self,md,fid) % {{{
 
-		WriteData(fid,'object',obj,'fieldname','name','format','String');
-		WriteData(fid,'object',obj,'fieldname','definitionenum','format','Integer');
-		WriteData(fid,'object',obj,'fieldname','namex','format','String');
-		WriteData(fid,'object',obj,'fieldname','namey','format','String');
-		WriteData(fid,'object',obj,'fieldname','alpha','format','Double');
-		WriteData(fid,'object',obj,'fieldname','beta','format','Double');
+		WriteData(fid,'object',self,'fieldname','name','format','String');
+		WriteData(fid,'object',self,'fieldname','definitionenum','format','Integer');
+		WriteData(fid,'object',self,'fieldname','namex','format','String');
+		WriteData(fid,'object',self,'fieldname','namey','format','String');
+		WriteData(fid,'object',self,'fieldname','alpha','format','Double');
+		WriteData(fid,'object',self,'fieldname','beta','format','Double');
 
 		end % }}}
 	end
Index: ../trunk-jpl/src/m/classes/transient.m
===================================================================
--- ../trunk-jpl/src/m/classes/transient.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/transient.m	(revision 19040)
@@ -17,62 +17,62 @@
 		requested_outputs = {};
 	end
 	methods
-        function createxml(obj,fid) % {{{
+        function createxml(self,fid) % {{{
             fprintf(fid, '<!-- transient -->\n');            
                     
             % transient solution parameters
             fprintf(fid,'%s\n%s\n%s\n','<frame key="1" label="transient solution parameters">','<section name="transient" />');                    
-                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="ismasstransport" type="',class(obj.ismasstransport),'" default="',convert2str(obj.ismasstransport),'">','     <section name="transient" />','     <help> indicates whether a masstransport solution is used in the transient </help>','  </parameter>');
-                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="isstressbalance" type="',class(obj.isstressbalance),'" default="',convert2str(obj.isstressbalance),'">','     <section name="transient" />','     <help> indicates whether a stressbalance solution is used in the transient </help>','  </parameter>');
-                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="isthermal" type="',class(obj.isthermal),'" default="',convert2str(obj.isthermal),'">','     <section name="transient" />','     <help> indicates whether a thermal solution is used in the transient </help>','  </parameter>');
-                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="isgroundingline" type="',class(obj.isgroundingline),'" default="',convert2str(obj.isgroundingline),'">','     <section name="transient" />','     <help> indicates whether a groundingline migration is used in the transient </help>','  </parameter>');
-                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="isgia" type="',class(obj.isgia),'" default="',convert2str(obj.isgia),'">','     <section name="transient" />','     <help> indicates whether a postglacial rebound model is used in the transient </help>','  </parameter>');
-                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="isdamageevolution" type="',class(obj.isdamageevolution),'" default="',convert2str(obj.isdamageevolution),'">','     <section name="transient" />','     <help> indicates whether damage evolution is used in the transient </help>','  </parameter>');
-                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="islevelset" type="',class(obj.islevelset),'" default="',convert2str(obj.islevelset),'">','     <section name="transient" />','     <help> LEVEL SET DESCRIPTION...  </help>','  </parameter>');
-                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="iscalving" type="',class(obj.iscalving),'" default="',convert2str(obj.iscalving),'">','     <section name="transient" />','     <help> indicates whether calving is used in the transient </help>','  </parameter>');
-                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="requested_outputs" type="',class(obj.requested_outputs),'" default="',convert2str(obj.requested_outputs),'">','     <section name="transient" />','     <help> list of additional outputs requested </help>','  </parameter>');
+                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="ismasstransport" type="',class(self.ismasstransport),'" default="',convert2str(self.ismasstransport),'">','     <section name="transient" />','     <help> indicates whether a masstransport solution is used in the transient </help>','  </parameter>');
+                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="isstressbalance" type="',class(self.isstressbalance),'" default="',convert2str(self.isstressbalance),'">','     <section name="transient" />','     <help> indicates whether a stressbalance solution is used in the transient </help>','  </parameter>');
+                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="isthermal" type="',class(self.isthermal),'" default="',convert2str(self.isthermal),'">','     <section name="transient" />','     <help> indicates whether a thermal solution is used in the transient </help>','  </parameter>');
+                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="isgroundingline" type="',class(self.isgroundingline),'" default="',convert2str(self.isgroundingline),'">','     <section name="transient" />','     <help> indicates whether a groundingline migration is used in the transient </help>','  </parameter>');
+                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="isgia" type="',class(self.isgia),'" default="',convert2str(self.isgia),'">','     <section name="transient" />','     <help> indicates whether a postglacial rebound model is used in the transient </help>','  </parameter>');
+                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="isdamageevolution" type="',class(self.isdamageevolution),'" default="',convert2str(self.isdamageevolution),'">','     <section name="transient" />','     <help> indicates whether damage evolution is used in the transient </help>','  </parameter>');
+                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="islevelset" type="',class(self.islevelset),'" default="',convert2str(self.islevelset),'">','     <section name="transient" />','     <help> LEVEL SET DESCRIPTION...  </help>','  </parameter>');
+                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="iscalving" type="',class(self.iscalving),'" default="',convert2str(self.iscalving),'">','     <section name="transient" />','     <help> indicates whether calving is used in the transient </help>','  </parameter>');
+                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="requested_outputs" type="',class(self.requested_outputs),'" default="',convert2str(self.requested_outputs),'">','     <section name="transient" />','     <help> list of additional outputs requested </help>','  </parameter>');
             fprintf(fid,'%s\n%s\n','</frame>');    
         
         end % }}}
-		function obj = transient(varargin) % {{{
+		function self = transient(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self = setdefaultparameters(self);
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = deactivateall(obj) % {{{
+		function self = deactivateall(self) % {{{
 
 			%full analysis: Stressbalance, Masstransport and Thermal but no groundingline migration for now
-			obj.ismasstransport = 0;
-			obj.isstressbalance = 0;
-			obj.isthermal       = 0;
-			obj.isgroundingline = 0;
-			obj.isgia           = 0;
-			obj.isdamageevolution = 0;
-			obj.islevelset      = 0;
-			obj.iscalving       =0;
-			obj.ishydrology     = 0;
+			self.ismasstransport = 0;
+			self.isstressbalance = 0;
+			self.isthermal       = 0;
+			self.isgroundingline = 0;
+			self.isgia           = 0;
+			self.isdamageevolution = 0;
+			self.islevelset      = 0;
+			self.iscalving       =0;
+			self.ishydrology     = 0;
 
 			%default output
-			obj.requested_outputs={};
+			self.requested_outputs={};
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 			%full analysis: Stressbalance, Masstransport and Thermal but no groundingline migration for now
-			obj.ismasstransport = 1;
-			obj.isstressbalance = 1;
-			obj.isthermal       = 1;
-			obj.isgroundingline = 0;
-			obj.isgia           = 0;
-			obj.isdamageevolution = 0;
-			obj.islevelset      = 0;
-			obj.iscalving       = 0;
-			obj.ishydrology     = 0;
+			self.ismasstransport = 1;
+			self.isstressbalance = 1;
+			self.isthermal       = 1;
+			self.isgroundingline = 0;
+			self.isgia           = 0;
+			self.isdamageevolution = 0;
+			self.islevelset      = 0;
+			self.iscalving       = 0;
+			self.ishydrology     = 0;
 
 			%default output
-			obj.requested_outputs={'default'};
+			self.requested_outputs={'default'};
 		end % }}}
 		function list = defaultoutputs(self,md) % {{{
 			if(self.ismasstransport)
@@ -81,7 +81,7 @@
 				list = {};
 			end
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 			%Early return
 			if solution~=TransientSolutionEnum(), return; end
@@ -98,38 +98,38 @@
 			md = checkfield(md,'fieldname','transient.requested_outputs','stringrow',1);
 
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   transient solution parameters:'));
 
-			fielddisplay(obj,'ismasstransport','indicates whether a masstransport solution is used in the transient');
-			fielddisplay(obj,'isstressbalance','indicates whether a stressbalance solution is used in the transient');
-			fielddisplay(obj,'isthermal','indicates whether a thermal solution is used in the transient');
-			fielddisplay(obj,'isgroundingline','indicates whether a groundingline migration is used in the transient');
-			fielddisplay(obj,'isgia','indicates whether a postglacial rebound model is used in the transient');
-			fielddisplay(obj,'isdamageevolution','indicates whether damage evolution is used in the transient');
-			fielddisplay(obj,'islevelset','LEVEL SET DESCRIPTION...');
-			fielddisplay(obj,'iscalving','indicates whether calving is used in the transient');
-			fielddisplay(obj,'ishydrology','indicates whether an hydrology model is used');
-			fielddisplay(obj,'requested_outputs','list of additional outputs requested');
+			fielddisplay(self,'ismasstransport','indicates whether a masstransport solution is used in the transient');
+			fielddisplay(self,'isstressbalance','indicates whether a stressbalance solution is used in the transient');
+			fielddisplay(self,'isthermal','indicates whether a thermal solution is used in the transient');
+			fielddisplay(self,'isgroundingline','indicates whether a groundingline migration is used in the transient');
+			fielddisplay(self,'isgia','indicates whether a postglacial rebound model is used in the transient');
+			fielddisplay(self,'isdamageevolution','indicates whether damage evolution is used in the transient');
+			fielddisplay(self,'islevelset','LEVEL SET DESCRIPTION...');
+			fielddisplay(self,'iscalving','indicates whether calving is used in the transient');
+			fielddisplay(self,'ishydrology','indicates whether an hydrology model is used');
+			fielddisplay(self,'requested_outputs','list of additional outputs requested');
 
 		end % }}}
-		function marshall(obj,md,fid) % {{{
-			WriteData(fid,'object',obj,'fieldname','ismasstransport','format','Boolean');
-			WriteData(fid,'object',obj,'fieldname','isstressbalance','format','Boolean');
-			WriteData(fid,'object',obj,'fieldname','isthermal','format','Boolean');
-			WriteData(fid,'object',obj,'fieldname','isgroundingline','format','Boolean');
-			WriteData(fid,'object',obj,'fieldname','isgia','format','Boolean');
-			WriteData(fid,'object',obj,'fieldname','isdamageevolution','format','Boolean');
-			WriteData(fid,'object',obj,'fieldname','ishydrology','format','Boolean');
-			WriteData(fid,'object',obj,'fieldname','islevelset','format','Boolean');
-			WriteData(fid,'object',obj,'fieldname','iscalving','format','Boolean');
+		function marshall(self,md,fid) % {{{
+			WriteData(fid,'object',self,'fieldname','ismasstransport','format','Boolean');
+			WriteData(fid,'object',self,'fieldname','isstressbalance','format','Boolean');
+			WriteData(fid,'object',self,'fieldname','isthermal','format','Boolean');
+			WriteData(fid,'object',self,'fieldname','isgroundingline','format','Boolean');
+			WriteData(fid,'object',self,'fieldname','isgia','format','Boolean');
+			WriteData(fid,'object',self,'fieldname','isdamageevolution','format','Boolean');
+			WriteData(fid,'object',self,'fieldname','ishydrology','format','Boolean');
+			WriteData(fid,'object',self,'fieldname','islevelset','format','Boolean');
+			WriteData(fid,'object',self,'fieldname','iscalving','format','Boolean');
 
 			%process requested outputs
-			outputs = obj.requested_outputs;
+			outputs = self.requested_outputs;
 			pos  = find(ismember(outputs,'default'));
 			if ~isempty(pos),
 				outputs(pos) = [];                         %remove 'default' from outputs
-				outputs      = [outputs defaultoutputs(obj,md)]; %add defaults
+				outputs      = [outputs defaultoutputs(self,md)]; %add defaults
 			end
 			WriteData(fid,'data',outputs,'enum',TransientRequestedOutputsEnum,'format','StringArray');
 		end % }}}
Index: ../trunk-jpl/src/m/classes/outputdefinition.m
===================================================================
--- ../trunk-jpl/src/m/classes/outputdefinition.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/outputdefinition.m	(revision 19040)
@@ -8,48 +8,48 @@
 		definitions                 = {};
 	end
 	methods
-	   function createxml(obj,fid) % {{{
+	   function createxml(self,fid) % {{{
             fprintf(fid, '<!-- outputdefinition -->\n');            
                     
             % outputdefinition solution parameters
             fprintf(fid,'%s\n%s\n%s\n','<frame key="1" label="outputdefinition">','<section name="outputdefinition" />');                    
-                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="definitions" type="',class(obj.definitions),'" default="',convert2str(obj.definitions),'">','     <section name="outputdefinition" />','     <help> list of potential outputs that can be requested, but which need additional data to be defined </help>','  </parameter>');
+                fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="definitions" type="',class(self.definitions),'" default="',convert2str(self.definitions),'">','     <section name="outputdefinition" />','     <help> list of potential outputs that can be requested, but which need additional data to be defined </help>','  </parameter>');
             fprintf(fid,'%s\n%s\n','</frame>');    
         
         end % }}}
-		function obj = outputdefinition(varargin) % {{{
+		function self = outputdefinition(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
-			obj.definitions={};
+			self.definitions={};
 
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 			md = checkfield(md,'fieldname','outputdefinition.definitions','cell',1);
 
-			for i=1:length(obj.definitions),
-				md=checkconsistency(obj.definitions{i},md,solution,analyses);
+			for i=1:length(self.definitions),
+				md=checkconsistency(self.definitions{i},md,solution,analyses);
 			end
 
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   outputdefinition:'));
-			fielddisplay(obj,'definitions','list of potential outputs that can be requested, but which need additional data to be defined');
+			fielddisplay(self,'definitions','list of potential outputs that can be requested, but which need additional data to be defined');
 
 		end % }}}
-		function marshall(obj,md,fid) % {{{
+		function marshall(self,md,fid) % {{{
 
-		enums=zeros(length(obj.definitions),1);
-		for i=1:length(obj.definitions),
-			obj.definitions{i}.marshall(md,fid);
-			classdefinition=class(obj.definitions{i});
+		enums=zeros(length(self.definitions),1);
+		for i=1:length(self.definitions),
+			self.definitions{i}.marshall(md,fid);
+			classdefinition=class(self.definitions{i});
 			classdefinition(1)=upper(classdefinition(1)); %so it matches our enums definitions.
 			enums(i)=StringToEnum(classdefinition);
 		end
Index: ../trunk-jpl/src/m/classes/constants.m
===================================================================
--- ../trunk-jpl/src/m/classes/constants.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/constants.m	(revision 19040)
@@ -11,37 +11,37 @@
 		referencetemperature = 0.;
 	end
 	methods
-        function createxml(obj,fid) % {{{
+        function createxml(self,fid) % {{{
             fprintf(fid, '\n\n');
             fprintf(fid, '%s\n', '<!-- constants -->');
-			 fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="g" type="',class(obj.g),'" default="',num2str(obj.g),'">','     <section name="constants" />','     <help> gravitational acceleration [m/s^2] </help>','</parameter>');
-             fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="yts" type="',class(obj.yts),'" default="',num2str(obj.yts),'">','     <section name="constants" />','     <help> number of seconds in a year [s/yr] </help>','</parameter>');
-             fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','<parameter key ="referencetemperature" type="',class(obj.referencetemperature),'" default="',num2str(obj.referencetemperature),'">','     <section name="constants" />','     <help> reference temperature used in the enthalpy model [K] </help>','</parameter>');
+			 fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="g" type="',class(self.g),'" default="',num2str(self.g),'">','     <section name="constants" />','     <help> gravitational acceleration [m/s^2] </help>','</parameter>');
+             fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="yts" type="',class(self.yts),'" default="',num2str(self.yts),'">','     <section name="constants" />','     <help> number of seconds in a year [s/yr] </help>','</parameter>');
+             fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','<parameter key ="referencetemperature" type="',class(self.referencetemperature),'" default="',num2str(self.referencetemperature),'">','     <section name="constants" />','     <help> reference temperature used in the enthalpy model [K] </help>','</parameter>');
 		end % }}}
-		function obj = constants(varargin) % {{{
+		function self = constants(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 			%acceleration due to gravity (m/s^2)
-			obj.g=9.81;
+			self.g=9.81;
 
 			%Earth's rotation speed 
-			obj.omega = 7.292*1e-5;
+			self.omega = 7.292*1e-5;
 
 			%converstion from year to seconds
-			obj.yts=365*24*3600;
+			self.yts=365*24*3600;
 
 			%the reference temperature for enthalpy model (cf Aschwanden)
-			obj.referencetemperature=223.15;
+			self.referencetemperature=223.15;
 
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 			md = checkfield(md,'fieldname','constants.g','>=',0,'size',[1 1]); %We allow 0 for validation tests
 			md = checkfield(md,'fieldname','constants.omega','>=',0,'size',[1 1]);
@@ -49,20 +49,20 @@
 			md = checkfield(md,'fieldname','constants.referencetemperature','size',[1 1]);
 
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   constants parameters:'));
 
-			fielddisplay(obj,'g','gravitational acceleration [m/s^2]');
-			fielddisplay(obj,'omega','angular velocity of Earth [rad/s]');
-			fielddisplay(obj,'yts','number of seconds in a year [s/yr]');
-			fielddisplay(obj,'referencetemperature','reference temperature used in the enthalpy model [K]');
+			fielddisplay(self,'g','gravitational acceleration [m/s^2]');
+			fielddisplay(self,'omega','angular velocity of Earth [rad/s]');
+			fielddisplay(self,'yts','number of seconds in a year [s/yr]');
+			fielddisplay(self,'referencetemperature','reference temperature used in the enthalpy model [K]');
 
 		end % }}}
-		function marshall(obj,md,fid) % {{{
-			WriteData(fid,'object',obj,'fieldname','g','format','Double');
-			WriteData(fid,'object',obj,'fieldname','omega','format','Double');
-			WriteData(fid,'object',obj,'fieldname','yts','format','Double');
-			WriteData(fid,'object',obj,'fieldname','referencetemperature','format','Double');
+		function marshall(self,md,fid) % {{{
+			WriteData(fid,'object',self,'fieldname','g','format','Double');
+			WriteData(fid,'object',self,'fieldname','omega','format','Double');
+			WriteData(fid,'object',self,'fieldname','yts','format','Double');
+			WriteData(fid,'object',self,'fieldname','referencetemperature','format','Double');
 		end % }}}
 	end
 end
Index: ../trunk-jpl/src/m/classes/adinversion.m
===================================================================
--- ../trunk-jpl/src/m/classes/adinversion.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/adinversion.m	(revision 19040)
@@ -25,10 +25,10 @@
 
 	end
 	methods
-		function obj = adinversion(varargin) % {{{
+		function self = adinversion(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				case 1
 					obj=structtoobj(adinversion(),varargin{1});
 				otherwise
@@ -56,10 +56,10 @@
 			self.gttol = 1e-4;
 
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 			%Early return
-			if ~obj.iscontrol, return; end
+			if ~self.iscontrol, return; end
 
 			if ~IssmConfig('_HAVE_M1QN3_'),
 				md = checkmessage(md,['M1QN3 has not been installed, ISSM needs to be reconfigured and recompiled with AD']);
@@ -94,24 +94,24 @@
 				end
 			end
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   adinversion parameters:'));
-			fielddisplay(obj,'iscontrol','is inversion activated?');
-			fielddisplay(obj,'control_parameters','ex: {''FrictionCoefficient''}, or {''MaterialsRheologyBbar''}');
-			fielddisplay(obj,'control_scaling_factors','order of magnitude of each control (useful for multi-parameter optimization)');
-			fielddisplay(obj,'maxsteps','maximum number of iterations (gradient computation)');
-			fielddisplay(obj,'maxiter','maximum number of Function evaluation (forward run)');
-			fielddisplay(obj,'dxmin','convergence criterion: two points less than dxmin from eachother (sup-norm) are considered identical');
-			fielddisplay(obj,'gttol','convergence criterion: ||g(X)||/||g(X0)|| (g(X0): gradient at initial guess X0)');
-			fielddisplay(obj,'cost_functions','indicate the type of response for each optimization step');
-			fielddisplay(obj,'cost_functions_coefficients','cost_functions_coefficients applied to the misfit of each vertex and for each control_parameter');
-			fielddisplay(obj,'min_parameters','absolute minimum acceptable value of the inversed parameter on each vertex');
-			fielddisplay(obj,'max_parameters','absolute maximum acceptable value of the inversed parameter on each vertex');
-			fielddisplay(obj,'vx_obs','observed velocity x component [m/yr]');
-			fielddisplay(obj,'vy_obs','observed velocity y component [m/yr]');
-			fielddisplay(obj,'vel_obs','observed velocity magnitude [m/yr]');
-			fielddisplay(obj,'thickness_obs','observed thickness [m]');
-			fielddisplay(obj,'surface_obs','observed surface elevation [m]');
+			fielddisplay(self,'iscontrol','is inversion activated?');
+			fielddisplay(self,'control_parameters','ex: {''FrictionCoefficient''}, or {''MaterialsRheologyBbar''}');
+			fielddisplay(self,'control_scaling_factors','order of magnitude of each control (useful for multi-parameter optimization)');
+			fielddisplay(self,'maxsteps','maximum number of iterations (gradient computation)');
+			fielddisplay(self,'maxiter','maximum number of Function evaluation (forward run)');
+			fielddisplay(self,'dxmin','convergence criterion: two points less than dxmin from eachother (sup-norm) are considered identical');
+			fielddisplay(self,'gttol','convergence criterion: ||g(X)||/||g(X0)|| (g(X0): gradient at initial guess X0)');
+			fielddisplay(self,'cost_functions','indicate the type of response for each optimization step');
+			fielddisplay(self,'cost_functions_coefficients','cost_functions_coefficients applied to the misfit of each vertex and for each control_parameter');
+			fielddisplay(self,'min_parameters','absolute minimum acceptable value of the inversed parameter on each vertex');
+			fielddisplay(self,'max_parameters','absolute maximum acceptable value of the inversed parameter on each vertex');
+			fielddisplay(self,'vx_obs','observed velocity x component [m/yr]');
+			fielddisplay(self,'vy_obs','observed velocity y component [m/yr]');
+			fielddisplay(self,'vel_obs','observed velocity magnitude [m/yr]');
+			fielddisplay(self,'thickness_obs','observed thickness [m]');
+			fielddisplay(self,'surface_obs','observed surface elevation [m]');
 			
 			disp('Available cost functions:');
 			disp('   101: SurfaceAbsVelMisfit');
@@ -124,67 +124,67 @@
 			disp('   502: RheologyBbarAbsGradient');
 			disp('   503: ThicknessAbsGradient');
 		end % }}}
-		function marshall(obj,md,fid) % {{{
+		function marshall(self,md,fid) % {{{
 
 			yts=365.0*24.0*3600.0;
 
-			WriteData(fid,'object',obj,'class','inversion','fieldname','iscontrol','format','Boolean');
+			WriteData(fid,'object',self,'class','inversion','fieldname','iscontrol','format','Boolean');
 			WriteData(fid,'enum',InversionTypeEnum(),'data',4,'format','Integer');
-			if ~obj.iscontrol, return; end
-			WriteData(fid,'object',obj,'class','inversion','fieldname','control_scaling_factors','format','DoubleMat','mattype',3);
-			WriteData(fid,'object',obj,'class','inversion','fieldname','maxsteps','format','Integer');
-			WriteData(fid,'object',obj,'class','inversion','fieldname','maxiter','format','Integer');
-			WriteData(fid,'object',obj,'class','inversion','fieldname','dxmin','format','Double');
-			WriteData(fid,'object',obj,'class','inversion','fieldname','gttol','format','Double');
-			WriteData(fid,'object',obj,'class','inversion','fieldname','cost_functions_coefficients','format','DoubleMat','mattype',1);
-			WriteData(fid,'object',obj,'class','inversion','fieldname','min_parameters','format','DoubleMat','mattype',3);
-			WriteData(fid,'object',obj,'class','inversion','fieldname','max_parameters','format','DoubleMat','mattype',3);
-			WriteData(fid,'object',obj,'class','inversion','fieldname','vx_obs','format','DoubleMat','mattype',1,'scale',1./yts);
-			WriteData(fid,'object',obj,'class','inversion','fieldname','vy_obs','format','DoubleMat','mattype',1,'scale',1./yts);
-			WriteData(fid,'object',obj,'class','inversion','fieldname','vz_obs','format','DoubleMat','mattype',1,'scale',1./yts);
-			if(numel(obj.thickness_obs)==md.mesh.numberofelements),
+			if ~self.iscontrol, return; end
+			WriteData(fid,'object',self,'class','inversion','fieldname','control_scaling_factors','format','DoubleMat','mattype',3);
+			WriteData(fid,'object',self,'class','inversion','fieldname','maxsteps','format','Integer');
+			WriteData(fid,'object',self,'class','inversion','fieldname','maxiter','format','Integer');
+			WriteData(fid,'object',self,'class','inversion','fieldname','dxmin','format','Double');
+			WriteData(fid,'object',self,'class','inversion','fieldname','gttol','format','Double');
+			WriteData(fid,'object',self,'class','inversion','fieldname','cost_functions_coefficients','format','DoubleMat','mattype',1);
+			WriteData(fid,'object',self,'class','inversion','fieldname','min_parameters','format','DoubleMat','mattype',3);
+			WriteData(fid,'object',self,'class','inversion','fieldname','max_parameters','format','DoubleMat','mattype',3);
+			WriteData(fid,'object',self,'class','inversion','fieldname','vx_obs','format','DoubleMat','mattype',1,'scale',1./yts);
+			WriteData(fid,'object',self,'class','inversion','fieldname','vy_obs','format','DoubleMat','mattype',1,'scale',1./yts);
+			WriteData(fid,'object',self,'class','inversion','fieldname','vz_obs','format','DoubleMat','mattype',1,'scale',1./yts);
+			if(numel(self.thickness_obs)==md.mesh.numberofelements),
 				mattype=2;
 			else
 				mattype=1;
 			end
-			WriteData(fid,'object',obj,'class','inversion','fieldname','thickness_obs','format','DoubleMat','mattype',mattype);
-			WriteData(fid,'object',obj,'class','inversion','fieldname','surface_obs','format','DoubleMat','mattype',mattype);
+			WriteData(fid,'object',self,'class','inversion','fieldname','thickness_obs','format','DoubleMat','mattype',mattype);
+			WriteData(fid,'object',self,'class','inversion','fieldname','surface_obs','format','DoubleMat','mattype',mattype);
 
 			%process control parameters
-			num_control_parameters=numel(obj.control_parameters);
+			num_control_parameters=numel(self.control_parameters);
 			data=zeros(1,num_control_parameters);
 			for i=1:num_control_parameters,
-				data(i)=StringToEnum(obj.control_parameters{i});
+				data(i)=StringToEnum(self.control_parameters{i});
 			end
 			WriteData(fid,'data',data,'enum',InversionControlParametersEnum(),'format','DoubleMat','mattype',3);
 			WriteData(fid,'data',num_control_parameters,'enum',InversionNumControlParametersEnum(),'format','Integer');
 
 			%process cost functions
-			num_cost_functions=size(obj.cost_functions,2);
-			data=obj.cost_functions;
-			pos=find(obj.cost_functions==101); data(pos)=SurfaceAbsVelMisfitEnum();
-			pos=find(obj.cost_functions==102); data(pos)=SurfaceRelVelMisfitEnum();
-			pos=find(obj.cost_functions==103); data(pos)=SurfaceLogVelMisfitEnum();
-			pos=find(obj.cost_functions==104); data(pos)=SurfaceLogVxVyMisfitEnum();
-			pos=find(obj.cost_functions==105); data(pos)=SurfaceAverageVelMisfitEnum();
-			pos=find(obj.cost_functions==201); data(pos)=ThicknessAbsMisfitEnum();
-			pos=find(obj.cost_functions==501); data(pos)=DragCoefficientAbsGradientEnum();
-			pos=find(obj.cost_functions==502); data(pos)=RheologyBbarAbsGradientEnum();
-			pos=find(obj.cost_functions==503); data(pos)=ThicknessAbsGradientEnum();
-			pos=find(obj.cost_functions==504); data(pos)=ThicknessAlongGradientEnum();
-			pos=find(obj.cost_functions==505); data(pos)=ThicknessAcrossGradientEnum();
-			pos=find(obj.cost_functions==506); data(pos)=BalancethicknessMisfitEnum();
-			pos=find(obj.cost_functions==601); data(pos)=SurfaceAbsMisfitEnum();
-			pos=find(obj.cost_functions==1001); data(pos)=Outputdefinition1Enum();
-			pos=find(obj.cost_functions==1002); data(pos)=Outputdefinition2Enum();
-			pos=find(obj.cost_functions==1003); data(pos)=Outputdefinition3Enum();
-			pos=find(obj.cost_functions==1004); data(pos)=Outputdefinition4Enum();
-			pos=find(obj.cost_functions==1005); data(pos)=Outputdefinition5Enum();
-			pos=find(obj.cost_functions==1006); data(pos)=Outputdefinition6Enum();
-			pos=find(obj.cost_functions==1007); data(pos)=Outputdefinition7Enum();
-			pos=find(obj.cost_functions==1008); data(pos)=Outputdefinition8Enum();
-			pos=find(obj.cost_functions==1009); data(pos)=Outputdefinition8Enum();
-			pos=find(obj.cost_functions==1010); data(pos)=Outputdefinition10Enum();
+			num_cost_functions=size(self.cost_functions,2);
+			data=self.cost_functions;
+			pos=find(self.cost_functions==101); data(pos)=SurfaceAbsVelMisfitEnum();
+			pos=find(self.cost_functions==102); data(pos)=SurfaceRelVelMisfitEnum();
+			pos=find(self.cost_functions==103); data(pos)=SurfaceLogVelMisfitEnum();
+			pos=find(self.cost_functions==104); data(pos)=SurfaceLogVxVyMisfitEnum();
+			pos=find(self.cost_functions==105); data(pos)=SurfaceAverageVelMisfitEnum();
+			pos=find(self.cost_functions==201); data(pos)=ThicknessAbsMisfitEnum();
+			pos=find(self.cost_functions==501); data(pos)=DragCoefficientAbsGradientEnum();
+			pos=find(self.cost_functions==502); data(pos)=RheologyBbarAbsGradientEnum();
+			pos=find(self.cost_functions==503); data(pos)=ThicknessAbsGradientEnum();
+			pos=find(self.cost_functions==504); data(pos)=ThicknessAlongGradientEnum();
+			pos=find(self.cost_functions==505); data(pos)=ThicknessAcrossGradientEnum();
+			pos=find(self.cost_functions==506); data(pos)=BalancethicknessMisfitEnum();
+			pos=find(self.cost_functions==601); data(pos)=SurfaceAbsMisfitEnum();
+			pos=find(self.cost_functions==1001); data(pos)=Outputdefinition1Enum();
+			pos=find(self.cost_functions==1002); data(pos)=Outputdefinition2Enum();
+			pos=find(self.cost_functions==1003); data(pos)=Outputdefinition3Enum();
+			pos=find(self.cost_functions==1004); data(pos)=Outputdefinition4Enum();
+			pos=find(self.cost_functions==1005); data(pos)=Outputdefinition5Enum();
+			pos=find(self.cost_functions==1006); data(pos)=Outputdefinition6Enum();
+			pos=find(self.cost_functions==1007); data(pos)=Outputdefinition7Enum();
+			pos=find(self.cost_functions==1008); data(pos)=Outputdefinition8Enum();
+			pos=find(self.cost_functions==1009); data(pos)=Outputdefinition8Enum();
+			pos=find(self.cost_functions==1010); data(pos)=Outputdefinition10Enum();
 			WriteData(fid,'data',data,'enum',InversionCostFunctionsEnum(),'format','DoubleMat','mattype',3);
 			WriteData(fid,'data',num_cost_functions,'enum',InversionNumCostFunctionsEnum(),'format','Integer');
 		end % }}}
Index: ../trunk-jpl/src/m/classes/mesh2d.m
===================================================================
--- ../trunk-jpl/src/m/classes/mesh2d.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/mesh2d.m	(revision 19040)
@@ -69,16 +69,16 @@
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 			%the connectivity is the averaged number of nodes linked to a
 			%given node through an edge. This connectivity is used to initially
 			%allocate memory to the stiffness matrix. A value of 16 seems to
 			%give a good memory/time ration. This value can be checked in
 			%trunk/test/Miscellaneous/runme.m
-			obj.average_vertex_connectivity=25;
+			self.average_vertex_connectivity=25;
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 			md = checkfield(md,'fieldname','mesh.x','NaN',1,'size',[md.mesh.numberofvertices 1]);
 			md = checkfield(md,'fieldname','mesh.y','NaN',1,'size',[md.mesh.numberofvertices 1]);
@@ -96,69 +96,69 @@
 					md = checkmessage(md,'thermal not supported for 2d mesh');
 			end
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   2D tria Mesh (horizontal):')); 
 
 			disp(sprintf('\n      Elements and vertices:'));
-			fielddisplay(obj,'numberofelements','number of elements');
-			fielddisplay(obj,'numberofvertices','number of vertices');
-			fielddisplay(obj,'elements','vertex indices of the mesh elements');
-			fielddisplay(obj,'x','vertices x coordinate [m]');
-			fielddisplay(obj,'y','vertices y coordinate [m]');
-			fielddisplay(obj,'edges','edges of the 2d mesh (vertex1 vertex2 element1 element2)');
-			fielddisplay(obj,'numberofedges','number of edges of the 2d mesh');
+			fielddisplay(self,'numberofelements','number of elements');
+			fielddisplay(self,'numberofvertices','number of vertices');
+			fielddisplay(self,'elements','vertex indices of the mesh elements');
+			fielddisplay(self,'x','vertices x coordinate [m]');
+			fielddisplay(self,'y','vertices y coordinate [m]');
+			fielddisplay(self,'edges','edges of the 2d mesh (vertex1 vertex2 element1 element2)');
+			fielddisplay(self,'numberofedges','number of edges of the 2d mesh');
 
 			disp(sprintf('\n      Properties:'));
-			fielddisplay(obj,'vertexonboundary','vertices on the boundary of the domain flag list');
-			fielddisplay(obj,'segments','edges on domain boundary (vertex1 vertex2 element)');
-			fielddisplay(obj,'segmentmarkers','number associated to each segment');
-			fielddisplay(obj,'vertexconnectivity','list of vertices connected to vertex_i');
-			fielddisplay(obj,'elementconnectivity','list of vertices connected to element_i');
-			fielddisplay(obj,'average_vertex_connectivity','average number of vertices connected to one vertex');
+			fielddisplay(self,'vertexonboundary','vertices on the boundary of the domain flag list');
+			fielddisplay(self,'segments','edges on domain boundary (vertex1 vertex2 element)');
+			fielddisplay(self,'segmentmarkers','number associated to each segment');
+			fielddisplay(self,'vertexconnectivity','list of vertices connected to vertex_i');
+			fielddisplay(self,'elementconnectivity','list of vertices connected to element_i');
+			fielddisplay(self,'average_vertex_connectivity','average number of vertices connected to one vertex');
 
 			disp(sprintf('\n      Extracted model:'));
-			fielddisplay(obj,'extractedvertices','vertices extracted from the model');
-			fielddisplay(obj,'extractedelements','elements extracted from the model');
+			fielddisplay(self,'extractedvertices','vertices extracted from the model');
+			fielddisplay(self,'extractedelements','elements extracted from the model');
 
 			disp(sprintf('\n      Projection:'));
-			fielddisplay(obj,'lat','vertices latitude [degrees]');
-			fielddisplay(obj,'long','vertices longitude [degrees]');
-			fielddisplay(obj,'epsg','EPSG code (ex: 3413 for UPS Greenland, 3031 for UPS Antarctica)');
+			fielddisplay(self,'lat','vertices latitude [degrees]');
+			fielddisplay(self,'long','vertices longitude [degrees]');
+			fielddisplay(self,'epsg','EPSG code (ex: 3413 for UPS Greenland, 3031 for UPS Antarctica)');
 		end % }}}
-		function createxml(obj,fid) % {{{
+		function createxml(self,fid) % {{{
 			fprintf(fid, '<!-- 2D tria Mesh (horizontal) -->\n');
 
 			%elements and vertices
 			fprintf(fid,'%s\n%s\n%s\n','<frame key="1" label="Elements and vertices">','<section name="mesh" />');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','  <parameter key ="numberofelements" type="',class(obj.numberofelements),'" default="',convert2str(obj.numberofelements),'">','     <section name="mesh" />','     <help> number of elements </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','  <parameter key ="numberofvertices" type="',class(obj.numberofvertices),'" default="',convert2str(obj.numberofvertices),'">','     <section name="mesh" />','     <help> number of vertices </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','  <parameter key ="elements" type="',class(obj.elements),'" default="',convert2str(obj.elements),'">','     <section name="mesh" />','     <help> vertex indices of the mesh elements </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="x" type="',class(obj.x),'" default="',convert2str(obj.x),'">','     <section name="mesh" />','     <help> vertices x coordinate [m] </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="y" type="',class(obj.y),'" default="',convert2str(obj.y),'">','     <section name="mesh" />','     <help> vertices y coordinate [m] </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="edges" type="',class(obj.edges),'" default="',convert2str(obj.edges),'">','     <section name="mesh" />','     <help> edges of the 2d mesh (vertex1 vertex2 element1 element2) </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="numberofedges" type="',class(obj.numberofedges),'" default="',convert2str(obj.numberofedges),'">','     <section name="mesh" />','     <help> number of edges of the 2d mesh </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','  <parameter key ="numberofelements" type="',class(self.numberofelements),'" default="',convert2str(self.numberofelements),'">','     <section name="mesh" />','     <help> number of elements </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','  <parameter key ="numberofvertices" type="',class(self.numberofvertices),'" default="',convert2str(self.numberofvertices),'">','     <section name="mesh" />','     <help> number of vertices </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','  <parameter key ="elements" type="',class(self.elements),'" default="',convert2str(self.elements),'">','     <section name="mesh" />','     <help> vertex indices of the mesh elements </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="x" type="',class(self.x),'" default="',convert2str(self.x),'">','     <section name="mesh" />','     <help> vertices x coordinate [m] </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="y" type="',class(self.y),'" default="',convert2str(self.y),'">','     <section name="mesh" />','     <help> vertices y coordinate [m] </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="edges" type="',class(self.edges),'" default="',convert2str(self.edges),'">','     <section name="mesh" />','     <help> edges of the 2d mesh (vertex1 vertex2 element1 element2) </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="numberofedges" type="',class(self.numberofedges),'" default="',convert2str(self.numberofedges),'">','     <section name="mesh" />','     <help> number of edges of the 2d mesh </help>','  </parameter>');
 			fprintf(fid,'%s\n%s\n','</frame>');
 
 			% properties
 			fprintf(fid,'%s\n%s\n%s\n','<frame key="2" label="Properties">','<section name="mesh" />');             
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="vertexonboundary" type="',class(obj.vertexonboundary),'" default="',convert2str(obj.vertexonboundary),'">','     <section name="mesh" />','     <help> vertices on the boundary of the domain flag list </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="segments" type="',class(obj.segments),'" default="',convert2str(obj.segments),'">','     <section name="mesh" />','     <help> edges on domain boundary (vertex1 vertex2 element) </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="segmentmarkers" type="',class(obj.segmentmarkers),'" default="',convert2str(obj.segmentmarkers),'">','     <section name="mesh" />','     <help> number associated to each segment </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="vertexconnectivity" type="',class(obj.vertexconnectivity),'" default="',convert2str(obj.vertexconnectivity),'">','     <section name="mesh" />','     <help> list of vertices connected to vertex_i </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="elementconnectivity" type="',class(obj.elementconnectivity),'" default="',convert2str(obj.elementconnectivity),'">','     <section name="mesh" />','     <help> list of vertices connected to element_i </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="average_vertex_connectivity" type="',class(obj.average_vertex_connectivity),'" default="',convert2str(obj.average_vertex_connectivity),'">','     <section name="mesh" />','     <help> average number of vertices connected to one vertex </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="vertexonboundary" type="',class(self.vertexonboundary),'" default="',convert2str(self.vertexonboundary),'">','     <section name="mesh" />','     <help> vertices on the boundary of the domain flag list </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="segments" type="',class(self.segments),'" default="',convert2str(self.segments),'">','     <section name="mesh" />','     <help> edges on domain boundary (vertex1 vertex2 element) </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="segmentmarkers" type="',class(self.segmentmarkers),'" default="',convert2str(self.segmentmarkers),'">','     <section name="mesh" />','     <help> number associated to each segment </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="vertexconnectivity" type="',class(self.vertexconnectivity),'" default="',convert2str(self.vertexconnectivity),'">','     <section name="mesh" />','     <help> list of vertices connected to vertex_i </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="elementconnectivity" type="',class(self.elementconnectivity),'" default="',convert2str(self.elementconnectivity),'">','     <section name="mesh" />','     <help> list of vertices connected to element_i </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="average_vertex_connectivity" type="',class(self.average_vertex_connectivity),'" default="',convert2str(self.average_vertex_connectivity),'">','     <section name="mesh" />','     <help> average number of vertices connected to one vertex </help>','  </parameter>');
 			fprintf(fid,'%s\n%s\n','</frame>');
 
 			%extracted model
 			fprintf(fid,'%s\n%s\n%s\n','<frame key="3" label="Extracted Model">','<section name="mesh" />'); 
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="extractedvertices" type="',class(obj.extractedvertices),'" default="',convert2str(obj.extractedvertices),'">','     <section name="mesh" />','     <help> vertices extracted from the model </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="extractedelements" type="',class(obj.extractedelements),'" default="',convert2str(obj.extractedelements),'">','     <section name="mesh" />','     <help> elements extracted from the model </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="extractedvertices" type="',class(self.extractedvertices),'" default="',convert2str(self.extractedvertices),'">','     <section name="mesh" />','     <help> vertices extracted from the model </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="extractedelements" type="',class(self.extractedelements),'" default="',convert2str(self.extractedelements),'">','     <section name="mesh" />','     <help> elements extracted from the model </help>','  </parameter>');
 			fprintf(fid,'%s\n%s\n','</frame>');
 
 			%projection
 			fprintf(fid,'%s\n%s\n%s\n','<frame key="4" label="Projection">','<section name="mesh" />'); 
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="lat" type="',class(obj.lat),'" default="',convert2str(obj.lat),'">','     <section name="mesh" />','     <help> vertices latitude [degrees] </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="long" type="',class(obj.long),'" default="',convert2str(obj.long),'">','     <section name="mesh" />','     <help> verticies longitude [degrees] </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="lat" type="',class(self.lat),'" default="',convert2str(self.lat),'">','     <section name="mesh" />','     <help> vertices latitude [degrees] </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="long" type="',class(self.long),'" default="',convert2str(self.long),'">','     <section name="mesh" />','     <help> verticies longitude [degrees] </help>','  </parameter>');
 			% choice (epsg) 'n' or 's'
 			fprintf(fid,'%s\n%s\n%s\n','  <parameter key ="epsg" type="alternative" optional="false">','     <section name="mesh" />','     <help> Indicate epsg ''n'' or ''s'' </help>');
 			fprintf(fid,'%s\n','       <option value="n" type="string" default="true"> </option>');
@@ -167,26 +167,26 @@
 			fprintf(fid,'%s\n%s\n','</frame>');
 
 		end % }}}
-		function marshall(obj,md,fid) % {{{
-			WriteData(fid,'enum',DomainTypeEnum(),'data',StringToEnum(['Domain' domaintype(obj)]),'format','Integer');
-			WriteData(fid,'enum',DomainDimensionEnum(),'data',dimension(obj),'format','Integer');
-			WriteData(fid,'enum',MeshElementtypeEnum(),'data',StringToEnum(elementtype(obj)),'format','Integer');
-			WriteData(fid,'object',obj,'class','mesh','fieldname','x','format','DoubleMat','mattype',1);
-			WriteData(fid,'object',obj,'class','mesh','fieldname','y','format','DoubleMat','mattype',1);
-			WriteData(fid,'enum',MeshZEnum(),'data',zeros(obj.numberofvertices,1),'format','DoubleMat','mattype',1);
-			WriteData(fid,'object',obj,'class','mesh','fieldname','elements','format','DoubleMat','mattype',2);
-			WriteData(fid,'object',obj,'class','mesh','fieldname','numberofelements','format','Integer');
-			WriteData(fid,'object',obj,'class','mesh','fieldname','numberofvertices','format','Integer');
-			WriteData(fid,'object',obj,'class','mesh','fieldname','average_vertex_connectivity','format','Integer');
-			WriteData(fid,'object',obj,'class','mesh','fieldname','vertexonboundary','format','DoubleMat','mattype',1);
+		function marshall(self,md,fid) % {{{
+			WriteData(fid,'enum',DomainTypeEnum(),'data',StringToEnum(['Domain' domaintype(self)]),'format','Integer');
+			WriteData(fid,'enum',DomainDimensionEnum(),'data',dimension(self),'format','Integer');
+			WriteData(fid,'enum',MeshElementtypeEnum(),'data',StringToEnum(elementtype(self)),'format','Integer');
+			WriteData(fid,'object',self,'class','mesh','fieldname','x','format','DoubleMat','mattype',1);
+			WriteData(fid,'object',self,'class','mesh','fieldname','y','format','DoubleMat','mattype',1);
+			WriteData(fid,'enum',MeshZEnum(),'data',zeros(self.numberofvertices,1),'format','DoubleMat','mattype',1);
+			WriteData(fid,'object',self,'class','mesh','fieldname','elements','format','DoubleMat','mattype',2);
+			WriteData(fid,'object',self,'class','mesh','fieldname','numberofelements','format','Integer');
+			WriteData(fid,'object',self,'class','mesh','fieldname','numberofvertices','format','Integer');
+			WriteData(fid,'object',self,'class','mesh','fieldname','average_vertex_connectivity','format','Integer');
+			WriteData(fid,'object',self,'class','mesh','fieldname','vertexonboundary','format','DoubleMat','mattype',1);
 		end % }}}
-		function t = domaintype(obj) % {{{
+		function t = domaintype(self) % {{{
 			t = '2Dhorizontal';
 		end % }}}
-		function d = dimension(obj) % {{{
+		function d = dimension(self) % {{{
 			d = 2;
 		end % }}}
-		function s = elementtype(obj) % {{{
+		function s = elementtype(self) % {{{
 			s = 'Tria';
 		end % }}}
 	end
Index: ../trunk-jpl/src/m/classes/calving.m
===================================================================
--- ../trunk-jpl/src/m/classes/calving.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/calving.m	(revision 19040)
@@ -10,10 +10,10 @@
 		meltingrate   = NaN;
 	end
 	methods
-		function obj = calving(varargin) % {{{
+		function self = calving(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				case 1
 					inputstruct=varargin{1};
 					list1 = properties('calving');
@@ -21,20 +21,20 @@
 					for i=1:length(list1)
 						fieldname = list1{i};
 						if ismember(fieldname,list2),
-							obj.(fieldname) = inputstruct.(fieldname);
+							self.(fieldname) = inputstruct.(fieldname);
 						end
 					end
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 			%stabilization = 2 by default
-			obj.stabilization = 2;
+			self.stabilization = 2;
 
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 			%Early return
 			if (solution~=TransientSolutionEnum() | md.transient.iscalving==0), return; end
 
@@ -42,18 +42,18 @@
 			md = checkfield(md,'fieldname','calving.calvingrate(1:md.mesh.numberofvertices,:)','>=',0,'timeseries',1,'NaN',1);
 			md = checkfield(md,'fieldname','calving.meltingrate(1:md.mesh.numberofvertices,:)','>=',0,'timeseries',1,'NaN',1);
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   Calving parameters:'));
-			fielddisplay(obj,'stabilization','0: no, 1: artificial_diffusivity, 2: streamline upwinding');
-			fielddisplay(obj,'calvingrate','calving rate at given location [m/a]');
-			fielddisplay(obj,'meltingrate','melting rate at given location [m/a]');
+			fielddisplay(self,'stabilization','0: no, 1: artificial_diffusivity, 2: streamline upwinding');
+			fielddisplay(self,'calvingrate','calving rate at given location [m/a]');
+			fielddisplay(self,'meltingrate','melting rate at given location [m/a]');
 		end % }}}
-		function marshall(obj,md,fid) % {{{
+		function marshall(self,md,fid) % {{{
 			yts=365.0*24.0*3600.0;
 			WriteData(fid,'enum',CalvingLawEnum(),'data',DefaultCalvingEnum(),'format','Integer');
-			WriteData(fid,'enum',LevelsetStabilizationEnum(),'data',obj.stabilization,'format','Integer');
-			WriteData(fid,'object',obj,'fieldname','calvingrate','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1,'scale',1./yts);
-			WriteData(fid,'object',obj,'fieldname','meltingrate','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1,'scale',1./yts);
+			WriteData(fid,'enum',LevelsetStabilizationEnum(),'data',self.stabilization,'format','Integer');
+			WriteData(fid,'object',self,'fieldname','calvingrate','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1,'scale',1./yts);
+			WriteData(fid,'object',self,'fieldname','meltingrate','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1,'scale',1./yts);
 		end % }}}
 	end
 end
Index: ../trunk-jpl/src/m/classes/inversionvalidation.m
===================================================================
--- ../trunk-jpl/src/m/classes/inversionvalidation.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/inversionvalidation.m	(revision 19040)
@@ -21,10 +21,10 @@
 		surface_obs                 = NaN
 	end
 	methods
-		function obj = inversionvalidation(varargin) % {{{
+		function self = inversionvalidation(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				case 1
 					obj=structtoobj(inversionvalidation(),varargin{1});
 				otherwise
@@ -46,10 +46,10 @@
 			%several responses can be used:
 			self.cost_functions=101;
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 			%Early return
-			if ~obj.iscontrol, return; end
+			if ~self.iscontrol, return; end
 
 			num_controls=numel(md.inversion.control_parameters);
 			num_costfunc=size(md.inversion.cost_functions,2);
@@ -74,21 +74,21 @@
 				end
 			end
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   inversionvalidation parameters:'));
-			fielddisplay(obj,'iscontrol','is inversion activated?');
-			fielddisplay(obj,'incomplete_adjoint','1: linear viscosity, 0: non-linear viscosity');
-			fielddisplay(obj,'control_parameters','ex: {''FrictionCoefficient''}, or {''MaterialsRheologyBbar''}');
-			fielddisplay(obj,'control_scaling_factors','order of magnitude of each control (useful for multi-parameter optimization)');
-			fielddisplay(obj,'cost_functions','indicate the type of response for each optimization step');
-			fielddisplay(obj,'cost_functions_coefficients','cost_functions_coefficients applied to the misfit of each vertex and for each control_parameter');
-			fielddisplay(obj,'min_parameters','absolute minimum acceptable value of the inversed parameter on each vertex');
-			fielddisplay(obj,'max_parameters','absolute maximum acceptable value of the inversed parameter on each vertex');
-			fielddisplay(obj,'vx_obs','observed velocity x component [m/yr]');
-			fielddisplay(obj,'vy_obs','observed velocity y component [m/yr]');
-			fielddisplay(obj,'vel_obs','observed velocity magnitude [m/yr]');
-			fielddisplay(obj,'thickness_obs','observed thickness [m]');
-			fielddisplay(obj,'surface_obs','observed surface elevation [m]');
+			fielddisplay(self,'iscontrol','is inversion activated?');
+			fielddisplay(self,'incomplete_adjoint','1: linear viscosity, 0: non-linear viscosity');
+			fielddisplay(self,'control_parameters','ex: {''FrictionCoefficient''}, or {''MaterialsRheologyBbar''}');
+			fielddisplay(self,'control_scaling_factors','order of magnitude of each control (useful for multi-parameter optimization)');
+			fielddisplay(self,'cost_functions','indicate the type of response for each optimization step');
+			fielddisplay(self,'cost_functions_coefficients','cost_functions_coefficients applied to the misfit of each vertex and for each control_parameter');
+			fielddisplay(self,'min_parameters','absolute minimum acceptable value of the inversed parameter on each vertex');
+			fielddisplay(self,'max_parameters','absolute maximum acceptable value of the inversed parameter on each vertex');
+			fielddisplay(self,'vx_obs','observed velocity x component [m/yr]');
+			fielddisplay(self,'vy_obs','observed velocity y component [m/yr]');
+			fielddisplay(self,'vel_obs','observed velocity magnitude [m/yr]');
+			fielddisplay(self,'thickness_obs','observed thickness [m]');
+			fielddisplay(self,'surface_obs','observed surface elevation [m]');
 			disp('Available cost functions:');
 			disp('   101: SurfaceAbsVelMisfit');
 			disp('   102: SurfaceRelVelMisfit');
@@ -100,41 +100,41 @@
 			disp('   502: RheologyBbarAbsGradient');
 			disp('   503: ThicknessAbsGradient');
 		end % }}}
-		function marshall(obj,md,fid) % {{{
+		function marshall(self,md,fid) % {{{
 
 			yts=365.0*24.0*3600.0;
 
-			WriteData(fid,'object',obj,'class','inversion','fieldname','iscontrol','format','Boolean');
+			WriteData(fid,'object',self,'class','inversion','fieldname','iscontrol','format','Boolean');
 			WriteData(fid,'enum',InversionTypeEnum(),'data',3,'format','Integer');
-			if ~obj.iscontrol, return; end
-			WriteData(fid,'object',obj,'class','inversion','fieldname','incomplete_adjoint','format','Boolean');
-			WriteData(fid,'object',obj,'class','inversion','fieldname','control_scaling_factors','format','DoubleMat','mattype',3);
-			WriteData(fid,'object',obj,'class','inversion','fieldname','cost_functions_coefficients','format','DoubleMat','mattype',1);
-			WriteData(fid,'object',obj,'class','inversion','fieldname','min_parameters','format','DoubleMat','mattype',3);
-			WriteData(fid,'object',obj,'class','inversion','fieldname','max_parameters','format','DoubleMat','mattype',3);
-			WriteData(fid,'object',obj,'class','inversion','fieldname','vx_obs','format','DoubleMat','mattype',1,'scale',1./yts);
-			WriteData(fid,'object',obj,'class','inversion','fieldname','vy_obs','format','DoubleMat','mattype',1,'scale',1./yts);
-			WriteData(fid,'object',obj,'class','inversion','fieldname','vz_obs','format','DoubleMat','mattype',1,'scale',1./yts);
-			if(numel(obj.thickness_obs)==md.mesh.numberofelements),
+			if ~self.iscontrol, return; end
+			WriteData(fid,'object',self,'class','inversion','fieldname','incomplete_adjoint','format','Boolean');
+			WriteData(fid,'object',self,'class','inversion','fieldname','control_scaling_factors','format','DoubleMat','mattype',3);
+			WriteData(fid,'object',self,'class','inversion','fieldname','cost_functions_coefficients','format','DoubleMat','mattype',1);
+			WriteData(fid,'object',self,'class','inversion','fieldname','min_parameters','format','DoubleMat','mattype',3);
+			WriteData(fid,'object',self,'class','inversion','fieldname','max_parameters','format','DoubleMat','mattype',3);
+			WriteData(fid,'object',self,'class','inversion','fieldname','vx_obs','format','DoubleMat','mattype',1,'scale',1./yts);
+			WriteData(fid,'object',self,'class','inversion','fieldname','vy_obs','format','DoubleMat','mattype',1,'scale',1./yts);
+			WriteData(fid,'object',self,'class','inversion','fieldname','vz_obs','format','DoubleMat','mattype',1,'scale',1./yts);
+			if(numel(self.thickness_obs)==md.mesh.numberofelements),
 				mattype=2; 
 			else
 				mattype=1;
 			end
-			WriteData(fid,'object',obj,'class','inversion','fieldname','thickness_obs','format','DoubleMat','mattype',mattype);
-			WriteData(fid,'object',obj,'class','inversion','fieldname','surface_obs','format','DoubleMat','mattype',mattype);
+			WriteData(fid,'object',self,'class','inversion','fieldname','thickness_obs','format','DoubleMat','mattype',mattype);
+			WriteData(fid,'object',self,'class','inversion','fieldname','surface_obs','format','DoubleMat','mattype',mattype);
 
 			%process control parameters
-			num_control_parameters=numel(obj.control_parameters);
+			num_control_parameters=numel(self.control_parameters);
 			data=zeros(1,num_control_parameters);
 			for i=1:num_control_parameters,
-				data(i)=StringToEnum(obj.control_parameters{i});
+				data(i)=StringToEnum(self.control_parameters{i});
 			end
 			WriteData(fid,'data',data,'enum',InversionControlParametersEnum(),'format','DoubleMat','mattype',3);
 			WriteData(fid,'data',num_control_parameters,'enum',InversionNumControlParametersEnum(),'format','Integer');
 
 			%process cost functions
-			num_cost_functions=size(obj.cost_functions,2);
-			data=marshallcostfunctions(obj.cost_functions);
+			num_cost_functions=size(self.cost_functions,2);
+			data=marshallcostfunctions(self.cost_functions);
 			WriteData(fid,'data',data,'enum',InversionCostFunctionsEnum(),'format','DoubleMat','mattype',3);
 			WriteData(fid,'data',num_cost_functions,'enum',InversionNumCostFunctionsEnum(),'format','Integer');
 		end % }}}
Index: ../trunk-jpl/src/m/classes/SMBcomponents.m
===================================================================
--- ../trunk-jpl/src/m/classes/SMBcomponents.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/SMBcomponents.m	(revision 19040)
@@ -10,7 +10,7 @@
 		evaporation = NaN;
 	end
 	methods
-		function obj = SMBcomponents(varargin) % {{{
+		function self = SMBcomponents(varargin) % {{{
 			switch nargin
 				case 0
 				otherwise
@@ -40,7 +40,7 @@
 			end
 
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 			if ismember(MasstransportAnalysisEnum(),analyses),
 				md = checkfield(md,'fieldname','surfaceforcings.accumulation','timeseries',1,'NaN',1);
@@ -61,20 +61,20 @@
 				md = checkfield(md,'fieldname','surfaceforcings.evaporation','size',[md.mesh.numberofvertices 1],'NaN',1);
 			end
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   surface forcings parameters (SMB=accumulation-runoff-evaporation) :'));
-			fielddisplay(obj,'accumulation','accumulated snow [m/yr ice eq]');
-			fielddisplay(obj,'runoff','amount of ice melt lost from the ice column [m/yr ice eq]');
-			fielddisplay(obj,'evaporation','amount of ice lost to evaporative processes [m/yr ice eq]');
+			fielddisplay(self,'accumulation','accumulated snow [m/yr ice eq]');
+			fielddisplay(self,'runoff','amount of ice melt lost from the ice column [m/yr ice eq]');
+			fielddisplay(self,'evaporation','amount of ice lost to evaporative processes [m/yr ice eq]');
 		end % }}}
-		function marshall(obj,md,fid) % {{{
+		function marshall(self,md,fid) % {{{
 
 			yts=365.0*24.0*3600.0;
 
 			WriteData(fid,'enum',SurfaceforcingsEnum(),'data',SMBcomponentsEnum(),'format','Integer');
-			WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','accumulation','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
-			WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','runoff','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
-			WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','evaporation','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
+			WriteData(fid,'object',self,'class','surfaceforcings','fieldname','accumulation','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
+			WriteData(fid,'object',self,'class','surfaceforcings','fieldname','runoff','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
+			WriteData(fid,'object',self,'class','surfaceforcings','fieldname','evaporation','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
 		end % }}}
 	end
 end
Index: ../trunk-jpl/src/m/classes/stressbalance.m
===================================================================
--- ../trunk-jpl/src/m/classes/stressbalance.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/stressbalance.m	(revision 19040)
@@ -25,15 +25,15 @@
 		requested_outputs      = {};
 	end
 	methods
-		function createxml(obj,fid) % {{{
+		function createxml(self,fid) % {{{
 			fprintf(fid, '\n\n');
 			fprintf(fid, '%s\n', '<!-- StressBalance solution parameters: -->');
 
 			% Convergence criteria            
 			fprintf(fid,'%s\n%s\n%s\n','<frame key="1" label="Convergence criteria">','<section name="stressbalance" />'); 
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="restol" type="',      class(obj.restol),'" default="',        convert2str(obj.restol),'">',	'     <section name="stressbalance" />','     <help> mechanical equilibrium residual convergence criterion </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="reltol" type="',          class(obj.reltol),'" default="',            convert2str(obj.reltol),'">',     '     <section name="stressbalance" />','     <help> velocity relative convergence criterion, NaN: not applied </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',	'<parameter key ="abstol" type="',        class(obj.abstol),'" default="',          convert2str(obj.abstol),'">',	'     <section name="stressbalance" />','     <help> velocity absolute convergence criterion, NaN: not applied </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="restol" type="',      class(self.restol),'" default="',        convert2str(self.restol),'">',	'     <section name="stressbalance" />','     <help> mechanical equilibrium residual convergence criterion </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="reltol" type="',          class(self.reltol),'" default="',            convert2str(self.reltol),'">',     '     <section name="stressbalance" />','     <help> velocity relative convergence criterion, NaN: not applied </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',	'<parameter key ="abstol" type="',        class(self.abstol),'" default="',          convert2str(self.abstol),'">',	'     <section name="stressbalance" />','     <help> velocity absolute convergence criterion, NaN: not applied </help>','</parameter>');
 
 			%is newton drop-down (0,1,or 2)
 			fprintf(fid,'%s\n%s\n%s\n%s\n',    '<parameter key ="isnewton" type="alternative" optional="false">',	'     <section name="stressbalance" />','     <help> 0: Picards fixed point, 1: Newtons method, 2: hybrid </help>');
@@ -41,38 +41,38 @@
 			fprintf(fid,'%s\n','       <option value="1" type="string" default="false"> </option>');
 			fprintf(fid,'%s\n%s\n','       <option value="2" type="string" default="false"> </option>','</parameter>');
 
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="maxiter" type="',  	class(obj.maxiter),'" default="',       convert2str(obj.maxiter),'">',     '     <section name="stressbalance" />','     <help> maximum number of nonlinear iterations </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="viscosity_overshoot" type="',         class(obj.viscosity_overshoot),'" default="',           convert2str(obj.viscosity_overshoot),'">',	'     <section name="stressbalance" />','     <help> over-shooting constant new=new+C*(new-old) </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="maxiter" type="',  	class(self.maxiter),'" default="',       convert2str(self.maxiter),'">',     '     <section name="stressbalance" />','     <help> maximum number of nonlinear iterations </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="viscosity_overshoot" type="',         class(self.viscosity_overshoot),'" default="',           convert2str(self.viscosity_overshoot),'">',	'     <section name="stressbalance" />','     <help> over-shooting constant new=new+C*(new-old) </help>','</parameter>');
 			fprintf(fid,'%s\n%s\n','</frame>');
 
 			% boundary conditions    
 			fprintf(fid,'%s\n%s\n%s\n','<frame key="2" label="Boundary conditions">','<section name="stressbalance" />'); 			 
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="spcvx" type="',     	class(obj.spcvx),'" default="',    	convert2str(obj.spcvx),'">',     '     <section name="stressbalance" />','     <help> x-axis velocity constraint (NaN means no constraint) [m/yr] </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="spcvy" type="',     	class(obj.spcvy),'" default="',    	convert2str(obj.spcvy),'">',	'     <section name="stressbalance" />','     <help> y-axis velocity constraint (NaN means no constraint) [m/yr] </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="spcvz" type="',    	class(obj.spcvz),'" default="',    	convert2str(obj.spcvz),'">',     '     <section name="stressbalance" />','     <help> z-axis velocity constraint (NaN means no constraint) [m/yr] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="spcvx" type="',     	class(self.spcvx),'" default="',    	convert2str(self.spcvx),'">',     '     <section name="stressbalance" />','     <help> x-axis velocity constraint (NaN means no constraint) [m/yr] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="spcvy" type="',     	class(self.spcvy),'" default="',    	convert2str(self.spcvy),'">',	'     <section name="stressbalance" />','     <help> y-axis velocity constraint (NaN means no constraint) [m/yr] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="spcvz" type="',    	class(self.spcvz),'" default="',    	convert2str(self.spcvz),'">',     '     <section name="stressbalance" />','     <help> z-axis velocity constraint (NaN means no constraint) [m/yr] </help>','</parameter>');
 			fprintf(fid,'%s\n%s\n','</frame>');
 
 			% Rift options   
 			fprintf(fid,'%s\n%s\n%s\n','<frame key="3" label="Rift options">','<section name="stressbalance" />'); 	
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="rift_penalty_threshold" type="',    	class(obj.rift_penalty_threshold),'" default="',       convert2str(obj.rift_penalty_threshold),'">',     '     <section name="stressbalance" />','     <help> threshold for instability of mechanical constraints </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    	'<parameter key ="rift_penalty_lock" type="',         class(obj.rift_penalty_lock),'" default="',           convert2str(obj.rift_penalty_lock),'">',	'     <section name="stressbalance" />','     <help> number of iterations before rift penalties are locked </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="rift_penalty_threshold" type="',    	class(self.rift_penalty_threshold),'" default="',       convert2str(self.rift_penalty_threshold),'">',     '     <section name="stressbalance" />','     <help> threshold for instability of mechanical constraints </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    	'<parameter key ="rift_penalty_lock" type="',         class(self.rift_penalty_lock),'" default="',           convert2str(self.rift_penalty_lock),'">',	'     <section name="stressbalance" />','     <help> number of iterations before rift penalties are locked </help>','</parameter>');
 			fprintf(fid,'%s\n%s\n','</frame>'); 
 
 			%others
 			fprintf(fid,'%s\n%s\n%s\n','<frame key="4" label="Other">','<section name="stressbalance" />'); 	
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="shelf_dampening" type="',  	class(obj.shelf_dampening),'" default="',       convert2str(obj.shelf_dampening),'">',     '     <section name="stressbalance" />','     <help> use dampening for floating ice ? Only for FS model </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',  	'<parameter key ="FSreconditioning" type="', 	class(obj.FSreconditioning),'" default="',           convert2str(obj.FSreconditioning),'">',	'     <section name="stressbalance" />','     <help> multiplier for incompressibility equation. Only for FS model </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="referential" type="',  	class(obj.referential),'" default="',       convert2str(obj.referential),'">',     '     <section name="stressbalance" />','     <help> local referential </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',  	'<parameter key ="loadingforce" type="', 	class(obj.loadingforce),'" default="',           convert2str(obj.loadingforce),'">',	'     <section name="stressbalance" />','     <help> loading force applied on each point [N/m^3] </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="requested_outputs" type="',  	class(obj.requested_outputs),'" default="',       convert2str(obj.requested_outputs),'">',     '     <section name="stressbalance" />','     <help> additional outputs requested </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="shelf_dampening" type="',  	class(self.shelf_dampening),'" default="',       convert2str(self.shelf_dampening),'">',     '     <section name="stressbalance" />','     <help> use dampening for floating ice ? Only for FS model </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',  	'<parameter key ="FSreconditioning" type="', 	class(self.FSreconditioning),'" default="',           convert2str(self.FSreconditioning),'">',	'     <section name="stressbalance" />','     <help> multiplier for incompressibility equation. Only for FS model </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="referential" type="',  	class(self.referential),'" default="',       convert2str(self.referential),'">',     '     <section name="stressbalance" />','     <help> local referential </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',  	'<parameter key ="loadingforce" type="', 	class(self.loadingforce),'" default="',           convert2str(self.loadingforce),'">',	'     <section name="stressbalance" />','     <help> loading force applied on each point [N/m^3] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="requested_outputs" type="',  	class(self.requested_outputs),'" default="',       convert2str(self.requested_outputs),'">',     '     <section name="stressbalance" />','     <help> additional outputs requested </help>','</parameter>');
 
 
 			fprintf(fid,'%s\n%s\n','</frame>'); 
 		end % }}}
-		function obj = stressbalance(varargin) % {{{
+		function self = stressbalance(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				case 1
 					inputstruct=varargin{1};
 					list1 = properties('stressbalance');
@@ -80,47 +80,47 @@
 					for i=1:length(list1)
 						fieldname = list1{i};
 						if ismember(fieldname,list2),
-							obj.(fieldname) = inputstruct.(fieldname);
+							self.(fieldname) = inputstruct.(fieldname);
 						end
 					end
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 			 %maximum of non-linear iterations.
-			 obj.maxiter=100;
+			 self.maxiter=100;
 
 			 %Convergence criterion: absolute, relative and residual
-			 obj.restol=10^-4; 
-			 obj.reltol=0.01;
-			 obj.abstol=10;
+			 self.restol=10^-4; 
+			 self.reltol=0.01;
+			 self.abstol=10;
 
-			 obj.FSreconditioning=10^13;
-			 obj.shelf_dampening=0;
+			 self.FSreconditioning=10^13;
+			 self.shelf_dampening=0;
 
 			 %Penalty factor applied kappa=max(stiffness matrix)*10^penalty_factor
-			 obj.penalty_factor=3;
+			 self.penalty_factor=3;
 
 			 %coefficient to update the viscosity between each iteration of
 			 %a stressbalance according to the following formula
 			 %viscosity(n)=viscosity(n)+viscosity_overshoot(viscosity(n)-viscosity(n-1))
-			 obj.viscosity_overshoot=0;
+			 self.viscosity_overshoot=0;
 
 			 %Stop the iterations of rift if below a threshold
-			 obj.rift_penalty_threshold=0;
+			 self.rift_penalty_threshold=0;
 
 			 %in some solutions, it might be needed to stop a run when only
 			 %a few constraints remain unstable. For thermal computation, this
 			 %parameter is often used.
-			 obj.rift_penalty_lock=10;
+			 self.rift_penalty_lock=10;
 
 			 %output default:
-			 obj.requested_outputs={'default'};
+			 self.requested_outputs={'default'};
 
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 			%Early return
 			if ~ismember(StressbalanceAnalysisEnum(),analyses), return; end
@@ -174,42 +174,42 @@
 			end
 
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 
 			disp(sprintf('   StressBalance solution parameters:'));
 
 			disp(sprintf('\n      %s','Convergence criteria:'));
-			fielddisplay(obj,'restol','mechanical equilibrium residual convergence criterion');
-			fielddisplay(obj,'reltol','velocity relative convergence criterion, NaN: not applied');
-			fielddisplay(obj,'abstol','velocity absolute convergence criterion, NaN: not applied');
-			fielddisplay(obj,'isnewton','0: Picard''s fixed point, 1: Newton''s method, 2: hybrid');
-			fielddisplay(obj,'maxiter','maximum number of nonlinear iterations');
-			fielddisplay(obj,'viscosity_overshoot','over-shooting constant new=new+C*(new-old)');
+			fielddisplay(self,'restol','mechanical equilibrium residual convergence criterion');
+			fielddisplay(self,'reltol','velocity relative convergence criterion, NaN: not applied');
+			fielddisplay(self,'abstol','velocity absolute convergence criterion, NaN: not applied');
+			fielddisplay(self,'isnewton','0: Picard''s fixed point, 1: Newton''s method, 2: hybrid');
+			fielddisplay(self,'maxiter','maximum number of nonlinear iterations');
+			fielddisplay(self,'viscosity_overshoot','over-shooting constant new=new+C*(new-old)');
 
 			disp(sprintf('\n      %s','boundary conditions:'));
-			fielddisplay(obj,'spcvx','x-axis velocity constraint (NaN means no constraint) [m/yr]');
-			fielddisplay(obj,'spcvy','y-axis velocity constraint (NaN means no constraint) [m/yr]');
-			fielddisplay(obj,'spcvz','z-axis velocity constraint (NaN means no constraint) [m/yr]');
+			fielddisplay(self,'spcvx','x-axis velocity constraint (NaN means no constraint) [m/yr]');
+			fielddisplay(self,'spcvy','y-axis velocity constraint (NaN means no constraint) [m/yr]');
+			fielddisplay(self,'spcvz','z-axis velocity constraint (NaN means no constraint) [m/yr]');
 
 			disp(sprintf('\n      %s','Rift options:'));
-			fielddisplay(obj,'rift_penalty_threshold','threshold for instability of mechanical constraints');
-			fielddisplay(obj,'rift_penalty_lock','number of iterations before rift penalties are locked');
+			fielddisplay(self,'rift_penalty_threshold','threshold for instability of mechanical constraints');
+			fielddisplay(self,'rift_penalty_lock','number of iterations before rift penalties are locked');
 
 			disp(sprintf('\n      %s','Penalty options:'));
-			fielddisplay(obj,'penalty_factor','offset used by penalties: penalty = Kmax*10^offset');
-			fielddisplay(obj,'vertex_pairing','pairs of vertices that are penalized');
+			fielddisplay(self,'penalty_factor','offset used by penalties: penalty = Kmax*10^offset');
+			fielddisplay(self,'vertex_pairing','pairs of vertices that are penalized');
 
 			disp(sprintf('\n      %s','Other:'));
-			fielddisplay(obj,'shelf_dampening','use dampening for floating ice ? Only for FS model');
-			fielddisplay(obj,'FSreconditioning','multiplier for incompressibility equation. Only for FS model');
-			fielddisplay(obj,'referential','local referential');
-			fielddisplay(obj,'loadingforce','loading force applied on each point [N/m^3]');
-			fielddisplay(obj,'requested_outputs','additional outputs requested');
+			fielddisplay(self,'shelf_dampening','use dampening for floating ice ? Only for FS model');
+			fielddisplay(self,'FSreconditioning','multiplier for incompressibility equation. Only for FS model');
+			fielddisplay(self,'referential','local referential');
+			fielddisplay(self,'loadingforce','loading force applied on each point [N/m^3]');
+			fielddisplay(self,'requested_outputs','additional outputs requested');
 
 		end % }}}
-		function marshall(obj,md,fid) % {{{
+		function marshall(self,md,fid) % {{{
 
-			WriteData(fid,'object',obj,'class','stressbalance','fieldname','vertex_pairing','format','DoubleMat','mattype',3);
+			WriteData(fid,'object',self,'class','stressbalance','fieldname','vertex_pairing','format','DoubleMat','mattype',3);
 
 			if md.private.solution==SeaiceSolutionEnum,
 				return;
@@ -217,32 +217,32 @@
 
 			yts=365.0*24.0*3600.0;
 
-			WriteData(fid,'object',obj,'class','stressbalance','fieldname','spcvx','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
-			WriteData(fid,'object',obj,'class','stressbalance','fieldname','spcvy','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
-			WriteData(fid,'object',obj,'class','stressbalance','fieldname','spcvz','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
-			WriteData(fid,'object',obj,'class','stressbalance','fieldname','restol','format','Double');
-			WriteData(fid,'object',obj,'class','stressbalance','fieldname','reltol','format','Double');
-			WriteData(fid,'object',obj,'class','stressbalance','fieldname','abstol','format','Double','scale',1./yts);
-			WriteData(fid,'object',obj,'class','stressbalance','fieldname','isnewton','format','Integer');
-			WriteData(fid,'object',obj,'class','stressbalance','fieldname','FSreconditioning','format','Double');
-			WriteData(fid,'object',obj,'class','stressbalance','fieldname','viscosity_overshoot','format','Double');
-			WriteData(fid,'object',obj,'class','stressbalance','fieldname','maxiter','format','Integer');
-			WriteData(fid,'object',obj,'class','stressbalance','fieldname','shelf_dampening','format','Integer');
-			WriteData(fid,'object',obj,'class','stressbalance','fieldname','penalty_factor','format','Double');
-			WriteData(fid,'object',obj,'class','stressbalance','fieldname','rift_penalty_lock','format','Integer');
-			WriteData(fid,'object',obj,'class','stressbalance','fieldname','rift_penalty_threshold','format','Integer');
-			WriteData(fid,'object',obj,'class','stressbalance','fieldname','referential','format','DoubleMat','mattype',1);
+			WriteData(fid,'object',self,'class','stressbalance','fieldname','spcvx','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
+			WriteData(fid,'object',self,'class','stressbalance','fieldname','spcvy','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
+			WriteData(fid,'object',self,'class','stressbalance','fieldname','spcvz','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
+			WriteData(fid,'object',self,'class','stressbalance','fieldname','restol','format','Double');
+			WriteData(fid,'object',self,'class','stressbalance','fieldname','reltol','format','Double');
+			WriteData(fid,'object',self,'class','stressbalance','fieldname','abstol','format','Double','scale',1./yts);
+			WriteData(fid,'object',self,'class','stressbalance','fieldname','isnewton','format','Integer');
+			WriteData(fid,'object',self,'class','stressbalance','fieldname','FSreconditioning','format','Double');
+			WriteData(fid,'object',self,'class','stressbalance','fieldname','viscosity_overshoot','format','Double');
+			WriteData(fid,'object',self,'class','stressbalance','fieldname','maxiter','format','Integer');
+			WriteData(fid,'object',self,'class','stressbalance','fieldname','shelf_dampening','format','Integer');
+			WriteData(fid,'object',self,'class','stressbalance','fieldname','penalty_factor','format','Double');
+			WriteData(fid,'object',self,'class','stressbalance','fieldname','rift_penalty_lock','format','Integer');
+			WriteData(fid,'object',self,'class','stressbalance','fieldname','rift_penalty_threshold','format','Integer');
+			WriteData(fid,'object',self,'class','stressbalance','fieldname','referential','format','DoubleMat','mattype',1);
 
-			WriteData(fid,'data',obj.loadingforce(:,1),'format','DoubleMat','mattype',1,'enum',LoadingforceXEnum);
-			WriteData(fid,'data',obj.loadingforce(:,2),'format','DoubleMat','mattype',1,'enum',LoadingforceYEnum);
-			WriteData(fid,'data',obj.loadingforce(:,3),'format','DoubleMat','mattype',1,'enum',LoadingforceZEnum);
+			WriteData(fid,'data',self.loadingforce(:,1),'format','DoubleMat','mattype',1,'enum',LoadingforceXEnum);
+			WriteData(fid,'data',self.loadingforce(:,2),'format','DoubleMat','mattype',1,'enum',LoadingforceYEnum);
+			WriteData(fid,'data',self.loadingforce(:,3),'format','DoubleMat','mattype',1,'enum',LoadingforceZEnum);
 
 			%process requested outputs
-			outputs = obj.requested_outputs;
+			outputs = self.requested_outputs;
 			pos  = find(ismember(outputs,'default'));
 			if ~isempty(pos),
 				outputs(pos) = [];                         %remove 'default' from outputs
-				outputs      = [outputs defaultoutputs(obj,md)]; %add defaults
+				outputs      = [outputs defaultoutputs(self,md)]; %add defaults
 			end
 			WriteData(fid,'data',outputs,'enum',StressbalanceRequestedOutputsEnum,'format','StringArray');
 		end % }}}
Index: ../trunk-jpl/src/m/classes/hydrologyshreve.m
===================================================================
--- ../trunk-jpl/src/m/classes/hydrologyshreve.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/hydrologyshreve.m	(revision 19040)
@@ -9,33 +9,33 @@
 		stabilization  = 0;
 	end
 	methods
-        function createxml(obj,fid) % {{{
+        function createxml(self,fid) % {{{
             fprintf(fid, '\n\n');
             fprintf(fid, '%s\n', '<!-- Hydrology -->');
             
             % Convergence criteria            
             fprintf(fid,'%s\n%s\n%s\n','<frame key="1" label="Hydrologyshreve solution parameters">','<section name="hydrologyshreve" />');                    
             
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="spcwatercolumn" type="',      class(obj.spcwatercolumn),'" default="',        convert2str(obj.spcwatercolumn),'">',	'     <section name="hydrologyshreve" />','     <help> water thickness constraints (NaN means no constraint) [m] </help>','</parameter>');
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="stabilization" type="',         class(obj.stabilization),'" default="',           convert2str(obj.stabilization),'">',	'     <section name="hydrologyshreve" />','     <help> artificial diffusivity (default is 1). can be more than 1 to increase diffusivity. </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="spcwatercolumn" type="',      class(self.spcwatercolumn),'" default="',        convert2str(self.spcwatercolumn),'">',	'     <section name="hydrologyshreve" />','     <help> water thickness constraints (NaN means no constraint) [m] </help>','</parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="stabilization" type="',         class(self.stabilization),'" default="',           convert2str(self.stabilization),'">',	'     <section name="hydrologyshreve" />','     <help> artificial diffusivity (default is 1). can be more than 1 to increase diffusivity. </help>','</parameter>');
             fprintf(fid,'%s\n%s\n','</frame>');
         end % }}}
-		function obj = hydrologyshreve(varargin) % {{{
+		function self = hydrologyshreve(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				case 1
-					obj=structtoobj(obj,varargin{1});
+					obj=structtoobj(self,varargin{1});
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 			%Type of stabilization to use 0:nothing 1:artificial_diffusivity
-			obj.stabilization=1;
+			self.stabilization=1;
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 			%Early return
 			if ~ismember(HydrologyShreveAnalysisEnum(),analyses)
@@ -45,16 +45,16 @@
 			md = checkfield(md,'fieldname','hydrology.spcwatercolumn','timeseries',1);
 			md = checkfield(md,'fieldname','hydrology.stabilization','>=',0);
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   hydrologyshreve solution parameters:'));
-			fielddisplay(obj,'spcwatercolumn','water thickness constraints (NaN means no constraint) [m]');
-			fielddisplay(obj,'stabilization','artificial diffusivity (default is 1). can be more than 1 to increase diffusivity.');
+			fielddisplay(self,'spcwatercolumn','water thickness constraints (NaN means no constraint) [m]');
+			fielddisplay(self,'stabilization','artificial diffusivity (default is 1). can be more than 1 to increase diffusivity.');
 
 		end % }}}
-		function marshall(obj,md,fid) % {{{
+		function marshall(self,md,fid) % {{{
 			WriteData(fid,'enum',HydrologyModelEnum(),'data',HydrologyshreveEnum(),'format','Integer');
-			WriteData(fid,'object',obj,'fieldname','spcwatercolumn','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
-			WriteData(fid,'object',obj,'fieldname','stabilization','format','Double');
+			WriteData(fid,'object',self,'fieldname','spcwatercolumn','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
+			WriteData(fid,'object',self,'fieldname','stabilization','format','Double');
 		end % }}}
 	end
 end
Index: ../trunk-jpl/src/m/classes/independent.m
===================================================================
--- ../trunk-jpl/src/m/classes/independent.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/independent.m	(revision 19040)
@@ -12,61 +12,61 @@
 		nods                 = 0;
 	end
 	methods
-		function obj = independent(varargin) % {{{
+		function self = independent(varargin) % {{{
 
 			%use provided options to change fields
 			options=pairoptions(varargin{:});
 
 			%OK get other fields
-			obj=AssignObjectFields(pairoptions(varargin{:}),obj);
+			self=AssignObjectFields(pairoptions(varargin{:}),self);
 
 		end
 		%}}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 			%do nothing
 
 		end % }}}
-		function md = checkconsistency(obj,md,i,solution,analyses,driver) % {{{
-			if ~isnan(obj.fos_forward_index),
+		function md = checkconsistency(self,md,i,solution,analyses,driver) % {{{
+			if ~isnan(self.fos_forward_index),
 				if ~strcmpi(driver,'fos_forward'),
 					error('cannot declare an independent with a fos_forward_index when the driver is not fos_forward!');
 				end
-				if obj.nods==0,
+				if self.nods==0,
 					error('independent checkconsistency error: nods should be set to the size of the independent variable');
 				end
 			end
 
-			if ~isempty(obj.fov_forward_indices),
+			if ~isempty(self.fov_forward_indices),
 				if ~strcmpi(driver,'fov_forward'),
 					error('cannot declare an independent with fov_forward_indices when the driver is not fov_forward!');
 				end
-				if obj.nods==0,
+				if self.nods==0,
 					error('independent checkconsistency error: nods should be set to the size of the independent variable');
 				end
-				md = checkfield(md,'fieldname',['autodiff.independents{' num2str(i) '}.fov_forward_indices'],'>=',1,'<=',obj.nods,'size',[NaN 1]);
+				md = checkfield(md,'fieldname',['autodiff.independents{' num2str(i) '}.fov_forward_indices'],'>=',1,'<=',self.nods,'size',[NaN 1]);
 			end
 
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   independent variable:'));
 
-			fielddisplay(obj,'name','variable name (must match corresponding Enum)');
-			fielddisplay(obj,'type','type of variable (''vertex'' or ''scalar'')');
-			if ~isnan(obj.fos_forward_index),
-				fielddisplay(obj,'fos_forward_index','index for fos_foward driver of ADOLC');
+			fielddisplay(self,'name','variable name (must match corresponding Enum)');
+			fielddisplay(self,'type','type of variable (''vertex'' or ''scalar'')');
+			if ~isnan(self.fos_forward_index),
+				fielddisplay(self,'fos_forward_index','index for fos_foward driver of ADOLC');
 			end
-			if ~isnan(obj.fov_forward_indices),
-				fielddisplay(obj,'fov_forward_indices','indices for fov_foward driver of ADOLC');
+			if ~isnan(self.fov_forward_indices),
+				fielddisplay(self,'fov_forward_indices','indices for fov_foward driver of ADOLC');
 			end
 		end % }}}
-		function scalartype=typetoscalar(obj) % {{{
-			if strcmpi(obj.type,'scalar'),
+		function scalartype=typetoscalar(self) % {{{
+			if strcmpi(self.type,'scalar'),
 				scalartype=0;
-			elseif strcmpi(obj.type,'vertex'),
+			elseif strcmpi(self.type,'vertex'),
 				scalartype=1;
-			elseif strcmpi(obj.type,'matrix'),
+			elseif strcmpi(self.type,'matrix'),
 				scalartype=1;
-			else error([obj.type ' not supported yet!']);
+			else error([self.type ' not supported yet!']);
 			end
 		end % }}}
 	end
Index: ../trunk-jpl/src/m/classes/seaiceocean.m
===================================================================
--- ../trunk-jpl/src/m/classes/seaiceocean.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/seaiceocean.m	(revision 19040)
@@ -15,31 +15,31 @@
 		ocean_vy             = NaN;
 	end
 	methods
-		function obj = seaiceocean(varargin) % {{{
+		function self = seaiceocean(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 			%ocean density (kg/m^3)
-			obj.rho_ocean=1025.;
+			self.rho_ocean=1025.;
 
 			%By default, we apply the full stress
-			obj.ocean_coef = 1.;
+			self.ocean_coef = 1.;
 
 			%drag coefficients (different from Hibler 0.0055)
-			obj.ocean_lin_drag_coef  = 0.;
-			obj.ocean_quad_drag_coef = 0.004;
+			self.ocean_lin_drag_coef  = 0.;
+			self.ocean_quad_drag_coef = 0.004;
 
 			%Turning angle in degrees (McPhee 1998)
-			obj.ocean_turning_angle = deg2rad(25.);
+			self.ocean_turning_angle = deg2rad(25.);
 
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 			md = checkfield(md,'fieldname','basalforcings.rho_ocean','NaN',1,'>',0.,'numel',1);
 			md = checkfield(md,'fieldname','basalforcings.ocean_coef','NaN',1,'>=',0.,'<=',1.,'numel',1);
 			md = checkfield(md,'fieldname','basalforcings.ocean_lin_drag_coef','NaN',1,'>=',0.,'numel',1);
@@ -49,28 +49,28 @@
 			md = checkfield(md,'fieldname','basalforcings.ocean_vx','NaN',1,'size',[md.mesh.numberofvertices 1]);
 			md = checkfield(md,'fieldname','basalforcings.ocean_vy','NaN',1,'size',[md.mesh.numberofvertices 1]);
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   Ocean forcings for sea ice:'));
 			%disp(sprintf('\n     tau_b = ocean_coef*rho_ocean*...'));
-			fielddisplay(obj,'rho_ocean','ocean density [kg/m^3]');
-			fielddisplay(obj,'ocean_coef','ocean stress spin up coefficient (between 0 and 1)');
-			fielddisplay(obj,'ocean_lin_drag_coef','ocean linear drag coefficient [Pa/(m/s)]');
-			fielddisplay(obj,'ocean_quad_drag_coef','ocean quadratic drag coefficient [Pa/(m/s)^2]');
-			fielddisplay(obj,'ocean_turning_angle','ocean turning angle [rad]');
-			fielddisplay(obj,'ocean_ssh','ocean sea surface height [m]');
-			fielddisplay(obj,'ocean_vx','ocean speed x-component [m/s]');
-			fielddisplay(obj,'ocean_vy','ocean speed y-component [m/s]');
+			fielddisplay(self,'rho_ocean','ocean density [kg/m^3]');
+			fielddisplay(self,'ocean_coef','ocean stress spin up coefficient (between 0 and 1)');
+			fielddisplay(self,'ocean_lin_drag_coef','ocean linear drag coefficient [Pa/(m/s)]');
+			fielddisplay(self,'ocean_quad_drag_coef','ocean quadratic drag coefficient [Pa/(m/s)^2]');
+			fielddisplay(self,'ocean_turning_angle','ocean turning angle [rad]');
+			fielddisplay(self,'ocean_ssh','ocean sea surface height [m]');
+			fielddisplay(self,'ocean_vx','ocean speed x-component [m/s]');
+			fielddisplay(self,'ocean_vy','ocean speed y-component [m/s]');
 		end % }}}
-		function marshall(obj,md,fid) % {{{
+		function marshall(self,md,fid) % {{{
 			WriteData(fid,'enum',BasalforcingsEnum(),'data',SeaiceoceanEnum(),'format','Integer');
-			WriteData(fid,'object',obj,'class','basalforcings','fieldname','rho_ocean','format','Double');
-			WriteData(fid,'object',obj,'class','basalforcings','fieldname','ocean_coef','format','Double');
-			WriteData(fid,'object',obj,'class','basalforcings','fieldname','ocean_lin_drag_coef','format','Double');
-			WriteData(fid,'object',obj,'class','basalforcings','fieldname','ocean_quad_drag_coef','format','Double');
-			WriteData(fid,'object',obj,'class','basalforcings','fieldname','ocean_turning_angle','format','Double');
-			WriteData(fid,'object',obj,'class','basalforcings','fieldname','ocean_ssh','format','DoubleMat','mattype',1);
-			WriteData(fid,'object',obj,'class','basalforcings','fieldname','ocean_vx','format','DoubleMat','mattype',1);
-			WriteData(fid,'object',obj,'class','basalforcings','fieldname','ocean_vy','format','DoubleMat','mattype',1);
+			WriteData(fid,'object',self,'class','basalforcings','fieldname','rho_ocean','format','Double');
+			WriteData(fid,'object',self,'class','basalforcings','fieldname','ocean_coef','format','Double');
+			WriteData(fid,'object',self,'class','basalforcings','fieldname','ocean_lin_drag_coef','format','Double');
+			WriteData(fid,'object',self,'class','basalforcings','fieldname','ocean_quad_drag_coef','format','Double');
+			WriteData(fid,'object',self,'class','basalforcings','fieldname','ocean_turning_angle','format','Double');
+			WriteData(fid,'object',self,'class','basalforcings','fieldname','ocean_ssh','format','DoubleMat','mattype',1);
+			WriteData(fid,'object',self,'class','basalforcings','fieldname','ocean_vx','format','DoubleMat','mattype',1);
+			WriteData(fid,'object',self,'class','basalforcings','fieldname','ocean_vy','format','DoubleMat','mattype',1);
 		end % }}}
 	end
 end
Index: ../trunk-jpl/src/m/classes/model.m
===================================================================
--- ../trunk-jpl/src/m/classes/model.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/model.m	(revision 19040)
@@ -1340,46 +1340,46 @@
 				md.mesh.average_vertex_connectivity=100;
 			end
 		end % }}}
-		function disp(obj) % {{{
-			disp(sprintf('%19s: %-22s -- %s','mesh'            ,['[1x1 ' class(obj.mesh) ']'],'mesh properties'));
-			disp(sprintf('%19s: %-22s -- %s','mask'            ,['[1x1 ' class(obj.mask) ']'],'defines grounded and floating elements'));
-			disp(sprintf('%19s: %-22s -- %s','geometry'        ,['[1x1 ' class(obj.geometry) ']'],'surface elevation, bedrock topography, ice thickness,...'));
-			disp(sprintf('%19s: %-22s -- %s','constants'       ,['[1x1 ' class(obj.constants) ']'],'physical constants'));
-			disp(sprintf('%19s: %-22s -- %s','surfaceforcings' ,['[1x1 ' class(obj.surfaceforcings) ']'],'surface forcings'));
-			disp(sprintf('%19s: %-22s -- %s','basalforcings'   ,['[1x1 ' class(obj.basalforcings) ']'],'bed forcings'));
-			disp(sprintf('%19s: %-22s -- %s','materials'       ,['[1x1 ' class(obj.materials) ']'],'material properties'));
-			disp(sprintf('%19s: %-22s -- %s','damage'          ,['[1x1 ' class(obj.damage) ']'],'parameters for damage evolution solution'));
-			disp(sprintf('%19s: %-22s -- %s','friction'        ,['[1x1 ' class(obj.friction) ']'],'basal friction/drag properties'));
-			disp(sprintf('%19s: %-22s -- %s','flowequation'    ,['[1x1 ' class(obj.flowequation) ']'],'flow equations'));
-			disp(sprintf('%19s: %-22s -- %s','timestepping'    ,['[1x1 ' class(obj.timestepping) ']'],'time stepping for transient models'));
-			disp(sprintf('%19s: %-22s -- %s','initialization'  ,['[1x1 ' class(obj.initialization) ']'],'initial guess/state'));
-			disp(sprintf('%19s: %-22s -- %s','rifts'           ,['[1x1 ' class(obj.rifts) ']'],'rifts properties'));
-			disp(sprintf('%19s: %-22s -- %s','debug'           ,['[1x1 ' class(obj.debug) ']'],'debugging tools (valgrind, gprof)'));
-			disp(sprintf('%19s: %-22s -- %s','verbose'         ,['[1x1 ' class(obj.verbose) ']'],'verbosity level in solve'));
-			disp(sprintf('%19s: %-22s -- %s','settings'        ,['[1x1 ' class(obj.settings) ']'],'settings properties'));
-			disp(sprintf('%19s: %-22s -- %s','toolkits'        ,['[1x1 ' class(obj.toolkits) ']'],'PETSc options for each solution'));
-			disp(sprintf('%19s: %-22s -- %s','cluster'         ,['[1x1 ' class(obj.cluster) ']'],'cluster parameters (number of cpus...)'));
-			disp(sprintf('%19s: %-22s -- %s','balancethickness',['[1x1 ' class(obj.balancethickness) ']'],'parameters for balancethickness solution'));
-			disp(sprintf('%19s: %-22s -- %s','stressbalance'   ,['[1x1 ' class(obj.stressbalance) ']'],'parameters for stressbalance solution'));
-			disp(sprintf('%19s: %-22s -- %s','groundingline'   ,['[1x1 ' class(obj.groundingline) ']'],'parameters for groundingline solution'));
-			disp(sprintf('%19s: %-22s -- %s','hydrology'       ,['[1x1 ' class(obj.hydrology) ']'],'parameters for hydrology solution'));
-			disp(sprintf('%19s: %-22s -- %s','masstransport'   ,['[1x1 ' class(obj.masstransport) ']'],'parameters for masstransport solution'));
-			disp(sprintf('%19s: %-22s -- %s','thermal'         ,['[1x1 ' class(obj.thermal) ']'],'parameters for thermal solution'));
-			disp(sprintf('%19s: %-22s -- %s','steadystate'     ,['[1x1 ' class(obj.steadystate) ']'],'parameters for steadystate solution'));
-			disp(sprintf('%19s: %-22s -- %s','transient'       ,['[1x1 ' class(obj.transient) ']'],'parameters for transient solution'));
-			disp(sprintf('%19s: %-22s -- %s','calving'         ,['[1x1 ' class(obj.calving) ']'],'parameters for calving'));
-			disp(sprintf('%19s: %-22s -- %s','gia'             ,['[1x1 ' class(obj.gia) ']'],'parameters for gia solution'));
-			disp(sprintf('%19s: %-22s -- %s','autodiff'        ,['[1x1 ' class(obj.autodiff) ']'],'automatic differentiation parameters'));
-			disp(sprintf('%19s: %-22s -- %s','flaim'           ,['[1x1 ' class(obj.flaim) ']'],'flaim parameters'));
-			disp(sprintf('%19s: %-22s -- %s','inversion'       ,['[1x1 ' class(obj.inversion) ']'],'parameters for inverse methods'));
-			disp(sprintf('%19s: %-22s -- %s','qmu'             ,['[1x1 ' class(obj.qmu) ']'],'dakota properties'));
-			disp(sprintf('%19s: %-22s -- %s','outputdefinition',['[1x1 ' class(obj.outputdefinition) ']'],'output definition'));
-			disp(sprintf('%19s: %-22s -- %s','results'         ,['[1x1 ' class(obj.results) ']'],'model results'));
-			disp(sprintf('%19s: %-22s -- %s','radaroverlay'    ,['[1x1 ' class(obj.radaroverlay) ']'],'radar image for plot overlay'));
-			disp(sprintf('%19s: %-22s -- %s','miscellaneous'   ,['[1x1 ' class(obj.miscellaneous) ']'],'miscellaneous fields'));
-			disp(sprintf('%19s: %-22s -- %s','seaice'       ,['[1x1 ' class(obj.seaice) ']'],'parameters for Sea Ice solution'));
+		function disp(self) % {{{
+			disp(sprintf('%19s: %-22s -- %s','mesh'            ,['[1x1 ' class(self.mesh) ']'],'mesh properties'));
+			disp(sprintf('%19s: %-22s -- %s','mask'            ,['[1x1 ' class(self.mask) ']'],'defines grounded and floating elements'));
+			disp(sprintf('%19s: %-22s -- %s','geometry'        ,['[1x1 ' class(self.geometry) ']'],'surface elevation, bedrock topography, ice thickness,...'));
+			disp(sprintf('%19s: %-22s -- %s','constants'       ,['[1x1 ' class(self.constants) ']'],'physical constants'));
+			disp(sprintf('%19s: %-22s -- %s','surfaceforcings' ,['[1x1 ' class(self.surfaceforcings) ']'],'surface forcings'));
+			disp(sprintf('%19s: %-22s -- %s','basalforcings'   ,['[1x1 ' class(self.basalforcings) ']'],'bed forcings'));
+			disp(sprintf('%19s: %-22s -- %s','materials'       ,['[1x1 ' class(self.materials) ']'],'material properties'));
+			disp(sprintf('%19s: %-22s -- %s','damage'          ,['[1x1 ' class(self.damage) ']'],'parameters for damage evolution solution'));
+			disp(sprintf('%19s: %-22s -- %s','friction'        ,['[1x1 ' class(self.friction) ']'],'basal friction/drag properties'));
+			disp(sprintf('%19s: %-22s -- %s','flowequation'    ,['[1x1 ' class(self.flowequation) ']'],'flow equations'));
+			disp(sprintf('%19s: %-22s -- %s','timestepping'    ,['[1x1 ' class(self.timestepping) ']'],'time stepping for transient models'));
+			disp(sprintf('%19s: %-22s -- %s','initialization'  ,['[1x1 ' class(self.initialization) ']'],'initial guess/state'));
+			disp(sprintf('%19s: %-22s -- %s','rifts'           ,['[1x1 ' class(self.rifts) ']'],'rifts properties'));
+			disp(sprintf('%19s: %-22s -- %s','debug'           ,['[1x1 ' class(self.debug) ']'],'debugging tools (valgrind, gprof)'));
+			disp(sprintf('%19s: %-22s -- %s','verbose'         ,['[1x1 ' class(self.verbose) ']'],'verbosity level in solve'));
+			disp(sprintf('%19s: %-22s -- %s','settings'        ,['[1x1 ' class(self.settings) ']'],'settings properties'));
+			disp(sprintf('%19s: %-22s -- %s','toolkits'        ,['[1x1 ' class(self.toolkits) ']'],'PETSc options for each solution'));
+			disp(sprintf('%19s: %-22s -- %s','cluster'         ,['[1x1 ' class(self.cluster) ']'],'cluster parameters (number of cpus...)'));
+			disp(sprintf('%19s: %-22s -- %s','balancethickness',['[1x1 ' class(self.balancethickness) ']'],'parameters for balancethickness solution'));
+			disp(sprintf('%19s: %-22s -- %s','stressbalance'   ,['[1x1 ' class(self.stressbalance) ']'],'parameters for stressbalance solution'));
+			disp(sprintf('%19s: %-22s -- %s','groundingline'   ,['[1x1 ' class(self.groundingline) ']'],'parameters for groundingline solution'));
+			disp(sprintf('%19s: %-22s -- %s','hydrology'       ,['[1x1 ' class(self.hydrology) ']'],'parameters for hydrology solution'));
+			disp(sprintf('%19s: %-22s -- %s','masstransport'   ,['[1x1 ' class(self.masstransport) ']'],'parameters for masstransport solution'));
+			disp(sprintf('%19s: %-22s -- %s','thermal'         ,['[1x1 ' class(self.thermal) ']'],'parameters for thermal solution'));
+			disp(sprintf('%19s: %-22s -- %s','steadystate'     ,['[1x1 ' class(self.steadystate) ']'],'parameters for steadystate solution'));
+			disp(sprintf('%19s: %-22s -- %s','transient'       ,['[1x1 ' class(self.transient) ']'],'parameters for transient solution'));
+			disp(sprintf('%19s: %-22s -- %s','calving'         ,['[1x1 ' class(self.calving) ']'],'parameters for calving'));
+			disp(sprintf('%19s: %-22s -- %s','gia'             ,['[1x1 ' class(self.gia) ']'],'parameters for gia solution'));
+			disp(sprintf('%19s: %-22s -- %s','autodiff'        ,['[1x1 ' class(self.autodiff) ']'],'automatic differentiation parameters'));
+			disp(sprintf('%19s: %-22s -- %s','flaim'           ,['[1x1 ' class(self.flaim) ']'],'flaim parameters'));
+			disp(sprintf('%19s: %-22s -- %s','inversion'       ,['[1x1 ' class(self.inversion) ']'],'parameters for inverse methods'));
+			disp(sprintf('%19s: %-22s -- %s','qmu'             ,['[1x1 ' class(self.qmu) ']'],'dakota properties'));
+			disp(sprintf('%19s: %-22s -- %s','outputdefinition',['[1x1 ' class(self.outputdefinition) ']'],'output definition'));
+			disp(sprintf('%19s: %-22s -- %s','results'         ,['[1x1 ' class(self.results) ']'],'model results'));
+			disp(sprintf('%19s: %-22s -- %s','radaroverlay'    ,['[1x1 ' class(self.radaroverlay) ']'],'radar image for plot overlay'));
+			disp(sprintf('%19s: %-22s -- %s','miscellaneous'   ,['[1x1 ' class(self.miscellaneous) ']'],'miscellaneous fields'));
+			disp(sprintf('%19s: %-22s -- %s','seaice'       ,['[1x1 ' class(self.seaice) ']'],'parameters for Sea Ice solution'));
 		end % }}}
-		function memory(obj) % {{{
+		function memory(self) % {{{
 
 		disp(sprintf('\nMemory imprint:\n'));
 
@@ -1387,7 +1387,7 @@
 		mem=0;
 
 		for i=1:length(fields),
-			field=obj.(fields{i});
+			field=self.(fields{i});
 			s=whos('field'); 
 			mem=mem+s.bytes/1e6;
 			disp(sprintf('%19s: %6.2f Mb',fields{i},s.bytes/1e6));
@@ -1395,7 +1395,7 @@
 		disp(sprintf('%19s--%10s','--------------','--------------'));
 		disp(sprintf('%19s: %g Mb','Total',mem));
 		end % }}}
-		function netcdf(obj,filename) % {{{
+		function netcdf(self,filename) % {{{
 		%NETCDF - save model as netcdf
 		%
 		%   Usage:
@@ -1408,7 +1408,7 @@
 		%1. Create NetCDF file
 		ncid=netcdf.create(filename,'CLOBBER');
 		netcdf.putAtt(ncid,netcdf.getConstant('NC_GLOBAL'),'Conventions','CF-1.4');
-		netcdf.putAtt(ncid,netcdf.getConstant('NC_GLOBAL'),'Title',['ISSM model (' obj.miscellaneous.name ')']);
+		netcdf.putAtt(ncid,netcdf.getConstant('NC_GLOBAL'),'Title',['ISSM model (' self.miscellaneous.name ')']);
 		netcdf.putAtt(ncid,netcdf.getConstant('NC_GLOBAL'),'Author',getenv('USER'));
 		netcdf.putAtt(ncid,netcdf.getConstant('NC_GLOBAL'),'Date',datestr(now));
 
@@ -1417,7 +1417,7 @@
 
 		for step=1:2,
 			counter=0;
-			[var_id,counter]=structtonc(ncid,'md',obj,0,var_id,counter,step);
+			[var_id,counter]=structtonc(ncid,'md',self,0,var_id,counter,step);
 			if step==1, netcdf.endDef(ncid); end
 		end
 
@@ -1427,10 +1427,10 @@
 
 		netcdf.close(ncid)
 		end % }}}
-		function xylim(obj) % {{{
+		function xylim(self) % {{{
 
-			xlim([min(obj.mesh.x) max(obj.mesh.x)]);
-			ylim([min(obj.mesh.y) max(obj.mesh.y)])
+			xlim([min(self.mesh.x) max(self.mesh.x)]);
+			ylim([min(self.mesh.y) max(self.mesh.y)])
 		end % }}}
 		function md=upload(md) % {{{
 		%the goal of this routine is to upload the model onto a server, and to empty it.
Index: ../trunk-jpl/src/m/classes/toolkits.py
===================================================================
--- ../trunk-jpl/src/m/classes/toolkits.py	(revision 19039)
+++ ../trunk-jpl/src/m/classes/toolkits.py	(revision 19040)
@@ -11,7 +11,7 @@
 	TOOLKITS class definition
 
 	   Usage:
-	      obj=toolkits();
+	      self=toolkits();
 	"""
 
 	def __init__(self):    # {{{
Index: ../trunk-jpl/src/m/classes/calvingpi.m
===================================================================
--- ../trunk-jpl/src/m/classes/calvingpi.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/calvingpi.m	(revision 19040)
@@ -10,10 +10,10 @@
 		meltingrate   = NaN;
 	end
 	methods
-		function obj = calvingpi(varargin) % {{{
+		function self = calvingpi(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				case 1
 					inputstruct=varargin{1};
 					list1 = properties('calvingpi');
@@ -21,22 +21,22 @@
 					for i=1:length(list1)
 						fieldname = list1{i};
 						if ismember(fieldname,list2),
-							obj.(fieldname) = inputstruct.(fieldname);
+							self.(fieldname) = inputstruct.(fieldname);
 						end
 					end
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 			%stabilization = 2 by default
-			obj.stabilization = 2;
+			self.stabilization = 2;
 
 			%Proportionality coefficient in Pi model
-			obj.coeff=2e13;
+			self.coeff=2e13;
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 			%Early return
 			if (solution~=TransientSolutionEnum() | md.transient.iscalving==0), return; end
 
@@ -44,19 +44,19 @@
 			md = checkfield(md,'fieldname','calving.coeff','>',0,'size',[md.mesh.numberofvertices 1]);
 			md = checkfield(md,'fieldname','calving.meltingrate','NaN',1,'size',[md.mesh.numberofvertices 1],'>=',0);
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   Calving Pi parameters:'));
-			fielddisplay(obj,'stabilization','0: no, 1: artificial_diffusivity, 2: streamline upwinding');
-			fielddisplay(obj,'coeff','proportionality coefficient in Pi model');
-			fielddisplay(obj,'meltingrate','melting rate at given location [m/a]');
+			fielddisplay(self,'stabilization','0: no, 1: artificial_diffusivity, 2: streamline upwinding');
+			fielddisplay(self,'coeff','proportionality coefficient in Pi model');
+			fielddisplay(self,'meltingrate','melting rate at given location [m/a]');
 
 		end % }}}
-		function marshall(obj,md,fid) % {{{
+		function marshall(self,md,fid) % {{{
 			yts=365.0*24.0*3600.0;
 			WriteData(fid,'enum',CalvingLawEnum(),'data',CalvingPiEnum(),'format','Integer');
-			WriteData(fid,'enum',LevelsetStabilizationEnum(),'data',obj.stabilization,'format','Integer');
-			WriteData(fid,'enum',CalvingpiCoeffEnum(),'data',obj.coeff,'format','DoubleMat','mattype',1);
-			WriteData(fid,'object',obj,'fieldname','meltingrate','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1,'scale',1./yts);
+			WriteData(fid,'enum',LevelsetStabilizationEnum(),'data',self.stabilization,'format','Integer');
+			WriteData(fid,'enum',CalvingpiCoeffEnum(),'data',self.coeff,'format','DoubleMat','mattype',1);
+			WriteData(fid,'object',self,'fieldname','meltingrate','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1,'scale',1./yts);
 		end % }}}
 	end
 end
Index: ../trunk-jpl/src/m/classes/flowequation.m
===================================================================
--- ../trunk-jpl/src/m/classes/flowequation.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/flowequation.m	(revision 19040)
@@ -25,7 +25,7 @@
 		borderFS                       = NaN;
 	end
 	methods (Static)
-		function obj = loadobj(obj) % {{{
+		function self = loadobj(self) % {{{
 			% This function is directly called by matlab when a model object is
 			% loaded. If the input is a struct it is an old version of this class and
 			% old fields must be recovered (make sure they are in the deprecated
@@ -43,35 +43,35 @@
 				% This has been fixed in MATLAB 7.9 (R2009b) and later versions
 			end
 
-			if isstruct(obj)
+			if isstruct(self)
 				disp('Recovering flowequation from older version');
-				objstruct = obj;
-				obj = structtoobj(flowequation(),objstruct);
+				objstruct = self;
+				self = structtoobj(flowequation(),objstruct);
 
 				%2013 July 23rd
-				if isfield(objstruct,'ishutter'),      obj.isSIA     = objstruct.ishutter;       end; 
-				if isfield(objstruct,'ismacayeal'),    obj.isSSA     = objstruct.ismacayeal;     end; 
-				if isfield(objstruct,'ispattyn'),      obj.isHO      = objstruct.ispattyn;       end; 
-				if isfield(objstruct,'isstokes'),      obj.isFS      = objstruct.isstokes;       end; 
-				if isfield(objstruct,'bordermacayeal'),obj.borderSSA = objstruct.bordermacayeal; end; 
-				if isfield(objstruct,'borderpattyn'),  obj.borderHO  = objstruct.borderpattyn;   end; 
-				if isfield(objstruct,'borderstokes'),  obj.borderFS  = objstruct.borderstokes;   end; 
+				if isfield(objstruct,'ishutter'),      self.isSIA     = objstruct.ishutter;       end; 
+				if isfield(objstruct,'ismacayeal'),    self.isSSA     = objstruct.ismacayeal;     end; 
+				if isfield(objstruct,'ispattyn'),      self.isHO      = objstruct.ispattyn;       end; 
+				if isfield(objstruct,'isstokes'),      self.isFS      = objstruct.isstokes;       end; 
+				if isfield(objstruct,'bordermacayeal'),self.borderSSA = objstruct.bordermacayeal; end; 
+				if isfield(objstruct,'borderpattyn'),  self.borderHO  = objstruct.borderpattyn;   end; 
+				if isfield(objstruct,'borderstokes'),  self.borderFS  = objstruct.borderstokes;   end; 
 			end
 
 		end% }}}
 	end
 	methods
-		function createxml(obj,fid) % {{{
+		function createxml(self,fid) % {{{
 			fprintf(fid, '\n\n');
 			fprintf(fid, '%s\n', '<!-- flowequation -->');
 			fprintf(fid,'%s\n%s\n%s\n','<frame key="1" label="Flow equation parameters">','<section name="flowequation" />');                    
 
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="isSIA" type="',              class(obj.isSIA),'" default="',                  convert2str(obj.isSIA),'">',              '     <section name="flowequation" />','     <help> is the Shallow Ice Approximation (SIA) used ? </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="isSSA" type="',            class(obj.isSSA),'" default="',                convert2str(obj.isSSA),'">',   '     <section name="flowequation" />','     <help> is the Shelfy-Stream Approximation (SSA) used ? </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',        '<parameter key ="isL1L2" type="',      class(obj.isL1L2),'" default="',          convert2str(obj.isL1L2),'">',            '     <section name="flowequation" />','     <help> is the L1L2 approximation used ? </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',        '<parameter key ="isHO" type="',     class(obj.isHO),'" default="',         convert2str(obj.isHO),'">',            '     <section name="flowequation" />','     <help> is the Higher-Order (HO) approximation used ? </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="isSIA" type="',              class(self.isSIA),'" default="',                  convert2str(self.isSIA),'">',              '     <section name="flowequation" />','     <help> is the Shallow Ice Approximation (SIA) used ? </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="isSSA" type="',            class(self.isSSA),'" default="',                convert2str(self.isSSA),'">',   '     <section name="flowequation" />','     <help> is the Shelfy-Stream Approximation (SSA) used ? </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',        '<parameter key ="isL1L2" type="',      class(self.isL1L2),'" default="',          convert2str(self.isL1L2),'">',            '     <section name="flowequation" />','     <help> is the L1L2 approximation used ? </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',        '<parameter key ="isHO" type="',     class(self.isHO),'" default="',         convert2str(self.isHO),'">',            '     <section name="flowequation" />','     <help> is the Higher-Order (HO) approximation used ? </help>','</parameter>');
 
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="isFS" type="',       class(obj.isFS),'" default="',              convert2str(obj.isFS),'">',              '     <section name="flowequation" />','     <help> are the Full-FS (FS) equations used ? </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="isFS" type="',       class(self.isFS),'" default="',              convert2str(self.isFS),'">',              '     <section name="flowequation" />','     <help> are the Full-FS (FS) equations used ? </help>','</parameter>');
 
 			% fe_SSA drop-down (P1, P1bubble, P1bubblecondensed, P2)
 			fprintf(fid,'%s\n%s\n%s\n%s\n',    '<parameter key ="fe_SSA" type="alternative" optional="false">','     <section name="flowequation" />','     <help> Finite Element for SSA  "P1", "P1bubble" "P1bubblecondensed" "P2" </help>');
@@ -97,35 +97,35 @@
 			fprintf(fid,'%s\n','       <option value="MINI" type="string" default="false"> </option>');
 			fprintf(fid,'%s\n%s\n','       <option value="TaylorHood" type="string" default="false"> </option>','</parameter>');
 
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',        '<parameter key ="vertex_equation" type="',      class(obj.vertex_equation),'" default="',            convert2str(obj.vertex_equation),'">',            '     <section name="flowequation" />','     <help> flow equation for each vertex </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',        '<parameter key ="vertex_equation" type="',      class(self.vertex_equation),'" default="',            convert2str(self.vertex_equation),'">',            '     <section name="flowequation" />','     <help> flow equation for each vertex </help>','</parameter>');
 
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="element_equation" type="',            class(obj.element_equation),'" default="',              convert2str(obj.element_equation),'">',              '     <section name="flowequation" />','     <help> flow equation for each element </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="borderSSA" type="', class(obj.borderSSA),'" default="',   convert2str(obj.borderSSA),'">',   '     <section name="flowequation" />','     <help> vertices on SSAs border (for tiling) </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',        '<parameter key ="borderHO" type="',          class(obj.borderHO),'" default="',            convert2str(obj.borderHO),'">',            '     <section name="flowequation" />','     <help> vertices on HOs border (for tiling) </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n',        '<parameter key ="borderFS" type="',          class(obj.borderFS),'" default="',            convert2str(obj.borderFS),'">',            '     <section name="flowequation" />','     <help> vertices on FS border (for tiling) </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="element_equation" type="',            class(self.element_equation),'" default="',              convert2str(self.element_equation),'">',              '     <section name="flowequation" />','     <help> flow equation for each element </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="borderSSA" type="', class(self.borderSSA),'" default="',   convert2str(self.borderSSA),'">',   '     <section name="flowequation" />','     <help> vertices on SSAs border (for tiling) </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',        '<parameter key ="borderHO" type="',          class(self.borderHO),'" default="',            convert2str(self.borderHO),'">',            '     <section name="flowequation" />','     <help> vertices on HOs border (for tiling) </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n',        '<parameter key ="borderFS" type="',          class(self.borderFS),'" default="',            convert2str(self.borderFS),'">',            '     <section name="flowequation" />','     <help> vertices on FS border (for tiling) </help>','</parameter>');
 
 			fprintf(fid,'%s\n%s\n','</frame>');
 		end % }}}
-		function obj = flowequation(varargin) % {{{
+		function self = flowequation(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 			%P1 for SSA
-			obj.fe_SSA= 'P1';
+			self.fe_SSA= 'P1';
 
 			%P1 for HO
-			obj.fe_HO= 'P1';
+			self.fe_HO= 'P1';
 
 			%MINI condensed element for FS by default
-			obj.fe_FS = 'MINIcondensed';
+			self.fe_FS = 'MINIcondensed';
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 
 			%Early return
@@ -159,55 +159,55 @@
 			else
 				error('Case not supported yet');
 			end
-			if ~(obj.isSIA || obj.isSSA || obj.isL1L2 || obj.isHO || obj.isFS),
+			if ~(self.isSIA || self.isSSA || self.isL1L2 || self.isHO || self.isFS),
 				md = checkmessage(md,['no element types set for this model']);
 			end
 			if ismember(StressbalanceSIAAnalysisEnum(),analyses),
-				if any(obj.element_equation==1),
-					if(obj.vertex_equation & md.mask.groundedice_levelset<0.),
+				if any(self.element_equation==1),
+					if(self.vertex_equation & md.mask.groundedice_levelset<0.),
 						disp(sprintf('\n !!! Warning: SIA''s model is not consistent on ice shelves !!!\n'));
 					end
 				end
 			end
 
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   flow equation parameters:'));
 
-			fielddisplay(obj,'isSIA','is the Shallow Ice Approximation (SIA) used ?');
-			fielddisplay(obj,'isSSA','is the Shelfy-Stream Approximation (SSA) used ?');
-			fielddisplay(obj,'isL1L2','is the L1L2 approximation used ?');
-			fielddisplay(obj,'isHO','is the Higher-Order (HO) approximation used ?');
-			fielddisplay(obj,'isFS','are the Full-FS (FS) equations used ?');
-			fielddisplay(obj,'fe_SSA','Finite Element for SSA  ''P1'', ''P1bubble'' ''P1bubblecondensed'' ''P2''');
-			fielddisplay(obj,'fe_HO', 'Finite Element for HO   ''P1'' ''P1bubble'' ''P1bubblecondensed'' ''P1xP2'' ''P2xP1'' ''P2''');
-			fielddisplay(obj,'fe_FS', 'Finite Element for FS   ''P1P1'' (debugging only) ''P1P1GLS'' ''MINIcondensed'' ''MINI'' ''TaylorHood'' ''XTaylorHood''');
-			fielddisplay(obj,'vertex_equation','flow equation for each vertex');
-			fielddisplay(obj,'element_equation','flow equation for each element');
-			fielddisplay(obj,'borderSSA','vertices on SSA''s border (for tiling)');
-			fielddisplay(obj,'borderHO','vertices on HO''s border (for tiling)');
-			fielddisplay(obj,'borderFS','vertices on FS'' border (for tiling)');
+			fielddisplay(self,'isSIA','is the Shallow Ice Approximation (SIA) used ?');
+			fielddisplay(self,'isSSA','is the Shelfy-Stream Approximation (SSA) used ?');
+			fielddisplay(self,'isL1L2','is the L1L2 approximation used ?');
+			fielddisplay(self,'isHO','is the Higher-Order (HO) approximation used ?');
+			fielddisplay(self,'isFS','are the Full-FS (FS) equations used ?');
+			fielddisplay(self,'fe_SSA','Finite Element for SSA  ''P1'', ''P1bubble'' ''P1bubblecondensed'' ''P2''');
+			fielddisplay(self,'fe_HO', 'Finite Element for HO   ''P1'' ''P1bubble'' ''P1bubblecondensed'' ''P1xP2'' ''P2xP1'' ''P2''');
+			fielddisplay(self,'fe_FS', 'Finite Element for FS   ''P1P1'' (debugging only) ''P1P1GLS'' ''MINIcondensed'' ''MINI'' ''TaylorHood'' ''XTaylorHood''');
+			fielddisplay(self,'vertex_equation','flow equation for each vertex');
+			fielddisplay(self,'element_equation','flow equation for each element');
+			fielddisplay(self,'borderSSA','vertices on SSA''s border (for tiling)');
+			fielddisplay(self,'borderHO','vertices on HO''s border (for tiling)');
+			fielddisplay(self,'borderFS','vertices on FS'' border (for tiling)');
 
 		end % }}}
-		function marshall(obj,md,fid) % {{{
-			WriteData(fid,'object',obj,'fieldname','isSIA','format','Boolean');
-			WriteData(fid,'object',obj,'fieldname','isSSA','format','Boolean');
-			WriteData(fid,'object',obj,'fieldname','isL1L2','format','Boolean');
-			WriteData(fid,'object',obj,'fieldname','isHO','format','Boolean');
-			WriteData(fid,'object',obj,'fieldname','isFS','format','Boolean');
-			WriteData(fid,'enum',FlowequationFeSSAEnum(),'data',StringToEnum(obj.fe_SSA),'format','Integer');
-			WriteData(fid,'enum',FlowequationFeHOEnum() ,'data',StringToEnum(obj.fe_HO) ,'format','Integer');
-			WriteData(fid,'enum',FlowequationFeFSEnum() ,'data',StringToEnum(obj.fe_FS) ,'format','Integer');
-			WriteData(fid,'enum',AugmentedLagrangianREnum(),'data',obj.augmented_lagrangian_r ,'format','Double');
-			WriteData(fid,'enum',AugmentedLagrangianRhopEnum(),'data',obj.augmented_lagrangian_rhop ,'format','Double');
-			WriteData(fid,'enum',AugmentedLagrangianRlambdaEnum(),'data',obj.augmented_lagrangian_rlambda ,'format','Double');
-			WriteData(fid,'enum',AugmentedLagrangianRholambdaEnum(),'data',obj.augmented_lagrangian_rholambda ,'format','Double');
-			WriteData(fid,'enum',AugmentedLagrangianThetaEnum() ,'data',obj.XTH_theta ,'format','Double');
-			WriteData(fid,'object',obj,'fieldname','borderSSA','format','DoubleMat','mattype',1);
-			WriteData(fid,'object',obj,'fieldname','borderHO','format','DoubleMat','mattype',1);
-			WriteData(fid,'object',obj,'fieldname','borderFS','format','DoubleMat','mattype',1);
+		function marshall(self,md,fid) % {{{
+			WriteData(fid,'object',self,'fieldname','isSIA','format','Boolean');
+			WriteData(fid,'object',self,'fieldname','isSSA','format','Boolean');
+			WriteData(fid,'object',self,'fieldname','isL1L2','format','Boolean');
+			WriteData(fid,'object',self,'fieldname','isHO','format','Boolean');
+			WriteData(fid,'object',self,'fieldname','isFS','format','Boolean');
+			WriteData(fid,'enum',FlowequationFeSSAEnum(),'data',StringToEnum(self.fe_SSA),'format','Integer');
+			WriteData(fid,'enum',FlowequationFeHOEnum() ,'data',StringToEnum(self.fe_HO) ,'format','Integer');
+			WriteData(fid,'enum',FlowequationFeFSEnum() ,'data',StringToEnum(self.fe_FS) ,'format','Integer');
+			WriteData(fid,'enum',AugmentedLagrangianREnum(),'data',self.augmented_lagrangian_r ,'format','Double');
+			WriteData(fid,'enum',AugmentedLagrangianRhopEnum(),'data',self.augmented_lagrangian_rhop ,'format','Double');
+			WriteData(fid,'enum',AugmentedLagrangianRlambdaEnum(),'data',self.augmented_lagrangian_rlambda ,'format','Double');
+			WriteData(fid,'enum',AugmentedLagrangianRholambdaEnum(),'data',self.augmented_lagrangian_rholambda ,'format','Double');
+			WriteData(fid,'enum',AugmentedLagrangianThetaEnum() ,'data',self.XTH_theta ,'format','Double');
+			WriteData(fid,'object',self,'fieldname','borderSSA','format','DoubleMat','mattype',1);
+			WriteData(fid,'object',self,'fieldname','borderHO','format','DoubleMat','mattype',1);
+			WriteData(fid,'object',self,'fieldname','borderFS','format','DoubleMat','mattype',1);
 			%convert approximations to enums
-			data=obj.vertex_equation;
+			data=self.vertex_equation;
 			pos=find(data==0); data(pos,end)=NoneApproximationEnum();
 			pos=find(data==1); data(pos,end)=SIAApproximationEnum();
 			pos=find(data==2); data(pos,end)=SSAApproximationEnum();
@@ -219,7 +219,7 @@
 			pos=find(data==7); data(pos,end)=HOFSApproximationEnum();
 			pos=find(data==8); data(pos,end)=SSAFSApproximationEnum();
 			WriteData(fid,'data',data,'enum',FlowequationVertexEquationEnum(),'format','DoubleMat','mattype',1);
-			data=obj.element_equation;
+			data=self.element_equation;
 			pos=find(data==0); data(pos,end)=NoneApproximationEnum();
 			pos=find(data==1); data(pos,end)=SIAApproximationEnum();
 			pos=find(data==2); data(pos,end)=SSAApproximationEnum();
Index: ../trunk-jpl/src/m/classes/basalforcings.m
===================================================================
--- ../trunk-jpl/src/m/classes/basalforcings.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/basalforcings.m	(revision 19040)
@@ -10,17 +10,17 @@
 		geothermalflux            = NaN;
 	end
 	methods
-        function createxml(obj,fid) % {{{
+        function createxml(self,fid) % {{{
             fprintf(fid, '\n\n');
             fprintf(fid, '%s\n', '<!-- basalforcings -->');
-			 fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="melting_rate" type="',            class(obj.melting_rate),'" default="',              num2str(obj.melting_rate),'">',              '     <section name="basalforcings" />','     <help> basal melting rate (positive if melting) [m/yr] </help>','</parameter>');
-             fprintf(fid,'%s%s%s%s%s\n%s\n%s\n',        '<parameter key ="geothermalflux" type="',          class(obj.geothermalflux),'" default="',            num2str(obj.geothermalflux),'">',            '     <section name="basalforcings" />','     <help> geothermal heat flux [W/m^2] </help>','</parameter>');
+			 fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="melting_rate" type="',            class(self.melting_rate),'" default="',              num2str(self.melting_rate),'">',              '     <section name="basalforcings" />','     <help> basal melting rate (positive if melting) [m/yr] </help>','</parameter>');
+             fprintf(fid,'%s%s%s%s%s\n%s\n%s\n',        '<parameter key ="geothermalflux" type="',          class(self.geothermalflux),'" default="',            num2str(self.geothermalflux),'">',            '     <section name="basalforcings" />','     <help> geothermal heat flux [W/m^2] </help>','</parameter>');
              
         end % }}}
-		function obj = basalforcings(varargin) % {{{
+		function self = basalforcings(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				otherwise
 					error('constructor not supported');
 			end
@@ -38,10 +38,10 @@
 			end
 
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 			if ismember(MasstransportAnalysisEnum(),analyses) & ~(solution==TransientSolutionEnum() & md.transient.ismasstransport==0),
 				md = checkfield(md,'fieldname','basalforcings.groundedice_melting_rate','NaN',1,'timeseries',1);
@@ -57,22 +57,22 @@
 				md = checkfield(md,'fieldname','basalforcings.geothermalflux','NaN',1,'timeseries',1,'>=',0);
 			end
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   basal forcings parameters:'));
 
-			fielddisplay(obj,'groundedice_melting_rate','basal melting rate (positive if melting) [m/yr]');
-			fielddisplay(obj,'floatingice_melting_rate','basal melting rate (positive if melting) [m/yr]');
-			fielddisplay(obj,'geothermalflux','geothermal heat flux [W/m^2]');
+			fielddisplay(self,'groundedice_melting_rate','basal melting rate (positive if melting) [m/yr]');
+			fielddisplay(self,'floatingice_melting_rate','basal melting rate (positive if melting) [m/yr]');
+			fielddisplay(self,'geothermalflux','geothermal heat flux [W/m^2]');
 
 		end % }}}
-		function marshall(obj,md,fid) % {{{
+		function marshall(self,md,fid) % {{{
 
 			yts=365.0*24.0*3600.0;
 
 			WriteData(fid,'enum',BasalforcingsEnum(),'data',FloatingMeltRateEnum(),'format','Integer');
-			WriteData(fid,'object',obj,'fieldname','groundedice_melting_rate','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1)
-			WriteData(fid,'object',obj,'fieldname','floatingice_melting_rate','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1)
-			WriteData(fid,'object',obj,'fieldname','geothermalflux','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
+			WriteData(fid,'object',self,'fieldname','groundedice_melting_rate','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1)
+			WriteData(fid,'object',self,'fieldname','floatingice_melting_rate','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1)
+			WriteData(fid,'object',self,'fieldname','geothermalflux','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
 		end % }}}
 	end
 end
Index: ../trunk-jpl/src/m/classes/damage.m
===================================================================
--- ../trunk-jpl/src/m/classes/damage.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/damage.m	(revision 19040)
@@ -31,12 +31,12 @@
 		requested_outputs   = {};
 	end
 	methods
-		function createxml(obj,fid) % {{{
+		function createxml(self,fid) % {{{
 			fprintf(fid, '\n\n');
 			fprintf(fid, '%s\n', '<!-- damage -->');
 			fprintf(fid, '%s\n', '<!-- Note: this class depends on different input of law -->');
 
-			%fprintf(fid,'%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="law" type="logical"',           '" default="',                num2str(obj.law),'">',   '     <section name="damage" />','     <help> damage law (string) from {"undamaged","pralong"} </help>','</parameter>');
+			%fprintf(fid,'%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="law" type="logical"',           '" default="',                num2str(self.law),'">',   '     <section name="damage" />','     <help> damage law (string) from {"undamaged","pralong"} </help>','</parameter>');
 			% drop-down 
 			fprintf(fid,'%s%s%s%s%s\n\t%s\n','<parameter key ="law" type="','alternative','" optional="','false','">','<section name="damage" />');
 
@@ -48,14 +48,14 @@
 			% law = 'pralong'
 			fprintf(fid,'\t%s%s%s%s%s\n\t\t%s\n','<option value="pralong" type="','string','" default="','false','">','<help> law = pralong </help>');
 
-			fprintf(fid,'\t\t%s%s%s%s%s\n\t\t\t%s\n\t\t%s\n',   '<parameter key ="stress_threshold" type="',class(obj.stress_threshold),'" default="',num2str(obj.stress_threshold),'">','<help> damage stress threshold [Pa] </help>','</parameter>');
-			fprintf(fid,'\t\t%s%s%s%s%s\n\t\t\t%s\n\t\t%s\n',	'<parameter key ="c1" type="', class(obj.c1),'" default="',   num2str(obj.c1),'">',   '<help> damage parameter 1 </help>','</parameter>');
-			fprintf(fid,'\t\t%s%s%s%s%s\n\t\t\t%s\n\t\t%s\n',  	'<parameter key ="c2" type="',          class(obj.c2),'" default="',            num2str(obj.c2),'">','<help> damage parameter 2 </help>','</parameter>');
-			fprintf(fid,'\t\t%s%s%s%s%s\n\t\t\t%s\n\t\t%s\n',  	'<parameter key ="c3" type="',          class(obj.c3),'" default="',            num2str(obj.c3),'">','<help> damage parameter 3 [W/m^2] </help>','</parameter>');
-			fprintf(fid,'\t\t%s%s%s%s%s\n\t\t\t%s\n\t\t%s\n',  	'<parameter key ="c4" type="',            class(obj.c4),'" default="',              num2str(obj.c4),'">','<help> damage parameter 4 </help>','</parameter>');
-			fprintf(fid,'\t\t%s%s%s%s%s\n\t\t\t%s\n\t\t%s\n',  	'<parameter key ="healing" type="', class(obj.healing),'" default="',   num2str(obj.healing),'">','<help> damage healing parameter 1 </help>','</parameter>');
-			fprintf(fid,'\t\t%s%s%s%s%s\n\t\t\t%s\n\t\t%s\n',  	'<parameter key ="equiv_stress" type="',          class(obj.equiv_stress),'" default="',convert2str(obj.equiv_stress),'">','<help> 0: von Mises </help>','</parameter>');
-			fprintf(fid,'\t\t%s%s%s%s%s\n\t\t\t%s\n\t\t%s\n',  	'<parameter key ="requested_outputs" type="',          class(obj.requested_outputs),'" default="',convert2str(obj.requested_outputs),'">','<help> additional outputs requested </help>','</parameter>');
+			fprintf(fid,'\t\t%s%s%s%s%s\n\t\t\t%s\n\t\t%s\n',   '<parameter key ="stress_threshold" type="',class(self.stress_threshold),'" default="',num2str(self.stress_threshold),'">','<help> damage stress threshold [Pa] </help>','</parameter>');
+			fprintf(fid,'\t\t%s%s%s%s%s\n\t\t\t%s\n\t\t%s\n',	'<parameter key ="c1" type="', class(self.c1),'" default="',   num2str(self.c1),'">',   '<help> damage parameter 1 </help>','</parameter>');
+			fprintf(fid,'\t\t%s%s%s%s%s\n\t\t\t%s\n\t\t%s\n',  	'<parameter key ="c2" type="',          class(self.c2),'" default="',            num2str(self.c2),'">','<help> damage parameter 2 </help>','</parameter>');
+			fprintf(fid,'\t\t%s%s%s%s%s\n\t\t\t%s\n\t\t%s\n',  	'<parameter key ="c3" type="',          class(self.c3),'" default="',            num2str(self.c3),'">','<help> damage parameter 3 [W/m^2] </help>','</parameter>');
+			fprintf(fid,'\t\t%s%s%s%s%s\n\t\t\t%s\n\t\t%s\n',  	'<parameter key ="c4" type="',            class(self.c4),'" default="',              num2str(self.c4),'">','<help> damage parameter 4 </help>','</parameter>');
+			fprintf(fid,'\t\t%s%s%s%s%s\n\t\t\t%s\n\t\t%s\n',  	'<parameter key ="healing" type="', class(self.healing),'" default="',   num2str(self.healing),'">','<help> damage healing parameter 1 </help>','</parameter>');
+			fprintf(fid,'\t\t%s%s%s%s%s\n\t\t\t%s\n\t\t%s\n',  	'<parameter key ="equiv_stress" type="',          class(self.equiv_stress),'" default="',convert2str(self.equiv_stress),'">','<help> 0: von Mises </help>','</parameter>');
+			fprintf(fid,'\t\t%s%s%s%s%s\n\t\t\t%s\n\t\t%s\n',  	'<parameter key ="requested_outputs" type="',          class(self.requested_outputs),'" default="',convert2str(self.requested_outputs),'">','<help> additional outputs requested </help>','</parameter>');
 
 
 			% footer for option
@@ -66,10 +66,10 @@
 			fprintf(fid,'\t%s\n%s\n%s','<help> damage law (string) from {"undamaged","pralong"} </help>','</parameter>');
 
 
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="D" type="',              class(obj.D),'" default="',                  num2str(obj.D),'">',              '     <section name="damage" />','     <help> damage tensor (scalar) </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="law" type="',            class(obj.law),'" default="',                num2str(obj.law),'">',   '     <section name="damage" />','     <help> damage law (string) from {"undamaged","pralong"} </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',        '<parameter key ="spcdamage" type="',      class(obj.spcdamage),'" default="',          num2str(obj.spcdamage),'">',            '     <section name="damage" />','     <help> damage constraints (NaN means no constraint) </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',        '<parameter key ="max_damage" type="',     class(obj.max_damage),'" default="',         num2str(obj.max_damage),'">',            '     <section name="damage" />','     <help> maximum possible damage (0&amp;lt;=max_damage&amp;lt;1) </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="D" type="',              class(self.D),'" default="',                  num2str(self.D),'">',              '     <section name="damage" />','     <help> damage tensor (scalar) </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="law" type="',            class(self.law),'" default="',                num2str(self.law),'">',   '     <section name="damage" />','     <help> damage law (string) from {"undamaged","pralong"} </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',        '<parameter key ="spcdamage" type="',      class(self.spcdamage),'" default="',          num2str(self.spcdamage),'">',            '     <section name="damage" />','     <help> damage constraints (NaN means no constraint) </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',        '<parameter key ="max_damage" type="',     class(self.max_damage),'" default="',         num2str(self.max_damage),'">',            '     <section name="damage" />','     <help> maximum possible damage (0&amp;lt;=max_damage&amp;lt;1) </help>','</parameter>');
 
 			% stabilization (0,1, or 2) drop-down
 			fprintf(fid,'%s\n%s\n%s\n%s\n',    '<parameter key ="stabilization" type="alternative" optional="false">','     <section name="damage" />','     <help> 0: no, 1: artificial_diffusivity, 2: SUPG </help>');
@@ -78,17 +78,17 @@
 			fprintf(fid, '%s\n', '       <option value="2" type="string" default="false"></option>');
 			fprintf(fid, '%s\n','</parameter>');
 
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="maxiter" type="',             class(obj.maxiter),'" default="',   num2str(obj.maxiter),'">',   '     <section name="damage" />','     <help> maximum number of non linear iterations </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',        '<parameter key ="penalty_lock" type="',        class(obj.penalty_lock),'" default="',            num2str(obj.penalty_lock),'">',            '     <section name="damage" />','     <help> stabilize unstable damage constraints that keep zigzagging after n iteration (default is 0, no stabilization) </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',        '<parameter key ="penalty_threshold" type="',   class(obj.penalty_threshold),'" default="',            num2str(obj.penalty_threshold),'">',            '     <section name="damage" />','     <help> threshold to declare convergence of damage evolution solution (default is 0) </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',        '<parameter key ="penalty_factor" type="',      class(obj.penalty_factor),'" default="',            num2str(obj.penalty_factor),'">',            '     <section name="damage" />','     <help> scaling exponent (default is 3) </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="maxiter" type="',             class(self.maxiter),'" default="',   num2str(self.maxiter),'">',   '     <section name="damage" />','     <help> maximum number of non linear iterations </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',        '<parameter key ="penalty_lock" type="',        class(self.penalty_lock),'" default="',            num2str(self.penalty_lock),'">',            '     <section name="damage" />','     <help> stabilize unstable damage constraints that keep zigzagging after n iteration (default is 0, no stabilization) </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',        '<parameter key ="penalty_threshold" type="',   class(self.penalty_threshold),'" default="',            num2str(self.penalty_threshold),'">',            '     <section name="damage" />','     <help> threshold to declare convergence of damage evolution solution (default is 0) </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',        '<parameter key ="penalty_factor" type="',      class(self.penalty_factor),'" default="',            num2str(self.penalty_factor),'">',            '     <section name="damage" />','     <help> scaling exponent (default is 3) </help>','</parameter>');
 
 		end % }}}
         
-		function obj = damage(varargin) % {{{
+		function self = damage(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				case 1
 					inputstruct=varargin{1};
 					list1 = properties('damage');
@@ -96,59 +96,59 @@
 					for i=1:length(list1)
 						fieldname = list1{i};
 						if ismember(fieldname,list2),
-							obj.(fieldname) = inputstruct.(fieldname);
+							self.(fieldname) = inputstruct.(fieldname);
 						end
 					end
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 			%damage parameters: 
-			obj.isdamage=0;
-			obj.D=0;
-			obj.law=0;
+			self.isdamage=0;
+			self.D=0;
+			self.law=0;
 			
-			obj.max_damage=1-1e-5; %if damage reaches 1, solve becomes singular, as viscosity becomes nil
+			self.max_damage=1-1e-5; %if damage reaches 1, solve becomes singular, as viscosity becomes nil
 		
 			%Type of stabilization used
-			obj.stabilization=2;
+			self.stabilization=2;
 			
 			%Maximum number of iterations
-			obj.maxiter=100;
+			self.maxiter=100;
 
 			%finite element interpolation
-			obj.elementinterp='P1';
+			self.elementinterp='P1';
 
 			%factor used to compute the values of the penalties: kappa=max(stiffness matrix)*10^penalty_factor
-			obj.penalty_factor=3;
+			self.penalty_factor=3;
 			
 			%stabilize unstable damage constraints that keep zigzagging after n iteration (default is 0, no stabilization)
-			obj.penalty_lock=0;
+			self.penalty_lock=0;
 			
 			%threshold to declare convergence of thermal solution (default is 0)
-			obj.penalty_threshold=0;
+			self.penalty_threshold=0;
 		
 			%damage evolution parameters 
-			obj.stress_threshold=0;
-			obj.healing=0;
-			obj.c1=0;
-			obj.c2=0;
-			obj.c3=0;
-			obj.c4=0;
-			obj.equiv_stress=0;
+			self.stress_threshold=0;
+			self.healing=0;
+			self.c1=0;
+			self.c2=0;
+			self.c3=0;
+			self.c4=0;
+			self.equiv_stress=0;
 
 			 %output default:
-			 obj.requested_outputs={'default'};
+			 self.requested_outputs={'default'};
 
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 			
 			md = checkfield(md,'fieldname','damage.isdamage','values',[1,0]);
-			if obj.isdamage,
+			if self.isdamage,
 				md = checkfield(md,'fieldname','damage.law','numel',[1],'values',[0,1,2]);
-				md = checkfield(md,'fieldname','damage.D','>=',0,'<=',obj.max_damage,'size',[md.mesh.numberofvertices 1]);
+				md = checkfield(md,'fieldname','damage.D','>=',0,'<=',self.max_damage,'size',[md.mesh.numberofvertices 1]);
 				md = checkfield(md,'fieldname','damage.spcdamage','timeseries',1);
 				md = checkfield(md,'fieldname','damage.max_damage','<',1,'>=',0);
 				md = checkfield(md,'fieldname','damage.stabilization','numel',[1],'values',[0 1 2]);
@@ -165,7 +165,7 @@
 				md = checkfield(md,'fieldname','damage.stress_threshold','>=',0);
 				md = checkfield(md,'fieldname','damage.equiv_stress','numel',[1],'values',[0 1]);
 				md = checkfield(md,'fieldname','damage.requested_outputs','stringrow',1);
-			elseif (obj.law~=0),
+			elseif (self.law~=0),
 				if (solution==DamageEvolutionSolutionEnum),
 					error('Invalid evolution law (md.damage.law) for a damage solution');
 				end
@@ -179,65 +179,65 @@
             list = {'DamageD'};
 			end
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   Damage:\n'));
 
-			fielddisplay(obj,'isdamage','is damage mechanics being used? {true,false}');
-			if obj.isdamage,
-				fielddisplay(obj,'law','damage law {''0: undamaged'',''1: pralong''}');
-				fielddisplay(obj,'D','damage tensor (scalar)');
-				fielddisplay(obj,'spcdamage','damage constraints (NaN means no constraint)');
-				fielddisplay(obj,'max_damage','maximum possible damage (0<=max_damage<1)');
+			fielddisplay(self,'isdamage','is damage mechanics being used? {true,false}');
+			if self.isdamage,
+				fielddisplay(self,'law','damage law {''0: undamaged'',''1: pralong''}');
+				fielddisplay(self,'D','damage tensor (scalar)');
+				fielddisplay(self,'spcdamage','damage constraints (NaN means no constraint)');
+				fielddisplay(self,'max_damage','maximum possible damage (0<=max_damage<1)');
 				
-				fielddisplay(obj,'stabilization','0: no, 1: artificial_diffusivity, 2: SUPG');
-				fielddisplay(obj,'maxiter','maximum number of non linear iterations');
-				fielddisplay(obj,'elementinterp','interpolation scheme for finite elements {''P1'',''P2''}');
-				fielddisplay(obj,'penalty_lock','stabilize unstable damage constraints that keep zigzagging after n iteration (default is 0, no stabilization)');
-				fielddisplay(obj,'penalty_threshold','threshold to declare convergence of damage evolution solution (default is 0)');
-				fielddisplay(obj,'penalty_factor','scaling exponent (default is 3)');
-				fielddisplay(obj,'c1','damage parameter 1');
-				fielddisplay(obj,'c2','damage parameter 2');
-				fielddisplay(obj,'c3','damage parameter 3');
-				fielddisplay(obj,'c4','damage parameter 4');
-				fielddisplay(obj,'healing','damage healing parameter');
-				fielddisplay(obj,'stress_threshold','damage stress threshold [Pa]');
-				fielddisplay(obj,'equiv_stress','0: von Mises, 1: max principal');
-				fielddisplay(obj,'requested_outputs','additional outputs requested');
+				fielddisplay(self,'stabilization','0: no, 1: artificial_diffusivity, 2: SUPG');
+				fielddisplay(self,'maxiter','maximum number of non linear iterations');
+				fielddisplay(self,'elementinterp','interpolation scheme for finite elements {''P1'',''P2''}');
+				fielddisplay(self,'penalty_lock','stabilize unstable damage constraints that keep zigzagging after n iteration (default is 0, no stabilization)');
+				fielddisplay(self,'penalty_threshold','threshold to declare convergence of damage evolution solution (default is 0)');
+				fielddisplay(self,'penalty_factor','scaling exponent (default is 3)');
+				fielddisplay(self,'c1','damage parameter 1');
+				fielddisplay(self,'c2','damage parameter 2');
+				fielddisplay(self,'c3','damage parameter 3');
+				fielddisplay(self,'c4','damage parameter 4');
+				fielddisplay(self,'healing','damage healing parameter');
+				fielddisplay(self,'stress_threshold','damage stress threshold [Pa]');
+				fielddisplay(self,'equiv_stress','0: von Mises, 1: max principal');
+				fielddisplay(self,'requested_outputs','additional outputs requested');
 			end
 
 		end % }}}
-		function marshall(obj,md,fid) % {{{
+		function marshall(self,md,fid) % {{{
 		
-			WriteData(fid,'object',obj,'fieldname','isdamage','format','Boolean');
-			if obj.isdamage,
-				WriteData(fid,'object',obj,'fieldname','law','format','Integer');
-				WriteData(fid,'object',obj,'fieldname','D','format','DoubleMat','mattype',1);
-				WriteData(fid,'object',obj,'fieldname','spcdamage','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
-				WriteData(fid,'object',obj,'fieldname','max_damage','format','Double');
+			WriteData(fid,'object',self,'fieldname','isdamage','format','Boolean');
+			if self.isdamage,
+				WriteData(fid,'object',self,'fieldname','law','format','Integer');
+				WriteData(fid,'object',self,'fieldname','D','format','DoubleMat','mattype',1);
+				WriteData(fid,'object',self,'fieldname','spcdamage','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
+				WriteData(fid,'object',self,'fieldname','max_damage','format','Double');
 
-				WriteData(fid,'object',obj,'fieldname','stabilization','format','Integer');
-				WriteData(fid,'object',obj,'fieldname','maxiter','format','Integer');
-				WriteData(fid,'enum',DamageElementinterpEnum(),'data',StringToEnum(obj.elementinterp),'format','Integer');
-				WriteData(fid,'object',obj,'fieldname','penalty_threshold','format','Integer');
-				WriteData(fid,'object',obj,'fieldname','penalty_lock','format','Integer');
-				WriteData(fid,'object',obj,'fieldname','penalty_factor','format','Double');
-				WriteData(fid,'object',obj,'fieldname','c1','format','Double');
-				WriteData(fid,'object',obj,'fieldname','c2','format','Double');
-				WriteData(fid,'object',obj,'fieldname','c3','format','Double');
-				WriteData(fid,'object',obj,'fieldname','c4','format','Double');
-				WriteData(fid,'object',obj,'fieldname','stress_threshold','format','Double');
-				WriteData(fid,'object',obj,'fieldname','healing','format','Double');
-				WriteData(fid,'object',obj,'fieldname','equiv_stress','format','Integer');
+				WriteData(fid,'object',self,'fieldname','stabilization','format','Integer');
+				WriteData(fid,'object',self,'fieldname','maxiter','format','Integer');
+				WriteData(fid,'enum',DamageElementinterpEnum(),'data',StringToEnum(self.elementinterp),'format','Integer');
+				WriteData(fid,'object',self,'fieldname','penalty_threshold','format','Integer');
+				WriteData(fid,'object',self,'fieldname','penalty_lock','format','Integer');
+				WriteData(fid,'object',self,'fieldname','penalty_factor','format','Double');
+				WriteData(fid,'object',self,'fieldname','c1','format','Double');
+				WriteData(fid,'object',self,'fieldname','c2','format','Double');
+				WriteData(fid,'object',self,'fieldname','c3','format','Double');
+				WriteData(fid,'object',self,'fieldname','c4','format','Double');
+				WriteData(fid,'object',self,'fieldname','stress_threshold','format','Double');
+				WriteData(fid,'object',self,'fieldname','healing','format','Double');
+				WriteData(fid,'object',self,'fieldname','equiv_stress','format','Integer');
 			end
 
 			%process requested outputs
-			outputs = obj.requested_outputs;
+			outputs = self.requested_outputs;
 			pos = find(ismember(outputs,'default'));
 			if ~isempty(pos),
 				outputs(pos) = [];                         %remove 'default' from outputs
-				outputs      = [outputs defaultoutputs(obj,md)]; %add defaults
+				outputs      = [outputs defaultoutputs(self,md)]; %add defaults
 			end
-			if obj.isdamage,
+			if self.isdamage,
 				WriteData(fid,'data',outputs,'enum',DamageEvolutionRequestedOutputsEnum,'format','StringArray');
 			end
 
Index: ../trunk-jpl/src/m/classes/taoinversion.m
===================================================================
--- ../trunk-jpl/src/m/classes/taoinversion.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/taoinversion.m	(revision 19040)
@@ -28,53 +28,53 @@
 		surface_obs               = NaN
 	end
 	methods
-		function obj = taoinversion(varargin) % {{{
+		function self = taoinversion(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				case 1
-					obj=structtoobj(taoinversion(),varargin{1});
+					self=structtoobj(taoinversion(),varargin{1});
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 			%default is incomplete adjoint for now
-			obj.incomplete_adjoint=1;
+			self.incomplete_adjoint=1;
 
 			%parameter to be inferred by control methods (only
 			%drag and B are supported yet)
-			obj.control_parameters={'FrictionCoefficient'};
+			self.control_parameters={'FrictionCoefficient'};
 
 			%number of iterations and steps
-			obj.maxsteps=20;
-			obj.maxiter =30;
+			self.maxsteps=20;
+			self.maxiter =30;
 
 			%default tolerances
-			obj.fatol = 0;
-			obj.frtol = 0;
-			obj.gatol = 0;
-			obj.grtol = 0;
-			obj.gttol = 1e-4;
+			self.fatol = 0;
+			self.frtol = 0;
+			self.gatol = 0;
+			self.grtol = 0;
+			self.gttol = 1e-4;
 
 			%minimization algorithm
 			PETSCMAJOR = IssmConfig('_PETSC_MAJOR_');
 			PETSCMINOR = IssmConfig('_PETSC_MINOR_');
 			if(PETSCMAJOR>3 | (PETSCMAJOR==3 & PETSCMINOR>=5))
-				obj.algorithm = 'blmvm';
+				self.algorithm = 'blmvm';
 			else
-				obj.algorithm = 'tao_blmvm';
+				self.algorithm = 'tao_blmvm';
 			end
 
 			%several responses can be used:
-			obj.cost_functions=101;
+			self.cost_functions=101;
 
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 			%Early return
-			if ~obj.iscontrol, return; end
+			if ~self.iscontrol, return; end
 
 			if ~IssmConfig('_HAVE_TAO_'),
 				md = checkmessage(md,['TAO has not been installed, ISSM needs to be reconfigured and recompiled with TAO']);
@@ -116,28 +116,28 @@
 				md = checkfield(md,'fieldname','inversion.vy_obs','size',[md.mesh.numberofvertices 1],'NaN',1);
 			end
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   taoinversion parameters:'));
-			fielddisplay(obj,'iscontrol','is inversion activated?');
-			fielddisplay(obj,'incomplete_adjoint','1: linear viscosity, 0: non-linear viscosity');
-			fielddisplay(obj,'control_parameters','ex: {''FrictionCoefficient''}, or {''MaterialsRheologyBbar''}');
-			fielddisplay(obj,'maxsteps','maximum number of iterations (gradient computation)');
-			fielddisplay(obj,'maxiter','maximum number of Function evaluation (forward run)');
-			fielddisplay(obj,'fatol','convergence criterion: f(X)-f(X*) (X: current iteration, X*: "true" solution, f: cost function)');
-			fielddisplay(obj,'frtol','convergence criterion: |f(X)-f(X*)|/|f(X*)|');
-			fielddisplay(obj,'gatol','convergence criterion: ||g(X)|| (g: gradient of the cost function)');
-			fielddisplay(obj,'grtol','convergence criterion: ||g(X)||/|f(X)|');
-			fielddisplay(obj,'gttol','convergence criterion: ||g(X)||/||g(X0)|| (g(X0): gradient at initial guess X0)');
-			fielddisplay(obj,'algorithm','minimization algorithm: ''tao_blmvm'', ''tao_cg'', ''tao_lmvm''');
-			fielddisplay(obj,'cost_functions','indicate the type of response for each optimization step');
-			fielddisplay(obj,'cost_functions_coefficients','cost_functions_coefficients applied to the misfit of each vertex and for each control_parameter');
-			fielddisplay(obj,'min_parameters','absolute minimum acceptable value of the inversed parameter on each vertex');
-			fielddisplay(obj,'max_parameters','absolute maximum acceptable value of the inversed parameter on each vertex');
-			fielddisplay(obj,'vx_obs','observed velocity x component [m/yr]');
-			fielddisplay(obj,'vy_obs','observed velocity y component [m/yr]');
-			fielddisplay(obj,'vel_obs','observed velocity magnitude [m/yr]');
-			fielddisplay(obj,'thickness_obs','observed thickness [m]');
-			fielddisplay(obj,'surface_obs','observed surface elevation [m]');
+			fielddisplay(self,'iscontrol','is inversion activated?');
+			fielddisplay(self,'incomplete_adjoint','1: linear viscosity, 0: non-linear viscosity');
+			fielddisplay(self,'control_parameters','ex: {''FrictionCoefficient''}, or {''MaterialsRheologyBbar''}');
+			fielddisplay(self,'maxsteps','maximum number of iterations (gradient computation)');
+			fielddisplay(self,'maxiter','maximum number of Function evaluation (forward run)');
+			fielddisplay(self,'fatol','convergence criterion: f(X)-f(X*) (X: current iteration, X*: "true" solution, f: cost function)');
+			fielddisplay(self,'frtol','convergence criterion: |f(X)-f(X*)|/|f(X*)|');
+			fielddisplay(self,'gatol','convergence criterion: ||g(X)|| (g: gradient of the cost function)');
+			fielddisplay(self,'grtol','convergence criterion: ||g(X)||/|f(X)|');
+			fielddisplay(self,'gttol','convergence criterion: ||g(X)||/||g(X0)|| (g(X0): gradient at initial guess X0)');
+			fielddisplay(self,'algorithm','minimization algorithm: ''tao_blmvm'', ''tao_cg'', ''tao_lmvm''');
+			fielddisplay(self,'cost_functions','indicate the type of response for each optimization step');
+			fielddisplay(self,'cost_functions_coefficients','cost_functions_coefficients applied to the misfit of each vertex and for each control_parameter');
+			fielddisplay(self,'min_parameters','absolute minimum acceptable value of the inversed parameter on each vertex');
+			fielddisplay(self,'max_parameters','absolute maximum acceptable value of the inversed parameter on each vertex');
+			fielddisplay(self,'vx_obs','observed velocity x component [m/yr]');
+			fielddisplay(self,'vy_obs','observed velocity y component [m/yr]');
+			fielddisplay(self,'vel_obs','observed velocity magnitude [m/yr]');
+			fielddisplay(self,'thickness_obs','observed thickness [m]');
+			fielddisplay(self,'surface_obs','observed surface elevation [m]');
 			disp('Available cost functions:');
 			disp('   101: SurfaceAbsVelMisfit');
 			disp('   102: SurfaceRelVelMisfit');
@@ -149,43 +149,43 @@
 			disp('   502: RheologyBbarAbsGradient');
 			disp('   503: ThicknessAbsGradient');
 		end % }}}
-		function marshall(obj,md,fid) % {{{
+		function marshall(self,md,fid) % {{{
 
 			yts=365.0*24.0*3600.0;
 
-			WriteData(fid,'object',obj,'class','inversion','fieldname','iscontrol','format','Boolean');
+			WriteData(fid,'object',self,'class','inversion','fieldname','iscontrol','format','Boolean');
 			WriteData(fid,'enum',InversionTypeEnum(),'data',1,'format','Integer');
-			if ~obj.iscontrol, return; end
-			WriteData(fid,'object',obj,'class','inversion','fieldname','incomplete_adjoint','format','Boolean');
-			WriteData(fid,'object',obj,'class','inversion','fieldname','maxsteps','format','Integer');
-			WriteData(fid,'object',obj,'class','inversion','fieldname','maxiter','format','Integer');
-			WriteData(fid,'object',obj,'class','inversion','fieldname','fatol','format','Double');
-			WriteData(fid,'object',obj,'class','inversion','fieldname','frtol','format','Double');
-			WriteData(fid,'object',obj,'class','inversion','fieldname','gatol','format','Double');
-			WriteData(fid,'object',obj,'class','inversion','fieldname','grtol','format','Double');
-			WriteData(fid,'object',obj,'class','inversion','fieldname','gttol','format','Double');
-			WriteData(fid,'object',obj,'class','inversion','fieldname','algorithm','format','String');
-			WriteData(fid,'object',obj,'class','inversion','fieldname','cost_functions_coefficients','format','DoubleMat','mattype',1);
-			WriteData(fid,'object',obj,'class','inversion','fieldname','min_parameters','format','DoubleMat','mattype',3);
-			WriteData(fid,'object',obj,'class','inversion','fieldname','max_parameters','format','DoubleMat','mattype',3);
-			WriteData(fid,'object',obj,'class','inversion','fieldname','vx_obs','format','DoubleMat','mattype',1,'scale',1./yts);
-			WriteData(fid,'object',obj,'class','inversion','fieldname','vy_obs','format','DoubleMat','mattype',1,'scale',1./yts);
-			WriteData(fid,'object',obj,'class','inversion','fieldname','vz_obs','format','DoubleMat','mattype',1,'scale',1./yts);
-			WriteData(fid,'object',obj,'class','inversion','fieldname','thickness_obs','format','DoubleMat','mattype',1);
-			WriteData(fid,'object',obj,'class','inversion','fieldname','surface_obs','format','DoubleMat','mattype',1);
+			if ~self.iscontrol, return; end
+			WriteData(fid,'object',self,'class','inversion','fieldname','incomplete_adjoint','format','Boolean');
+			WriteData(fid,'object',self,'class','inversion','fieldname','maxsteps','format','Integer');
+			WriteData(fid,'object',self,'class','inversion','fieldname','maxiter','format','Integer');
+			WriteData(fid,'object',self,'class','inversion','fieldname','fatol','format','Double');
+			WriteData(fid,'object',self,'class','inversion','fieldname','frtol','format','Double');
+			WriteData(fid,'object',self,'class','inversion','fieldname','gatol','format','Double');
+			WriteData(fid,'object',self,'class','inversion','fieldname','grtol','format','Double');
+			WriteData(fid,'object',self,'class','inversion','fieldname','gttol','format','Double');
+			WriteData(fid,'object',self,'class','inversion','fieldname','algorithm','format','String');
+			WriteData(fid,'object',self,'class','inversion','fieldname','cost_functions_coefficients','format','DoubleMat','mattype',1);
+			WriteData(fid,'object',self,'class','inversion','fieldname','min_parameters','format','DoubleMat','mattype',3);
+			WriteData(fid,'object',self,'class','inversion','fieldname','max_parameters','format','DoubleMat','mattype',3);
+			WriteData(fid,'object',self,'class','inversion','fieldname','vx_obs','format','DoubleMat','mattype',1,'scale',1./yts);
+			WriteData(fid,'object',self,'class','inversion','fieldname','vy_obs','format','DoubleMat','mattype',1,'scale',1./yts);
+			WriteData(fid,'object',self,'class','inversion','fieldname','vz_obs','format','DoubleMat','mattype',1,'scale',1./yts);
+			WriteData(fid,'object',self,'class','inversion','fieldname','thickness_obs','format','DoubleMat','mattype',1);
+			WriteData(fid,'object',self,'class','inversion','fieldname','surface_obs','format','DoubleMat','mattype',1);
 
 			%process control parameters
-			num_control_parameters=numel(obj.control_parameters);
+			num_control_parameters=numel(self.control_parameters);
 			data=zeros(1,num_control_parameters);
 			for i=1:num_control_parameters,
-				data(i)=StringToEnum(obj.control_parameters{i});
+				data(i)=StringToEnum(self.control_parameters{i});
 			end
 			WriteData(fid,'data',data,'enum',InversionControlParametersEnum(),'format','DoubleMat','mattype',3);
 			WriteData(fid,'data',num_control_parameters,'enum',InversionNumControlParametersEnum(),'format','Integer');
 
 			%process cost functions
-			num_cost_functions=size(obj.cost_functions,2);
-			data=marshallcostfunctions(obj.cost_functions);
+			num_cost_functions=size(self.cost_functions,2);
+			data=marshallcostfunctions(self.cost_functions);
 			WriteData(fid,'data',data,'enum',InversionCostFunctionsEnum(),'format','DoubleMat','mattype',3);
 			WriteData(fid,'data',num_cost_functions,'enum',InversionNumCostFunctionsEnum(),'format','Integer');
 		end % }}}
Index: ../trunk-jpl/src/m/classes/calvingdev.m
===================================================================
--- ../trunk-jpl/src/m/classes/calvingdev.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/calvingdev.m	(revision 19040)
@@ -10,10 +10,10 @@
 		meltingrate   = NaN;
 	end
 	methods
-		function obj = calvingdev(varargin) % {{{
+		function self = calvingdev(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				case 1
 					inputstruct=varargin{1};
 					list1 = properties('calvingdev');
@@ -21,22 +21,22 @@
 					for i=1:length(list1)
 						fieldname = list1{i};
 						if ismember(fieldname,list2),
-							obj.(fieldname) = inputstruct.(fieldname);
+							self.(fieldname) = inputstruct.(fieldname);
 						end
 					end
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 			%stabilization = 2 by default
-			obj.stabilization = 2;
+			self.stabilization = 2;
 
 			%Proportionality coefficient in Pi model
-			obj.coeff=2e13;
+			self.coeff=2e13;
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 			%Early return
 			if (solution~=TransientSolutionEnum() | md.transient.iscalving==0), return; end
 
@@ -44,19 +44,19 @@
 			md = checkfield(md,'fieldname','calving.coeff','>',0,'size',[md.mesh.numberofvertices 1]);
 			md = checkfield(md,'fieldname','calving.meltingrate','NaN',1,'size',[md.mesh.numberofvertices 1],'>=',0);
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   Calving Pi parameters:'));
-			fielddisplay(obj,'stabilization','0: no, 1: artificial_diffusivity, 2: streamline upwinding');
-			fielddisplay(obj,'coeff','proportionality coefficient in Pi model');
-			fielddisplay(obj,'meltingrate','melting rate at given location [m/a]');
+			fielddisplay(self,'stabilization','0: no, 1: artificial_diffusivity, 2: streamline upwinding');
+			fielddisplay(self,'coeff','proportionality coefficient in Pi model');
+			fielddisplay(self,'meltingrate','melting rate at given location [m/a]');
 
 		end % }}}
-		function marshall(obj,md,fid) % {{{
+		function marshall(self,md,fid) % {{{
 			yts=365.0*24.0*3600.0;
 			WriteData(fid,'enum',CalvingLawEnum(),'data',CalvingDevEnum(),'format','Integer');
-			WriteData(fid,'enum',LevelsetStabilizationEnum(),'data',obj.stabilization,'format','Integer');
-			WriteData(fid,'enum',CalvingpiCoeffEnum(),'data',obj.coeff,'format','DoubleMat','mattype',1);
-			WriteData(fid,'class','calving','object',obj,'fieldname','meltingrate','format','DoubleMat','mattype',1,'forcinglength',md.mesh.numberofvertices+1,'scale',1./yts);
+			WriteData(fid,'enum',LevelsetStabilizationEnum(),'data',self.stabilization,'format','Integer');
+			WriteData(fid,'enum',CalvingpiCoeffEnum(),'data',self.coeff,'format','DoubleMat','mattype',1);
+			WriteData(fid,'class','calving','object',self,'fieldname','meltingrate','format','DoubleMat','mattype',1,'forcinglength',md.mesh.numberofvertices+1,'scale',1./yts);
 		end % }}}
 	end
 end
Index: ../trunk-jpl/src/m/classes/hydrologydc.m
===================================================================
--- ../trunk-jpl/src/m/classes/hydrologydc.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/hydrologydc.m	(revision 19040)
@@ -36,11 +36,11 @@
 		eplflip_lock             = 0;
   end
 	methods
-		% {{{ function obj = hydrologydc(varargin) 
-		function obj = hydrologydc(varargin) 
+		% {{{ function self = hydrologydc(varargin) 
+		function self = hydrologydc(varargin) 
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				otherwise
 					error('constructor not supported');
 	    end
@@ -53,38 +53,38 @@
 			end
 
 		end % }}}
-		% {{{ function obj = setdefaultparameters(obj) 
-		function obj = setdefaultparameters(obj) 
+		% {{{ function self = setdefaultparameters(self) 
+		function self = setdefaultparameters(self) 
 
 		%Parameters from de Fleurian 2014
-			obj.water_compressibility    = 5.04e-10;
-			obj.isefficientlayer         = 1;
-			obj.penalty_factor           = 3;
-			obj.penalty_lock             = 0;
-			obj.rel_tol                  = 1.0e-06;
-			obj.max_iter                 = 100;
-			obj.sedimentlimit_flag       = 0;
-			obj.sedimentlimit            = 0;
-			obj.transfer_flag            = 0;
-			obj.leakage_factor           = 10.0;
+			self.water_compressibility    = 5.04e-10;
+			self.isefficientlayer         = 1;
+			self.penalty_factor           = 3;
+			self.penalty_lock             = 0;
+			self.rel_tol                  = 1.0e-06;
+			self.max_iter                 = 100;
+			self.sedimentlimit_flag       = 0;
+			self.sedimentlimit            = 0;
+			self.transfer_flag            = 0;
+			self.leakage_factor           = 10.0;
 
-			obj.sediment_compressibility = 1.0e-08;
-			obj.sediment_porosity        = 0.4;
-			obj.sediment_thickness       = 20.0;
-			obj.sediment_transmitivity   = 8.0e-04;
+			self.sediment_compressibility = 1.0e-08;
+			self.sediment_porosity        = 0.4;
+			self.sediment_thickness       = 20.0;
+			self.sediment_transmitivity   = 8.0e-04;
 
-			obj.epl_compressibility      = 1.0e-08;
-			obj.epl_porosity             = 0.4;
-			obj.epl_initial_thickness    = 1.0;
-			obj.epl_colapse_thickness    = 1.0e-3;
-			obj.epl_thick_comp           = 1;
-			obj.epl_max_thickness        = 5.0;
-			obj.epl_conductivity         = 8.0e-02;
-			obj.eplflip_lock             = 0;
+			self.epl_compressibility      = 1.0e-08;
+			self.epl_porosity             = 0.4;
+			self.epl_initial_thickness    = 1.0;
+			self.epl_colapse_thickness    = 1.0e-3;
+			self.epl_thick_comp           = 1;
+			self.epl_max_thickness        = 5.0;
+			self.epl_conductivity         = 8.0e-02;
+			self.eplflip_lock             = 0;
 		end 
 		% }}}
-		% {{{ function md = checkconsistency(obj,md,solution,analyses) 
-		function md = checkconsistency(obj,md,solution,analyses) 
+		% {{{ function md = checkconsistency(self,md,solution,analyses) 
+		function md = checkconsistency(self,md,solution,analyses) 
 		%Early return
 			if ~ismember(HydrologyDCInefficientAnalysisEnum(),analyses) & ~ismember(HydrologyDCEfficientAnalysisEnum(),analyses),
 				return;
@@ -98,10 +98,10 @@
 			md = checkfield(md,'fieldname','hydrology.max_iter','>',0,'numel',1);
 			md = checkfield(md,'fieldname','hydrology.sedimentlimit_flag','numel',[1],'values',[0 1 2 3]);
 			md = checkfield(md,'fieldname','hydrology.transfer_flag','numel',[1],'values',[0 1]);
-			if obj.sedimentlimit_flag==1,
+			if self.sedimentlimit_flag==1,
 				md = checkfield(md,'fieldname','hydrology.sedimentlimit','>',0,'numel',1);
 	    end
-			if obj.transfer_flag==1,
+			if self.transfer_flag==1,
 				md = checkfield(md,'fieldname','hydrology.leakage_factor','>',0,'numel',1);
 	    end
 			md = checkfield(md,'fieldname','hydrology.basal_moulin_input','NaN',1,'timeseries',1);
@@ -112,7 +112,7 @@
 			md = checkfield(md,'fieldname','hydrology.sediment_thickness','>',0,'numel',1);
 			md = checkfield(md,'fieldname','hydrology.sediment_transmitivity','>=',0,'size',[md.mesh.numberofvertices 1]);
 
-			if obj.isefficientlayer==1,
+			if self.isefficientlayer==1,
 				md = checkfield(md,'fieldname','hydrology.spcepl_head','timeseries',1);
 				md = checkfield(md,'fieldname','hydrology.mask_eplactive_node','size',[md.mesh.numberofvertices 1],'values',[0 1]);
 				md = checkfield(md,'fieldname','hydrology.epl_compressibility','>',0,'numel',1);
@@ -123,96 +123,96 @@
 				md = checkfield(md,'fieldname','hydrology.epl_max_thickness','>',0,'numel',1);
 				md = checkfield(md,'fieldname','hydrology.epl_conductivity','>',0,'numel',1);
 				md = checkfield(md,'fieldname','hydrology.eplflip_lock','>=',0,'numel',1);
-				if (obj.epl_colapse_thickness>obj.epl_initial_thickness),
+				if (self.epl_colapse_thickness>self.epl_initial_thickness),
 					md = checkmessage(md,'Colapsing thickness for EPL larger than initial thickness');
 				end 
 	    end
 		end 
 		% }}}
-		% {{{ function disp(obj)
-		function disp(obj) 
+		% {{{ function disp(self)
+		function disp(self) 
 			disp(sprintf('   hydrology Dual Porous Continuum Equivalent parameters:'));
 			disp(sprintf('   - general parameters'));
-			fielddisplay(obj,'water_compressibility','compressibility of water [Pa^-1]');
-			fielddisplay(obj,'isefficientlayer','do we use an efficient drainage system [1: true; 0: false]');
-			fielddisplay(obj,'penalty_factor','exponent of the value used in the penalisation method [dimensionless]');
-			fielddisplay(obj,'penalty_lock','stabilize unstable constraints that keep zigzagging after n iteration (default is 0, no stabilization)');
-			fielddisplay(obj,'rel_tol','tolerance of the nonlinear iteration for the transfer between layers [dimensionless]');
-			fielddisplay(obj,'max_iter','maximum number of nonlinear iteration');
-			fielddisplay(obj,'sedimentlimit_flag','what kind of upper limit is applied for the inefficient layer');
+			fielddisplay(self,'water_compressibility','compressibility of water [Pa^-1]');
+			fielddisplay(self,'isefficientlayer','do we use an efficient drainage system [1: true; 0: false]');
+			fielddisplay(self,'penalty_factor','exponent of the value used in the penalisation method [dimensionless]');
+			fielddisplay(self,'penalty_lock','stabilize unstable constraints that keep zigzagging after n iteration (default is 0, no stabilization)');
+			fielddisplay(self,'rel_tol','tolerance of the nonlinear iteration for the transfer between layers [dimensionless]');
+			fielddisplay(self,'max_iter','maximum number of nonlinear iteration');
+			fielddisplay(self,'sedimentlimit_flag','what kind of upper limit is applied for the inefficient layer');
 			disp(sprintf('%55s  0: no limit',' '));
 			disp(sprintf('%55s  1: user defined: %s',' ','sedimentlimit'));
 			disp(sprintf('%55s  2: hydrostatic pressure',' '));
 			disp(sprintf('%55s  3: normal stress',' '));
-			if obj.sedimentlimit_flag==1,
-				fielddisplay(obj,'sedimentlimit','user defined upper limit for the inefficient layer [m]');
+			if self.sedimentlimit_flag==1,
+				fielddisplay(self,'sedimentlimit','user defined upper limit for the inefficient layer [m]');
 	    end
-			fielddisplay(obj,'transfer_flag',['what kind of transfer method is applied between the layers']);
+			fielddisplay(self,'transfer_flag',['what kind of transfer method is applied between the layers']);
 			disp(sprintf('%55s  0: no transfer',' '));
 			disp(sprintf('%55s  1: constant leakage factor: %s',' ','leakage_factor'));
-			if obj.transfer_flag==1,
-				fielddisplay(obj,'leakage_factor','user defined leakage factor [m]');
+			if self.transfer_flag==1,
+				fielddisplay(self,'leakage_factor','user defined leakage factor [m]');
 	    end
-			fielddisplay(obj,'basal_moulin_input','water flux at a given point [m3 s-1]');
+			fielddisplay(self,'basal_moulin_input','water flux at a given point [m3 s-1]');
 			disp(sprintf('   - for the sediment layer'));
-			fielddisplay(obj,'spcsediment_head','sediment water head constraints (NaN means no constraint) [m above MSL]');
-			fielddisplay(obj,'sediment_compressibility','sediment compressibility [Pa^-1]');
-			fielddisplay(obj,'sediment_porosity','sediment [dimensionless]');
-			fielddisplay(obj,'sediment_thickness','sediment thickness [m]');
-			fielddisplay(obj,'sediment_transmitivity','sediment transmitivity [m^2/s]');
+			fielddisplay(self,'spcsediment_head','sediment water head constraints (NaN means no constraint) [m above MSL]');
+			fielddisplay(self,'sediment_compressibility','sediment compressibility [Pa^-1]');
+			fielddisplay(self,'sediment_porosity','sediment [dimensionless]');
+			fielddisplay(self,'sediment_thickness','sediment thickness [m]');
+			fielddisplay(self,'sediment_transmitivity','sediment transmitivity [m^2/s]');
 
-			if obj.isefficientlayer==1,
+			if self.isefficientlayer==1,
 				disp(sprintf('   - for the epl layer'));
-				fielddisplay(obj,'spcepl_head','epl water head constraints (NaN means no constraint) [m above MSL]');
-				fielddisplay(obj,'mask_eplactive_node','active (1) or not (0) EPL');
-				fielddisplay(obj,'epl_compressibility','epl compressibility [Pa^-1]');
-				fielddisplay(obj,'epl_porosity','epl [dimensionless]');
-				fielddisplay(obj,'epl_initial_thickness','epl initial thickness [m]');
-				fielddisplay(obj,'epl_colapse_thickness','epl colapsing thickness [m]');
-				fielddisplay(obj,'epl_thick_comp','epl thickness computation flag');
-				fielddisplay(obj,'epl_max_thickness','epl maximal thickness [m]');
-				fielddisplay(obj,'epl_conductivity','epl conductivity [m^2/s]');
-				fielddisplay(obj,'eplflip_lock','lock the epl activation to avoid fli-floping (default is 0, no stabilization)');
+				fielddisplay(self,'spcepl_head','epl water head constraints (NaN means no constraint) [m above MSL]');
+				fielddisplay(self,'mask_eplactive_node','active (1) or not (0) EPL');
+				fielddisplay(self,'epl_compressibility','epl compressibility [Pa^-1]');
+				fielddisplay(self,'epl_porosity','epl [dimensionless]');
+				fielddisplay(self,'epl_initial_thickness','epl initial thickness [m]');
+				fielddisplay(self,'epl_colapse_thickness','epl colapsing thickness [m]');
+				fielddisplay(self,'epl_thick_comp','epl thickness computation flag');
+				fielddisplay(self,'epl_max_thickness','epl maximal thickness [m]');
+				fielddisplay(self,'epl_conductivity','epl conductivity [m^2/s]');
+				fielddisplay(self,'eplflip_lock','lock the epl activation to avoid fli-floping (default is 0, no stabilization)');
 	    end
 
 		end 
 		% }}}
-		% {{{ function marshall(obj,md,fid) 
-		function marshall(obj,md,fid) 
+		% {{{ function marshall(self,md,fid) 
+		function marshall(self,md,fid) 
 			WriteData(fid,'enum',HydrologyModelEnum(),'data',HydrologydcEnum(),'format','Integer');
-			WriteData(fid,'object',obj,'fieldname','water_compressibility','format','Double');
-			WriteData(fid,'object',obj,'fieldname','isefficientlayer','format','Boolean');
-			WriteData(fid,'object',obj,'fieldname','penalty_factor','format','Double');
-			WriteData(fid,'object',obj,'fieldname','penalty_lock','format','Integer');
-			WriteData(fid,'object',obj,'fieldname','rel_tol','format','Double');
-			WriteData(fid,'object',obj,'fieldname','max_iter','format','Integer');
-			WriteData(fid,'object',obj,'fieldname','sedimentlimit_flag','format','Integer');
-			WriteData(fid,'object',obj,'fieldname','transfer_flag','format','Integer');
-			if obj.sedimentlimit_flag==1,
-				WriteData(fid,'object',obj,'fieldname','sedimentlimit','format','Double');
+			WriteData(fid,'object',self,'fieldname','water_compressibility','format','Double');
+			WriteData(fid,'object',self,'fieldname','isefficientlayer','format','Boolean');
+			WriteData(fid,'object',self,'fieldname','penalty_factor','format','Double');
+			WriteData(fid,'object',self,'fieldname','penalty_lock','format','Integer');
+			WriteData(fid,'object',self,'fieldname','rel_tol','format','Double');
+			WriteData(fid,'object',self,'fieldname','max_iter','format','Integer');
+			WriteData(fid,'object',self,'fieldname','sedimentlimit_flag','format','Integer');
+			WriteData(fid,'object',self,'fieldname','transfer_flag','format','Integer');
+			if self.sedimentlimit_flag==1,
+				WriteData(fid,'object',self,'fieldname','sedimentlimit','format','Double');
 	    end
-			if obj.transfer_flag==1,
-				WriteData(fid,'object',obj,'fieldname','leakage_factor','format','Double');
+			if self.transfer_flag==1,
+				WriteData(fid,'object',self,'fieldname','leakage_factor','format','Double');
 	    end
-			WriteData(fid,'object',obj,'fieldname','basal_moulin_input','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1)
+			WriteData(fid,'object',self,'fieldname','basal_moulin_input','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1)
 
-			WriteData(fid,'object',obj,'fieldname','spcsediment_head','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
-			WriteData(fid,'object',obj,'fieldname','sediment_compressibility','format','Double');			
-			WriteData(fid,'object',obj,'fieldname','sediment_porosity','format','Double');			
-			WriteData(fid,'object',obj,'fieldname','sediment_thickness','format','Double');
-			WriteData(fid,'object',obj,'fieldname','sediment_transmitivity','format','DoubleMat','mattype',1');		
+			WriteData(fid,'object',self,'fieldname','spcsediment_head','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
+			WriteData(fid,'object',self,'fieldname','sediment_compressibility','format','Double');			
+			WriteData(fid,'object',self,'fieldname','sediment_porosity','format','Double');			
+			WriteData(fid,'object',self,'fieldname','sediment_thickness','format','Double');
+			WriteData(fid,'object',self,'fieldname','sediment_transmitivity','format','DoubleMat','mattype',1');		
 
-			if obj.isefficientlayer==1,	
-				WriteData(fid,'object',obj,'fieldname','spcepl_head','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);	
-				WriteData(fid,'object',obj,'fieldname','mask_eplactive_node','format','DoubleMat','mattype',1);
-				WriteData(fid,'object',obj,'fieldname','epl_compressibility','format','Double');			
-				WriteData(fid,'object',obj,'fieldname','epl_porosity','format','Double');			
-				WriteData(fid,'object',obj,'fieldname','epl_initial_thickness','format','Double');
-				WriteData(fid,'object',obj,'fieldname','epl_colapse_thickness','format','Double');
-				WriteData(fid,'object',obj,'fieldname','epl_thick_comp','format','Integer');
-				WriteData(fid,'object',obj,'fieldname','epl_max_thickness','format','Double');
-				WriteData(fid,'object',obj,'fieldname','epl_conductivity','format','Double');
-				WriteData(fid,'object',obj,'fieldname','eplflip_lock','format','Integer');
+			if self.isefficientlayer==1,	
+				WriteData(fid,'object',self,'fieldname','spcepl_head','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);	
+				WriteData(fid,'object',self,'fieldname','mask_eplactive_node','format','DoubleMat','mattype',1);
+				WriteData(fid,'object',self,'fieldname','epl_compressibility','format','Double');			
+				WriteData(fid,'object',self,'fieldname','epl_porosity','format','Double');			
+				WriteData(fid,'object',self,'fieldname','epl_initial_thickness','format','Double');
+				WriteData(fid,'object',self,'fieldname','epl_colapse_thickness','format','Double');
+				WriteData(fid,'object',self,'fieldname','epl_thick_comp','format','Integer');
+				WriteData(fid,'object',self,'fieldname','epl_max_thickness','format','Double');
+				WriteData(fid,'object',self,'fieldname','epl_conductivity','format','Double');
+				WriteData(fid,'object',self,'fieldname','eplflip_lock','format','Integer');
 	    end
 		end 
 % }}}
Index: ../trunk-jpl/src/m/classes/flaim.m
===================================================================
--- ../trunk-jpl/src/m/classes/flaim.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/flaim.m	(revision 19040)
@@ -20,51 +20,51 @@
 		opt_niter          = 30000
 	end
 	methods
-  	 	function createxml(obj,fid) % {{{
+  	 	function createxml(self,fid) % {{{
             fprintf(fid, '<!-- flaim -->\n');            
                     
             % Input
             fprintf(fid,'%s\n%s\n%s\n','<frame key="1" label="Input:">','<section name="flaim" />');                    
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="targets" type="',class(obj.targets),'" default="',convert2str(obj.targets),'">','     <section name="flaim" />','     <help> name of kml output targets file </help>','  </parameter>');
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="tracks" type="',class(obj.tracks),'" default="',convert2str(obj.tracks),'">','     <section name="flaim" />','     <help> name of kml input tracks file </help>','  </parameter>');
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="flightreqs" type="',class(obj.flightreqs),'" default="',convert2str(obj.flightreqs),'">','     <section name="flaim" />','     <help> structure of kml flight requirements (not used yet) </help>','  </parameter>');
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="criterion" type="',class(obj.criterion),'" default="',convert2str(obj.criterion),'">','     <section name="flaim" />','     <help> element or nodal criterion for flight path evaluation (metric) </help>','  </parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="targets" type="',class(self.targets),'" default="',convert2str(self.targets),'">','     <section name="flaim" />','     <help> name of kml output targets file </help>','  </parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="tracks" type="',class(self.tracks),'" default="',convert2str(self.tracks),'">','     <section name="flaim" />','     <help> name of kml input tracks file </help>','  </parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="flightreqs" type="',class(self.flightreqs),'" default="',convert2str(self.flightreqs),'">','     <section name="flaim" />','     <help> structure of kml flight requirements (not used yet) </help>','  </parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="criterion" type="',class(self.criterion),'" default="',convert2str(self.criterion),'">','     <section name="flaim" />','     <help> element or nodal criterion for flight path evaluation (metric) </help>','  </parameter>');
         	fprintf(fid,'%s\n%s\n','</frame>');    
             
             % Arguments
             fprintf(fid,'%s\n%s\n%s\n','<frame key="2" label="Arguments:">','<section name="flaim" />');                    
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="gridsatequator" type="',class(obj.gridsatequator),'" default="',convert2str(obj.gridsatequator),'">','     <section name="flaim" />','     <help> number of grids at equator (determines resolution) </help>','  </parameter>');
-            fprintf(fid,'%s%s%s\n%s\n%s%s%s\n%s\n%s\n','  <parameter key ="usevalueordering" type="',class(obj.usevalueordering),'" optional="false">','     <section name="flaim" />','         <option value="',convert2str(obj.usevalueordering),'" type="string" default="true"></option>','     <help> flag to consider target values for flight path evaluation </help>','  </parameter>');
-            fprintf(fid,'%s%s%s\n%s\n%s%s%s\n%s\n%s\n','  <parameter key ="split_antimeridian" type="',class(obj.split_antimeridian),'" optional="false">','     <section name="flaim" />','         <option value="',convert2str(obj.split_antimeridian),'" type="string" default="true"></option>','     <help> flag to split polygons on the antimeridian </help>','  </parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="gridsatequator" type="',class(self.gridsatequator),'" default="',convert2str(self.gridsatequator),'">','     <section name="flaim" />','     <help> number of grids at equator (determines resolution) </help>','  </parameter>');
+            fprintf(fid,'%s%s%s\n%s\n%s%s%s\n%s\n%s\n','  <parameter key ="usevalueordering" type="',class(self.usevalueordering),'" optional="false">','     <section name="flaim" />','         <option value="',convert2str(self.usevalueordering),'" type="string" default="true"></option>','     <help> flag to consider target values for flight path evaluation </help>','  </parameter>');
+            fprintf(fid,'%s%s%s\n%s\n%s%s%s\n%s\n%s\n','  <parameter key ="split_antimeridian" type="',class(self.split_antimeridian),'" optional="false">','     <section name="flaim" />','         <option value="',convert2str(self.split_antimeridian),'" type="string" default="true"></option>','     <help> flag to split polygons on the antimeridian </help>','  </parameter>');
             fprintf(fid,'%s\n%s\n','</frame>');   
             
             % Optimization
             fprintf(fid,'%s\n%s\n%s\n','<frame key="3" label="Optimization:">','<section name="flaim" />');                    
-            fprintf(fid,'%s%s%s\n%s\n%s%s%s\n%s\n%s\n','  <parameter key ="path_optimize" type="',class(obj.path_optimize),'" optional="false">','     <section name="flaim" />','         <option value="',convert2str(obj.path_optimize),'" type="string" default="true"></option>','     <help> optimize? (default false) </help>','  </parameter>');
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="opt_ndir" type="',class(obj.opt_ndir),'" default="',convert2str(obj.opt_ndir),'">','     <section name="flaim" />','     <help> number of directions to test when moving a point.  If this value = 1, a random direction is tested. A value > 1 results in directions equally spaced from [0, 2*PI] being tested. For example, 4 would result in directions [0, PI/2, PI, 3PI/2] </help>','  </parameter>');
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="opt_dist" type="',class(obj.opt_dist),'" default="',convert2str(obj.opt_dist),'">','     <section name="flaim" />','     <help> specifies the distance in km (default 25) to move a randomly selected path point on each iteration </help>','  </parameter>');
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="opt_niter" type="',class(obj.opt_niter),'" default="',convert2str(obj.opt_niter),'">','     <section name="flaim" />','     <help> number of iterations (default 30,000) to run for flightplan optimization, i.e. the number of times to randomly select a point and move it. </help>','  </parameter>');
+            fprintf(fid,'%s%s%s\n%s\n%s%s%s\n%s\n%s\n','  <parameter key ="path_optimize" type="',class(self.path_optimize),'" optional="false">','     <section name="flaim" />','         <option value="',convert2str(self.path_optimize),'" type="string" default="true"></option>','     <help> optimize? (default false) </help>','  </parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="opt_ndir" type="',class(self.opt_ndir),'" default="',convert2str(self.opt_ndir),'">','     <section name="flaim" />','     <help> number of directions to test when moving a point.  If this value = 1, a random direction is tested. A value > 1 results in directions equally spaced from [0, 2*PI] being tested. For example, 4 would result in directions [0, PI/2, PI, 3PI/2] </help>','  </parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="opt_dist" type="',class(self.opt_dist),'" default="',convert2str(self.opt_dist),'">','     <section name="flaim" />','     <help> specifies the distance in km (default 25) to move a randomly selected path point on each iteration </help>','  </parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="opt_niter" type="',class(self.opt_niter),'" default="',convert2str(self.opt_niter),'">','     <section name="flaim" />','     <help> number of iterations (default 30,000) to run for flightplan optimization, i.e. the number of times to randomly select a point and move it. </help>','  </parameter>');
         	fprintf(fid,'%s\n%s\n','</frame>');     
             
             % Output
             fprintf(fid,'%s\n%s\n%s\n','<frame key="4" label="Output:">','<section name="flaim" />');                    
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="solution" type="',class(obj.solution),'" default="',convert2str(obj.solution),'">','     <section name="flaim" />','     <help> name of kml solution file </help>','  </parameter>');
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="quality" type="',class(obj.quality),'" default="',convert2str(obj.quality),'">','     <section name="flaim" />','     <help> quality of kml solution </help>','  </parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="solution" type="',class(self.solution),'" default="',convert2str(self.solution),'">','     <section name="flaim" />','     <help> name of kml solution file </help>','  </parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="quality" type="',class(self.quality),'" default="',convert2str(self.quality),'">','     <section name="flaim" />','     <help> quality of kml solution </help>','  </parameter>');
             fprintf(fid,'%s\n%s\n','</frame>');              
         
         end % }}}
-		function obj = flaim(varargin) % {{{
+		function self = flaim(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 			%Early return
 			if solution~=FlaimSolutionEnum(), return; end
@@ -77,33 +77,33 @@
 			end
 
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 
 			disp(sprintf('   FLAIM - Flight Line Adaptation using Ice sheet Modeling:')); 
 
 			disp(sprintf('\n      Input:'));
-			fielddisplay(obj,'targets'            ,'name of kml output targets file ');
-			fielddisplay(obj,'tracks'             ,'name of kml input tracks file ');
-			fielddisplay(obj,'flightreqs'         ,'structure of kml flight requirements (not used yet)');
-			fielddisplay(obj,'criterion'          ,'element or nodal criterion for flight path evaluation (metric)');
+			fielddisplay(self,'targets'            ,'name of kml output targets file ');
+			fielddisplay(self,'tracks'             ,'name of kml input tracks file ');
+			fielddisplay(self,'flightreqs'         ,'structure of kml flight requirements (not used yet)');
+			fielddisplay(self,'criterion'          ,'element or nodal criterion for flight path evaluation (metric)');
 
 			disp(sprintf('\n      Arguments:'));
-			fielddisplay(obj,'gridsatequator'     ,'number of grids at equator (determines resolution)');
-			fielddisplay(obj,'usevalueordering'   ,'flag to consider target values for flight path evaluation');
-			fielddisplay(obj,'split_antimeridian' ,'flag to split polygons on the antimeridian');
+			fielddisplay(self,'gridsatequator'     ,'number of grids at equator (determines resolution)');
+			fielddisplay(self,'usevalueordering'   ,'flag to consider target values for flight path evaluation');
+			fielddisplay(self,'split_antimeridian' ,'flag to split polygons on the antimeridian');
 
 			disp(sprintf('\n      Optimization:'));
-			fielddisplay(obj,'path_optimize'     ,'optimize? (default false)');
-			fielddisplay(obj,'opt_ndir'     ,{'number of directions to test when moving a point.  If this value = 1, a random direction is tested.',...
+			fielddisplay(self,'path_optimize'     ,'optimize? (default false)');
+			fielddisplay(self,'opt_ndir'     ,{'number of directions to test when moving a point.  If this value = 1, a random direction is tested.',...
 											  'A value > 1 results in directions equally spaced from [0, 2*PI] being tested.',...
 											  'For example, 4 would result in directions [0, PI/2, PI, 3PI/2].'});
-			fielddisplay(obj,'opt_dist'     ,'specifies the distance in km (default 25) to move a randomly selected path point on each iteration');
-			fielddisplay(obj,'opt_niter'     ,{'number of iterations (default 30,000) to run for flightplan optimization',...
+			fielddisplay(self,'opt_dist'     ,'specifies the distance in km (default 25) to move a randomly selected path point on each iteration');
+			fielddisplay(self,'opt_niter'     ,{'number of iterations (default 30,000) to run for flightplan optimization',...
 											   'i.e. the number of times to randomly select a point and move it.'});
 
 			disp(sprintf('\n      Output:'));
-			fielddisplay(obj,'solution'           ,'name of kml solution file');
-			fielddisplay(obj,'quality'            ,'quality of kml solution');
+			fielddisplay(self,'solution'           ,'name of kml solution file');
+			fielddisplay(self,'quality'            ,'quality of kml solution');
 		end % }}}
 	end
 end
Index: ../trunk-jpl/src/m/classes/calvinglevermann.m
===================================================================
--- ../trunk-jpl/src/m/classes/calvinglevermann.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/calvinglevermann.m	(revision 19040)
@@ -10,10 +10,10 @@
 		meltingrate   = NaN;
 	end
 	methods
-		function obj = calvinglevermann(varargin) % {{{
+		function self = calvinglevermann(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				case 1
 					inputstruct=varargin{1};
 					list1 = properties('calvinglevermann');
@@ -21,22 +21,22 @@
 					for i=1:length(list1)
 						fieldname = list1{i};
 						if ismember(fieldname,list2),
-							obj.(fieldname) = inputstruct.(fieldname);
+							self.(fieldname) = inputstruct.(fieldname);
 						end
 					end
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 			%stabilization = 2 by default
-			obj.stabilization = 2;
+			self.stabilization = 2;
 
 			%Proportionality coefficient in Levermann model
-			obj.coeff=2e13;
+			self.coeff=2e13;
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 			%Early return
 			if (solution~=TransientSolutionEnum() | md.transient.iscalving==0), return; end
 
@@ -44,19 +44,19 @@
 			md = checkfield(md,'fieldname','calving.coeff','>',0,'size',[md.mesh.numberofvertices 1]);
 			md = checkfield(md,'fieldname','calving.meltingrate','NaN',1,'size',[md.mesh.numberofvertices 1],'>=',0);
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   Calving Levermann parameters:'));
-			fielddisplay(obj,'stabilization','0: no, 1: artificial_diffusivity, 2: streamline upwinding');
-			fielddisplay(obj,'coeff','proportionality coefficient in Levermann model');
-			fielddisplay(obj,'meltingrate','melting rate at given location [m/a]');
+			fielddisplay(self,'stabilization','0: no, 1: artificial_diffusivity, 2: streamline upwinding');
+			fielddisplay(self,'coeff','proportionality coefficient in Levermann model');
+			fielddisplay(self,'meltingrate','melting rate at given location [m/a]');
 
 		end % }}}
-		function marshall(obj,md,fid) % {{{
+		function marshall(self,md,fid) % {{{
 			yts=365.0*24.0*3600.0;
 			WriteData(fid,'enum',CalvingLawEnum(),'data',CalvingLevermannEnum(),'format','Integer');
-			WriteData(fid,'enum',LevelsetStabilizationEnum(),'data',obj.stabilization,'format','Integer');
-			WriteData(fid,'enum',CalvinglevermannCoeffEnum(),'data',obj.coeff,'format','DoubleMat','mattype',1);
-			WriteData(fid,'object',obj,'fieldname','meltingrate','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1,'scale',1./yts);
+			WriteData(fid,'enum',LevelsetStabilizationEnum(),'data',self.stabilization,'format','Integer');
+			WriteData(fid,'enum',CalvinglevermannCoeffEnum(),'data',self.coeff,'format','DoubleMat','mattype',1);
+			WriteData(fid,'object',self,'fieldname','meltingrate','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1,'scale',1./yts);
 		end % }}}
 	end
 end
Index: ../trunk-jpl/src/m/classes/mask.m
===================================================================
--- ../trunk-jpl/src/m/classes/mask.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/mask.m	(revision 19040)
@@ -9,36 +9,36 @@
 		ice_levelset         = NaN;
 	end
 	methods (Static)
-		function obj = loadobj(obj) % {{{
+		function self = loadobj(self) % {{{
 			% This function is directly called by matlab when a model object is
 			% loaded. Update old properties here
 
 			%2014 February 5th
-			if numel(obj.ice_levelset)>1 & all(obj.ice_levelset>=0),
+			if numel(self.ice_levelset)>1 & all(self.ice_levelset>=0),
 				disp('WARNING: md.mask.ice_levelset>=0, you probably need to change the sign of this levelset');
 			end
 
 		end% }}}
 	end
 	methods
-        function createxml(obj,fid) % {{{
+        function createxml(self,fid) % {{{
             fprintf(fid, '\n\n');
             fprintf(fid, '%s\n', '<!-- mask -->');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="groundedice_levelset" type="',class(obj.groundedice_levelset),'" default="',obj.groundedice_levelset,'">','     <section name="mask" />','     <help> is ice grounded ? grounded ice if > 0, grounding line position if = 0, floating ice if &amp;lt; 0 </help>','</parameter>');
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','<parameter key ="ice_levelset" type="',class(obj.ice_levelset),'" default="',obj.ice_levelset,'">','     <section name="mask" />','     <help> presence of ice if > 0, icefront position if = 0, no ice if &amp;lt; 0 </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="groundedice_levelset" type="',class(self.groundedice_levelset),'" default="',self.groundedice_levelset,'">','     <section name="mask" />','     <help> is ice grounded ? grounded ice if > 0, grounding line position if = 0, floating ice if &amp;lt; 0 </help>','</parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','<parameter key ="ice_levelset" type="',class(self.ice_levelset),'" default="',self.ice_levelset,'">','     <section name="mask" />','     <help> presence of ice if > 0, icefront position if = 0, no ice if &amp;lt; 0 </help>','</parameter>');
 		end % }}}
-		function obj = mask(varargin) % {{{
+		function self = mask(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 			if (solution==SeaiceSolutionEnum()),
 				return;
 			end
@@ -57,15 +57,15 @@
 				error('At least one element has all nodes on ice front, change md.mask.ice_levelset to fix it')
 			end
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   masks:'));
 
-			fielddisplay(obj,'groundedice_levelset','is ice grounded ? grounded ice if > 0, grounding line position if = 0, floating ice if < 0');
-			fielddisplay(obj,'ice_levelset','presence of ice if < 0, icefront position if = 0, no ice if > 0');
+			fielddisplay(self,'groundedice_levelset','is ice grounded ? grounded ice if > 0, grounding line position if = 0, floating ice if < 0');
+			fielddisplay(self,'ice_levelset','presence of ice if < 0, icefront position if = 0, no ice if > 0');
 		end % }}}
-		function marshall(obj,md,fid) % {{{
-			WriteData(fid,'object',obj,'fieldname','groundedice_levelset','format','DoubleMat','mattype',1);
-			WriteData(fid,'object',obj,'fieldname','ice_levelset','format','DoubleMat','mattype',1);
+		function marshall(self,md,fid) % {{{
+			WriteData(fid,'object',self,'fieldname','groundedice_levelset','format','DoubleMat','mattype',1);
+			WriteData(fid,'object',self,'fieldname','ice_levelset','format','DoubleMat','mattype',1);
 
 			if(md.private.solution==SeaiceSolutionEnum()),
 				return;
Index: ../trunk-jpl/src/m/classes/balancethickness.m
===================================================================
--- ../trunk-jpl/src/m/classes/balancethickness.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/balancethickness.m	(revision 19040)
@@ -12,21 +12,21 @@
 		omega             = NaN;
 	end
 	methods
-		function obj = balancethickness(varargin) % {{{
+		function self = balancethickness(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 			%Type of stabilization used
-			obj.stabilization=1;
+			self.stabilization=1;
 
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 			%Early return
 			if solution~=BalancethicknessSolutionEnum(), return; end
 
@@ -36,23 +36,23 @@
 
 			%md = checkfield(md,'fieldname','balancethickness.omega','size',[md.mesh.numberofvertices 1],'NaN',1,'>=',0);
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   balance thickness solution parameters:'));
 
-			fielddisplay(obj,'spcthickness','thickness constraints (NaN means no constraint) [m]');
-			fielddisplay(obj,'thickening_rate','ice thickening rate used in the mass conservation (dh/dt) [m/yr]');
-			fielddisplay(obj,'stabilization','0: None, 1: SU, 2: SSA''s artificial diffusivity, 3:DG');
+			fielddisplay(self,'spcthickness','thickness constraints (NaN means no constraint) [m]');
+			fielddisplay(self,'thickening_rate','ice thickening rate used in the mass conservation (dh/dt) [m/yr]');
+			fielddisplay(self,'stabilization','0: None, 1: SU, 2: SSA''s artificial diffusivity, 3:DG');
 
 		end % }}}
-		function marshall(obj,md,fid) % {{{
+		function marshall(self,md,fid) % {{{
 
 			yts=365.0*24.0*3600.0;
 
-			WriteData(fid,'object',obj,'fieldname','spcthickness','format','DoubleMat','mattype',1);
-			WriteData(fid,'object',obj,'fieldname','thickening_rate','format','DoubleMat','mattype',1,'scale',1./yts);
-			WriteData(fid,'object',obj,'fieldname','stabilization','format','Integer');
+			WriteData(fid,'object',self,'fieldname','spcthickness','format','DoubleMat','mattype',1);
+			WriteData(fid,'object',self,'fieldname','thickening_rate','format','DoubleMat','mattype',1,'scale',1./yts);
+			WriteData(fid,'object',self,'fieldname','stabilization','format','Integer');
 
-			WriteData(fid,'object',obj,'fieldname','omega','format','DoubleMat','mattype',1);
+			WriteData(fid,'object',self,'fieldname','omega','format','DoubleMat','mattype',1);
 		end % }}}
 	end
 end
Index: ../trunk-jpl/src/m/classes/matdamageice.m
===================================================================
--- ../trunk-jpl/src/m/classes/matdamageice.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/matdamageice.m	(revision 19040)
@@ -29,44 +29,44 @@
 
 	end
 	methods
-		function createxml(obj,fid) % {{{
+		function createxml(self,fid) % {{{
 			fprintf(fid, '\n\n');
 			fprintf(fid, '<!-- materials -->\n');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="rho_ice" type="',class(obj.rho_ice),'" default="',convert2str(obj.rho_ice),'">','     <section name="materials" />','     <help> ice density [kg/m^3] </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="rho_water" type="',class(obj.rho_water),'" default="',convert2str(obj.rho_water),'">','     <section name="materials" />','     <help> ocean water density [kg/m^3] </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="rho_freshwater" type="',class(obj.rho_freshwater),'" default="',convert2str(obj.rho_freshwater),'">','     <section name="materials" />','     <help> fresh water density [kg/m^3] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="rho_ice" type="',class(self.rho_ice),'" default="',convert2str(self.rho_ice),'">','     <section name="materials" />','     <help> ice density [kg/m^3] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="rho_water" type="',class(self.rho_water),'" default="',convert2str(self.rho_water),'">','     <section name="materials" />','     <help> ocean water density [kg/m^3] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="rho_freshwater" type="',class(self.rho_freshwater),'" default="',convert2str(self.rho_freshwater),'">','     <section name="materials" />','     <help> fresh water density [kg/m^3] </help>','</parameter>');
 
 
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="mu_water" type="',class(obj.mu_water),'" default="',convert2str(obj.mu_water),'">','     <section name="materials" />','     <help> water viscosity [N s/m^2] </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="heatcapacity" type="',class(obj.heatcapacity),'" default="',convert2str(obj.heatcapacity),'">','     <section name="materials" />','     <help> heat capacity [J/kg/K] </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="latentheat" type="',class(obj.latentheat),'" default="',convert2str(obj.latentheat),'">','     <section name="materials" />','     <help> latent heat of fusion [J/kg] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="mu_water" type="',class(self.mu_water),'" default="',convert2str(self.mu_water),'">','     <section name="materials" />','     <help> water viscosity [N s/m^2] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="heatcapacity" type="',class(self.heatcapacity),'" default="',convert2str(self.heatcapacity),'">','     <section name="materials" />','     <help> heat capacity [J/kg/K] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="latentheat" type="',class(self.latentheat),'" default="',convert2str(self.latentheat),'">','     <section name="materials" />','     <help> latent heat of fusion [J/kg] </help>','</parameter>');
 
 
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="thermalconductivity" type="',class(obj.thermalconductivity),'" default="',convert2str(obj.thermalconductivity),'">','     <section name="materials" />','     <help> ice thermal conductivity [W/m/K] </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="temperateiceconductivity" type="',class(obj.temperateiceconductivity),'" default="',convert2str(obj.temperateiceconductivity),'">','     <section name="materials" />','     <help> temperate ice thermal conductivity [W/m/K] </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="meltingpoint" type="',class(obj.meltingpoint),'" default="',convert2str(obj.meltingpoint),'">','     <section name="materials" />','     <help> melting point of ice at 1atm in K </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="thermalconductivity" type="',class(self.thermalconductivity),'" default="',convert2str(self.thermalconductivity),'">','     <section name="materials" />','     <help> ice thermal conductivity [W/m/K] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="temperateiceconductivity" type="',class(self.temperateiceconductivity),'" default="',convert2str(self.temperateiceconductivity),'">','     <section name="materials" />','     <help> temperate ice thermal conductivity [W/m/K] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="meltingpoint" type="',class(self.meltingpoint),'" default="',convert2str(self.meltingpoint),'">','     <section name="materials" />','     <help> melting point of ice at 1atm in K </help>','</parameter>');
 
 
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="beta" type="',class(obj.beta),'" default="',convert2str(obj.beta),'">','     <section name="materials" />','     <help> rate of change of melting point with pressure [K/Pa] </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="mixed_layer_capacity" type="',class(obj.mixed_layer_capacity),'" default="',convert2str(obj.mixed_layer_capacity),'">','     <section name="materials" />','     <help> mixed layer capacity [W/kg/K] </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="thermal_exchange_velocity" type="',class(obj.thermal_exchange_velocity),'" default="',convert2str(obj.thermal_exchange_velocity),'">','     <section name="materials" />','     <help> thermal exchange velocity [m/s] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="beta" type="',class(self.beta),'" default="',convert2str(self.beta),'">','     <section name="materials" />','     <help> rate of change of melting point with pressure [K/Pa] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="mixed_layer_capacity" type="',class(self.mixed_layer_capacity),'" default="',convert2str(self.mixed_layer_capacity),'">','     <section name="materials" />','     <help> mixed layer capacity [W/kg/K] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="thermal_exchange_velocity" type="',class(self.thermal_exchange_velocity),'" default="',convert2str(self.thermal_exchange_velocity),'">','     <section name="materials" />','     <help> thermal exchange velocity [m/s] </help>','</parameter>');
 
 
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="rheology_B" type="',class(obj.rheology_B),'" default="',convert2str(obj.rheology_B),'">','     <section name="materials" />','     <help> flow law parameter [Pa/s^(1/n)] </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="rheology_n" type="',class(obj.rheology_n),'" default="',convert2str(obj.rheology_n),'">','     <section name="materials" />','     <help> Glens flow law exponent </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="rheology_law" type="',class(obj.rheology_law),'" default="',convert2str(obj.rheology_law),'">','     <section name="materials" />','     <help> law for the temperature dependance of the rheology: "None", "Paterson",  "Arrhenius" or "LliboutryDuval" </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="rheology_B" type="',class(self.rheology_B),'" default="',convert2str(self.rheology_B),'">','     <section name="materials" />','     <help> flow law parameter [Pa/s^(1/n)] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="rheology_n" type="',class(self.rheology_n),'" default="',convert2str(self.rheology_n),'">','     <section name="materials" />','     <help> Glens flow law exponent </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="rheology_law" type="',class(self.rheology_law),'" default="',convert2str(self.rheology_law),'">','     <section name="materials" />','     <help> law for the temperature dependance of the rheology: "None", "Paterson",  "Arrhenius" or "LliboutryDuval" </help>','</parameter>');
 
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="lithosphere_shear_modulus" type="',class(obj.lithosphere_shear_modulus),'" default="',convert2str(obj.lithosphere_shear_modulus),'">','     <section name="materials" />','     <help> Lithosphere shear modulus [Pa] </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="lithosphere_density" type="',class(obj.lithosphere_density),'" default="',convert2str(obj.lithosphere_density),'">','     <section name="materials" />','     <help> Lithosphere density [g/cm^-3] </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="mantle_shear_modulus" type="',class(obj.mantle_shear_modulus),'" default="',convert2str(obj.mantle_shear_modulus),'">','     <section name="materials" />','     <help> Mantle shear modulus [Pa] </help>','</parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="mantle_density" type="',class(obj.mantle_density),'" default="',convert2str(obj.mantle_density),'">','     <section name="materials" />','     <help> Mantle density [g/cm^-3] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="lithosphere_shear_modulus" type="',class(self.lithosphere_shear_modulus),'" default="',convert2str(self.lithosphere_shear_modulus),'">','     <section name="materials" />','     <help> Lithosphere shear modulus [Pa] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="lithosphere_density" type="',class(self.lithosphere_density),'" default="',convert2str(self.lithosphere_density),'">','     <section name="materials" />','     <help> Lithosphere density [g/cm^-3] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="mantle_shear_modulus" type="',class(self.mantle_shear_modulus),'" default="',convert2str(self.mantle_shear_modulus),'">','     <section name="materials" />','     <help> Mantle shear modulus [Pa] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="mantle_density" type="',class(self.mantle_density),'" default="',convert2str(self.mantle_density),'">','     <section name="materials" />','     <help> Mantle density [g/cm^-3] </help>','</parameter>');
 
 
 		end % }}}
-		function obj = matdamageice(varargin) % {{{
+		function self = matdamageice(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				case 1
 					inputstruct=varargin{1};
 					list1 = properties('matdamageice');
@@ -74,63 +74,63 @@
 					for i=1:length(list1)
 						fieldname = list1{i};
 						if ismember(fieldname,list2),
-							obj.(fieldname) = inputstruct.(fieldname);
+							self.(fieldname) = inputstruct.(fieldname);
 						end
 					end
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 			%ice density (kg/m^3)
-			obj.rho_ice=917.;
+			self.rho_ice=917.;
 
 			%ocean water density (kg/m^3)
-			obj.rho_water=1023.;
+			self.rho_water=1023.;
 
 			%fresh water density (kg/m^3)
-			obj.rho_freshwater=1000.;
+			self.rho_freshwater=1000.;
 
 			%water viscosity (N.s/m^2)
-			obj.mu_water=0.001787;  
+			self.mu_water=0.001787;  
 
 			%ice heat capacity cp (J/kg/K)
-			obj.heatcapacity=2093.;
+			self.heatcapacity=2093.;
 
 			%ice latent heat of fusion L (J/kg)
-			obj.latentheat=3.34*10^5;
+			self.latentheat=3.34*10^5;
 
 			%ice thermal conductivity (W/m/K)
-			obj.thermalconductivity=2.4;
+			self.thermalconductivity=2.4;
 			
 			%wet ice thermal conductivity (W/m/K)
-			obj.temperateiceconductivity=.24;
+			self.temperateiceconductivity=.24;
 
 			%the melting point of ice at 1 atmosphere of pressure in K
-			obj.meltingpoint=273.15;
+			self.meltingpoint=273.15;
 
 			%rate of change of melting point with pressure (K/Pa)
-			obj.beta=9.8*10^-8;
+			self.beta=9.8*10^-8;
 
 			%mixed layer (ice-water interface) heat capacity (J/kg/K)
-			obj.mixed_layer_capacity=3974.;
+			self.mixed_layer_capacity=3974.;
 
 			%thermal exchange velocity (ice-water interface) (m/s)
-			obj.thermal_exchange_velocity=1.00*10^-4;
+			self.thermal_exchange_velocity=1.00*10^-4;
 
 			%Rheology law: what is the temperature dependence of B with T
 			%available: none, paterson and arrhenius
-			obj.rheology_law='Paterson';
+			self.rheology_law='Paterson';
 
 			% GIA:
-			obj.lithosphere_shear_modulus  = 6.7*10^10;  % (Pa)
-			obj.lithosphere_density        = 3.32;       % (g/cm^-3)
-			obj.mantle_shear_modulus       = 1.45*10^11; % (Pa)
-			obj.mantle_density             = 3.34;       % (g/cm^-3)
+			self.lithosphere_shear_modulus  = 6.7*10^10;  % (Pa)
+			self.lithosphere_density        = 3.32;       % (g/cm^-3)
+			self.mantle_shear_modulus       = 1.45*10^11; % (Pa)
+			self.mantle_density             = 3.34;       % (g/cm^-3)
 
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 			md = checkfield(md,'fieldname','materials.rho_ice','>',0);
 			md = checkfield(md,'fieldname','materials.rho_water','>',0);
 			md = checkfield(md,'fieldname','materials.rho_freshwater','>',0);
@@ -147,51 +147,51 @@
 			end
 
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   Materials:'));
 
-			fielddisplay(obj,'rho_ice','ice density [kg/m^3]');
-			fielddisplay(obj,'rho_water','ocean water density [kg/m^3]');
-			fielddisplay(obj,'rho_freshwater','fresh water density [kg/m^3]');
-			fielddisplay(obj,'mu_water','water viscosity [N s/m^2]');
-			fielddisplay(obj,'heatcapacity','heat capacity [J/kg/K]');
-			fielddisplay(obj,'thermalconductivity',['ice thermal conductivity [W/m/K]']);
-			fielddisplay(obj,'temperateiceconductivity','temperate ice thermal conductivity [W/m/K]');
-			fielddisplay(obj,'meltingpoint','melting point of ice at 1atm in K');
-			fielddisplay(obj,'latentheat','latent heat of fusion [J/kg]');
-			fielddisplay(obj,'beta','rate of change of melting point with pressure [K/Pa]');
-			fielddisplay(obj,'mixed_layer_capacity','mixed layer capacity [W/kg/K]');
-			fielddisplay(obj,'thermal_exchange_velocity','thermal exchange velocity [m/s]');
-			fielddisplay(obj,'rheology_B','flow law parameter [Pa/s^(1/n)]');
-			fielddisplay(obj,'rheology_n','Glen''s flow law exponent');
-			fielddisplay(obj,'rheology_law',['law for the temperature dependance of the rheology: ''None'', ''Cuffey'', ''Paterson'', ''Arrhenius'' or ''LliboutryDuval''']);
-			fielddisplay(obj,'lithosphere_shear_modulus','Lithosphere shear modulus [Pa]');
-			fielddisplay(obj,'lithosphere_density','Lithosphere density [g/cm^-3]');
-			fielddisplay(obj,'mantle_shear_modulus','Mantle shear modulus [Pa]');
-			fielddisplay(obj,'mantle_density','Mantle density [g/cm^-3]');
+			fielddisplay(self,'rho_ice','ice density [kg/m^3]');
+			fielddisplay(self,'rho_water','ocean water density [kg/m^3]');
+			fielddisplay(self,'rho_freshwater','fresh water density [kg/m^3]');
+			fielddisplay(self,'mu_water','water viscosity [N s/m^2]');
+			fielddisplay(self,'heatcapacity','heat capacity [J/kg/K]');
+			fielddisplay(self,'thermalconductivity',['ice thermal conductivity [W/m/K]']);
+			fielddisplay(self,'temperateiceconductivity','temperate ice thermal conductivity [W/m/K]');
+			fielddisplay(self,'meltingpoint','melting point of ice at 1atm in K');
+			fielddisplay(self,'latentheat','latent heat of fusion [J/kg]');
+			fielddisplay(self,'beta','rate of change of melting point with pressure [K/Pa]');
+			fielddisplay(self,'mixed_layer_capacity','mixed layer capacity [W/kg/K]');
+			fielddisplay(self,'thermal_exchange_velocity','thermal exchange velocity [m/s]');
+			fielddisplay(self,'rheology_B','flow law parameter [Pa/s^(1/n)]');
+			fielddisplay(self,'rheology_n','Glen''s flow law exponent');
+			fielddisplay(self,'rheology_law',['law for the temperature dependance of the rheology: ''None'', ''Cuffey'', ''Paterson'', ''Arrhenius'' or ''LliboutryDuval''']);
+			fielddisplay(self,'lithosphere_shear_modulus','Lithosphere shear modulus [Pa]');
+			fielddisplay(self,'lithosphere_density','Lithosphere density [g/cm^-3]');
+			fielddisplay(self,'mantle_shear_modulus','Mantle shear modulus [Pa]');
+			fielddisplay(self,'mantle_density','Mantle density [g/cm^-3]');
 		end % }}}
-		function marshall(obj,md,fid) % {{{
+		function marshall(self,md,fid) % {{{
 			WriteData(fid,'enum',MaterialsEnum(),'data',MatdamageiceEnum(),'format','Integer');
-			WriteData(fid,'object',obj,'class','materials','fieldname','rho_ice','format','Double');
-			WriteData(fid,'object',obj,'class','materials','fieldname','rho_water','enum',MaterialsRhoSeawaterEnum(),'format','Double');
-			WriteData(fid,'object',obj,'class','materials','fieldname','rho_freshwater','format','Double');
-			WriteData(fid,'object',obj,'class','materials','fieldname','mu_water','format','Double');
-			WriteData(fid,'object',obj,'class','materials','fieldname','heatcapacity','format','Double');
-			WriteData(fid,'object',obj,'class','materials','fieldname','latentheat','format','Double');
-			WriteData(fid,'object',obj,'class','materials','fieldname','thermalconductivity','format','Double');
-			WriteData(fid,'object',obj,'class','materials','fieldname','temperateiceconductivity','format','Double');
-			WriteData(fid,'object',obj,'class','materials','fieldname','meltingpoint','format','Double');
-			WriteData(fid,'object',obj,'class','materials','fieldname','beta','format','Double');
-			WriteData(fid,'object',obj,'class','materials','fieldname','mixed_layer_capacity','format','Double');
-			WriteData(fid,'object',obj,'class','materials','fieldname','thermal_exchange_velocity','format','Double');
-			WriteData(fid,'object',obj,'class','materials','fieldname','rheology_B','format','DoubleMat','mattype',1);
-			WriteData(fid,'object',obj,'class','materials','fieldname','rheology_n','format','DoubleMat','mattype',2);
-			WriteData(fid,'data',StringToEnum(obj.rheology_law),'enum',MaterialsRheologyLawEnum(),'format','Integer');
+			WriteData(fid,'object',self,'class','materials','fieldname','rho_ice','format','Double');
+			WriteData(fid,'object',self,'class','materials','fieldname','rho_water','enum',MaterialsRhoSeawaterEnum(),'format','Double');
+			WriteData(fid,'object',self,'class','materials','fieldname','rho_freshwater','format','Double');
+			WriteData(fid,'object',self,'class','materials','fieldname','mu_water','format','Double');
+			WriteData(fid,'object',self,'class','materials','fieldname','heatcapacity','format','Double');
+			WriteData(fid,'object',self,'class','materials','fieldname','latentheat','format','Double');
+			WriteData(fid,'object',self,'class','materials','fieldname','thermalconductivity','format','Double');
+			WriteData(fid,'object',self,'class','materials','fieldname','temperateiceconductivity','format','Double');
+			WriteData(fid,'object',self,'class','materials','fieldname','meltingpoint','format','Double');
+			WriteData(fid,'object',self,'class','materials','fieldname','beta','format','Double');
+			WriteData(fid,'object',self,'class','materials','fieldname','mixed_layer_capacity','format','Double');
+			WriteData(fid,'object',self,'class','materials','fieldname','thermal_exchange_velocity','format','Double');
+			WriteData(fid,'object',self,'class','materials','fieldname','rheology_B','format','DoubleMat','mattype',1);
+			WriteData(fid,'object',self,'class','materials','fieldname','rheology_n','format','DoubleMat','mattype',2);
+			WriteData(fid,'data',StringToEnum(self.rheology_law),'enum',MaterialsRheologyLawEnum(),'format','Integer');
 
-			WriteData(fid,'object',obj,'class','materials','fieldname','lithosphere_shear_modulus','format','Double');
-			WriteData(fid,'object',obj,'class','materials','fieldname','lithosphere_density','format','Double','scale',10^3);
-			WriteData(fid,'object',obj,'class','materials','fieldname','mantle_shear_modulus','format','Double');
-			WriteData(fid,'object',obj,'class','materials','fieldname','mantle_density','format','Double','scale',10^3);
+			WriteData(fid,'object',self,'class','materials','fieldname','lithosphere_shear_modulus','format','Double');
+			WriteData(fid,'object',self,'class','materials','fieldname','lithosphere_density','format','Double','scale',10^3);
+			WriteData(fid,'object',self,'class','materials','fieldname','mantle_shear_modulus','format','Double');
+			WriteData(fid,'object',self,'class','materials','fieldname','mantle_density','format','Double','scale',10^3);
 		end % }}}
 	end
 end
Index: ../trunk-jpl/src/m/classes/SMBpdd.m
===================================================================
--- ../trunk-jpl/src/m/classes/SMBpdd.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/SMBpdd.m	(revision 19040)
@@ -25,10 +25,10 @@
 		precipitations_lgm        = NaN;
 	end
 	methods
-		function obj = SMBpdd(varargin) % {{{
+		function self = SMBpdd(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				otherwise
 					error('constructor not supported');
 			end
@@ -54,18 +54,18 @@
 			% end
 
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
-		  obj.isdelta18o = 0;
-		  obj.ismungsm   = 0;
-		  obj.desfac     = 0.5;
-		  obj.s0p        = 0;
-		  obj.s0t        = 0;
-		  obj.rlaps      = 6.5;
-		  obj.rlapslgm   = 6.5;
+		  self.isdelta18o = 0;
+		  self.ismungsm   = 0;
+		  self.desfac     = 0.5;
+		  self.s0p        = 0;
+		  self.s0t        = 0;
+		  self.rlaps      = 6.5;
+		  self.rlapslgm   = 6.5;
                   
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 			if ismember(MasstransportAnalysisEnum(),analyses),
 				md = checkfield(md,'fieldname','surfaceforcings.desfac','<=',1,'numel',1);
@@ -73,10 +73,10 @@
 				md = checkfield(md,'fieldname','surfaceforcings.s0t','>=',0,'numel',1);
 				md = checkfield(md,'fieldname','surfaceforcings.rlaps','>=',0,'numel',1);
 				md = checkfield(md,'fieldname','surfaceforcings.rlapslgm','>=',0,'numel',1);
-				if(obj.isdelta18o==0 & obj.ismungsm==0)
+				if(self.isdelta18o==0 & self.ismungsm==0)
 					md = checkfield(md,'fieldname','surfaceforcings.monthlytemperatures','timeseries',1,'NaN',1);
 					md = checkfield(md,'fieldname','surfaceforcings.precipitation','timeseries',1,'NaN',1);
-				elseif(obj.isdelta18o==1) 
+				elseif(self.isdelta18o==1) 
 					md = checkfield(md,'fieldname','surfaceforcings.delta18o','NaN',1);
 					md = checkfield(md,'fieldname','surfaceforcings.delta18o_surface','NaN',1);
 					md = checkfield(md,'fieldname','surfaceforcings.temperatures_presentday','size',[md.mesh.numberofvertices+1 12],'NaN',1);
@@ -85,7 +85,7 @@
 					md = checkfield(md,'fieldname','surfaceforcings.precipitations_lgm','size',[md.mesh.numberofvertices+1 12],'NaN',1);                                       
 					md = checkfield(md,'fieldname','surfaceforcings.Tdiff','NaN',1);
 					md = checkfield(md,'fieldname','surfaceforcings.sealev','NaN',1);
-				elseif(obj.ismungsm==1) 
+				elseif(self.ismungsm==1) 
 					md = checkfield(md,'fieldname','surfaceforcings.temperatures_presentday','size',[md.mesh.numberofvertices+1 12],'NaN',1);
 					md = checkfield(md,'fieldname','surfaceforcings.temperatures_lgm','size',[md.mesh.numberofvertices+1 12],'NaN',1);
 					md = checkfield(md,'fieldname','surfaceforcings.precipitations_presentday','size',[md.mesh.numberofvertices+1 12],'NaN',1);
@@ -96,74 +96,74 @@
 				end
 			end
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   surface forcings parameters:'));
 
 			disp(sprintf('\n   PDD and deltaO18 parameters:'));
-			fielddisplay(obj,'isdelta18o','is temperature and precipitation delta18o parametrisation activated (0 or 1, default is 0)');
-			fielddisplay(obj,'ismungsm','is temperature and precipitation mungsm parametrisation activated (0 or 1, default is 0)');
-			fielddisplay(obj,'desfac','desertification elevation factor (between 0 and 1, default is 0.5) [m]');
-			fielddisplay(obj,'s0p','should be set to elevation from precip source (between 0 and a few 1000s m, default is 0) [m]');
-			fielddisplay(obj,'s0t','should be set to elevation from temperature source (between 0 and a few 1000s m, default is 0) [m]');
-			fielddisplay(obj,'rlaps','present day lapse rate [degree/km]');
-			fielddisplay(obj,'rlapslgm','LGM lapse rate [degree/km]');
-                        if(obj.isdelta18o==0 & obj.ismungsm==0)
-                            fielddisplay(obj,'monthlytemperatures',['monthly surface temperatures [K], required if pdd is activated and delta18o not activated']);
-                            fielddisplay(obj,'precipitation',['monthly surface precipitation [m/yr water eq], required if pdd is activated and delta18o or mungsm not activated']);
-                        elseif(obj.isdelta18o==1)
-                            fielddisplay(obj,'delta18o','delta18o, required if pdd is activated and delta18o activated');
-                            fielddisplay(obj,'delta18o_surface','surface elevation of the delta18o site, required if pdd is activated and delta18o activated');
-                            fielddisplay(obj,'temperatures_presentday','monthly present day surface temperatures [K], required if delta18o/mungsm is activated');
-                            fielddisplay(obj,'temperatures_lgm','monthly LGM surface temperatures [K], required if delta18o or mungsm is activated');
-                            fielddisplay(obj,'precipitations_presentday','monthly surface precipitation [m/yr water eq], required if delta18o or mungsm is activated');
-                            fielddisplay(obj,'precipitations_lgm','monthly surface precipitation [m/yr water eq], required if delta18o or mungsm is activated');
-                            fielddisplay(obj,'Tdiff','time interpolation parameter for temperature, 1D(year), required if mungsm is activated');
-                            fielddisplay(obj,'sealev','sea level [m], 1D(year), required if mungsm is activated');
-                        elseif(obj.ismungsm==1)
-                            fielddisplay(obj,'temperatures_presentday','monthly present day surface temperatures [K], required if delta18o/mungsm is activated');
-                            fielddisplay(obj,'temperatures_lgm','monthly LGM surface temperatures [K], required if delta18o or mungsm is activated');
-                            fielddisplay(obj,'precipitations_presentday','monthly surface precipitation [m/yr water eq], required if delta18o or mungsm is activated');
-                            fielddisplay(obj,'precipitations_lgm','monthly surface precipitation [m/yr water eq], required if delta18o or mungsm is activated');
-                            fielddisplay(obj,'Pfac','time interpolation parameter for precipitation, 1D(year), required if mungsm is activated');
-                            fielddisplay(obj,'Tdiff','time interpolation parameter for temperature, 1D(year), required if mungsm is activated');
-                            fielddisplay(obj,'sealev','sea level [m], 1D(year), required if mungsm is activated');
+			fielddisplay(self,'isdelta18o','is temperature and precipitation delta18o parametrisation activated (0 or 1, default is 0)');
+			fielddisplay(self,'ismungsm','is temperature and precipitation mungsm parametrisation activated (0 or 1, default is 0)');
+			fielddisplay(self,'desfac','desertification elevation factor (between 0 and 1, default is 0.5) [m]');
+			fielddisplay(self,'s0p','should be set to elevation from precip source (between 0 and a few 1000s m, default is 0) [m]');
+			fielddisplay(self,'s0t','should be set to elevation from temperature source (between 0 and a few 1000s m, default is 0) [m]');
+			fielddisplay(self,'rlaps','present day lapse rate [degree/km]');
+			fielddisplay(self,'rlapslgm','LGM lapse rate [degree/km]');
+                        if(self.isdelta18o==0 & self.ismungsm==0)
+                            fielddisplay(self,'monthlytemperatures',['monthly surface temperatures [K], required if pdd is activated and delta18o not activated']);
+                            fielddisplay(self,'precipitation',['monthly surface precipitation [m/yr water eq], required if pdd is activated and delta18o or mungsm not activated']);
+                        elseif(self.isdelta18o==1)
+                            fielddisplay(self,'delta18o','delta18o, required if pdd is activated and delta18o activated');
+                            fielddisplay(self,'delta18o_surface','surface elevation of the delta18o site, required if pdd is activated and delta18o activated');
+                            fielddisplay(self,'temperatures_presentday','monthly present day surface temperatures [K], required if delta18o/mungsm is activated');
+                            fielddisplay(self,'temperatures_lgm','monthly LGM surface temperatures [K], required if delta18o or mungsm is activated');
+                            fielddisplay(self,'precipitations_presentday','monthly surface precipitation [m/yr water eq], required if delta18o or mungsm is activated');
+                            fielddisplay(self,'precipitations_lgm','monthly surface precipitation [m/yr water eq], required if delta18o or mungsm is activated');
+                            fielddisplay(self,'Tdiff','time interpolation parameter for temperature, 1D(year), required if mungsm is activated');
+                            fielddisplay(self,'sealev','sea level [m], 1D(year), required if mungsm is activated');
+                        elseif(self.ismungsm==1)
+                            fielddisplay(self,'temperatures_presentday','monthly present day surface temperatures [K], required if delta18o/mungsm is activated');
+                            fielddisplay(self,'temperatures_lgm','monthly LGM surface temperatures [K], required if delta18o or mungsm is activated');
+                            fielddisplay(self,'precipitations_presentday','monthly surface precipitation [m/yr water eq], required if delta18o or mungsm is activated');
+                            fielddisplay(self,'precipitations_lgm','monthly surface precipitation [m/yr water eq], required if delta18o or mungsm is activated');
+                            fielddisplay(self,'Pfac','time interpolation parameter for precipitation, 1D(year), required if mungsm is activated');
+                            fielddisplay(self,'Tdiff','time interpolation parameter for temperature, 1D(year), required if mungsm is activated');
+                            fielddisplay(self,'sealev','sea level [m], 1D(year), required if mungsm is activated');
                         end
 		end % }}}
-		function marshall(obj,md,fid) % {{{
+		function marshall(self,md,fid) % {{{
 
 			yts=365.0*24.0*3600.0;
 
 			WriteData(fid,'enum',SurfaceforcingsEnum(),'data',SMBpddEnum(),'format','Integer');
 
-			WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','isdelta18o','format','Boolean');
-			WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','ismungsm','format','Boolean');
-			WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','desfac','format','Double');
-			WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','s0p','format','Double');
-			WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','s0t','format','Double');
-			WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','rlaps','format','Double');
-			WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','rlapslgm','format','Double');
+			WriteData(fid,'object',self,'class','surfaceforcings','fieldname','isdelta18o','format','Boolean');
+			WriteData(fid,'object',self,'class','surfaceforcings','fieldname','ismungsm','format','Boolean');
+			WriteData(fid,'object',self,'class','surfaceforcings','fieldname','desfac','format','Double');
+			WriteData(fid,'object',self,'class','surfaceforcings','fieldname','s0p','format','Double');
+			WriteData(fid,'object',self,'class','surfaceforcings','fieldname','s0t','format','Double');
+			WriteData(fid,'object',self,'class','surfaceforcings','fieldname','rlaps','format','Double');
+			WriteData(fid,'object',self,'class','surfaceforcings','fieldname','rlapslgm','format','Double');
 
-			if(obj.isdelta18o==0 & obj.ismungsm==0)
-				%WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','monthlytemperatures','format','DoubleMat','mattype',1);
-				WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','monthlytemperatures','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
-				WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','precipitation','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
-			elseif obj.isdelta18o
-				WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','temperatures_presentday','format','DoubleMat','mattype',1);
-				WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','temperatures_lgm','format','DoubleMat','mattype',1);
-				WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','precipitations_presentday','format','DoubleMat','mattype',1);
-				WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','precipitations_lgm','format','DoubleMat','mattype',1);
-				WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','delta18o_surface','format','DoubleMat','mattype',1);
-				WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','delta18o','format','DoubleMat','mattype',1);
-				WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','Tdiff','format','DoubleMat','mattype',1);
-				WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','sealev','format','DoubleMat','mattype',1);
-			elseif obj.ismungsm
-				WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','temperatures_presentday','format','DoubleMat','mattype',1);
-				WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','temperatures_lgm','format','DoubleMat','mattype',1);
-				WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','precipitations_presentday','format','DoubleMat','mattype',1);
-				WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','precipitations_lgm','format','DoubleMat','mattype',1);
-				WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','Pfac','format','DoubleMat','mattype',1);
-				WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','Tdiff','format','DoubleMat','mattype',1);
-				WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','sealev','format','DoubleMat','mattype',1);
+			if(self.isdelta18o==0 & self.ismungsm==0)
+				%WriteData(fid,'object',self,'class','surfaceforcings','fieldname','monthlytemperatures','format','DoubleMat','mattype',1);
+				WriteData(fid,'object',self,'class','surfaceforcings','fieldname','monthlytemperatures','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
+				WriteData(fid,'object',self,'class','surfaceforcings','fieldname','precipitation','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
+			elseif self.isdelta18o
+				WriteData(fid,'object',self,'class','surfaceforcings','fieldname','temperatures_presentday','format','DoubleMat','mattype',1);
+				WriteData(fid,'object',self,'class','surfaceforcings','fieldname','temperatures_lgm','format','DoubleMat','mattype',1);
+				WriteData(fid,'object',self,'class','surfaceforcings','fieldname','precipitations_presentday','format','DoubleMat','mattype',1);
+				WriteData(fid,'object',self,'class','surfaceforcings','fieldname','precipitations_lgm','format','DoubleMat','mattype',1);
+				WriteData(fid,'object',self,'class','surfaceforcings','fieldname','delta18o_surface','format','DoubleMat','mattype',1);
+				WriteData(fid,'object',self,'class','surfaceforcings','fieldname','delta18o','format','DoubleMat','mattype',1);
+				WriteData(fid,'object',self,'class','surfaceforcings','fieldname','Tdiff','format','DoubleMat','mattype',1);
+				WriteData(fid,'object',self,'class','surfaceforcings','fieldname','sealev','format','DoubleMat','mattype',1);
+			elseif self.ismungsm
+				WriteData(fid,'object',self,'class','surfaceforcings','fieldname','temperatures_presentday','format','DoubleMat','mattype',1);
+				WriteData(fid,'object',self,'class','surfaceforcings','fieldname','temperatures_lgm','format','DoubleMat','mattype',1);
+				WriteData(fid,'object',self,'class','surfaceforcings','fieldname','precipitations_presentday','format','DoubleMat','mattype',1);
+				WriteData(fid,'object',self,'class','surfaceforcings','fieldname','precipitations_lgm','format','DoubleMat','mattype',1);
+				WriteData(fid,'object',self,'class','surfaceforcings','fieldname','Pfac','format','DoubleMat','mattype',1);
+				WriteData(fid,'object',self,'class','surfaceforcings','fieldname','Tdiff','format','DoubleMat','mattype',1);
+				WriteData(fid,'object',self,'class','surfaceforcings','fieldname','sealev','format','DoubleMat','mattype',1);
 			end
 		end % }}}
 	end
Index: ../trunk-jpl/src/m/classes/inversion.m
===================================================================
--- ../trunk-jpl/src/m/classes/inversion.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/inversion.m	(revision 19040)
@@ -25,36 +25,36 @@
 		surface_obs                 = NaN
 	end
 	methods
-		function createxml(obj,fid) % {{{
+		function createxml(self,fid) % {{{
 			fprintf(fid, '<!-- inversion -->\n');            
 
 			% inversion parameters
 			fprintf(fid,'%s\n%s\n%s\n','<frame key="1" label="inversion parameters">','<section name="inversion" />');                    
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="iscontrol" type="',class(obj.iscontrol),'" default="',convert2str(obj.iscontrol),'">','     <section name="inversion" />','     <help> is inversion activated? </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="iscontrol" type="',class(self.iscontrol),'" default="',convert2str(self.iscontrol),'">','     <section name="inversion" />','     <help> is inversion activated? </help>','  </parameter>');
 
 			% incompleteadjoing drop-down (0 or 1)
 			fprintf(fid,'%s\n%s\n%s\n%s\n','  <parameter key ="incomplete_adjoint" type="alternative" optional="false">','     <section name="inversion" />','     <help> 1: linear viscosity, 0: non-linear viscosity </help>');
 			fprintf(fid,'%s\n','       <option value="0" type="string" default="true"> </option>');
 			fprintf(fid,'%s\n%s\n','       <option value="1" type="string" default="false"> </option>','</parameter>');
 
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="control_parameters" type="',class(obj.control_parameters),'" default="',convert2str(obj.control_parameters),'">','     <section name="inversion" />','     <help> ex: {''FrictionCoefficient''}, or {''MaterialsRheologyBbar''} </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="control_parameters" type="',class(self.control_parameters),'" default="',convert2str(self.control_parameters),'">','     <section name="inversion" />','     <help> ex: {''FrictionCoefficient''}, or {''MaterialsRheologyBbar''} </help>','  </parameter>');
 
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="nsteps" type="',class(obj.nsteps),'" default="',convert2str(obj.nsteps),'">','     <section name="inversion" />','     <help> number of optimization searches </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="cost_functions" type="',class(obj.cost_functions),'" default="',convert2str(obj.cost_functions),'">','     <section name="inversion" />','     <help> indicate the type of response for each optimization step  </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="cost_functions_coefficients" type="',class(obj.cost_functions_coefficients),'" default="',convert2str(obj.cost_functions_coefficients),'">','     <section name="inversion" />','     <help> cost_functions_coefficients applied to the misfit of each vertex and for each control_parameter </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="nsteps" type="',class(self.nsteps),'" default="',convert2str(self.nsteps),'">','     <section name="inversion" />','     <help> number of optimization searches </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="cost_functions" type="',class(self.cost_functions),'" default="',convert2str(self.cost_functions),'">','     <section name="inversion" />','     <help> indicate the type of response for each optimization step  </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="cost_functions_coefficients" type="',class(self.cost_functions_coefficients),'" default="',convert2str(self.cost_functions_coefficients),'">','     <section name="inversion" />','     <help> cost_functions_coefficients applied to the misfit of each vertex and for each control_parameter </help>','  </parameter>');
 
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="cost_function_threshold" type="',class(obj.cost_function_threshold),'" default="',convert2str(obj.cost_function_threshold),'">','     <section name="inversion" />','     <help> misfit convergence criterion. Default is 1%, NaN if not applied </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="maxiter_per_step" type="',class(obj.maxiter_per_step),'" default="',convert2str(obj.maxiter_per_step),'">','     <section name="inversion" />','     <help> maximum iterations during each optimization step  </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="gradient_scaling" type="',class(obj.gradient_scaling),'" default="',convert2str(obj.gradient_scaling),'">','     <section name="inversion" />','     <help> scaling factor on gradient direction during optimization, for each optimization step </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="cost_function_threshold" type="',class(self.cost_function_threshold),'" default="',convert2str(self.cost_function_threshold),'">','     <section name="inversion" />','     <help> misfit convergence criterion. Default is 1%, NaN if not applied </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="maxiter_per_step" type="',class(self.maxiter_per_step),'" default="',convert2str(self.maxiter_per_step),'">','     <section name="inversion" />','     <help> maximum iterations during each optimization step  </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="gradient_scaling" type="',class(self.gradient_scaling),'" default="',convert2str(self.gradient_scaling),'">','     <section name="inversion" />','     <help> scaling factor on gradient direction during optimization, for each optimization step </help>','  </parameter>');
 
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="step_threshold" type="',class(obj.step_threshold),'" default="',convert2str(obj.step_threshold),'">','     <section name="inversion" />','     <help> decrease threshold for misfit, default is 30% </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="min_parameters" type="',class(obj.min_parameters),'" default="',convert2str(obj.min_parameters),'">','     <section name="inversion" />','     <help> absolute minimum acceptable value of the inversed parameter on each vertex </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="max_parameters" type="',class(obj.max_parameters),'" default="',convert2str(obj.max_parameters),'">','     <section name="inversion" />','     <help> absolute maximum acceptable value of the inversed parameter on each vertex </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="step_threshold" type="',class(self.step_threshold),'" default="',convert2str(self.step_threshold),'">','     <section name="inversion" />','     <help> decrease threshold for misfit, default is 30% </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="min_parameters" type="',class(self.min_parameters),'" default="',convert2str(self.min_parameters),'">','     <section name="inversion" />','     <help> absolute minimum acceptable value of the inversed parameter on each vertex </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="max_parameters" type="',class(self.max_parameters),'" default="',convert2str(self.max_parameters),'">','     <section name="inversion" />','     <help> absolute maximum acceptable value of the inversed parameter on each vertex </help>','  </parameter>');
 
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="vx_obs" type="',class(obj.vx_obs),'" default="',convert2str(obj.vx_obs),'">','     <section name="inversion" />','     <help> observed velocity x component [m/yr] </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="vy_obs" type="',class(obj.vy_obs),'" default="',convert2str(obj.vy_obs),'">','     <section name="inversion" />','     <help> observed velocity y component [m/yr]  </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="vel_obs" type="',class(obj.vel_obs),'" default="',convert2str(obj.vel_obs),'">','     <section name="inversion" />','     <help> observed velocity magnitude [m/yr] </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="thickness_obs" type="',class(obj.thickness_obs),'" default="',convert2str(obj.thickness_obs),'">','     <section name="inversion" />','     <help> observed thickness [m]) </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="vx_obs" type="',class(self.vx_obs),'" default="',convert2str(self.vx_obs),'">','     <section name="inversion" />','     <help> observed velocity x component [m/yr] </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="vy_obs" type="',class(self.vy_obs),'" default="',convert2str(self.vy_obs),'">','     <section name="inversion" />','     <help> observed velocity y component [m/yr]  </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="vel_obs" type="',class(self.vel_obs),'" default="',convert2str(self.vel_obs),'">','     <section name="inversion" />','     <help> observed velocity magnitude [m/yr] </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="thickness_obs" type="',class(self.thickness_obs),'" default="',convert2str(self.thickness_obs),'">','     <section name="inversion" />','     <help> observed thickness [m]) </help>','  </parameter>');
 
 			fprintf(fid,'%s\n%s\n','</frame>');    
 
@@ -74,57 +74,57 @@
 			fprintf(fid,'%s\n%s\n','</frame>');    
 
 		end % }}}       
-		function obj = inversion(varargin) % {{{
+		function self = inversion(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				case 1
-					obj=structtoobj(inversion(),varargin{1});
+					self =structtoobj(inversion(),varargin{1});
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 			%default is incomplete adjoint for now
-			obj.incomplete_adjoint=1;
+			self.incomplete_adjoint=1;
 
 			%parameter to be inferred by control methods (only
 			%drag and B are supported yet)
-			obj.control_parameters={'FrictionCoefficient'};
+			self.control_parameters={'FrictionCoefficient'};
 
 			%number of steps in the control methods
-			obj.nsteps=20;
+			self.nsteps=20;
 
 			%maximum number of iteration in the optimization algorithm for
 			%each step
-			obj.maxiter_per_step=20*ones(obj.nsteps,1);
+			self.maxiter_per_step=20*ones(self.nsteps,1);
 
 			%the inversed parameter is updated as follows:
 			%new_par=old_par + gradient_scaling(n)*C*gradient with C in [0 1];
 			%usually the gradient_scaling must be of the order of magnitude of the 
 			%inversed parameter (10^8 for B, 50 for drag) and can be decreased
 			%after the first iterations
-			obj.gradient_scaling=50*ones(obj.nsteps,1);
+			self.gradient_scaling=50*ones(self.nsteps,1);
 
 			%several responses can be used:
-			obj.cost_functions=101;
+			self.cost_functions=101;
 
 			%step_threshold is used to speed up control method. When
-			%misfit(1)/misfit(0) < obj.step_threshold, we go directly to
+			%misfit(1)/misfit(0) < self.step_threshold, we go directly to
 			%the next step
-			obj.step_threshold=.7*ones(obj.nsteps,1); %30 per cent decrement.
+			self.step_threshold=.7*ones(self.nsteps,1); %30 per cent decrement.
 
 			%cost_function_threshold is a criteria to stop the control methods.
 			%if J[n]-J[n-1]/J[n] < criteria, the control run stops
 			%NaN if not applied
-			obj.cost_function_threshold=NaN; %not activated
+			self.cost_function_threshold=NaN; %not activated
 
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 			%Early return
-			if ~obj.iscontrol, return; end
+			if ~self.iscontrol, return; end
 
 			num_controls=numel(md.inversion.control_parameters);
 			num_costfunc=size(md.inversion.cost_functions,2);
@@ -157,25 +157,25 @@
 				md = checkfield(md,'fieldname','inversion.vy_obs','size',[md.mesh.numberofvertices 1],'NaN',1);
 			end
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   inversion parameters:'));
-			fielddisplay(obj,'iscontrol','is inversion activated?');
-			fielddisplay(obj,'incomplete_adjoint','1: linear viscosity, 0: non-linear viscosity');
-			fielddisplay(obj,'control_parameters','ex: {''FrictionCoefficient''}, or {''MaterialsRheologyBbar''}');
-			fielddisplay(obj,'nsteps','number of optimization searches');
-			fielddisplay(obj,'cost_functions','indicate the type of response for each optimization step');
-			fielddisplay(obj,'cost_functions_coefficients','cost_functions_coefficients applied to the misfit of each vertex and for each control_parameter');
-			fielddisplay(obj,'cost_function_threshold','misfit convergence criterion. Default is 1%, NaN if not applied');
-			fielddisplay(obj,'maxiter_per_step','maximum iterations during each optimization step');
-			fielddisplay(obj,'gradient_scaling','scaling factor on gradient direction during optimization, for each optimization step');
-			fielddisplay(obj,'step_threshold','decrease threshold for misfit, default is 30%');
-			fielddisplay(obj,'min_parameters','absolute minimum acceptable value of the inversed parameter on each vertex');
-			fielddisplay(obj,'max_parameters','absolute maximum acceptable value of the inversed parameter on each vertex');
-			fielddisplay(obj,'vx_obs','observed velocity x component [m/yr]');
-			fielddisplay(obj,'vy_obs','observed velocity y component [m/yr]');
-			fielddisplay(obj,'vel_obs','observed velocity magnitude [m/yr]');
-			fielddisplay(obj,'thickness_obs','observed thickness [m]');
-			fielddisplay(obj,'surface_obs','observed surface elevation [m]');
+			fielddisplay(self,'iscontrol','is inversion activated?');
+			fielddisplay(self,'incomplete_adjoint','1: linear viscosity, 0: non-linear viscosity');
+			fielddisplay(self,'control_parameters','ex: {''FrictionCoefficient''}, or {''MaterialsRheologyBbar''}');
+			fielddisplay(self,'nsteps','number of optimization searches');
+			fielddisplay(self,'cost_functions','indicate the type of response for each optimization step');
+			fielddisplay(self,'cost_functions_coefficients','cost_functions_coefficients applied to the misfit of each vertex and for each control_parameter');
+			fielddisplay(self,'cost_function_threshold','misfit convergence criterion. Default is 1%, NaN if not applied');
+			fielddisplay(self,'maxiter_per_step','maximum iterations during each optimization step');
+			fielddisplay(self,'gradient_scaling','scaling factor on gradient direction during optimization, for each optimization step');
+			fielddisplay(self,'step_threshold','decrease threshold for misfit, default is 30%');
+			fielddisplay(self,'min_parameters','absolute minimum acceptable value of the inversed parameter on each vertex');
+			fielddisplay(self,'max_parameters','absolute maximum acceptable value of the inversed parameter on each vertex');
+			fielddisplay(self,'vx_obs','observed velocity x component [m/yr]');
+			fielddisplay(self,'vy_obs','observed velocity y component [m/yr]');
+			fielddisplay(self,'vel_obs','observed velocity magnitude [m/yr]');
+			fielddisplay(self,'thickness_obs','observed thickness [m]');
+			fielddisplay(self,'surface_obs','observed surface elevation [m]');
 			disp('Available cost functions:');
 			disp('   101: SurfaceAbsVelMisfit');
 			disp('   102: SurfaceRelVelMisfit');
@@ -187,46 +187,46 @@
 			disp('   502: RheologyBbarAbsGradient');
 			disp('   503: ThicknessAbsGradient');
 		end % }}}
-		function marshall(obj,md,fid) % {{{
+		function marshall(self,md,fid) % {{{
 
 			yts=365.0*24.0*3600.0;
 
 			WriteData(fid,'enum',InversionTypeEnum(),'data',0,'format','Integer');
-			WriteData(fid,'object',obj,'fieldname','iscontrol','format','Boolean');
-			WriteData(fid,'object',obj,'fieldname','incomplete_adjoint','format','Boolean');
-			if ~obj.iscontrol, return; end
-			WriteData(fid,'object',obj,'fieldname','nsteps','format','Integer');
-			WriteData(fid,'object',obj,'fieldname','maxiter_per_step','format','IntMat','mattype',3);
-			WriteData(fid,'object',obj,'fieldname','cost_functions_coefficients','format','DoubleMat','mattype',1);
-			WriteData(fid,'object',obj,'fieldname','gradient_scaling','format','DoubleMat','mattype',3);
-			WriteData(fid,'object',obj,'fieldname','cost_function_threshold','format','Double');
-			WriteData(fid,'object',obj,'fieldname','min_parameters','format','DoubleMat','mattype',3);
-			WriteData(fid,'object',obj,'fieldname','max_parameters','format','DoubleMat','mattype',3);
-			WriteData(fid,'object',obj,'fieldname','step_threshold','format','DoubleMat','mattype',3);
-			WriteData(fid,'object',obj,'fieldname','vx_obs','format','DoubleMat','mattype',1,'scale',1./yts);
-			WriteData(fid,'object',obj,'fieldname','vy_obs','format','DoubleMat','mattype',1,'scale',1./yts);
-			WriteData(fid,'object',obj,'fieldname','vz_obs','format','DoubleMat','mattype',1,'scale',1./yts);
-			if(numel(obj.thickness_obs)==md.mesh.numberofelements),
+			WriteData(fid,'object',self,'fieldname','iscontrol','format','Boolean');
+			WriteData(fid,'object',self,'fieldname','incomplete_adjoint','format','Boolean');
+			if ~self.iscontrol, return; end
+			WriteData(fid,'object',self,'fieldname','nsteps','format','Integer');
+			WriteData(fid,'object',self,'fieldname','maxiter_per_step','format','IntMat','mattype',3);
+			WriteData(fid,'object',self,'fieldname','cost_functions_coefficients','format','DoubleMat','mattype',1);
+			WriteData(fid,'object',self,'fieldname','gradient_scaling','format','DoubleMat','mattype',3);
+			WriteData(fid,'object',self,'fieldname','cost_function_threshold','format','Double');
+			WriteData(fid,'object',self,'fieldname','min_parameters','format','DoubleMat','mattype',3);
+			WriteData(fid,'object',self,'fieldname','max_parameters','format','DoubleMat','mattype',3);
+			WriteData(fid,'object',self,'fieldname','step_threshold','format','DoubleMat','mattype',3);
+			WriteData(fid,'object',self,'fieldname','vx_obs','format','DoubleMat','mattype',1,'scale',1./yts);
+			WriteData(fid,'object',self,'fieldname','vy_obs','format','DoubleMat','mattype',1,'scale',1./yts);
+			WriteData(fid,'object',self,'fieldname','vz_obs','format','DoubleMat','mattype',1,'scale',1./yts);
+			if(numel(self.thickness_obs)==md.mesh.numberofelements),
 				mattype=2;
 			else
 				mattype=1;
 			end
-			WriteData(fid,'object',obj,'class','inversion','fieldname','thickness_obs','format','DoubleMat','mattype',mattype);
-			WriteData(fid,'object',obj,'class','inversion','fieldname','surface_obs','format','DoubleMat','mattype',mattype);
+			WriteData(fid,'object',self,'class','inversion','fieldname','thickness_obs','format','DoubleMat','mattype',mattype);
+			WriteData(fid,'object',self,'class','inversion','fieldname','surface_obs','format','DoubleMat','mattype',mattype);
 
 
 			%process control parameters
-			num_control_parameters=numel(obj.control_parameters);
+			num_control_parameters=numel(self.control_parameters);
 			data=zeros(1,num_control_parameters);
 			for i=1:num_control_parameters,
-				data(i)=StringToEnum(obj.control_parameters{i});
+				data(i)=StringToEnum(self.control_parameters{i});
 			end
 			WriteData(fid,'data',data,'enum',InversionControlParametersEnum(),'format','DoubleMat','mattype',3);
 			WriteData(fid,'data',num_control_parameters,'enum',InversionNumControlParametersEnum(),'format','Integer');
 
 			%process cost functions
-			num_cost_functions=size(obj.cost_functions,2);
-			data=marshallcostfunctions(obj.cost_functions);
+			num_cost_functions=size(self.cost_functions,2);
+			data=marshallcostfunctions(self.cost_functions);
 			WriteData(fid,'data',data,'enum',InversionCostFunctionsEnum(),'format','DoubleMat','mattype',3);
 			WriteData(fid,'data',num_cost_functions,'enum',InversionNumCostFunctionsEnum(),'format','Integer');
 		end % }}}
Index: ../trunk-jpl/src/m/classes/mesh3dprisms.m
===================================================================
--- ../trunk-jpl/src/m/classes/mesh3dprisms.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/mesh3dprisms.m	(revision 19040)
@@ -61,56 +61,56 @@
 		end% }}}
 	end
 	methods
-		function createxml(obj,fid) % {{{
+		function createxml(self,fid) % {{{
 			fprintf(fid, '<!-- 3D prism Mesh -->\n');
 
 			% Elements and verticies of the original 2d mesh
 			fprintf(fid,'%s\n%s\n%s\n','       <frame key="1" label="Elements and vertices of the orginal 2d mesh">','       <section name="mesh3dprisms" />');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','          <parameter key ="numberofelements2d" type="',class(obj.numberofelements2d),'" default="',convert2str(obj.numberofelements2d),'">','              <help> number of elements </help>','          </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','          <parameter key ="numberofvertices2d" type="',class(obj.numberofvertices2d),'" default="',convert2str(obj.numberofvertices2d),'">','              <help> number of vertices </help>','          </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','          <parameter key ="elements2d" type="',class(obj.elements2d),'" default="',convert2str(obj.elements2d),'">','              <help> vertex indices of the mesh elements </help>','          </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="x2d" type="',class(obj.x2d),'" default="',convert2str(obj.x2d),'">','     <section name="mesh3dprisms" />','     <help> vertices x coordinate [m] </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="y2d" type="',class(obj.y2d),'" default="',convert2str(obj.y2d),'">','     <section name="mesh3dprisms" />','     <help> vertices y coordinate [m] </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','          <parameter key ="numberofelements2d" type="',class(self.numberofelements2d),'" default="',convert2str(self.numberofelements2d),'">','              <help> number of elements </help>','          </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','          <parameter key ="numberofvertices2d" type="',class(self.numberofvertices2d),'" default="',convert2str(self.numberofvertices2d),'">','              <help> number of vertices </help>','          </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','          <parameter key ="elements2d" type="',class(self.elements2d),'" default="',convert2str(self.elements2d),'">','              <help> vertex indices of the mesh elements </help>','          </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="x2d" type="',class(self.x2d),'" default="',convert2str(self.x2d),'">','     <section name="mesh3dprisms" />','     <help> vertices x coordinate [m] </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="y2d" type="',class(self.y2d),'" default="',convert2str(self.y2d),'">','     <section name="mesh3dprisms" />','     <help> vertices y coordinate [m] </help>','  </parameter>');
 			fprintf(fid,'%s\n%s\n','       </frame>');
 
 			% Elements and vertices of the extruded 3d mesh
 			fprintf(fid,'%s\n%s\n%s\n','       <frame key="2" label="Elements and vertices of the orginal 3d mesh">','       <section name="mesh3dprisms" />');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','          <parameter key ="numberofelements" type="',class(obj.numberofelements),'" default="',convert2str(obj.numberofelements),'">','              <help> number of elements </help>','          </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','          <parameter key ="numberofvertices" type="',class(obj.numberofvertices),'" default="',convert2str(obj.numberofvertices),'">','              <help> number of vertices </help>','          </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','          <parameter key ="elements" type="',class(obj.elements),'" default="',convert2str(obj.elements),'">','              <help> vertex indices of the mesh elements </help>','          </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="x" type="',class(obj.x),'" default="',convert2str(obj.x),'">','     <section name="mesh3dprisms" />','     <help> vertices x coordinate [m] </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="y" type="',class(obj.y),'" default="',convert2str(obj.y),'">','     <section name="mesh3dprisms" />','     <help> vertices y coordinate [m] </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="z" type="',class(obj.y),'" default="',convert2str(obj.y),'">','     <section name="mesh3dprisms" />','     <help> vertices z coordinate [m] </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','          <parameter key ="numberofelements" type="',class(self.numberofelements),'" default="',convert2str(self.numberofelements),'">','              <help> number of elements </help>','          </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','          <parameter key ="numberofvertices" type="',class(self.numberofvertices),'" default="',convert2str(self.numberofvertices),'">','              <help> number of vertices </help>','          </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','          <parameter key ="elements" type="',class(self.elements),'" default="',convert2str(self.elements),'">','              <help> vertex indices of the mesh elements </help>','          </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="x" type="',class(self.x),'" default="',convert2str(self.x),'">','     <section name="mesh3dprisms" />','     <help> vertices x coordinate [m] </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="y" type="',class(self.y),'" default="',convert2str(self.y),'">','     <section name="mesh3dprisms" />','     <help> vertices y coordinate [m] </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="z" type="',class(self.y),'" default="',convert2str(self.y),'">','     <section name="mesh3dprisms" />','     <help> vertices z coordinate [m] </help>','  </parameter>');
 			fprintf(fid,'%s\n%s\n','       </frame>');
 
 			% properties
 			fprintf(fid,'%s\n%s\n%s\n','<frame key="3" label="Properties">','<section name="mesh3dprisms" />');             
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="numberoflayers" type="',class(obj.numberoflayers),'" default="',convert2str(obj.numberoflayers),'">','     <section name="mesh3dprisms" />','     <help> number of extrusion layers </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="vertexonbase" type="',class(obj.vertexonbase),'" default="',convert2str(obj.vertexonbase),'">','     <section name="mesh3dprisms" />','     <help> lower vertices flags list </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="elementontbase" type="',class(obj.elementontbase),'" default="',convert2str(obj.elementontbase),'">','     <section name="mesh3dprisms" />','     <help> lower elements flags list </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="vertexonsurface" type="',class(obj.vertexonsurface),'" default="',convert2str(obj.vertexonsurface),'">','     <section name="mesh3dprisms" />','     <help> upper vertices flags list </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="elementontsurface" type="',class(obj.elementontsurface),'" default="',convert2str(obj.elementontsurface),'">','     <section name="mesh3dprisms" />','     <help> upper elements flags list </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="uppervertex" type="',class(obj.uppervertex),'" default="',convert2str(obj.uppervertex),'">','     <section name="mesh3dprisms" />','     <help> upper vertex list (NaN for vertex on the upper surface) </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="upperelements" type="',class(obj.upperelements),'" default="',convert2str(obj.upperelements),'">','     <section name="mesh3dprisms" />','     <help> upper element list (NaN for element on the upper layer) </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="lowervertex" type="',class(obj.lowervertex),'" default="',convert2str(obj.lowervertex),'">','     <section name="mesh3dprisms" />','     <help> lower vertex list (NaN for vertex on the lower surface) </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="lowerelements" type="',class(obj.lowerelements),'" default="',convert2str(obj.lowerelements),'">','     <section name="mesh3dprisms" />','     <help> element list (NaN for element on the lower layer) </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="vertexonboundary" type="',class(obj.vertexonboundary),'" default="',convert2str(obj.vertexonboundary),'">','     <section name="mesh3dprisms" />','     <help> vertices on the boundary of the domain flag list </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="vertexconnectivity" type="',class(obj.vertexconnectivity),'" default="',convert2str(obj.vertexconnectivity),'">','     <section name="mesh3dprisms" />','     <help> list of vertices connected to vertex_i </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="elementconnectivity" type="',class(obj.elementconnectivity),'" default="',convert2str(obj.elementconnectivity),'">','     <section name="mesh3dprisms" />','     <help> average number of vertices connected to one vertex </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="average_vertex_connectivity" type="',class(obj.average_vertex_connectivity),'" default="',convert2str(obj.average_vertex_connectivity),'">','     <section name="mesh3dprisms" />','     <help> average number of vertices connected to one vertex </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="numberoflayers" type="',class(self.numberoflayers),'" default="',convert2str(self.numberoflayers),'">','     <section name="mesh3dprisms" />','     <help> number of extrusion layers </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="vertexonbase" type="',class(self.vertexonbase),'" default="',convert2str(self.vertexonbase),'">','     <section name="mesh3dprisms" />','     <help> lower vertices flags list </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="elementontbase" type="',class(self.elementontbase),'" default="',convert2str(self.elementontbase),'">','     <section name="mesh3dprisms" />','     <help> lower elements flags list </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="vertexonsurface" type="',class(self.vertexonsurface),'" default="',convert2str(self.vertexonsurface),'">','     <section name="mesh3dprisms" />','     <help> upper vertices flags list </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="elementontsurface" type="',class(self.elementontsurface),'" default="',convert2str(self.elementontsurface),'">','     <section name="mesh3dprisms" />','     <help> upper elements flags list </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="uppervertex" type="',class(self.uppervertex),'" default="',convert2str(self.uppervertex),'">','     <section name="mesh3dprisms" />','     <help> upper vertex list (NaN for vertex on the upper surface) </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="upperelements" type="',class(self.upperelements),'" default="',convert2str(self.upperelements),'">','     <section name="mesh3dprisms" />','     <help> upper element list (NaN for element on the upper layer) </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="lowervertex" type="',class(self.lowervertex),'" default="',convert2str(self.lowervertex),'">','     <section name="mesh3dprisms" />','     <help> lower vertex list (NaN for vertex on the lower surface) </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="lowerelements" type="',class(self.lowerelements),'" default="',convert2str(self.lowerelements),'">','     <section name="mesh3dprisms" />','     <help> element list (NaN for element on the lower layer) </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="vertexonboundary" type="',class(self.vertexonboundary),'" default="',convert2str(self.vertexonboundary),'">','     <section name="mesh3dprisms" />','     <help> vertices on the boundary of the domain flag list </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="vertexconnectivity" type="',class(self.vertexconnectivity),'" default="',convert2str(self.vertexconnectivity),'">','     <section name="mesh3dprisms" />','     <help> list of vertices connected to vertex_i </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="elementconnectivity" type="',class(self.elementconnectivity),'" default="',convert2str(self.elementconnectivity),'">','     <section name="mesh3dprisms" />','     <help> average number of vertices connected to one vertex </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="average_vertex_connectivity" type="',class(self.average_vertex_connectivity),'" default="',convert2str(self.average_vertex_connectivity),'">','     <section name="mesh3dprisms" />','     <help> average number of vertices connected to one vertex </help>','  </parameter>');
 			fprintf(fid,'%s\n%s\n','</frame>');
 
 			% Extracted model
 			fprintf(fid,'%s\n%s\n%s\n','<frame key="4" label="Extracted Model">','<section name="mesh3dprisms" />'); 
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="extractedvertices" type="',class(obj.extractedvertices),'" default="',convert2str(obj.extractedvertices),'">','     <section name="mesh3dprisms" />','     <help> vertices extracted from the model </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="extractedelements" type="',class(obj.extractedelements),'" default="',convert2str(obj.extractedelements),'">','     <section name="mesh3dprisms" />','     <help> elements extracted from the model </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="extractedvertices" type="',class(self.extractedvertices),'" default="',convert2str(self.extractedvertices),'">','     <section name="mesh3dprisms" />','     <help> vertices extracted from the model </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="extractedelements" type="',class(self.extractedelements),'" default="',convert2str(self.extractedelements),'">','     <section name="mesh3dprisms" />','     <help> elements extracted from the model </help>','  </parameter>');
 			fprintf(fid,'%s\n%s\n','</frame>');
 
 			% Projection
 			fprintf(fid,'%s\n%s\n%s\n','<frame key="5" label="Projection">','<section name="mesh3dprisms" />'); 
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="lat" type="',class(obj.lat),'" default="',convert2str(obj.lat),'">','     <section name="mesh3dprisms" />','     <help> vertices latitude [degrees] </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="long" type="',class(obj.long),'" default="',convert2str(obj.long),'">','     <section name="mesh3dprisms" />','     <help> verticies longitude [degrees] </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','  <parameter key ="epsg" type="',class(obj.epsg),'" default="',convert2str(obj.epsg),'">','     <section name="mesh3dprisms" />','     <help> Indicate epsg ''n'' or ''s'' </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="lat" type="',class(self.lat),'" default="',convert2str(self.lat),'">','     <section name="mesh3dprisms" />','     <help> vertices latitude [degrees] </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="long" type="',class(self.long),'" default="',convert2str(self.long),'">','     <section name="mesh3dprisms" />','     <help> verticies longitude [degrees] </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','  <parameter key ="epsg" type="',class(self.epsg),'" default="',convert2str(self.epsg),'">','     <section name="mesh3dprisms" />','     <help> Indicate epsg ''n'' or ''s'' </help>','  </parameter>');
 			fprintf(fid,'%s\n%s\n','</frame>');
 
 		end % }}}cd
@@ -132,16 +132,16 @@
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 			%the connectivity is the averaged number of nodes linked to a
 			%given node through an edge. This connectivity is used to initially
 			%allocate memory to the stiffness matrix. A value of 16 seems to
 			%give a good memory/time ration. This value can be checked in
 			%trunk/test/Miscellaneous/runme.m
-			obj.average_vertex_connectivity=25;
+			self.average_vertex_connectivity=25;
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 			md = checkfield(md,'fieldname','mesh.x','NaN',1,'size',[md.mesh.numberofvertices 1]);
 			md = checkfield(md,'fieldname','mesh.y','NaN',1,'size',[md.mesh.numberofvertices 1]);
@@ -160,74 +160,74 @@
 			md = checkfield(md,'fieldname','mesh.z','<=',md.geometry.surface+10^-10,'message','''mesh.z'' higher than surface elevation');
 			md = checkfield(md,'fieldname','mesh.average_vertex_connectivity','>=',24,'message','''mesh.average_vertex_connectivity'' should be at least 24 in 3d');
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   3D prism Mesh:')); 
 
 			disp(sprintf('\n      Elements and vertices of the original 2d mesh:'));
-			fielddisplay(obj,'numberofelements2d','number of elements');
-			fielddisplay(obj,'numberofvertices2d','number of vertices');
-			fielddisplay(obj,'elements2d','vertex indices of the mesh elements');
-			fielddisplay(obj,'x2d','vertices x coordinate [m]');
-			fielddisplay(obj,'y2d','vertices y coordinate [m]');
+			fielddisplay(self,'numberofelements2d','number of elements');
+			fielddisplay(self,'numberofvertices2d','number of vertices');
+			fielddisplay(self,'elements2d','vertex indices of the mesh elements');
+			fielddisplay(self,'x2d','vertices x coordinate [m]');
+			fielddisplay(self,'y2d','vertices y coordinate [m]');
 
 			disp(sprintf('\n      Elements and vertices of the extruded 3d mesh:'));
-			fielddisplay(obj,'numberofelements','number of elements');
-			fielddisplay(obj,'numberofvertices','number of vertices');
-			fielddisplay(obj,'elements','vertex indices of the mesh elements');
-			fielddisplay(obj,'x','vertices x coordinate [m]');
-			fielddisplay(obj,'y','vertices y coordinate [m]');
-			fielddisplay(obj,'z','vertices z coordinate [m]');
+			fielddisplay(self,'numberofelements','number of elements');
+			fielddisplay(self,'numberofvertices','number of vertices');
+			fielddisplay(self,'elements','vertex indices of the mesh elements');
+			fielddisplay(self,'x','vertices x coordinate [m]');
+			fielddisplay(self,'y','vertices y coordinate [m]');
+			fielddisplay(self,'z','vertices z coordinate [m]');
 
 			disp(sprintf('\n      Properties:'));
-			fielddisplay(obj,'numberoflayers','number of extrusion layers');
-			fielddisplay(obj,'vertexonbase','lower vertices flags list');
-			fielddisplay(obj,'vertexonsurface','upper vertices flags list');
-			fielddisplay(obj,'uppervertex','upper vertex list (NaN for vertex on the upper surface)');
-			fielddisplay(obj,'upperelements','upper element list (NaN for element on the upper layer)');
-			fielddisplay(obj,'lowervertex','lower vertex list (NaN for vertex on the lower surface)');
-			fielddisplay(obj,'lowerelements','lower element list (NaN for element on the lower layer');
-			fielddisplay(obj,'vertexonboundary','vertices on the boundary of the domain flag list');
+			fielddisplay(self,'numberoflayers','number of extrusion layers');
+			fielddisplay(self,'vertexonbase','lower vertices flags list');
+			fielddisplay(self,'vertexonsurface','upper vertices flags list');
+			fielddisplay(self,'uppervertex','upper vertex list (NaN for vertex on the upper surface)');
+			fielddisplay(self,'upperelements','upper element list (NaN for element on the upper layer)');
+			fielddisplay(self,'lowervertex','lower vertex list (NaN for vertex on the lower surface)');
+			fielddisplay(self,'lowerelements','lower element list (NaN for element on the lower layer');
+			fielddisplay(self,'vertexonboundary','vertices on the boundary of the domain flag list');
 
-			fielddisplay(obj,'vertexconnectivity','list of vertices connected to vertex_i');
-			fielddisplay(obj,'elementconnectivity','list of vertices connected to element_i');
-			fielddisplay(obj,'average_vertex_connectivity','average number of vertices connected to one vertex');
+			fielddisplay(self,'vertexconnectivity','list of vertices connected to vertex_i');
+			fielddisplay(self,'elementconnectivity','list of vertices connected to element_i');
+			fielddisplay(self,'average_vertex_connectivity','average number of vertices connected to one vertex');
 
 			disp(sprintf('\n      Extracted model:'));
-			fielddisplay(obj,'extractedvertices','vertices extracted from the model');
-			fielddisplay(obj,'extractedelements','elements extracted from the model');
+			fielddisplay(self,'extractedvertices','vertices extracted from the model');
+			fielddisplay(self,'extractedelements','elements extracted from the model');
 
 			disp(sprintf('\n      Projection:'));
-			fielddisplay(obj,'lat','vertices latitude [degrees]');
-			fielddisplay(obj,'long','vertices longitude [degrees]');
-			fielddisplay(obj,'epsg','EPSG code (ex: 3413 for UPS Greenland, 3031 for UPS Antarctica)');
+			fielddisplay(self,'lat','vertices latitude [degrees]');
+			fielddisplay(self,'long','vertices longitude [degrees]');
+			fielddisplay(self,'epsg','EPSG code (ex: 3413 for UPS Greenland, 3031 for UPS Antarctica)');
 		end % }}}
-		function marshall(obj,md,fid) % {{{
-			WriteData(fid,'enum',DomainTypeEnum(),'data',StringToEnum(['Domain' domaintype(obj)]),'format','Integer');
-			WriteData(fid,'enum',DomainDimensionEnum(),'data',dimension(obj),'format','Integer');
-			WriteData(fid,'enum',MeshElementtypeEnum(),'data',StringToEnum(elementtype(obj)),'format','Integer');
-			WriteData(fid,'object',obj,'class','mesh','fieldname','x','format','DoubleMat','mattype',1);
-			WriteData(fid,'object',obj,'class','mesh','fieldname','y','format','DoubleMat','mattype',1);
-			WriteData(fid,'object',obj,'class','mesh','fieldname','z','format','DoubleMat','mattype',1);
-			WriteData(fid,'object',obj,'class','mesh','fieldname','elements','format','DoubleMat','mattype',2);
-			WriteData(fid,'object',obj,'class','mesh','fieldname','numberoflayers','format','Integer');
-			WriteData(fid,'object',obj,'class','mesh','fieldname','numberofelements','format','Integer');
-			WriteData(fid,'object',obj,'class','mesh','fieldname','numberofvertices','format','Integer');
-			WriteData(fid,'object',obj,'class','mesh','fieldname','vertexonbase','format','BooleanMat','mattype',1);
-			WriteData(fid,'object',obj,'class','mesh','fieldname','vertexonsurface','format','BooleanMat','mattype',1);
-			WriteData(fid,'object',obj,'class','mesh','fieldname','lowerelements','format','DoubleMat','mattype',2);
-			WriteData(fid,'object',obj,'class','mesh','fieldname','upperelements','format','DoubleMat','mattype',2);
-			WriteData(fid,'object',obj,'class','mesh','fieldname','average_vertex_connectivity','format','Integer');
-			WriteData(fid,'object',obj,'class','mesh','fieldname','elements2d','format','DoubleMat','mattype',3);
-			WriteData(fid,'object',obj,'class','mesh','fieldname','numberofvertices2d','format','Integer');
-			WriteData(fid,'object',obj,'class','mesh','fieldname','numberofelements2d','format','Integer');
+		function marshall(self,md,fid) % {{{
+			WriteData(fid,'enum',DomainTypeEnum(),'data',StringToEnum(['Domain' domaintype(self)]),'format','Integer');
+			WriteData(fid,'enum',DomainDimensionEnum(),'data',dimension(self),'format','Integer');
+			WriteData(fid,'enum',MeshElementtypeEnum(),'data',StringToEnum(elementtype(self)),'format','Integer');
+			WriteData(fid,'object',self,'class','mesh','fieldname','x','format','DoubleMat','mattype',1);
+			WriteData(fid,'object',self,'class','mesh','fieldname','y','format','DoubleMat','mattype',1);
+			WriteData(fid,'object',self,'class','mesh','fieldname','z','format','DoubleMat','mattype',1);
+			WriteData(fid,'object',self,'class','mesh','fieldname','elements','format','DoubleMat','mattype',2);
+			WriteData(fid,'object',self,'class','mesh','fieldname','numberoflayers','format','Integer');
+			WriteData(fid,'object',self,'class','mesh','fieldname','numberofelements','format','Integer');
+			WriteData(fid,'object',self,'class','mesh','fieldname','numberofvertices','format','Integer');
+			WriteData(fid,'object',self,'class','mesh','fieldname','vertexonbase','format','BooleanMat','mattype',1);
+			WriteData(fid,'object',self,'class','mesh','fieldname','vertexonsurface','format','BooleanMat','mattype',1);
+			WriteData(fid,'object',self,'class','mesh','fieldname','lowerelements','format','DoubleMat','mattype',2);
+			WriteData(fid,'object',self,'class','mesh','fieldname','upperelements','format','DoubleMat','mattype',2);
+			WriteData(fid,'object',self,'class','mesh','fieldname','average_vertex_connectivity','format','Integer');
+			WriteData(fid,'object',self,'class','mesh','fieldname','elements2d','format','DoubleMat','mattype',3);
+			WriteData(fid,'object',self,'class','mesh','fieldname','numberofvertices2d','format','Integer');
+			WriteData(fid,'object',self,'class','mesh','fieldname','numberofelements2d','format','Integer');
 		end % }}}
-		function type = domaintype(obj) % {{{
+		function type = domaintype(self) % {{{
 			type = '3D';
 		end % }}}
-		function d = dimension(obj) % {{{
+		function d = dimension(self) % {{{
 			d = 3;
 		end % }}}
-		function s = elementtype(obj) % {{{
+		function s = elementtype(self) % {{{
 			s = 'Penta';
 		end % }}}
 	end
Index: ../trunk-jpl/src/m/classes/seaice.m
===================================================================
--- ../trunk-jpl/src/m/classes/seaice.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/seaice.m	(revision 19040)
@@ -13,16 +13,16 @@
 		coriolis_factor   = NaN;
 	end
 	methods
-		function obj = seaice(varargin) % {{{
+		function self = seaice(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 					return;
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 			if solution~=SeaiceSolutionEnum(), return; end
 			md = checkfield(md,'fieldname','seaice.min_concentration','NaN',1,'>=',0,'numel',1);
 			md = checkfield(md,'fieldname','seaice.min_thickness','NaN',1,'>=',0,'numel',1);
@@ -31,34 +31,34 @@
 			md = checkfield(md,'fieldname','seaice.spcvy','size',[md.mesh.numberofvertices 1]);
 			md = checkfield(md,'fieldname','seaice.coriolis_factor','size',[md.mesh.numberofelements 1],'NaN',1,'>=',0);
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 			%Minimum ice concentration allowed in the simulation
-			obj.min_concentration=0.;
+			self.min_concentration=0.;
 
 			%Minimum ice thickness allowed in the simulation
-			obj.min_thickness=0.;
+			self.min_thickness=0.;
 
 			%Maxmimum ice thickness allowed in the simulation
-			obj.max_thickness=25.;
+			self.max_thickness=25.;
 
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   seaice parameters:'));
-			fielddisplay(obj,'min_concentration','minimum ice concentration allowed in the simulation [no unit]');
-			fielddisplay(obj,'min_thickness','minimum ice thickness allowed in the simulation [m]');
-			fielddisplay(obj,'max_thickness','maximum ice thickness allowed in the simulation [m]');
-			fielddisplay(obj,'spcvx','x-axis velocity constraint (NaN means no constraint) [m/s]');
-			fielddisplay(obj,'spcvy','y-axis velocity constraint (NaN means no constraint) [m/s]');
-			fielddisplay(obj,'coriolis_factor','factor applied to Coriolis forces (latitude dependent)');
+			fielddisplay(self,'min_concentration','minimum ice concentration allowed in the simulation [no unit]');
+			fielddisplay(self,'min_thickness','minimum ice thickness allowed in the simulation [m]');
+			fielddisplay(self,'max_thickness','maximum ice thickness allowed in the simulation [m]');
+			fielddisplay(self,'spcvx','x-axis velocity constraint (NaN means no constraint) [m/s]');
+			fielddisplay(self,'spcvy','y-axis velocity constraint (NaN means no constraint) [m/s]');
+			fielddisplay(self,'coriolis_factor','factor applied to Coriolis forces (latitude dependent)');
 		end % }}}
-		function marshall(obj,md,fid) % {{{
-			WriteData(fid,'object',obj,'fieldname','min_concentration','format','Double');
-			WriteData(fid,'object',obj,'fieldname','min_thickness','format','Double');
-			WriteData(fid,'object',obj,'fieldname','max_thickness','format','Double');
-			WriteData(fid,'object',obj,'fieldname','spcvx','format','DoubleMat','mattype',1);
-			WriteData(fid,'object',obj,'fieldname','spcvy','format','DoubleMat','mattype',1);
-			WriteData(fid,'object',obj,'fieldname','coriolis_factor','format','DoubleMat','mattype',2);
+		function marshall(self,md,fid) % {{{
+			WriteData(fid,'object',self,'fieldname','min_concentration','format','Double');
+			WriteData(fid,'object',self,'fieldname','min_thickness','format','Double');
+			WriteData(fid,'object',self,'fieldname','max_thickness','format','Double');
+			WriteData(fid,'object',self,'fieldname','spcvx','format','DoubleMat','mattype',1);
+			WriteData(fid,'object',self,'fieldname','spcvy','format','DoubleMat','mattype',1);
+			WriteData(fid,'object',self,'fieldname','coriolis_factor','format','DoubleMat','mattype',2);
 		end % }}}
 	end
 end
Index: ../trunk-jpl/src/m/classes/geometry.m
===================================================================
--- ../trunk-jpl/src/m/classes/geometry.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/geometry.m	(revision 19040)
@@ -12,50 +12,50 @@
 		hydrostatic_ratio = NaN;
 	end
 	methods (Static)
-		function obj = loadobj(obj) % {{{
+		function self = loadobj(self) % {{{
 			% This function is directly called by matlab when a model object is
 			% loaded. Update old properties here
 
 			%2014 March 26th
-			if isstruct(obj),
+			if isstruct(self),
 				disp('WARNING: updating geometry');
 				disp('         md.geometry.bed        is now md.geometry.base');
 				disp('         md.geometry.bathymetry is now md.geometry.bed');
-				obj2=obj;
-				obj=geometry();
-				obj.surface    = obj2.surface;
-				obj.thickness  = obj2.thickness;
-				obj.base       = obj2.bed;
-				obj.bed        = obj2.bathymetry;
+				obj2 = self;
+				self = geometry();
+				self.surface    = obj2.surface;
+				self.thickness  = obj2.thickness;
+				self.base       = obj2.bed;
+				self.bed        = obj2.bathymetry;
 			end
 
 		end% }}}
 	end
 	methods
-        %function createxml(obj,fid)
-        function createxml(obj, fid)% {{{
+        %function createxml(self,fid)
+        function createxml(self, fid)% {{{
             fprintf(fid, '\n\n');
             fprintf(fid, '%s\n', '<!-- geometry -->');
             fprintf(fid,'%s\n%s\n%s\n','<frame key="1" label="Geometry parameters">','<section name="geometry" />'); 
 			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="surface" type="','path','" optional="','false','">','     <section name="geometry" />','     <help> surface elevation [m] </help>','</parameter>');
             fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="thickness" type="','path','" optional="','false','">','     <section name="geometry" />','     <help> ice thickness [m] </help>','</parameter>');
             fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="bed" type="','path','" optional="','false','">','     <section name="geometry" />','     <help> bed elevation [m] </help>','</parameter>');
-            %fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="bathymetry" type="',class(obj.bathymetry),'" default="',convert2str(obj.bathymetry),'">','     <section name="geometry" />','     <help> bathymetry elevation [m] </help>','</parameter>');
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','<parameter key ="hydrostatic_ratio" type="',class(obj.hydrostatic_ratio),'" default="',convert2str(obj.hydrostatic_ratio),'">','     <section name="geometry" />','     <help> coefficient for ice shelves; thickness correction: hydrostatic_ratio H_obs+ (1-hydrostatic_ratio) H_hydro </help>','</parameter>');
+            %fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','<parameter key ="bathymetry" type="',class(self.bathymetry),'" default="',convert2str(self.bathymetry),'">','     <section name="geometry" />','     <help> bathymetry elevation [m] </help>','</parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','<parameter key ="hydrostatic_ratio" type="',class(self.hydrostatic_ratio),'" default="',convert2str(self.hydrostatic_ratio),'">','     <section name="geometry" />','     <help> coefficient for ice shelves; thickness correction: hydrostatic_ratio H_obs+ (1-hydrostatic_ratio) H_hydro </help>','</parameter>');
             fprintf(fid,'%s\n%s\n','</frame>');
         end % }}}
-		function obj = geometry(varargin) % {{{
+		function self = geometry(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 			if (solution==SeaiceSolutionEnum()),
 				return;
@@ -67,7 +67,7 @@
 				md = checkfield(md,'fieldname','geometry.surface'  ,'NaN',1,'size',[md.mesh.numberofvertices 1]);
 				md = checkfield(md,'fieldname','geometry.base'      ,'NaN',1,'size',[md.mesh.numberofvertices 1]);
 				md = checkfield(md,'fieldname','geometry.thickness','NaN',1,'size',[md.mesh.numberofvertices 1],'>',0);
-				if any((obj.thickness-obj.surface+obj.base)>10^-9),
+				if any((self.thickness-self.surface+self.base)>10^-9),
 					md = checkmessage(md,['equality thickness=surface-base violated']);
 				end 
 				if solution==TransientSolutionEnum() & md.transient.isgroundingline,
@@ -75,21 +75,21 @@
 				end
 			end
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   geometry parameters:'));
 
-			fielddisplay(obj,'surface','ice upper surface elevation [m]');
-			fielddisplay(obj,'thickness','ice thickness [m]');
-			fielddisplay(obj,'base','ice base elevation [m]');
-			fielddisplay(obj,'bed','bed elevation [m]');
+			fielddisplay(self,'surface','ice upper surface elevation [m]');
+			fielddisplay(self,'thickness','ice thickness [m]');
+			fielddisplay(self,'base','ice base elevation [m]');
+			fielddisplay(self,'bed','bed elevation [m]');
 
 		end % }}}
-		function marshall(obj,md,fid) % {{{
-			WriteData(fid,'data',obj.surface,'format','DoubleMat','mattype',1,'enum',SurfaceEnum());
-			WriteData(fid,'data',obj.thickness,'format','DoubleMat','mattype',1,'enum',ThicknessEnum(),'timeserieslength',md.mesh.numberofvertices+1);
-			WriteData(fid,'data',obj.base,'format','DoubleMat','mattype',1,'enum',BaseEnum());
-			WriteData(fid,'data',obj.bed,'format','DoubleMat','mattype',1,'enum',BedEnum());
-			WriteData(fid,'object',obj,'fieldname','hydrostatic_ratio','format','DoubleMat','mattype',1);
+		function marshall(self,md,fid) % {{{
+			WriteData(fid,'data',self.surface,'format','DoubleMat','mattype',1,'enum',SurfaceEnum());
+			WriteData(fid,'data',self.thickness,'format','DoubleMat','mattype',1,'enum',ThicknessEnum(),'timeserieslength',md.mesh.numberofvertices+1);
+			WriteData(fid,'data',self.base,'format','DoubleMat','mattype',1,'enum',BaseEnum());
+			WriteData(fid,'data',self.bed,'format','DoubleMat','mattype',1,'enum',BedEnum());
+			WriteData(fid,'object',self,'fieldname','hydrostatic_ratio','format','DoubleMat','mattype',1);
 		end % }}}
 	end
 end
Index: ../trunk-jpl/src/m/classes/gia.m
===================================================================
--- ../trunk-jpl/src/m/classes/gia.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/gia.m	(revision 19040)
@@ -10,13 +10,13 @@
 		cross_section_shape           = 0;
 	end
 	methods
-         function createxml(obj,fid) % {{{
+         function createxml(self,fid) % {{{
             fprintf(fid, '<!-- gia -->\n');            
                     
             % gia solution parameters
             fprintf(fid,'%s\n%s\n%s\n','<frame key="1" label="gia parameters">','<section name="gia" />');                    
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="mantle_viscosity" type="',class(obj.mantle_viscosity),'" default="',convert2str(obj.mantle_viscosity),'">','     <section name="gia" />','     <help> mantle viscosity[Pa s] </help>','  </parameter>');
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="lithosphere_thickness" type="',class(obj.lithosphere_thickness),'" default="',convert2str(obj.lithosphere_thickness),'">','     <section name="gia" />','     <help> lithosphere thickness (km) </help>','  </parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="mantle_viscosity" type="',class(self.mantle_viscosity),'" default="',convert2str(self.mantle_viscosity),'">','     <section name="gia" />','     <help> mantle viscosity[Pa s] </help>','  </parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="lithosphere_thickness" type="',class(self.lithosphere_thickness),'" default="',convert2str(self.lithosphere_thickness),'">','     <section name="gia" />','     <help> lithosphere thickness (km) </help>','  </parameter>');
             %cross_section_shape drop-down (1 o r 2)
             fprintf(fid,'%s\n%s\n%s\n%s\n','  <parameter key ="cross_section_shape" type="alternative" optional="false">','     <section name="gia" />','     <help> 1: square-edged (default). 2: elliptical.  See iedge in GiaDeflectionCore </help>');
             fprintf(fid,'%s\n','       <option value="1" type="string" default="true"> </option>');
@@ -25,18 +25,18 @@
             fprintf(fid,'%s\n%s\n','</frame>');    
         
         end % }}}
-		function obj = gia(varargin) % {{{
+		function self = gia(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
-		obj.cross_section_shape=1; %square as default (see iedge in GiaDeflectionCorex)
+		function self = setdefaultparameters(self) % {{{
+		self.cross_section_shape=1; %square as default (see iedge in GiaDeflectionCorex)
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 			if ~ismember(GiaAnalysisEnum(),analyses), return; end
 			md = checkfield(md,'fieldname','gia.mantle_viscosity','NaN',1,'size',[md.mesh.numberofvertices 1],'>',0);
@@ -59,18 +59,18 @@
 			end
 
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   gia parameters:'));
 
-			fielddisplay(obj,'mantle_viscosity','mantle viscosity[Pa s]');
-			fielddisplay(obj,'lithosphere_thickness','lithosphere thickness (km)');
-			fielddisplay(obj,'cross_section_shape','1: square-edged (default). 2: elliptical.  See iedge in GiaDeflectionCore');
+			fielddisplay(self,'mantle_viscosity','mantle viscosity[Pa s]');
+			fielddisplay(self,'lithosphere_thickness','lithosphere thickness (km)');
+			fielddisplay(self,'cross_section_shape','1: square-edged (default). 2: elliptical.  See iedge in GiaDeflectionCore');
 
 		end % }}}
-		function marshall(obj,md,fid) % {{{
-			WriteData(fid,'object',obj,'fieldname','mantle_viscosity','format','DoubleMat','mattype',1);
-			WriteData(fid,'object',obj,'fieldname','lithosphere_thickness','format','DoubleMat','mattype',1,'scale',10^3); %from km to m
-			WriteData(fid,'object',obj,'fieldname','cross_section_shape','format','Integer');
+		function marshall(self,md,fid) % {{{
+			WriteData(fid,'object',self,'fieldname','mantle_viscosity','format','DoubleMat','mattype',1);
+			WriteData(fid,'object',self,'fieldname','lithosphere_thickness','format','DoubleMat','mattype',1,'scale',10^3); %from km to m
+			WriteData(fid,'object',self,'fieldname','cross_section_shape','format','Integer');
 		end % }}}
 	end
 end
Index: ../trunk-jpl/src/m/classes/settings.m
===================================================================
--- ../trunk-jpl/src/m/classes/settings.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/settings.m	(revision 19040)
@@ -18,56 +18,56 @@
 
 	end
 	methods
-        function createxml(obj,fid) % {{{
+        function createxml(self,fid) % {{{
             fprintf(fid, '\n\n');
             fprintf(fid, '%s\n', '<!-- settings -->');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="results_on_nodes" type="',      class(obj.results_on_nodes),'" default="',        convert2str(obj.results_on_nodes),'">',	'     <section name="settings" />','     <help> results are output for all the nodes of each element </help>','</parameter>');
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="io_gather" type="',          class(obj.io_gather),'" default="',           convert2str(obj.io_gather),'">',     '     <section name="settings" />','     <help> I/O gathering strategy for result outputs (default 1) </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="results_on_nodes" type="',      class(self.results_on_nodes),'" default="',        convert2str(self.results_on_nodes),'">',	'     <section name="settings" />','     <help> results are output for all the nodes of each element </help>','</parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="io_gather" type="',          class(self.io_gather),'" default="',           convert2str(self.io_gather),'">',     '     <section name="settings" />','     <help> I/O gathering strategy for result outputs (default 1) </help>','</parameter>');
             
             % lowmen drop-down (0 or 1)
             fprintf(fid,'%s\n%s\n%s\n%s\n',	'<parameter key ="lowmem" type="alternative" optional="true">',	'     <section name="settings" />','     <help> is the memory limited ? (0 or 1) </help>');
             fprintf(fid,'%s\n','       <option value="0" type="string" default="true"> </option>');
             fprintf(fid,'%s\n%s\n','       <option value="1" type="string" default="false"> </option>','</parameter>');
 
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="output_frequency" type="',          class(obj.output_frequency),'" default="',           convert2str(obj.output_frequency),'">',	'     <section name="settings" />','     <help> frequency at which results are saved in all solutions with multiple time_steps </help>','</parameter>');
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="waitonlock" type="',  	class(obj.waitonlock),'" default="',      convert2str(obj.waitonlock),'">',     '     <section name="settings" />','     <help> maximum number of minutes to wait for batch results (NaN to deactivate) </help>','</parameter>');
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="upload_server" type="',         class(obj.upload_server),'" default="',          convert2str(obj.upload_server),'">',	'     <section name="settings" />','     <help> server hostname where model should be uploaded </help>','</parameter>');
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="upload_path" type="',             class(obj.upload_path),'" default="',              convert2str(obj.upload_path),'">',     '     <section name="settings" />','     <help> path on server where model should be uploaded </help>','</parameter>');
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="upload_login" type="',        class(obj.upload_login),'" default="',         convert2str(obj.upload_login),'">',	'     <section name="settings" />','     <help> server login </help>','</parameter>');
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="upload_port" type="',    	class(obj.upload_port),'" default="',      convert2str(obj.upload_port),'">',     '     <section name="settings" />','     <help> port login (default is 0) </help>','</parameter>');
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n',    	'<parameter key ="upload_filename" type="',         class(obj.upload_filename),'" default="',          convert2str(obj.upload_filename),'">',	'     <section name="settings" />','     <help> unique id generated when uploading the file to server </help>','</parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="output_frequency" type="',          class(self.output_frequency),'" default="',           convert2str(self.output_frequency),'">',	'     <section name="settings" />','     <help> frequency at which results are saved in all solutions with multiple time_steps </help>','</parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="waitonlock" type="',  	class(self.waitonlock),'" default="',      convert2str(self.waitonlock),'">',     '     <section name="settings" />','     <help> maximum number of minutes to wait for batch results (NaN to deactivate) </help>','</parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="upload_server" type="',         class(self.upload_server),'" default="',          convert2str(self.upload_server),'">',	'     <section name="settings" />','     <help> server hostname where model should be uploaded </help>','</parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="upload_path" type="',             class(self.upload_path),'" default="',              convert2str(self.upload_path),'">',     '     <section name="settings" />','     <help> path on server where model should be uploaded </help>','</parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="upload_login" type="',        class(self.upload_login),'" default="',         convert2str(self.upload_login),'">',	'     <section name="settings" />','     <help> server login </help>','</parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="upload_port" type="',    	class(self.upload_port),'" default="',      convert2str(self.upload_port),'">',     '     <section name="settings" />','     <help> port login (default is 0) </help>','</parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n',    	'<parameter key ="upload_filename" type="',         class(self.upload_filename),'" default="',          convert2str(self.upload_filename),'">',	'     <section name="settings" />','     <help> unique id generated when uploading the file to server </help>','</parameter>');
              
         end % }}}
-		function obj = settings(varargin) % {{{
+		function self = settings(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 			%are we short in memory ? (0 faster but requires more memory)
-			obj.lowmem=0;
+			self.lowmem=0;
 
 			%i/o:
-			obj.io_gather=1;
+			self.io_gather=1;
 
 			%results frequency by default every step
-			obj.output_frequency=1;
+			self.output_frequency=1;
 
 			%this option can be activated to load automatically the results
 			%onto the model after a parallel run by waiting for the lock file
 			%N minutes that is generated once the solution has converged
 			%0 to deactivate
-			obj.waitonlock=Inf;
+			self.waitonlock=Inf;
 
 			%upload options: 
 			upload_port         = 0;
 
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 			md = checkfield(md,'fieldname','settings.results_on_nodes','numel',[1],'values',[0 1]);
 			md = checkfield(md,'fieldname','settings.io_gather','numel',[1],'values',[0 1]);
@@ -76,27 +76,27 @@
 			md = checkfield(md,'fieldname','settings.waitonlock','numel',[1]);
 
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   general settings parameters:'));
 
-			fielddisplay(obj,'results_on_nodes','results are output for all the nodes of each element');
-			fielddisplay(obj,'io_gather','I/O gathering strategy for result outputs (default 1)');
-			fielddisplay(obj,'lowmem','is the memory limited ? (0 or 1)');
-			fielddisplay(obj,'output_frequency','frequency at which results are saved in all solutions with multiple time_steps');
-			fielddisplay(obj,'waitonlock','maximum number of minutes to wait for batch results (NaN to deactivate)');
-			fielddisplay(obj,'upload_server','server hostname where model should be uploaded');
-			fielddisplay(obj,'upload_path','path on server where model should be uploaded');
-			fielddisplay(obj,'upload_login','server login');
-			fielddisplay(obj,'upload_port','port login (default is 0)');
-			fielddisplay(obj,'upload_filename','unique id generated when uploading the file to server');
+			fielddisplay(self,'results_on_nodes','results are output for all the nodes of each element');
+			fielddisplay(self,'io_gather','I/O gathering strategy for result outputs (default 1)');
+			fielddisplay(self,'lowmem','is the memory limited ? (0 or 1)');
+			fielddisplay(self,'output_frequency','frequency at which results are saved in all solutions with multiple time_steps');
+			fielddisplay(self,'waitonlock','maximum number of minutes to wait for batch results (NaN to deactivate)');
+			fielddisplay(self,'upload_server','server hostname where model should be uploaded');
+			fielddisplay(self,'upload_path','path on server where model should be uploaded');
+			fielddisplay(self,'upload_login','server login');
+			fielddisplay(self,'upload_port','port login (default is 0)');
+			fielddisplay(self,'upload_filename','unique id generated when uploading the file to server');
 
 		end % }}}
-		function marshall(obj,md,fid) % {{{
-			WriteData(fid,'object',obj,'fieldname','results_on_nodes','format','Boolean');
-			WriteData(fid,'object',obj,'fieldname','io_gather','format','Boolean');
-			WriteData(fid,'object',obj,'fieldname','lowmem','format','Boolean');
-			WriteData(fid,'object',obj,'fieldname','output_frequency','format','Integer');
-			if obj.waitonlock>0,
+		function marshall(self,md,fid) % {{{
+			WriteData(fid,'object',self,'fieldname','results_on_nodes','format','Boolean');
+			WriteData(fid,'object',self,'fieldname','io_gather','format','Boolean');
+			WriteData(fid,'object',self,'fieldname','lowmem','format','Boolean');
+			WriteData(fid,'object',self,'fieldname','output_frequency','format','Integer');
+			if self.waitonlock>0,
 				WriteData(fid,'enum',SettingsWaitonlockEnum(),'data',true,'format','Boolean');
 			else
 				WriteData(fid,'enum',SettingsWaitonlockEnum(),'data',false,'format','Boolean');
Index: ../trunk-jpl/src/m/classes/groundingline.m
===================================================================
--- ../trunk-jpl/src/m/classes/groundingline.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/groundingline.m	(revision 19040)
@@ -8,7 +8,7 @@
 		migration    = '';
 	end
 	methods
-		function createxml(obj,fid) % {{{
+		function createxml(self,fid) % {{{
 			fprintf(fid, '\n\n');
 			fprintf(fid, '%s\n', '<!-- groundingline -->');
 
@@ -23,25 +23,25 @@
 
 			fprintf(fid,'%s\n%s\n','</frame>');
 		end % }}}
-		function obj = groundingline(varargin) % {{{
+		function self = groundingline(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 			%Type of migration
-			obj.migration='None';
+			self.migration='None';
 
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 			md = checkfield(md,'fieldname','groundingline.migration','values',{'None' 'AggressiveMigration' 'SoftMigration' 'SubelementMigration' 'SubelementMigration2' 'Contact' 'None' 'GroundingOnly'});
 
-			if ~strcmp(obj.migration,'None'),
+			if ~strcmp(self.migration,'None'),
 				if isnan(md.geometry.bed),
 					md = checkmessage(md,['requesting grounding line migration, but bathymetry is absent!']);
 				end
@@ -55,13 +55,13 @@
 			end
 
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   grounding line migration parameters:'));
-			fielddisplay(obj,'migration','type of grounding line migration: ''SoftMigration'',''AggressiveMigration'',''SubelementMigration'',''SubelementMigration2'' or ''None''');
+			fielddisplay(self,'migration','type of grounding line migration: ''SoftMigration'',''AggressiveMigration'',''SubelementMigration'',''SubelementMigration2'' or ''None''');
 
 		end % }}}
-		function marshall(obj,md,fid) % {{{
-			WriteData(fid,'data',StringToEnum(obj.migration),'enum',GroundinglineMigrationEnum(),'format','Integer');
+		function marshall(self,md,fid) % {{{
+			WriteData(fid,'data',StringToEnum(self.migration),'enum',GroundinglineMigrationEnum(),'format','Integer');
 		end % }}}
 	end
 end
Index: ../trunk-jpl/src/m/classes/SMBmeltcomponents.m
===================================================================
--- ../trunk-jpl/src/m/classes/SMBmeltcomponents.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/SMBmeltcomponents.m	(revision 19040)
@@ -11,7 +11,7 @@
 		refreeze = NaN;
 	end
 	methods
-		function obj = SMBmeltcomponents(varargin) % {{{
+		function self = SMBmeltcomponents(varargin) % {{{
 			switch nargin
 				case 0
 				otherwise
@@ -46,7 +46,7 @@
 			end
 
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 			if ismember(MasstransportAnalysisEnum(),analyses),
 				md = checkfield(md,'fieldname','surfaceforcings.accumulation','timeseries',1,'NaN',1);
@@ -73,22 +73,22 @@
 				md = checkfield(md,'fieldname','surfaceforcings.melt','size',[md.mesh.numberofvertices 1],'NaN',1);
 			end
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   surface forcings parameters with melt (SMB=accumulation-evaporation-melt+refreeze) :'));
-			fielddisplay(obj,'accumulation','accumulated snow [m/yr ice eq]');
-			fielddisplay(obj,'evaporation','amount of ice lost to evaporative processes [m/yr ice eq]');
-			fielddisplay(obj,'melt','amount of ice melt in ice column [m/yr ice eq]');
-			fielddisplay(obj,'refreeze','amount of ice melt refrozen in ice column [m/yr ice eq]');
+			fielddisplay(self,'accumulation','accumulated snow [m/yr ice eq]');
+			fielddisplay(self,'evaporation','amount of ice lost to evaporative processes [m/yr ice eq]');
+			fielddisplay(self,'melt','amount of ice melt in ice column [m/yr ice eq]');
+			fielddisplay(self,'refreeze','amount of ice melt refrozen in ice column [m/yr ice eq]');
 		end % }}}
-		function marshall(obj,md,fid) % {{{
+		function marshall(self,md,fid) % {{{
 
 			yts=365.0*24.0*3600.0;
 
 			WriteData(fid,'enum',SurfaceforcingsEnum(),'data',SMBmeltcomponentsEnum(),'format','Integer');
-			WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','accumulation','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
-			WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','evaporation','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
-			WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','melt','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
-			WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','refreeze','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
+			WriteData(fid,'object',self,'class','surfaceforcings','fieldname','accumulation','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
+			WriteData(fid,'object',self,'class','surfaceforcings','fieldname','evaporation','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
+			WriteData(fid,'object',self,'class','surfaceforcings','fieldname','melt','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
+			WriteData(fid,'object',self,'class','surfaceforcings','fieldname','refreeze','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
 		end % }}}
 	end
 end
Index: ../trunk-jpl/src/m/classes/clusters/generic.m
===================================================================
--- ../trunk-jpl/src/m/classes/clusters/generic.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/clusters/generic.m	(revision 19040)
@@ -23,22 +23,22 @@
 		%}}}
 	end
 	methods
-        function createxml(obj,fid) % {{{
+        function createxml(self,fid) % {{{
             fprintf(fid, '\n\n');
             fprintf(fid, '%s\n', '<!-- generic -->');
             
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="name" type="',class(obj.name),'" default="',convert2str(obj.name),'">',	'     <section name="cluster" />','     <help> N/A </help>','</parameter>');
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="login" type="',class(obj.login),'" default="',convert2str(obj.login),'">',     '     <section name="cluster" />','     <help> N/A </help>','</parameter>');
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',	'<parameter key ="np" type="',class(obj.np),'" default="',convert2str(obj.np),'">',	'     <section name="cluster" />','     <help> N/A </help>','</parameter>');
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="port" type="',class(obj.port),'" default="',convert2str(obj.port),'">',	'     <section name="cluster" />','     <help> N/A </help>','</parameter>');
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="codepath" type="',class(obj.codepath),'" default="',convert2str(obj.codepath),'">',     '     <section name="cluster" />','     <help> N/A </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="name" type="',class(self.name),'" default="',convert2str(self.name),'">',	'     <section name="cluster" />','     <help> N/A </help>','</parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="login" type="',class(self.login),'" default="',convert2str(self.login),'">',     '     <section name="cluster" />','     <help> N/A </help>','</parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',	'<parameter key ="np" type="',class(self.np),'" default="',convert2str(self.np),'">',	'     <section name="cluster" />','     <help> N/A </help>','</parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="port" type="',class(self.port),'" default="',convert2str(self.port),'">',	'     <section name="cluster" />','     <help> N/A </help>','</parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="codepath" type="',class(self.codepath),'" default="',convert2str(self.codepath),'">',     '     <section name="cluster" />','     <help> N/A </help>','</parameter>');
              
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="executionpath" type="',class(obj.executionpath),'" default="',convert2str(obj.executionpath),'">',	'     <section name="cluster" />','     <help> N/A </help>','</parameter>');
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="etcpath" type="',class(obj.etcpath),'" default="',convert2str(obj.etcpath),'">',     '     <section name="cluster" />','     <help> N/A </help>','</parameter>');
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="valgrind" type="',class(obj.valgrind),'" default="',convert2str(obj.valgrind),'">',	'     <section name="cluster" />','     <help> N/A </help>','</parameter>');
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="valgrindlib" type="',class(obj.valgrindlib),'" default="',convert2str(obj.valgrindlib),'">',     '     <section name="cluster" />','     <help> N/A </help>','</parameter>');
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="valgrindsup" type="',class(obj.valgrindsup),'" default="',convert2str(obj.valgrindsup),'">',     '     <section name="cluster" />','     <help> N/A </help>','</parameter>');
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n',    	'<parameter key ="verbose" type="',class(obj.verbose),'" default="',convert2str(obj.verbose),'">',	'     <section name="cluster" />','     <help> N/A </help>','</parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="executionpath" type="',class(self.executionpath),'" default="',convert2str(self.executionpath),'">',	'     <section name="cluster" />','     <help> N/A </help>','</parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="etcpath" type="',class(self.etcpath),'" default="',convert2str(self.etcpath),'">',     '     <section name="cluster" />','     <help> N/A </help>','</parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="valgrind" type="',class(self.valgrind),'" default="',convert2str(self.valgrind),'">',	'     <section name="cluster" />','     <help> N/A </help>','</parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="valgrindlib" type="',class(self.valgrindlib),'" default="',convert2str(self.valgrindlib),'">',     '     <section name="cluster" />','     <help> N/A </help>','</parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="valgrindsup" type="',class(self.valgrindsup),'" default="',convert2str(self.valgrindsup),'">',     '     <section name="cluster" />','     <help> N/A </help>','</parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n',    	'<parameter key ="verbose" type="',class(self.verbose),'" default="',convert2str(self.verbose),'">',	'     <section name="cluster" />','     <help> N/A </help>','</parameter>');
              
         end % }}}
 		function cluster=generic(varargin) % {{{
Index: ../trunk-jpl/src/m/classes/mesh2dvertical.m
===================================================================
--- ../trunk-jpl/src/m/classes/mesh2dvertical.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/mesh2dvertical.m	(revision 19040)
@@ -50,43 +50,43 @@
 		end% }}}
 	end
 	methods
-		function createxml(obj,fid) % {{{
+		function createxml(self,fid) % {{{
 			fprintf(fid, '<!-- 2d Mesh (Vertical) -->\n');
 
 			%elements and vertices
 			fprintf(fid,'%s\n%s\n%s\n','       <frame key="1" label="Elements and vertices">','       <section name="mesh" />');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','          <parameter key ="numberofelements" type="',class(obj.numberofelements),'" default="',convert2str(obj.numberofelements),'">','              <help> number of elements </help>','          </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','          <parameter key ="numberofvertices" type="',class(obj.numberofvertices),'" default="',convert2str(obj.numberofvertices),'">','              <help> number of vertices </help>','          </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','          <parameter key ="elements" type="',class(obj.elements),'" default="',convert2str(obj.elements),'">','              <help> vertex indices of the mesh elements </help>','          </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="x" type="',class(obj.x),'" default="',convert2str(obj.x),'">','     <section name="mesh" />','     <help> vertices x coordinate [m] </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="y" type="',class(obj.y),'" default="',convert2str(obj.y),'">','     <section name="mesh" />','     <help> vertices y coordinate [m] </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="edges" type="',class(obj.edges),'" default="',convert2str(obj.edges),'">','     <section name="mesh" />','     <help> edges of the 2d mesh (vertex1 vertex2 element1 element2) </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="numberofedges" type="',class(obj.numberofedges),'" default="',convert2str(obj.numberofedges),'">','     <section name="mesh" />','     <help> number of edges of the 2d mesh </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','          <parameter key ="numberofelements" type="',class(self.numberofelements),'" default="',convert2str(self.numberofelements),'">','              <help> number of elements </help>','          </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','          <parameter key ="numberofvertices" type="',class(self.numberofvertices),'" default="',convert2str(self.numberofvertices),'">','              <help> number of vertices </help>','          </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','          <parameter key ="elements" type="',class(self.elements),'" default="',convert2str(self.elements),'">','              <help> vertex indices of the mesh elements </help>','          </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="x" type="',class(self.x),'" default="',convert2str(self.x),'">','     <section name="mesh" />','     <help> vertices x coordinate [m] </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="y" type="',class(self.y),'" default="',convert2str(self.y),'">','     <section name="mesh" />','     <help> vertices y coordinate [m] </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="edges" type="',class(self.edges),'" default="',convert2str(self.edges),'">','     <section name="mesh" />','     <help> edges of the 2d mesh (vertex1 vertex2 element1 element2) </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="numberofedges" type="',class(self.numberofedges),'" default="',convert2str(self.numberofedges),'">','     <section name="mesh" />','     <help> number of edges of the 2d mesh </help>','  </parameter>');
 			fprintf(fid,'%s\n%s\n','       </frame>');
 
 			% properties
 			fprintf(fid,'%s\n%s\n%s\n','<frame key="2" label="Properties">','<section name="mesh" />');             
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="vertexonboundary" type="',class(obj.vertexonboundary),'" default="',convert2str(obj.vertexonboundary),'">','     <section name="mesh" />','     <help> vertices on the boundary of the domain flag list </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="vertexonbase" type="',class(obj.vertexonbase),'" default="',convert2str(obj.vertexonbase),'">','     <section name="mesh" />','     <help> vertices on the bed of the domain flag list </help>','  </parameter>');            
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="segments" type="',class(obj.segments),'" default="',convert2str(obj.segments),'">','     <section name="mesh" />','     <help> edges on domain boundary (vertex1 vertex2 element) </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="segmentmarkers" type="',class(obj.segmentmarkers),'" default="',convert2str(obj.segmentmarkers),'">','     <section name="mesh" />','     <help> number associated to each segment </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="vertexconnectivity" type="',class(obj.vertexconnectivity),'" default="',convert2str(obj.vertexconnectivity),'">','     <section name="mesh" />','     <help> list of vertices connected to vertex_i </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="elementconnectivity" type="',class(obj.elementconnectivity),'" default="',convert2str(obj.elementconnectivity),'">','     <section name="mesh" />','     <help> list of vertices connected to element_i </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="average_vertex_connectivity" type="',class(obj.average_vertex_connectivity),'" default="',convert2str(obj.average_vertex_connectivity),'">','     <section name="mesh" />','     <help> average number of vertices connected to one vertex </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="vertexonboundary" type="',class(self.vertexonboundary),'" default="',convert2str(self.vertexonboundary),'">','     <section name="mesh" />','     <help> vertices on the boundary of the domain flag list </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="vertexonbase" type="',class(self.vertexonbase),'" default="',convert2str(self.vertexonbase),'">','     <section name="mesh" />','     <help> vertices on the bed of the domain flag list </help>','  </parameter>');            
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="segments" type="',class(self.segments),'" default="',convert2str(self.segments),'">','     <section name="mesh" />','     <help> edges on domain boundary (vertex1 vertex2 element) </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="segmentmarkers" type="',class(self.segmentmarkers),'" default="',convert2str(self.segmentmarkers),'">','     <section name="mesh" />','     <help> number associated to each segment </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="vertexconnectivity" type="',class(self.vertexconnectivity),'" default="',convert2str(self.vertexconnectivity),'">','     <section name="mesh" />','     <help> list of vertices connected to vertex_i </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="elementconnectivity" type="',class(self.elementconnectivity),'" default="',convert2str(self.elementconnectivity),'">','     <section name="mesh" />','     <help> list of vertices connected to element_i </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="average_vertex_connectivity" type="',class(self.average_vertex_connectivity),'" default="',convert2str(self.average_vertex_connectivity),'">','     <section name="mesh" />','     <help> average number of vertices connected to one vertex </help>','  </parameter>');
 			fprintf(fid,'%s\n%s\n','</frame>');
 
 			%projection
 			fprintf(fid,'%s\n%s\n%s\n','<frame key="3" label="Projection">','<section name="mesh" />'); 
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="lat" type="',class(obj.lat),'" default="',convert2str(obj.lat),'">','     <section name="mesh" />','     <help> vertices latitude [degrees] </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="long" type="',class(obj.long),'" default="',convert2str(obj.long),'">','     <section name="mesh" />','     <help> verticies longitude [degrees] </help>','  </parameter>');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','  <parameter key ="epsg" type="',class(obj.epsg),'" default="',convert2str(obj.epsg),'">','     <section name="mesh" />','     <help> Indicate epsg ''n'' or ''s'' </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="lat" type="',class(self.lat),'" default="',convert2str(self.lat),'">','     <section name="mesh" />','     <help> vertices latitude [degrees] </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n','  <parameter key ="long" type="',class(self.long),'" default="',convert2str(self.long),'">','     <section name="mesh" />','     <help> verticies longitude [degrees] </help>','  </parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n','  <parameter key ="epsg" type="',class(self.epsg),'" default="',convert2str(self.epsg),'">','     <section name="mesh" />','     <help> Indicate epsg ''n'' or ''s'' </help>','  </parameter>');
 			fprintf(fid,'%s\n%s\n','</frame>');
 
 		end % }}}
-		function obj = mesh2dvertical(varargin) % {{{
+		function self = mesh2dvertical(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				case 1
 					inputstruct=varargin{1};
 					list1 = properties('mesh2dvertical');
@@ -94,23 +94,23 @@
 					for i=1:length(list1)
 						fieldname = list1{i};
 						if ismember(fieldname,list2),
-							obj.(fieldname) = inputstruct.(fieldname);
+							self.(fieldname) = inputstruct.(fieldname);
 						end
 					end
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 			%the connectivity is the averaged number of nodes linked to a
 			%given node through an edge. This connectivity is used to initially
 			%allocate memory to the stiffness matrix. A value of 16 seems to
 			%give a good memory/time ration. This value can be checked in
 			%trunk/test/Miscellaneous/runme.m
-			obj.average_vertex_connectivity=25;
+			self.average_vertex_connectivity=25;
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 			md = checkfield(md,'fieldname','mesh.x','NaN',1,'size',[md.mesh.numberofvertices 1]);
 			md = checkfield(md,'fieldname','mesh.y','NaN',1,'size',[md.mesh.numberofvertices 1]);
@@ -130,54 +130,54 @@
 					md = checkmessage(md,'thermal not supported for 2d mesh');
 			end
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   2D tria Mesh (vertical):')); 
 
 			disp(sprintf('\n      Elements and vertices:'));
-			fielddisplay(obj,'numberofelements','number of elements');
-			fielddisplay(obj,'numberofvertices','number of vertices');
-			fielddisplay(obj,'elements','vertex indices of the mesh elements');
-			fielddisplay(obj,'x','vertices x coordinate [m]');
-			fielddisplay(obj,'y','vertices y coordinate [m]');
-			fielddisplay(obj,'edges','edges of the 2d mesh (vertex1 vertex2 element1 element2)');
-			fielddisplay(obj,'numberofedges','number of edges of the 2d mesh');
+			fielddisplay(self,'numberofelements','number of elements');
+			fielddisplay(self,'numberofvertices','number of vertices');
+			fielddisplay(self,'elements','vertex indices of the mesh elements');
+			fielddisplay(self,'x','vertices x coordinate [m]');
+			fielddisplay(self,'y','vertices y coordinate [m]');
+			fielddisplay(self,'edges','edges of the 2d mesh (vertex1 vertex2 element1 element2)');
+			fielddisplay(self,'numberofedges','number of edges of the 2d mesh');
 
 			disp(sprintf('\n      Properties:'));
-			fielddisplay(obj,'vertexonboundary','vertices on the boundary of the domain flag list');
-			fielddisplay(obj,'vertexonbase','vertices on the bed of the domain flag list');
-			fielddisplay(obj,'vertexonsurface','vertices on the surface of the domain flag list');
-			fielddisplay(obj,'segments','edges on domain boundary (vertex1 vertex2 element)');
-			fielddisplay(obj,'segmentmarkers','number associated to each segment');
-			fielddisplay(obj,'vertexconnectivity','list of vertices connected to vertex_i');
-			fielddisplay(obj,'elementconnectivity','list of vertices connected to element_i');
-			fielddisplay(obj,'average_vertex_connectivity','average number of vertices connected to one vertex');
+			fielddisplay(self,'vertexonboundary','vertices on the boundary of the domain flag list');
+			fielddisplay(self,'vertexonbase','vertices on the bed of the domain flag list');
+			fielddisplay(self,'vertexonsurface','vertices on the surface of the domain flag list');
+			fielddisplay(self,'segments','edges on domain boundary (vertex1 vertex2 element)');
+			fielddisplay(self,'segmentmarkers','number associated to each segment');
+			fielddisplay(self,'vertexconnectivity','list of vertices connected to vertex_i');
+			fielddisplay(self,'elementconnectivity','list of vertices connected to element_i');
+			fielddisplay(self,'average_vertex_connectivity','average number of vertices connected to one vertex');
 
 			disp(sprintf('\n      Projection:'));
-			fielddisplay(obj,'lat','vertices latitude [degrees]');
-			fielddisplay(obj,'long','vertices longitude [degrees]');
-			fielddisplay(obj,'epsg','EPSG code (ex: 3413 for UPS Greenland, 3031 for UPS Antarctica)');
+			fielddisplay(self,'lat','vertices latitude [degrees]');
+			fielddisplay(self,'long','vertices longitude [degrees]');
+			fielddisplay(self,'epsg','EPSG code (ex: 3413 for UPS Greenland, 3031 for UPS Antarctica)');
 		end % }}}
-		function marshall(obj,md,fid) % {{{
-			WriteData(fid,'enum',DomainTypeEnum(),'data',StringToEnum(['Domain' domaintype(obj)]),'format','Integer');
-			WriteData(fid,'enum',DomainDimensionEnum(),'data',dimension(obj),'format','Integer');
-			WriteData(fid,'enum',MeshElementtypeEnum(),'data',StringToEnum(elementtype(obj)),'format','Integer');
-			WriteData(fid,'object',obj,'class','mesh','fieldname','x','format','DoubleMat','mattype',1);
-			WriteData(fid,'object',obj,'class','mesh','fieldname','y','format','DoubleMat','mattype',1);
-			WriteData(fid,'enum',MeshZEnum(),'data',zeros(obj.numberofvertices,1),'format','DoubleMat','mattype',1);
-			WriteData(fid,'object',obj,'class','mesh','fieldname','elements','format','DoubleMat','mattype',2);
-			WriteData(fid,'object',obj,'class','mesh','fieldname','numberofelements','format','Integer');
-			WriteData(fid,'object',obj,'class','mesh','fieldname','numberofvertices','format','Integer');
-			WriteData(fid,'object',obj,'class','mesh','fieldname','vertexonbase','format','BooleanMat','mattype',1);
-			WriteData(fid,'object',obj,'class','mesh','fieldname','vertexonsurface','format','BooleanMat','mattype',1);
-			WriteData(fid,'object',obj,'class','mesh','fieldname','average_vertex_connectivity','format','Integer');
+		function marshall(self,md,fid) % {{{
+			WriteData(fid,'enum',DomainTypeEnum(),'data',StringToEnum(['Domain' domaintype(self)]),'format','Integer');
+			WriteData(fid,'enum',DomainDimensionEnum(),'data',dimension(self),'format','Integer');
+			WriteData(fid,'enum',MeshElementtypeEnum(),'data',StringToEnum(elementtype(self)),'format','Integer');
+			WriteData(fid,'object',self,'class','mesh','fieldname','x','format','DoubleMat','mattype',1);
+			WriteData(fid,'object',self,'class','mesh','fieldname','y','format','DoubleMat','mattype',1);
+			WriteData(fid,'enum',MeshZEnum(),'data',zeros(self.numberofvertices,1),'format','DoubleMat','mattype',1);
+			WriteData(fid,'object',self,'class','mesh','fieldname','elements','format','DoubleMat','mattype',2);
+			WriteData(fid,'object',self,'class','mesh','fieldname','numberofelements','format','Integer');
+			WriteData(fid,'object',self,'class','mesh','fieldname','numberofvertices','format','Integer');
+			WriteData(fid,'object',self,'class','mesh','fieldname','vertexonbase','format','BooleanMat','mattype',1);
+			WriteData(fid,'object',self,'class','mesh','fieldname','vertexonsurface','format','BooleanMat','mattype',1);
+			WriteData(fid,'object',self,'class','mesh','fieldname','average_vertex_connectivity','format','Integer');
 		end % }}}
-		function t = domaintype(obj) % {{{
+		function t = domaintype(self) % {{{
 			t = '2Dvertical';
 		end % }}}
-		function d = dimension(obj) % {{{
+		function d = dimension(self) % {{{
 			d = 2;
 		end % }}}
-		function s = elementtype(obj) % {{{
+		function s = elementtype(self) % {{{
 			s = 'Tria';
 		end % }}}
 		function flags = vertexflags(self,value) % {{{
Index: ../trunk-jpl/src/m/classes/friction.m
===================================================================
--- ../trunk-jpl/src/m/classes/friction.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/friction.m	(revision 19040)
@@ -10,27 +10,27 @@
 		q           = NaN;
 	end
 	methods
-        function createxml(obj,fid) % {{{
+        function createxml(self,fid) % {{{
             fprintf(fid, '\n\n');
             fprintf(fid, '%s\n', '<!-- Friction: Sigma= drag^2 * Neff ^r * u ^s, with Neff=rho_ice*g*thickness+rho_water*g*bed, r=q/p and s=1/p -->');
             fprintf(fid,'%s\n%s\n%s\n','<frame key="1" label="Friction: Sigma= drag^2 * Neff ^r * u ^s, with Neff=rho_ice*g*thickness+rho_water*g*bed, r=q/p and s=1/p">','<section name="friction" />');   
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="coefficient" type="',   	class(obj.coefficient),'" default="',     	convert2str(obj.coefficient),'">',              '     <section name="friction" />','     <help> friction coefficient [SI] </help>','</parameter>');
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="p" type="',               class(obj.p),'" default="',                 convert2str(obj.p),'">',   '     <section name="friction" />','     <help> p exponent </help>','</parameter>');
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n',        '<parameter key ="q" type="',               class(obj.q),'" default="',                 convert2str(obj.q),'">',            '     <section name="friction" />','     <help> q exponent </help>','</parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="coefficient" type="',   	class(self.coefficient),'" default="',     	convert2str(self.coefficient),'">',              '     <section name="friction" />','     <help> friction coefficient [SI] </help>','</parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="p" type="',               class(self.p),'" default="',                 convert2str(self.p),'">',   '     <section name="friction" />','     <help> p exponent </help>','</parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n',        '<parameter key ="q" type="',               class(self.q),'" default="',                 convert2str(self.q),'">',            '     <section name="friction" />','     <help> q exponent </help>','</parameter>');
             fprintf(fid,'%s\n%s\n','</frame>');
         end % }}}
-		function obj = friction(varargin) % {{{
+		function self = friction(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 			%Early return
 			if ~ismember(StressbalanceAnalysisEnum(),analyses) & ~ismember(ThermalAnalysisEnum(),analyses), return; end
@@ -38,20 +38,20 @@
 			md = checkfield(md,'fieldname','friction.q','NaN',1,'size',[md.mesh.numberofelements 1]);
 			md = checkfield(md,'fieldname','friction.p','NaN',1,'size',[md.mesh.numberofelements 1]);
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('Basal shear stress parameters: Sigma_b = coefficient^2 * Neff ^r * |u_b|^(s-1) * u_b\n(effective stress Neff=rho_ice*g*thickness+rho_water*g*bed, r=q/p and s=1/p)'));
-			fielddisplay(obj,'coefficient','friction coefficient [SI]');
-			fielddisplay(obj,'p','p exponent');
-			fielddisplay(obj,'q','q exponent');
+			fielddisplay(self,'coefficient','friction coefficient [SI]');
+			fielddisplay(self,'p','p exponent');
+			fielddisplay(self,'q','q exponent');
 		end % }}}
-		function marshall(obj,md,fid) % {{{
+		function marshall(self,md,fid) % {{{
 			yts=365.0*24.0*3600.0;
 
 			WriteData(fid,'enum',FrictionLawEnum,'data',1,'format','Integer');
-			WriteData(fid,'object',obj,'fieldname','coefficient','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
-			%WriteData(fid,'object',obj,'fieldname','coefficient','format','DoubleMat','mattype',1);
-			WriteData(fid,'object',obj,'fieldname','p','format','DoubleMat','mattype',2);
-			WriteData(fid,'object',obj,'fieldname','q','format','DoubleMat','mattype',2);
+			WriteData(fid,'object',self,'fieldname','coefficient','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
+			%WriteData(fid,'object',self,'fieldname','coefficient','format','DoubleMat','mattype',1);
+			WriteData(fid,'object',self,'fieldname','p','format','DoubleMat','mattype',2);
+			WriteData(fid,'object',self,'fieldname','q','format','DoubleMat','mattype',2);
 			
 
 		end % }}}
Index: ../trunk-jpl/src/m/classes/frictionweertman.m
===================================================================
--- ../trunk-jpl/src/m/classes/frictionweertman.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/frictionweertman.m	(revision 19040)
@@ -9,49 +9,49 @@
 		m = NaN;
 	end
 	methods
-        function createxml(obj,fid) % {{{
+        function createxml(self,fid) % {{{
             fprintf(fid, '\n\n');
             fprintf(fid, '%s\n', '<!-- Friction: Sigma= drag^2 * Neff ^r * u ^s, with Neff=rho_ice*g*thickness+rho_water*g*bed, r=q/p and s=1/p -->');
             fprintf(fid,'%s\n%s\n%s\n','<frame key="1" label="Friction: Sigma= drag^2 * Neff ^r * u ^s, with Neff=rho_ice*g*thickness+rho_water*g*bed, r=q/p and s=1/p">','<section name="frictionweertman" />');   
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="coefficient" type="',   	class(obj.coefficient),'" default="',     	convert2str(obj.coefficient),'">',              '     <section name="frictionweertman" />','     <help> frictionweertman coefficient [SI] </help>','</parameter>');
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="p" type="',               class(obj.p),'" default="',                 convert2str(obj.p),'">',   '     <section name="frictionweertman" />','     <help> p exponent </help>','</parameter>');
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n',        '<parameter key ="q" type="',               class(obj.q),'" default="',                 convert2str(obj.q),'">',            '     <section name="frictionweertman" />','     <help> q exponent </help>','</parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="coefficient" type="',   	class(self.coefficient),'" default="',     	convert2str(self.coefficient),'">',              '     <section name="frictionweertman" />','     <help> frictionweertman coefficient [SI] </help>','</parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="p" type="',               class(self.p),'" default="',                 convert2str(self.p),'">',   '     <section name="frictionweertman" />','     <help> p exponent </help>','</parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n',        '<parameter key ="q" type="',               class(self.q),'" default="',                 convert2str(self.q),'">',            '     <section name="frictionweertman" />','     <help> q exponent </help>','</parameter>');
             fprintf(fid,'%s\n%s\n','</frame>');
         end % }}}
-		function obj = frictionweertman(varargin) % {{{
+		function self = frictionweertman(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 			%Early return
 			if ~ismember(StressbalanceAnalysisEnum(),analyses) & ~ismember(ThermalAnalysisEnum(),analyses), return; end
 			md = checkfield(md,'fieldname','friction.C','timeseries',1,'NaN',1);
 			md = checkfield(md,'fieldname','friction.m','NaN',1,'size',[md.mesh.numberofelements 1]);
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp('Weertman sliding law parameters:');
 			disp('   Weertman''s sliding law reads:');
 			disp('      v_b = C * Sigma_b^m');
 			disp('   In ISSM, this law is rewritten as:');
 			disp('      Sigma_b = C^(-1/m) * |u_b|^(1/m-1)  u_b');
 			disp(' ');
-			fielddisplay(obj,'C','friction coefficient [SI]');
-			fielddisplay(obj,'m','m exponent');
+			fielddisplay(self,'C','friction coefficient [SI]');
+			fielddisplay(self,'m','m exponent');
 		end % }}}
-		function marshall(obj,md,fid) % {{{
+		function marshall(self,md,fid) % {{{
 			yts=365.0*24.0*3600.0;
 
 			WriteData(fid,'enum',FrictionLawEnum,'data',2,'format','Integer');
-			WriteData(fid,'class','friction','object',obj,'fieldname','C','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
-			WriteData(fid,'class','friction','object',obj,'fieldname','m','format','DoubleMat','mattype',2);
+			WriteData(fid,'class','friction','object',self,'fieldname','C','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
+			WriteData(fid,'class','friction','object',self,'fieldname','m','format','DoubleMat','mattype',2);
 			
 
 		end % }}}
Index: ../trunk-jpl/src/m/classes/SMBgradients.m
===================================================================
--- ../trunk-jpl/src/m/classes/SMBgradients.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/SMBgradients.m	(revision 19040)
@@ -11,10 +11,10 @@
 		b_neg  = NaN;
 	end
 	methods
-		function obj = SMBgradients(varargin) % {{{
+		function self = SMBgradients(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				otherwise
 					error('constructor not supported');
 			end
@@ -29,12 +29,12 @@
 			%Nothing done for now
 
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 			%Nothing for now
 
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 			if ismember(MasstransportAnalysisEnum(),analyses),
 				md = checkfield(md,'fieldname','surfaceforcings.href','timeseries',1,'NaN',1);
@@ -43,25 +43,25 @@
 				md = checkfield(md,'fieldname','surfaceforcings.b_neg','timeseries',1,'NaN',1);
 			end
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   surface forcings parameters:'));
 
 			disp(sprintf('\n   SMB gradients parameters:'));
-			fielddisplay(obj,'href',' reference elevation from which deviation is used to calculate SMB adjustment in smb gradients method [m]');
-			fielddisplay(obj,'smbref',' reference smb from which deviation is calculated in smb gradients method [mm/yr water equiv]');
-			fielddisplay(obj,'b_pos',' slope of hs - smb regression line for accumulation regime required if smb gradients is activated');
-			fielddisplay(obj,'b_neg',' slope of hs - smb regression line for ablation regime required if smb gradients is activated');
+			fielddisplay(self,'href',' reference elevation from which deviation is used to calculate SMB adjustment in smb gradients method [m]');
+			fielddisplay(self,'smbref',' reference smb from which deviation is calculated in smb gradients method [mm/yr water equiv]');
+			fielddisplay(self,'b_pos',' slope of hs - smb regression line for accumulation regime required if smb gradients is activated');
+			fielddisplay(self,'b_neg',' slope of hs - smb regression line for ablation regime required if smb gradients is activated');
 
 		end % }}}
-		function marshall(obj,md,fid) % {{{
+		function marshall(self,md,fid) % {{{
 
 			yts=365.0*24.0*3600.0;
 
 			WriteData(fid,'enum',SurfaceforcingsEnum(),'data',SMBgradientsEnum(),'format','Integer');
-			WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','href','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
-			WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','smbref','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
-			WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','b_pos','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
-			WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','b_neg','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
+			WriteData(fid,'object',self,'class','surfaceforcings','fieldname','href','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
+			WriteData(fid,'object',self,'class','surfaceforcings','fieldname','smbref','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
+			WriteData(fid,'object',self,'class','surfaceforcings','fieldname','b_pos','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
+			WriteData(fid,'object',self,'class','surfaceforcings','fieldname','b_neg','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
 
 		end % }}}
 	end
Index: ../trunk-jpl/src/m/classes/frictionhydro.m
===================================================================
--- ../trunk-jpl/src/m/classes/frictionhydro.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/frictionhydro.m	(revision 19040)
@@ -11,18 +11,18 @@
 		effective_pressure = NaN; 
 	end
 	methods
-		function obj = frictionhydro(varargin) % {{{
+		function self = frictionhydro(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 			%Early return
 			if ~ismember(StressbalanceAnalysisEnum(),analyses) & ~ismember(ThermalAnalysisEnum(),analyses), return; end
@@ -30,19 +30,19 @@
 			md = checkfield(md,'fieldname','friction.C','NaN',1,'size',[md.mesh.numberofelements 1]);
 			md = checkfield(md,'fieldname','friction.As','NaN',1,'size',[md.mesh.numberofelements 1]);
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('Effective Pressure based friction law described in Gagliardini 2007'));
-			fielddisplay(obj,'q','friction law exponent q>=1');
-			fielddisplay(obj,'C','friction law max value [SI]');
-			fielddisplay(obj,'As','Sliding Parameter without cavitation [m Pa^-n s^-1]');
-			fielddisplay(obj,'effective_pressure','Effective Pressure [Pa]');
+			fielddisplay(self,'q','friction law exponent q>=1');
+			fielddisplay(self,'C','friction law max value [SI]');
+			fielddisplay(self,'As','Sliding Parameter without cavitation [m Pa^-n s^-1]');
+			fielddisplay(self,'effective_pressure','Effective Pressure [Pa]');
 		end % }}}
-		function marshall(obj,md,fid) % {{{
+		function marshall(self,md,fid) % {{{
 			WriteData(fid,'enum',FrictionLawEnum,'data',3,'format','Integer');
-			WriteData(fid,'class','friction','object',obj,'fieldname','q','format','DoubleMat','mattype',2);
-			WriteData(fid,'class','friction','object',obj,'fieldname','C','format','DoubleMat','mattype',2);
-			WriteData(fid,'class','friction','object',obj,'fieldname','As','format','DoubleMat','mattype',2);
-			WriteData(fid,'class','friction','object',obj,'fieldname','effective_pressure','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
+			WriteData(fid,'class','friction','object',self,'fieldname','q','format','DoubleMat','mattype',2);
+			WriteData(fid,'class','friction','object',self,'fieldname','C','format','DoubleMat','mattype',2);
+			WriteData(fid,'class','friction','object',self,'fieldname','As','format','DoubleMat','mattype',2);
+			WriteData(fid,'class','friction','object',self,'fieldname','effective_pressure','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
 		end % }}}
 	end
 end
Index: ../trunk-jpl/src/m/classes/modellist.m
===================================================================
--- ../trunk-jpl/src/m/classes/modellist.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/modellist.m	(revision 19040)
@@ -121,7 +121,7 @@
 			md_list=modellist(models);
 
 		end % }}}
-		function obj = modellist(varargin) % {{{
+		function self = modellist(varargin) % {{{
 
 			%initialize list
 			if nargin==0,
@@ -145,11 +145,11 @@
 					end
 				end
 
-				obj.models  = celllist;
-				obj.cluster = obj.models{1}.cluster;
+				self.models  = celllist;
+				self.cluster = self.models{1}.cluster;
 			end
 		end % }}}
-		function val = get(obj, propName)% {{{
+		function val = get(self, propName)% {{{
 		%GET - gets model propertie from a specified object ans returns the value
 		% 
 		%   Usage:
@@ -157,32 +157,32 @@
 
 			switch propName
 				case 'numberofelements'
-					val = obj.numberofelements;
+					val = self.numberofelements;
 				case 'numberofnodes'
-					val = obj.numberofnodes;
+					val = self.numberofnodes;
 				case 'elements' 
-					val = obj.elements;
+					val = self.elements;
 				case 'x' 
-					val = obj.x;
+					val = self.x;
 				case 'y' 
-					val = obj.y;
+					val = self.y;
 				case 'z' 
-					val = obj.z;
+					val = self.z;
 				otherwise
 					error(['get error message: ' propName,' is not a valid model property'])
 			end
 		end % }}}
-		function obj = loadmultipleresultsfromcluster(obj) % {{{
+		function self = loadmultipleresultsfromcluster(self) % {{{
 			%LOADMULTIPLERESULTSFROMCLUSTER - load multiple results of solution sequences from cluster
 			%
 			%   Usage:
-			%      obj=loadresultsfromcluster(obj);
+			%      self=loadresultsfromcluster(self);
 
-			nummodels=length(obj.models);
+			nummodels=length(self.models);
 
 			%Get cluster settings
-			cluster=obj.cluster;
-			name=obj.name;
+			cluster=self.cluster;
+			name=self.name;
 			cluster_rc_location=which('cluster.rc');
 			[codepath,executionpath]=ClusterParameters(cluster,cluster_rc_location);
 
@@ -199,7 +199,7 @@
 			%ok, go through list and load results from disk: 
 			for i=1:nummodels,
 				%load  results for this model
-				obj.models{i}=loadresultsfromdisk(obj.models{i},[name '-' num2str(i) 'vs' num2str(nummodels) '.outbin']);
+				self.models{i}=loadresultsfromdisk(self.models{i},[name '-' num2str(i) 'vs' num2str(nummodels) '.outbin']);
 
 				delete([name '-' num2str(i) 'vs' num2str(nummodels) '.outbin']);
 			end
@@ -207,16 +207,16 @@
 			%erase files 
 			delete('ModelResults.tar.gz');
 		end % }}}
-		function obj = solve(obj,varargin)% {{{
+		function self = solve(self,varargin)% {{{
 			%SOLVE - apply solution sequence for  a list of models. Used in batch mode.
 			%
 			%   Usage:
-			%      obj=solve(obj,varargin)
+			%      self=solve(self,varargin)
 			%      where varargin is a lit of paired arguments. 
 			%      arguments can be: 'analysis_type': 'stressbalance','thermal','masstransport','transient'
 			%
 			%   Examples:
-			%      obj=solve(obj,'analysis_type','stressbalance');
+			%      self=solve(self,'analysis_type','stressbalance');
 
 			%recover options
 			options=pairoptions(varargin{:});
@@ -225,13 +225,13 @@
 			options=process_solve_options(options);
 
 			%length of list
-			nummodels=length(obj.models);
+			nummodels=length(self.models);
 
 			%name of queue: to make it unique, add a time stamp
-			name=[obj.name '-' datestr(now,1) '-' datestr(now,'HH-MM-SS') ];
+			name=[self.name '-' datestr(now,1) '-' datestr(now,'HH-MM-SS') ];
 
 			%name of cluster will be first name of list
-			cluster=obj.cluster;
+			cluster=self.cluster;
 
 			%Figure out parameters for this particular cluster
 			cluster_rc_location=which('cluster.rc');
@@ -241,17 +241,17 @@
 			for i=1:nummodels,
 
 				%model
-				mdex=obj.models{i};
+				mdex=self.models{i};
 
 				%recover some fields
 				mdex.analysis_type=options.analysis_type;
 
 				mdex.name=[name '-' num2str(i) 'vs' num2str(nummodels)];
-				mdex.time=obj.time;
-				mdex.queue=obj.queue;
-				mdex.cluster=obj.cluster;
-				if ~isnan(obj.np),
-					mdex.np=obj.np;
+				mdex.time=self.time;
+				mdex.queue=self.queue;
+				mdex.cluster=self.cluster;
+				if ~isnan(self.np),
+					mdex.np=self.np;
 				end
 
 				%call solve in batch mode:
@@ -262,7 +262,7 @@
 				end
 
 				%feed back
-				obj.models{i}=mdex;
+				self.models{i}=mdex;
 			end
 
 			%locally, we are done.
@@ -286,7 +286,7 @@
 			delete('ModelList.tar.gz');
 
 			%save name: 
-			obj.name=name;
+			self.name=name;
 		end % }}}
 	end
 end
Index: ../trunk-jpl/src/m/classes/seaiceinitialization.m
===================================================================
--- ../trunk-jpl/src/m/classes/seaiceinitialization.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/seaiceinitialization.m	(revision 19040)
@@ -19,7 +19,7 @@
 		mesh_y             = NaN;
 	end
 	methods
-		function obj = seaiceinitialization(varargin) % {{{
+		function self = seaiceinitialization(varargin) % {{{
 			switch nargin
 				case 0
 					return;
@@ -27,7 +27,7 @@
 					error('constructor not supported');
 			end
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 			md = checkfield(md,'fieldname','initialization.thickness','size',[md.mesh.numberofelements 1],'NaN',1,'>=',0);
 			md = checkfield(md,'fieldname','initialization.concentration','size',[md.mesh.numberofelements 1],'NaN',1,'>=',0);
 			md = checkfield(md,'fieldname','initialization.vx','NaN',1,'size',[md.mesh.numberofvertices 1]);
@@ -41,34 +41,34 @@
 			md = checkfield(md,'fieldname','initialization.mesh_x','NaN',1,'size',[md.mesh.numberofvertices 1]);
 			md = checkfield(md,'fieldname','initialization.mesh_y','NaN',1,'size',[md.mesh.numberofvertices 1]);
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   initial field values:'));
-			fielddisplay(obj,'thickness','sea ice thickness [m]');
-			fielddisplay(obj,'concentration','sea ice concentration (between 0 and 1)');
-			fielddisplay(obj,'vx','x component of the ice velocity [m/s]');
-			fielddisplay(obj,'vy','y component of the ice velocity [m/s]');
-			fielddisplay(obj,'vx_coriolis','x component of the ice velocity used to calculate coriolis forces [m/s]');
-			fielddisplay(obj,'vy_coriolis','y component of the ice velocity used to calculate coriolis forces [m/s]');
-			fielddisplay(obj,'sigma_predictor_xx','Predictor for the xx component of the Cauchy stress tensor [Pa]');
-			fielddisplay(obj,'sigma_predictor_yy','Predictor for the yy component of the Cauchy stress tensor [Pa]');
-			fielddisplay(obj,'sigma_predictor_xy','Predictor for the xy component of the Cauchy stress tensor [Pa]');
-			fielddisplay(obj,'damage','damage, between 0 (no damage) and 1 (fully damaged)');
-			fielddisplay(obj,'mesh_x','x position of each vertex of the mesh using a Lagrangian approach');
-			fielddisplay(obj,'mesh_y','y position of each vertex of the mesh using a Lagrangian approach');
+			fielddisplay(self,'thickness','sea ice thickness [m]');
+			fielddisplay(self,'concentration','sea ice concentration (between 0 and 1)');
+			fielddisplay(self,'vx','x component of the ice velocity [m/s]');
+			fielddisplay(self,'vy','y component of the ice velocity [m/s]');
+			fielddisplay(self,'vx_coriolis','x component of the ice velocity used to calculate coriolis forces [m/s]');
+			fielddisplay(self,'vy_coriolis','y component of the ice velocity used to calculate coriolis forces [m/s]');
+			fielddisplay(self,'sigma_predictor_xx','Predictor for the xx component of the Cauchy stress tensor [Pa]');
+			fielddisplay(self,'sigma_predictor_yy','Predictor for the yy component of the Cauchy stress tensor [Pa]');
+			fielddisplay(self,'sigma_predictor_xy','Predictor for the xy component of the Cauchy stress tensor [Pa]');
+			fielddisplay(self,'damage','damage, between 0 (no damage) and 1 (fully damaged)');
+			fielddisplay(self,'mesh_x','x position of each vertex of the mesh using a Lagrangian approach');
+			fielddisplay(self,'mesh_y','y position of each vertex of the mesh using a Lagrangian approach');
 		end % }}}
-		function marshall(obj,md,fid) % {{{
-			WriteData(fid,'data',obj.thickness,'format','DoubleMat','mattype',2,'enum',SeaiceThicknessEnum());
-			WriteData(fid,'data',obj.concentration,'format','DoubleMat','mattype',2,'enum',SeaiceConcentrationEnum());
-			WriteData(fid,'data',obj.vx,'format','DoubleMat','mattype',1,'enum',VxEnum);
-			WriteData(fid,'data',obj.vy,'format','DoubleMat','mattype',1,'enum',VyEnum);
-			WriteData(fid,'data',obj.vx_coriolis,'format','DoubleMat','mattype',1,'enum',VxStarEnum());
-			WriteData(fid,'data',obj.vy_coriolis,'format','DoubleMat','mattype',1,'enum',VyStarEnum());
-			WriteData(fid,'data',obj.sigma_predictor_xx,'format','DoubleMat','mattype',2,'enum',StressTensorPredictorxxEnum());
-			WriteData(fid,'data',obj.sigma_predictor_yy,'format','DoubleMat','mattype',2,'enum',StressTensorPredictoryyEnum());
-			WriteData(fid,'data',obj.sigma_predictor_xy,'format','DoubleMat','mattype',2,'enum',StressTensorPredictorxyEnum());
-			WriteData(fid,'data',obj.damage,'format','DoubleMat','mattype',2,'enum',DamageEnum());
-			WriteData(fid,'data',obj.mesh_x,'format','DoubleMat','mattype',1,'enum',MeshXEnum());
-			WriteData(fid,'data',obj.mesh_y,'format','DoubleMat','mattype',1,'enum',MeshYEnum());
+		function marshall(self,md,fid) % {{{
+			WriteData(fid,'data',self.thickness,'format','DoubleMat','mattype',2,'enum',SeaiceThicknessEnum());
+			WriteData(fid,'data',self.concentration,'format','DoubleMat','mattype',2,'enum',SeaiceConcentrationEnum());
+			WriteData(fid,'data',self.vx,'format','DoubleMat','mattype',1,'enum',VxEnum);
+			WriteData(fid,'data',self.vy,'format','DoubleMat','mattype',1,'enum',VyEnum);
+			WriteData(fid,'data',self.vx_coriolis,'format','DoubleMat','mattype',1,'enum',VxStarEnum());
+			WriteData(fid,'data',self.vy_coriolis,'format','DoubleMat','mattype',1,'enum',VyStarEnum());
+			WriteData(fid,'data',self.sigma_predictor_xx,'format','DoubleMat','mattype',2,'enum',StressTensorPredictorxxEnum());
+			WriteData(fid,'data',self.sigma_predictor_yy,'format','DoubleMat','mattype',2,'enum',StressTensorPredictoryyEnum());
+			WriteData(fid,'data',self.sigma_predictor_xy,'format','DoubleMat','mattype',2,'enum',StressTensorPredictorxyEnum());
+			WriteData(fid,'data',self.damage,'format','DoubleMat','mattype',2,'enum',DamageEnum());
+			WriteData(fid,'data',self.mesh_x,'format','DoubleMat','mattype',1,'enum',MeshXEnum());
+			WriteData(fid,'data',self.mesh_y,'format','DoubleMat','mattype',1,'enum',MeshYEnum());
 		end % }}}
 	end
 end
Index: ../trunk-jpl/src/m/classes/frictionweertmantemp.m
===================================================================
--- ../trunk-jpl/src/m/classes/frictionweertmantemp.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/frictionweertmantemp.m	(revision 19040)
@@ -10,39 +10,39 @@
 		m = NaN;
 	end
 	methods
-		function obj = frictionweertmantemp(varargin) % {{{
+		function self = frictionweertmantemp(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 			%Early return
 			if ~ismember(StressbalanceAnalysisEnum(),analyses) & ~ismember(ThermalAnalysisEnum(),analyses), return; end
 			md = checkfield(md,'fieldname','friction.C','timeseries',1,'NaN',1);
 			md = checkfield(md,'fieldname','friction.m','NaN',1,'size',[md.mesh.numberofelements 1]);
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp('Weertman sliding law parameters:');
 			disp('      Sigma_b = C^(-1/m) * |u_b|^(1/m-1)  u_b * 1/f(T)');
 			disp(' ');
-			fielddisplay(obj,'gamma','submelt sliding parameter f(T) = exp((T-Tpmp)/gamma)');
-			fielddisplay(obj,'C','friction coefficient [SI]');
-			fielddisplay(obj,'m','m exponent');
+			fielddisplay(self,'gamma','submelt sliding parameter f(T) = exp((T-Tpmp)/gamma)');
+			fielddisplay(self,'C','friction coefficient [SI]');
+			fielddisplay(self,'m','m exponent');
 		end % }}}
-		function marshall(obj,md,fid) % {{{
+		function marshall(self,md,fid) % {{{
 			yts=365.0*24.0*3600.0;
 
 			WriteData(fid,'enum',FrictionLawEnum,'data',6,'format','Integer');
-			WriteData(fid,'class','friction','object',obj,'fieldname','gamma','format','Double');
-			WriteData(fid,'class','friction','object',obj,'fieldname','C','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
-			WriteData(fid,'class','friction','object',obj,'fieldname','m','format','DoubleMat','mattype',2);
+			WriteData(fid,'class','friction','object',self,'fieldname','gamma','format','Double');
+			WriteData(fid,'class','friction','object',self,'fieldname','C','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
+			WriteData(fid,'class','friction','object',self,'fieldname','m','format','DoubleMat','mattype',2);
 			
 
 		end % }}}
Index: ../trunk-jpl/src/m/classes/dependent.m
===================================================================
--- ../trunk-jpl/src/m/classes/dependent.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/dependent.m	(revision 19040)
@@ -14,71 +14,71 @@
 		nods                 = 0;
 	end
 	methods
-		function obj = dependent(varargin) % {{{
+		function self = dependent(varargin) % {{{
 
 			%use provided options to change fields
 			options=pairoptions(varargin{:});
 
-			obj.name=getfieldvalue(options,'name','');
-			obj.type=getfieldvalue(options,'type','');
-			obj.exp=getfieldvalue(options,'exp','');
-			obj.segments=getfieldvalue(options,'segments',[]);
-			obj.index=getfieldvalue(options,'index',-1);
-			obj.nods=getfieldvalue(options,'nods',0);
+			self.name=getfieldvalue(options,'name','');
+			self.type=getfieldvalue(options,'type','');
+			self.exp=getfieldvalue(options,'exp','');
+			self.segments=getfieldvalue(options,'segments',[]);
+			self.index=getfieldvalue(options,'index',-1);
+			self.nods=getfieldvalue(options,'nods',0);
 
 			%if name is mass flux: 
-			if strcmpi(obj.name,'MassFlux'),
+			if strcmpi(self.name,'MassFlux'),
 				%make sure that we supplied a file and that it exists! 
-				if exist(obj.exp)~=2,
+				if exist(self.exp)~=2,
 					error('dependent checkconsistency: specified ''exp'' file does not exist!');
 				end
 				%process the file and retrieve segments
 				mesh=getfieldvalue(options,'mesh');
-				obj.segments=MeshProfileIntersection(mesh.elements,mesh.x,mesh.y,obj.exp);
+				self.segments=MeshProfileIntersection(mesh.elements,mesh.x,mesh.y,self.exp);
 			end
 		end
 		%}}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 			%do nothing
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
-			if strcmpi(obj.name,'MassFlux'),
-				if isempty(obj.segments),
+		function md = checkconsistency(self,md,solution,analyses) % {{{
+			if strcmpi(self.name,'MassFlux'),
+				if isempty(self.segments),
 					error('dependent checkconsistency error: need segments to compute this dependent response');
 				end
-				if obj.index<=0,
+				if self.index<=0,
 					error('dependent checkconsistency error: index for segments should be >=1');
 				end
 			end
-			if ~isnan(obj.fos_reverse_index),
+			if ~isnan(self.fos_reverse_index),
 				if ~strcmpi(driver,'fos_reverse'),
 					error('cannot declare a dependent with a fos_reverse_index when the driver is not fos_reverse!');
 				end
-				if obj.nods==0,
+				if self.nods==0,
 					error('dependent checkconsistency error: nods should be set to the size of the independent variable');
 				end
 			end
 
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   dependent variable:'));
 
-			fielddisplay(obj,'name','variable name (must match corresponding Enum)');
-			fielddisplay(obj,'type','type of variable (''vertex'' or ''scalar'')');
+			fielddisplay(self,'name','variable name (must match corresponding Enum)');
+			fielddisplay(self,'type','type of variable (''vertex'' or ''scalar'')');
 
-			if ~isnan(obj.fos_reverse_index),
-				fielddisplay(obj,'fos_reverse_index','index for fos_reverse driver of ADOLC');
+			if ~isnan(self.fos_reverse_index),
+				fielddisplay(self,'fos_reverse_index','index for fos_reverse driver of ADOLC');
 			end
-			if ~isempty(obj.exp),
-				fielddisplay(obj,'exp','file needed to compute dependent variable');
-				fielddisplay(obj,'segments','mass flux segments');
+			if ~isempty(self.exp),
+				fielddisplay(self,'exp','file needed to compute dependent variable');
+				fielddisplay(self,'segments','mass flux segments');
 			end
 
 		end % }}}
-		function scalar=typetoscalar(obj) % {{{
-			if strcmpi(obj.type,'scalar'),
+		function scalar=typetoscalar(self) % {{{
+			if strcmpi(self.type,'scalar'),
 				scalar=0;
-			elseif strcmpi(obj.type,'vertex'),
+			elseif strcmpi(self.type,'vertex'),
 				scalar=1;
 			end
 
Index: ../trunk-jpl/src/m/classes/timestepping.m
===================================================================
--- ../trunk-jpl/src/m/classes/timestepping.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/timestepping.m	(revision 19040)
@@ -14,47 +14,47 @@
 		in_years        = 1;
 	end
 	methods
-       function createxml(obj,fid) % {{{
+       function createxml(self,fid) % {{{
             fprintf(fid, '\n\n');
             fprintf(fid, '%s\n', '<!-- Timestepping -->');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="start_time" type="',              class(obj.start_time),'" default="',                  convert2str(obj.start_time),'">',              '     <section name="timestepping" />','     <help> simulation starting time [yr] </help>','</parameter>');
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="final_time" type="',            class(obj.final_time),'" default="',                convert2str(obj.final_time),'">',   '     <section name="timestepping" />','     <help> final time to stop the simulation [yr] </help>','</parameter>');
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',        '<parameter key ="time_step" type="',      class(obj.time_step),'" default="',          convert2str(obj.time_step),'">',            '     <section name="timestepping" />','     <help> length of time steps [yr] </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="start_time" type="',              class(self.start_time),'" default="',                  convert2str(self.start_time),'">',              '     <section name="timestepping" />','     <help> simulation starting time [yr] </help>','</parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="final_time" type="',            class(self.final_time),'" default="',                convert2str(self.final_time),'">',   '     <section name="timestepping" />','     <help> final time to stop the simulation [yr] </help>','</parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',        '<parameter key ="time_step" type="',      class(self.time_step),'" default="',          convert2str(self.time_step),'">',            '     <section name="timestepping" />','     <help> length of time steps [yr] </help>','</parameter>');
             % time_adapt 0 or 1 drop down
             fprintf(fid,'%s\n%s\n%s\n%s\n','<parameter key ="time_adapt" type="alternative" optional="false">','     <section name="timestepping" />','     <help> use cfl condition to define time step ? (0 or 1)  </help>');
             fprintf(fid, '%s\n',   '       <option value="0" type="string" default="true"></option>');
             fprintf(fid, '%s\n%s\n',   '       <option value="1" type="string" default="false"></option>','</parameter>');
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="cfl_coefficient" type="',       class(obj.cfl_coefficient),'" default="',              convert2str(obj.cfl_coefficient),'">',              '     <section name="timestepping" />','     <help> coefficient applied to cfl condition </help>','</parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="cfl_coefficient" type="',       class(self.cfl_coefficient),'" default="',              convert2str(self.cfl_coefficient),'">',              '     <section name="timestepping" />','     <help> coefficient applied to cfl condition </help>','</parameter>');
             
         end % }}}
         
-		function obj = timestepping(varargin) % {{{
+		function self = timestepping(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 			%time between 2 time steps
-			obj.time_step=1./2.;
+			self.time_step=1./2.;
 
 			%final time
-			obj.final_time=10.*obj.time_step;
+			self.final_time=10.*self.time_step;
 
 			%time adaptation? 
-			obj.time_adapt=0;
-			obj.cfl_coefficient=0.5;
+			self.time_adapt=0;
+			self.cfl_coefficient=0.5;
 
 			%should we interpolate forcings between timesteps?
-			obj.interp_forcings=1;
+			self.interp_forcings=1;
 
 			%In years by default
-			obj.in_years = 1;
+			self.in_years = 1;
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 			md = checkfield(md,'fieldname','timestepping.start_time','numel',[1],'NaN',1);
 			md = checkfield(md,'fieldname','timestepping.final_time','numel',[1],'NaN',1);
@@ -62,40 +62,40 @@
 			md = checkfield(md,'fieldname','timestepping.time_adapt','numel',[1],'values',[0 1]);
 			md = checkfield(md,'fieldname','timestepping.cfl_coefficient','numel',[1],'>',0,'<=',1);
 			md = checkfield(md,'fieldname','timestepping.interp_forcings','numel',[1],'values',[0 1]);
-			if obj.final_time-obj.start_time<0,
+			if self.final_time-self.start_time<0,
 				md = checkmessage(md,'timestepping.final_time should be larger than timestepping.start_time');
 			end 
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   timestepping parameters:'));
 
-			if(obj.in_years)
+			if(self.in_years)
 				unit = 'yr';
 			else
 				unit = 's';
 			end
-			fielddisplay(obj,'start_time',['simulation starting time [' unit ']']);
-			fielddisplay(obj,'final_time',['final time to stop the simulation [' unit ']']);
-			fielddisplay(obj,'time_step',['length of time steps [' unit ']']);
-			fielddisplay(obj,'time_adapt','use cfl condition to define time step ? (0 or 1) ');
-			fielddisplay(obj,'cfl_coefficient','coefficient applied to cfl condition');
-			fielddisplay(obj,'interp_forcings','interpolate in time between requested forcing values ? (0 or 1)');
-			fielddisplay(obj,'in_years','time unit, 1: years, 0: seconds');
+			fielddisplay(self,'start_time',['simulation starting time [' unit ']']);
+			fielddisplay(self,'final_time',['final time to stop the simulation [' unit ']']);
+			fielddisplay(self,'time_step',['length of time steps [' unit ']']);
+			fielddisplay(self,'time_adapt','use cfl condition to define time step ? (0 or 1) ');
+			fielddisplay(self,'cfl_coefficient','coefficient applied to cfl condition');
+			fielddisplay(self,'interp_forcings','interpolate in time between requested forcing values ? (0 or 1)');
+			fielddisplay(self,'in_years','time unit, 1: years, 0: seconds');
 
 		end % }}}
-		function marshall(obj,md,fid) % {{{
+		function marshall(self,md,fid) % {{{
 
-			if obj.in_years,
+			if self.in_years,
 				scale = 365.0*24.0*3600.0;
 			else
 				scale = 1.;
 			end
-			WriteData(fid,'object',obj,'fieldname','start_time','format','Double','scale',scale);
-			WriteData(fid,'object',obj,'fieldname','final_time','format','Double','scale',scale);
-			WriteData(fid,'object',obj,'fieldname','time_step','format','Double','scale',scale);
-			WriteData(fid,'object',obj,'fieldname','time_adapt','format','Boolean');
-			WriteData(fid,'object',obj,'fieldname','cfl_coefficient','format','Double');
-			WriteData(fid,'object',obj,'fieldname','interp_forcings','format','Boolean');
+			WriteData(fid,'object',self,'fieldname','start_time','format','Double','scale',scale);
+			WriteData(fid,'object',self,'fieldname','final_time','format','Double','scale',scale);
+			WriteData(fid,'object',self,'fieldname','time_step','format','Double','scale',scale);
+			WriteData(fid,'object',self,'fieldname','time_adapt','format','Boolean');
+			WriteData(fid,'object',self,'fieldname','cfl_coefficient','format','Double');
+			WriteData(fid,'object',self,'fieldname','interp_forcings','format','Boolean');
 		end % }}}
 	end
 end
Index: ../trunk-jpl/src/m/classes/private.m
===================================================================
--- ../trunk-jpl/src/m/classes/private.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/private.m	(revision 19040)
@@ -11,27 +11,27 @@
 		solution     = '';
 	end
 	methods
-		function obj = private(varargin) % {{{
+		function self = private(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   private parameters: do not change'));
 
-			fielddisplay(obj,'isconsistent','is model self consistent');
-			fielddisplay(obj,'runtimename','name of the run launched');
-			fielddisplay(obj,'bamg','structure with mesh properties constructed if bamg is used to mesh the domain');
-			fielddisplay(obj,'solution','type of solution launched');
+			fielddisplay(self,'isconsistent','is model self consistent');
+			fielddisplay(self,'runtimename','name of the run launched');
+			fielddisplay(self,'bamg','structure with mesh properties constructed if bamg is used to mesh the domain');
+			fielddisplay(self,'solution','type of solution launched');
 
 		end % }}}
 	end
Index: ../trunk-jpl/src/m/classes/snowpack.m
===================================================================
--- ../trunk-jpl/src/m/classes/snowpack.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/snowpack.m	(revision 19040)
@@ -104,10 +104,10 @@
 
 	end
 	methods
-		function obj = snowpack(varargin) % {{{
+		function self = snowpack(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				case 1
 					inputstruct=varargin{1};
 					list1 = properties('snowpack');
@@ -115,108 +115,108 @@
 					for i=1:length(list1)
 						fieldname = list1{i};
 						if ismember(fieldname,list2),
-							obj.(fieldname) = inputstruct.(fieldname);
+							self.(fieldname) = inputstruct.(fieldname);
 						end
 					end
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 		%snowpack:  %{{{
-		obj.snowpack_meas_tss = 1;
-		obj.snowpack_enforce_measured_snow_heights = 0;
-		obj.snowpack_sw_mode = 0;
-		obj.snowpack_incoming_longwave = 1;
-		obj.snowpack_height_of_wind_value = 12.;
-		obj.snowpack_height_of_meteo_values = 12.;
-		obj.snowpack_neutral = 0;
-		obj.snowpack_roughness_length = 0.002;
-		obj.snowpack_number_slopes = 1;
-		obj.snowpack_snow_redistribution = 1;
-		obj.snowpack_calculation_step_length = 15.0;
-		obj.snowpack_change_bc = 0;
-		obj.snowpack_thresh_change_bc = -1.0;
-		obj.snowpack_snp_soil = 0;
-		obj.snowpack_soil_flux = 0;
-		obj.snowpack_geo_heat = 0.06;
-		obj.snowpack_canopy = 0;
+		self.snowpack_meas_tss = 1;
+		self.snowpack_enforce_measured_snow_heights = 0;
+		self.snowpack_sw_mode = 0;
+		self.snowpack_incoming_longwave = 1;
+		self.snowpack_height_of_wind_value = 12.;
+		self.snowpack_height_of_meteo_values = 12.;
+		self.snowpack_neutral = 0;
+		self.snowpack_roughness_length = 0.002;
+		self.snowpack_number_slopes = 1;
+		self.snowpack_snow_redistribution = 1;
+		self.snowpack_calculation_step_length = 15.0;
+		self.snowpack_change_bc = 0;
+		self.snowpack_thresh_change_bc = -1.0;
+		self.snowpack_snp_soil = 0;
+		self.snowpack_soil_flux = 0;
+		self.snowpack_geo_heat = 0.06;
+		self.snowpack_canopy = 0;
 		%}}}
 		%snowpackadvanced:  %{{{
-		obj.snowpackadvanced_variant = 'ANTARCTICA'; % use 320 kg m-3 for fixed density
-		obj.snowpackadvanced_hn_density = 'EVENT';
+		self.snowpackadvanced_variant = 'ANTARCTICA'; % use 320 kg m-3 for fixed density
+		self.snowpackadvanced_hn_density = 'EVENT';
 		%}}}
 		%general:  %{{{
-		obj.general_pluginpath = '/usr/local/lib/meteoio/plugins/';
-		obj.general_buff_chunk_size = 90;
-		obj.general_buff_before = 1.5;
+		self.general_pluginpath = '/usr/local/lib/meteoio/plugins/';
+		self.general_buff_chunk_size = 90;
+		self.general_buff_before = 1.5;
 		%}}}
 		%input {{{
-		obj.input_coordsys = 'ch1903';
-		obj.input_coordparam = 'null';
-		obj.input_time_zone = 8;
-		obj.input_meteo = 'smet';
-		obj.input_meteopath = './input';
-		obj.input_station1 = 'domec.smet';
-		obj.input_snowfile1 = 'domec.sno';
+		self.input_coordsys = 'ch1903';
+		self.input_coordparam = 'null';
+		self.input_time_zone = 8;
+		self.input_meteo = 'smet';
+		self.input_meteopath = './input';
+		self.input_station1 = 'domec.smet';
+		self.input_snowfile1 = 'domec.sno';
 		%}}}
 		%output {{{
-		obj.output_coordsys = 'ch1903';
-		obj.output_coordparam = 'null';
-		obj.output_time_zone = 8;
-		obj.output_meteopath = './output';
-		obj.output_experiment = 'smet';
-		obj.output_ts_write = 1;
-		obj.output_ts_start = 0.0;
-		obj.output_ts_days_between = 0.04166667;
-		obj.output_profile = 'ascii';
-		obj.output_prof_write = 1;
-		obj.output_prof_start = 0.0;
-		obj.output_prof_days_between = 0.04166667;
+		self.output_coordsys = 'ch1903';
+		self.output_coordparam = 'null';
+		self.output_time_zone = 8;
+		self.output_meteopath = './output';
+		self.output_experiment = 'smet';
+		self.output_ts_write = 1;
+		self.output_ts_start = 0.0;
+		self.output_ts_days_between = 0.04166667;
+		self.output_profile = 'ascii';
+		self.output_prof_write = 1;
+		self.output_prof_start = 0.0;
+		self.output_prof_days_between = 0.04166667;
 		%}}}
 		%interpolations1d %{{{
-		obj.interpolations1d_window_size = 439200; %that is 5 d and 2 h; 1 d = 86400
-		obj.interpolations1d_hnw_resample = 'none';
-		obj.interpolations1d_hs_resample = 'linear';
-		obj.interpolations1d_tsg_resample = 'linear';
-		obj.interpolations1d_rho_hn_resample = 'none';
-		obj.interpolations1d_vw_resample = 'nearest_neighbour';
-		obj.interpolations1d_vw_args = 'extrapolate';
+		self.interpolations1d_window_size = 439200; %that is 5 d and 2 h; 1 d = 86400
+		self.interpolations1d_hnw_resample = 'none';
+		self.interpolations1d_hs_resample = 'linear';
+		self.interpolations1d_tsg_resample = 'linear';
+		self.interpolations1d_rho_hn_resample = 'none';
+		self.interpolations1d_vw_resample = 'nearest_neighbour';
+		self.interpolations1d_vw_args = 'extrapolate';
 		%}}}
 		%filters {{{
-		obj.filters_ta_filter1 = 'min_max';
-		obj.filters_ta_arg1 = [190 280];
-		obj.filters_rh_filter1 = 'min_max';
-		obj.filters_rh_arg1 = [0.01 1.2];
-		obj.filters_rh_filter2 = 'min_max';
-		obj.filters_rh_arg2 = {'soft' 0.01 1.0};
-		obj.filters_iswr_filter1 = 'min_max';
-		obj.filters_iswr_arg1 = [-10 1500];
-		obj.filters_iswr_filter2 = 'min_max';
-		obj.filters_iswr_arg2 = {'soft' 0 1500};
-		obj.filters_rswr_filter1 = 'min_max';
-		obj.filters_rswr_arg1 = [-10 1500];
-		obj.filters_rswr_filter2 = 'min_max';
-		obj.filters_rswr_arg2 = {'soft' 0 1500};
+		self.filters_ta_filter1 = 'min_max';
+		self.filters_ta_arg1 = [190 280];
+		self.filters_rh_filter1 = 'min_max';
+		self.filters_rh_arg1 = [0.01 1.2];
+		self.filters_rh_filter2 = 'min_max';
+		self.filters_rh_arg2 = {'soft' 0.01 1.0};
+		self.filters_iswr_filter1 = 'min_max';
+		self.filters_iswr_arg1 = [-10 1500];
+		self.filters_iswr_filter2 = 'min_max';
+		self.filters_iswr_arg2 = {'soft' 0 1500};
+		self.filters_rswr_filter1 = 'min_max';
+		self.filters_rswr_arg1 = [-10 1500];
+		self.filters_rswr_filter2 = 'min_max';
+		self.filters_rswr_arg2 = {'soft' 0 1500};
 
 		%for ta between 190 and 280 k;
-		obj.filters_ilwr_filter1 = 'min_max';
-		obj.filters_ilwr_arg1 = [30 355];
-		obj.filters_ilwr_filter2 = 'min_max';
-		obj.filters_ilwr_arg2 = {'soft' 35 350};
-		obj.filters_tss_filter1 = 'min_max';
-		obj.filters_tss_arg1 = [180 275];
-		obj.filters_tsg_filter1 = 'min_max';
-		obj.filters_tsg_arg1 = [200 275];
-		obj.filters_vw_filter1 = 'min_max';
-		obj.filters_vw_arg1 = [-2 70];
-		obj.filters_vw_filter2 = 'min_max';
-		obj.filters_vw_arg2 = {'soft' 0 50};
+		self.filters_ilwr_filter1 = 'min_max';
+		self.filters_ilwr_arg1 = [30 355];
+		self.filters_ilwr_filter2 = 'min_max';
+		self.filters_ilwr_arg2 = {'soft' 35 350};
+		self.filters_tss_filter1 = 'min_max';
+		self.filters_tss_arg1 = [180 275];
+		self.filters_tsg_filter1 = 'min_max';
+		self.filters_tsg_arg1 = [200 275];
+		self.filters_vw_filter1 = 'min_max';
+		self.filters_vw_arg1 = [-2 70];
+		self.filters_vw_filter2 = 'min_max';
+		self.filters_vw_arg2 = {'soft' 0 50};
 		%}}}
 
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 			%snowpack:  %{{{
 			md=checkfield(md,'fieldname','snowpack.snowpack_meas_tss','values',[0 1]);
 			md=checkfield(md,'fieldname','snowpack.snowpack_enforce_measured_snow_heights','values',[0 1]);
@@ -336,144 +336,144 @@
 
 			%}}}
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 
 			disp(sprintf('   Snowpack solution parameters:'));
 			disp(sprintf('\n	%s','Snowpack parameters:')); % {{{
-			fielddisplay(obj,'snowpack_meas_tss',{'A measured surface temperature is available and can be reliably ','used for various consistency tests (it needs to be set to true if enabling CHANGE_BC) (0 or 1)'});
-			fielddisplay(obj,'snowpack_enforce_measured_snow_heights','Input mode by which a measurement of snow depth is used to drive the snow cover mass balance (0 or 1)');
-			fielddisplay(obj,'snowpack_sw_mode',{'Define the shortwave radiation input:',...
+			fielddisplay(self,'snowpack_meas_tss',{'A measured surface temperature is available and can be reliably ','used for various consistency tests (it needs to be set to true if enabling CHANGE_BC) (0 or 1)'});
+			fielddisplay(self,'snowpack_enforce_measured_snow_heights','Input mode by which a measurement of snow depth is used to drive the snow cover mass balance (0 or 1)');
+			fielddisplay(self,'snowpack_sw_mode',{'Define the shortwave radiation input:',...
 				'0 Incoming shortwave radiation is measured and albedo estimated by the model',...
 				'1 Reflected shortwave radiation is available as input and albedo is estimated by the model (IMIS standard)',...
 				'2 Incoming and reflected shortwave radiation are both measured and the albedo is estimated from both measurements subject to plausibility checks.'});
-			fielddisplay(obj,'snowpack_incoming_longwave','Use the provided incoming long wave on the virtual slopes? (0 or 1)');
-			fielddisplay(obj,'snowpack_height_of_wind_value',{'The instrument height (or model layer height) for wind input data; note that height ',...
+			fielddisplay(self,'snowpack_incoming_longwave','Use the provided incoming long wave on the virtual slopes? (0 or 1)');
+			fielddisplay(self,'snowpack_height_of_wind_value',{'The instrument height (or model layer height) for wind input data; note that height ',...
 				'is above ground for a standard SNOWPACK application but above surface (snow or ground) for Alpine3D applications '});
-			fielddisplay(obj,'snowpack_height_of_meteo_values',{'The instrument height (or model layer height) for meteorological input data except for wind,',...
+			fielddisplay(self,'snowpack_height_of_meteo_values',{'The instrument height (or model layer height) for meteorological input data except for wind,',...
 				'which may be at a different height; note that height is above ground for a standard SNOWPACK ',...
 				'application but above surface (snow or ground) for Alpine3D applications. '});
-			fielddisplay(obj,'snowpack_neutral',{'Select the atmospheric stability correction model:',...
+			fielddisplay(self,'snowpack_neutral',{'Select the atmospheric stability correction model:',...
 				'-1 use a simplified Richardson number stability correction',...
 				'0 assume standard Monin-Obukhov bulk formulation for surface exchange iteration with Paulson, Stearns and Weidner (can be used with BC_CHANGE=0)',...
 				'1 force Monin-Obukhov formulation to assume neutral conditions regardless of the actual stratification; it has been shown to work well in ',...
 				'complex terrain settings. It should be used with BC_CHANGE=1, i.e., Dirichlet /* but also is recommended with Neumann b.c., i.e., BC_CHANGE=0.'});
-			fielddisplay(obj,'snowpack_roughness_length',{'Aerodynamic roughness length as a parameter for the Monin-Obukhov bulk formulation;',...
+			fielddisplay(self,'snowpack_roughness_length',{'Aerodynamic roughness length as a parameter for the Monin-Obukhov bulk formulation;',...
 				'A typical value for complex terrain is 0.01 m and for snow covered flat sites 0.001 m. '});
-			fielddisplay(obj,'snowpack_number_slopes',{'Based on meteorological input from a (flat field) automatic station or numerical weather model,',...
+			fielddisplay(self,'snowpack_number_slopes',{'Based on meteorological input from a (flat field) automatic station or numerical weather model,',...
 				'up to 8 expositions can be calculated in addition to the flat field if the corresponding *.sno files are provided. For example,',...
 				'if you provide a flat field *.snow file (mandatory), which is named KLO3.sno and you want 4 slopes to be calculated the corresponding',...
 				'slope files should be named KLO21.sno, ...,KLO24.sno '});
-			fielddisplay(obj,'snowpack_snow_redistribution',{'Specifies if redistribution of snow is allowed from (upwind) expositions to lee slopes.',...
+			fielddisplay(self,'snowpack_snow_redistribution',{'Specifies if redistribution of snow is allowed from (upwind) expositions to lee slopes.',...
 				'In case just the flat field is calculated, snow erosion is enabled but only for "ENFORCE_MEASURED_SNOW_HEIGHTS".'});
-				fielddisplay(obj,'snowpack_calculation_step_length',{'Internal time step (in minutes) used for model simulation. Please note that this MUST ',...
+				fielddisplay(self,'snowpack_calculation_step_length',{'Internal time step (in minutes) used for model simulation. Please note that this MUST ',...
 				'be the same as HNW::accumulate (the latter being in seconds) if re-acumulating precipitation, otherwise it would lead to wrong results.'});
-			fielddisplay(obj,'snowpack_change_bc',{'Use measured surface temperature as Dirichlet temperature BC for sub-freezing snowpacks and switch to ',...
+			fielddisplay(self,'snowpack_change_bc',{'Use measured surface temperature as Dirichlet temperature BC for sub-freezing snowpacks and switch to ',...
 			'Neumann only for melting snowpacks. If set to false, assumes Neumann boundary conditions.'});
-			fielddisplay(obj,'snowpack_thresh_change_bc','Threshold value (small number below freezing), which switches from Dirichlet to Neumann BCs if CHANGE_BC is selected');
-			fielddisplay(obj,'snowpack_snp_soil','Soil layers as defined by the *.sno files are included in the simulation');
-			fielddisplay(obj,'snowpack_soil_flux','Assume that the lower temperature boundary condition is given by GEO_HEAT (Neumann) and not by a measured temperature');
-			fielddisplay(obj,'snowpack_geo_heat','Constant geothermal heat flux at great) depth W m-2): Lower flux boundary condition for temperature equation if BC is Neumann');
-			fielddisplay(obj,'snowpack_canopy','Switch to tell the model that canopy is present (note that Canopy parameters should then be provided in the *.sno file)');
+			fielddisplay(self,'snowpack_thresh_change_bc','Threshold value (small number below freezing), which switches from Dirichlet to Neumann BCs if CHANGE_BC is selected');
+			fielddisplay(self,'snowpack_snp_soil','Soil layers as defined by the *.sno files are included in the simulation');
+			fielddisplay(self,'snowpack_soil_flux','Assume that the lower temperature boundary condition is given by GEO_HEAT (Neumann) and not by a measured temperature');
+			fielddisplay(self,'snowpack_geo_heat','Constant geothermal heat flux at great) depth W m-2): Lower flux boundary condition for temperature equation if BC is Neumann');
+			fielddisplay(self,'snowpack_canopy','Switch to tell the model that canopy is present (note that Canopy parameters should then be provided in the *.sno file)');
 			% }}}
 			disp(sprintf('\n	%s','Snowpackadvanced parameters:')); % {{{
-			fielddisplay(obj,'snowpackadvanced_variant','variant selection (includes a choice of specific models, DEFAULT, ANTARCTICA and JAPAN )'); % use 320 kg m-3 for fixed density
-			fielddisplay(obj,'snowpackadvanced_hn_density',{'Fixed value to be used as new snow density if a constant density model is chosen, otherwise the choices are "PARAMETERIZED" "EVENT" "MEASURED"'});
+			fielddisplay(self,'snowpackadvanced_variant','variant selection (includes a choice of specific models, DEFAULT, ANTARCTICA and JAPAN )'); % use 320 kg m-3 for fixed density
+			fielddisplay(self,'snowpackadvanced_hn_density',{'Fixed value to be used as new snow density if a constant density model is chosen, otherwise the choices are "PARAMETERIZED" "EVENT" "MEASURED"'});
 			% }}}
 			disp(sprintf('\n	%s','General parameters:')); % {{{
-			fielddisplay(obj,'general_pluginpath','');
-			fielddisplay(obj,'general_buff_chunk_size','Size in days of a chunk of data to read at once.');
-			fielddisplay(obj,'general_buff_before','Alternate way of buffer centering: When rebuffering, the new date will be located BUFF_BEFORE days from the beginning of the buffer (therefore, it takes a value in days). ');
+			fielddisplay(self,'general_pluginpath','');
+			fielddisplay(self,'general_buff_chunk_size','Size in days of a chunk of data to read at once.');
+			fielddisplay(self,'general_buff_before','Alternate way of buffer centering: When rebuffering, the new date will be located BUFF_BEFORE days from the beginning of the buffer (therefore, it takes a value in days). ');
 			% }}}
 			disp(sprintf('\n	%s','Input  parameter:')); % {{{
-			fielddisplay(obj,'input_coordsys','coordinates in the Swiss Grid (http://geomatics.ladetto.ch/ch1903_wgs84_de.pdf). One of CH1903,UTM,UPS,PROJ4 or LOCAL');
-			fielddisplay(obj,'input_coordparam',' ');
-			fielddisplay(obj,'input_time_zone',' ');
-			fielddisplay(obj,'input_meteo','plugin for METEO data (one of BORMA,COSMO,GEOTOP,GRIB,GS,IMIS,SMET,SNOWPACK');
-			fielddisplay(obj,'input_meteopath','string containing the path to the xml files.');
-			fielddisplay(obj,'input_station1','Meteorology file for station number #');
-			fielddisplay(obj,'input_snowfile1','File name for the initial snow profile for station number #');
+			fielddisplay(self,'input_coordsys','coordinates in the Swiss Grid (http://geomatics.ladetto.ch/ch1903_wgs84_de.pdf). One of CH1903,UTM,UPS,PROJ4 or LOCAL');
+			fielddisplay(self,'input_coordparam',' ');
+			fielddisplay(self,'input_time_zone',' ');
+			fielddisplay(self,'input_meteo','plugin for METEO data (one of BORMA,COSMO,GEOTOP,GRIB,GS,IMIS,SMET,SNOWPACK');
+			fielddisplay(self,'input_meteopath','string containing the path to the xml files.');
+			fielddisplay(self,'input_station1','Meteorology file for station number #');
+			fielddisplay(self,'input_snowfile1','File name for the initial snow profile for station number #');
 			% }}}
 			disp(sprintf('\n	%s','Output parameters:')); % {{{
-			fielddisplay(obj,'output_coordsys','Coordinates in the Swiss Grid http://geomatics.ladetto.ch/ch1903_wgs84_de.pdf. One of CH1903,UTM,UPS,PROJ4 or LOCAL ');
-			fielddisplay(obj,'output_coordparam','');
-			fielddisplay(obj,'output_time_zone','');
-			fielddisplay(obj,'output_meteopath','Path to the outputs (this path MUST exist, it won''t be created)');
-			fielddisplay(obj,'output_experiment','Option to give an additional simulation specific output name to the run in addition to "STATION_NAME"');
-			fielddisplay(obj,'output_ts_write','Write meteo data out? (0 or 1)');
-			fielddisplay(obj,'output_ts_start','When to start writing meteo data out (offset, in days)');
-			fielddisplay(obj,'output_ts_days_between','How often to write meteo data out (in days: 3 hours=.125, 1 hour=4.1666e-2)');
-			fielddisplay(obj,'output_profile','How to write the profiles (default: ASCII, choice is ASCII,IMIS or ASCII IMIS)');
+			fielddisplay(self,'output_coordsys','Coordinates in the Swiss Grid http://geomatics.ladetto.ch/ch1903_wgs84_de.pdf. One of CH1903,UTM,UPS,PROJ4 or LOCAL ');
+			fielddisplay(self,'output_coordparam','');
+			fielddisplay(self,'output_time_zone','');
+			fielddisplay(self,'output_meteopath','Path to the outputs (this path MUST exist, it won''t be created)');
+			fielddisplay(self,'output_experiment','Option to give an additional simulation specific output name to the run in addition to "STATION_NAME"');
+			fielddisplay(self,'output_ts_write','Write meteo data out? (0 or 1)');
+			fielddisplay(self,'output_ts_start','When to start writing meteo data out (offset, in days)');
+			fielddisplay(self,'output_ts_days_between','How often to write meteo data out (in days: 3 hours=.125, 1 hour=4.1666e-2)');
+			fielddisplay(self,'output_profile','How to write the profiles (default: ASCII, choice is ASCII,IMIS or ASCII IMIS)');
 )');
-			fielddisplay(obj,'output_prof_write','Write profile data out? (0 or 1) ');
-			fielddisplay(obj,'output_prof_start','When to start writing profile data out (offset, in days)');
-			fielddisplay(obj,'output_prof_days_between','How often to write profile data out (in days: 3 hours=.125, 1 hour=4.1666e-2)');
+			fielddisplay(self,'output_prof_write','Write profile data out? (0 or 1) ');
+			fielddisplay(self,'output_prof_start','When to start writing profile data out (offset, in days)');
+			fielddisplay(self,'output_prof_days_between','How often to write profile data out (in days: 3 hours=.125, 1 hour=4.1666e-2)');
 			% }}}
 			disp(sprintf('\n	%s','Interpolations1d parameters:')); % {{{
-			fielddisplay(obj,'interpolations1d_window_size','Affects resampling: expresses (in seconds) how far a valid point can be searched for when re-interpolating a missing value'); 
-			fielddisplay(obj,'interpolations1d_hnw_resample','NONE, NEAREST_NEIGHBOUR, ACCUMULATE or LINEAR');
+			fielddisplay(self,'interpolations1d_window_size','Affects resampling: expresses (in seconds) how far a valid point can be searched for when re-interpolating a missing value'); 
+			fielddisplay(self,'interpolations1d_hnw_resample','NONE, NEAREST_NEIGHBOUR, ACCUMULATE or LINEAR');
  ');
-			fielddisplay(obj,'interpolations1d_hs_resample','Mean average processing. The mean average filter returns the mean value of all values within a user given time window. (NONE, NEAREST_NEIGHBOUR, ACCUMULATE or LINEAR)');
-			fielddisplay(obj,'interpolations1d_tsg_resample','Mean average processing. The mean average filter returns the mean value of all values within a user given time window.(NONE, NEAREST_NEIGHBOUR, ACCUMULATE or LINEAR)');
-			fielddisplay(obj,'interpolations1d_rho_hn_resample','(NONE, NEAREST_NEIGHBOUR, ACCUMULATE or LINEAR)');
-			fielddisplay(obj,'interpolations1d_vw_resample','(NONE, NEAREST_NEIGHBOUR, ACCUMULATE or LINEAR)');
-			fielddisplay(obj,'interpolations1d_vw_args','default nothing, otherwise, ''extrapolcate''');
+			fielddisplay(self,'interpolations1d_hs_resample','Mean average processing. The mean average filter returns the mean value of all values within a user given time window. (NONE, NEAREST_NEIGHBOUR, ACCUMULATE or LINEAR)');
+			fielddisplay(self,'interpolations1d_tsg_resample','Mean average processing. The mean average filter returns the mean value of all values within a user given time window.(NONE, NEAREST_NEIGHBOUR, ACCUMULATE or LINEAR)');
+			fielddisplay(self,'interpolations1d_rho_hn_resample','(NONE, NEAREST_NEIGHBOUR, ACCUMULATE or LINEAR)');
+			fielddisplay(self,'interpolations1d_vw_resample','(NONE, NEAREST_NEIGHBOUR, ACCUMULATE or LINEAR)');
+			fielddisplay(self,'interpolations1d_vw_args','default nothing, otherwise, ''extrapolcate''');
 			% }}}
 			disp(sprintf('\n	%s','Filters parameters:')); % {{{
-			fielddisplay(obj,'filters_ta_filter1',' ');
-			fielddisplay(obj,'filters_ta_arg1','');
-			fielddisplay(obj,'filters_rh_filter1',' ');
-			fielddisplay(obj,'filters_rh_arg1','');
-			fielddisplay(obj,'filters_rh_filter2',' ');
-			fielddisplay(obj,'filters_rh_arg2','');
-			fielddisplay(obj,'filters_iswr_filter1',' ');
-			fielddisplay(obj,'filters_iswr_arg1','');
-			fielddisplay(obj,'filters_iswr_filter2',' ');
-			fielddisplay(obj,'filters_iswr_arg2','');
-			fielddisplay(obj,'filters_rswr_filter1',' ');
-			fielddisplay(obj,'filters_rswr_arg1','');
-			fielddisplay(obj,'filters_rswr_filter2',' ');
-			fielddisplay(obj,'filters_rswr_arg2','');
+			fielddisplay(self,'filters_ta_filter1',' ');
+			fielddisplay(self,'filters_ta_arg1','');
+			fielddisplay(self,'filters_rh_filter1',' ');
+			fielddisplay(self,'filters_rh_arg1','');
+			fielddisplay(self,'filters_rh_filter2',' ');
+			fielddisplay(self,'filters_rh_arg2','');
+			fielddisplay(self,'filters_iswr_filter1',' ');
+			fielddisplay(self,'filters_iswr_arg1','');
+			fielddisplay(self,'filters_iswr_filter2',' ');
+			fielddisplay(self,'filters_iswr_arg2','');
+			fielddisplay(self,'filters_rswr_filter1',' ');
+			fielddisplay(self,'filters_rswr_arg1','');
+			fielddisplay(self,'filters_rswr_filter2',' ');
+			fielddisplay(self,'filters_rswr_arg2','');
 
 			%for ta between 190 and 280 k;
-			fielddisplay(obj,'filters_ilwr_filter1',' ');
-			fielddisplay(obj,'filters_ilwr_arg1','');
-			fielddisplay(obj,'filters_ilwr_filter2',' ');
-			fielddisplay(obj,'filters_ilwr_arg2','');
-			fielddisplay(obj,'filters_tss_filter1',' ');
-			fielddisplay(obj,'filters_tss_arg1','');
-			fielddisplay(obj,'filters_tsg_filter1',' ');
-			fielddisplay(obj,'filters_tsg_arg1','');
-			fielddisplay(obj,'filters_vw_filter1',' ');
-			fielddisplay(obj,'filters_vw_arg1','');
-			fielddisplay(obj,'filters_vw_filter2',' ');
-			fielddisplay(obj,'filters_vw_arg2','');
+			fielddisplay(self,'filters_ilwr_filter1',' ');
+			fielddisplay(self,'filters_ilwr_arg1','');
+			fielddisplay(self,'filters_ilwr_filter2',' ');
+			fielddisplay(self,'filters_ilwr_arg2','');
+			fielddisplay(self,'filters_tss_filter1',' ');
+			fielddisplay(self,'filters_tss_arg1','');
+			fielddisplay(self,'filters_tsg_filter1',' ');
+			fielddisplay(self,'filters_tsg_arg1','');
+			fielddisplay(self,'filters_vw_filter1',' ');
+			fielddisplay(self,'filters_vw_arg1','');
+			fielddisplay(self,'filters_vw_filter2',' ');
+			fielddisplay(self,'filters_vw_arg2','');
 			% }}}
 
 		end % }}}
-		function marshall(obj,md,fid) % {{{
+		function marshall(self,md,fid) % {{{
 
 			yts=365.0*24.0*3600.0;
 
-			WriteData(fid,'object',obj,'class','snowpack','fieldname','spcvx','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
-			WriteData(fid,'object',obj,'class','snowpack','fieldname','spcvy','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
-			WriteData(fid,'object',obj,'class','snowpack','fieldname','spcvz','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
-			WriteData(fid,'object',obj,'class','snowpack','fieldname','restol','format','Double');
-			WriteData(fid,'object',obj,'class','snowpack','fieldname','reltol','format','Double');
-			WriteData(fid,'object',obj,'class','snowpack','fieldname','abstol','format','Double');
-			WriteData(fid,'object',obj,'class','snowpack','fieldname','isnewton','format','Integer');
-			WriteData(fid,'object',obj,'class','snowpack','fieldname','FSreconditioning','format','Double');
-			WriteData(fid,'object',obj,'class','snowpack','fieldname','viscosity_overshoot','format','Double');
-			WriteData(fid,'object',obj,'class','snowpack','fieldname','maxiter','format','Integer');
-			WriteData(fid,'object',obj,'class','snowpack','fieldname','shelf_dampening','format','Integer');
-			WriteData(fid,'object',obj,'class','snowpack','fieldname','vertex_pairing','format','DoubleMat','mattype',3);
-			WriteData(fid,'object',obj,'class','snowpack','fieldname','penalty_factor','format','Double');
-			WriteData(fid,'object',obj,'class','snowpack','fieldname','rift_penalty_lock','format','Integer');
-			WriteData(fid,'object',obj,'class','snowpack','fieldname','rift_penalty_threshold','format','Integer');
-			WriteData(fid,'object',obj,'class','snowpack','fieldname','referential','format','DoubleMat','mattype',1);
-			WriteData(fid,'object',obj,'class','snowpack','fieldname','requested_outputs','format','StringArray');
-			WriteData(fid,'data',obj.loadingforce(:,1),'format','DoubleMat','mattype',1,'enum',LoadingforceXEnum);
-			WriteData(fid,'data',obj.loadingforce(:,2),'format','DoubleMat','mattype',1,'enum',LoadingforceYEnum);
-			WriteData(fid,'data',obj.loadingforce(:,3),'format','DoubleMat','mattype',1,'enum',LoadingforceZEnum);
+			WriteData(fid,'object',self,'class','snowpack','fieldname','spcvx','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
+			WriteData(fid,'object',self,'class','snowpack','fieldname','spcvy','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
+			WriteData(fid,'object',self,'class','snowpack','fieldname','spcvz','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
+			WriteData(fid,'object',self,'class','snowpack','fieldname','restol','format','Double');
+			WriteData(fid,'object',self,'class','snowpack','fieldname','reltol','format','Double');
+			WriteData(fid,'object',self,'class','snowpack','fieldname','abstol','format','Double');
+			WriteData(fid,'object',self,'class','snowpack','fieldname','isnewton','format','Integer');
+			WriteData(fid,'object',self,'class','snowpack','fieldname','FSreconditioning','format','Double');
+			WriteData(fid,'object',self,'class','snowpack','fieldname','viscosity_overshoot','format','Double');
+			WriteData(fid,'object',self,'class','snowpack','fieldname','maxiter','format','Integer');
+			WriteData(fid,'object',self,'class','snowpack','fieldname','shelf_dampening','format','Integer');
+			WriteData(fid,'object',self,'class','snowpack','fieldname','vertex_pairing','format','DoubleMat','mattype',3);
+			WriteData(fid,'object',self,'class','snowpack','fieldname','penalty_factor','format','Double');
+			WriteData(fid,'object',self,'class','snowpack','fieldname','rift_penalty_lock','format','Integer');
+			WriteData(fid,'object',self,'class','snowpack','fieldname','rift_penalty_threshold','format','Integer');
+			WriteData(fid,'object',self,'class','snowpack','fieldname','referential','format','DoubleMat','mattype',1);
+			WriteData(fid,'object',self,'class','snowpack','fieldname','requested_outputs','format','StringArray');
+			WriteData(fid,'data',self.loadingforce(:,1),'format','DoubleMat','mattype',1,'enum',LoadingforceXEnum);
+			WriteData(fid,'data',self.loadingforce(:,2),'format','DoubleMat','mattype',1,'enum',LoadingforceYEnum);
+			WriteData(fid,'data',self.loadingforce(:,3),'format','DoubleMat','mattype',1,'enum',LoadingforceZEnum);
 		end % }}}
 	end
 end
Index: ../trunk-jpl/src/m/classes/rifts.m
===================================================================
--- ../trunk-jpl/src/m/classes/rifts.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/rifts.m	(revision 19040)
@@ -9,35 +9,35 @@
 		riftproperties = NaN;
 	end
 	methods
-        function createxml(obj,fid) % {{{
+        function createxml(self,fid) % {{{
             fprintf(fid, '\n\n');
             fprintf(fid, '%s\n', '<!-- rifts -->');
-			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="riftstruct" type="',              class(obj.riftstruct),'" default="',                  obj.riftstruct,'">',              '     <section name="rifts" />','     <help> structure containing all rift information (vertices coordinates, segments, type of melange, ...) </help>','</parameter>');
-            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="riftproperties" type="',            class(obj.riftproperties),'" default="',                obj.riftproperties,'">',   '     <section name="rifts" />','     <help> N/A </help>','</parameter>');
+			fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="riftstruct" type="',              class(self.riftstruct),'" default="',                  self.riftstruct,'">',              '     <section name="rifts" />','     <help> structure containing all rift information (vertices coordinates, segments, type of melange, ...) </help>','</parameter>');
+            fprintf(fid,'%s%s%s%s%s\n%s\n%s\n%s\n',    '<parameter key ="riftproperties" type="',            class(self.riftproperties),'" default="',                self.riftproperties,'">',   '     <section name="rifts" />','     <help> N/A </help>','</parameter>');
     
         end % }}}
-		function obj = rifts(varargin) % {{{
+		function self = rifts(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
-			if isempty(obj.riftstruct) | isnans(obj.riftstruct),
+		function md = checkconsistency(self,md,solution,analyses) % {{{
+			if isempty(self.riftstruct) | isnans(self.riftstruct),
 				numrifts=0;
 			else
-				numrifts=numel(obj.riftstruct);
+				numrifts=numel(self.riftstruct);
 			end
 			if numrifts,
 				if ~(strcmp(domaintype(md.mesh),'2Dhorizontal')),
 					md = checkmessage(md,['models with rifts are only supported in 2d for now!']);
 				end
-				if ~isstruct(obj.riftstruct),
+				if ~isstruct(self.riftstruct),
 					md = checkmessage(md,['rifts.riftstruct should be a structure!']);
 				end
 				if ~isempty(find(md.mesh.segmentmarkers>=2)),
@@ -48,42 +48,42 @@
 					md = checkfield(md,'fieldname',sprintf('rifts.riftstruct(%d).fill',i),'values',[WaterEnum() AirEnum() IceEnum() MelangeEnum()]);
 				end
 			else
-				if ~isnans(obj.riftstruct),
+				if ~isnans(self.riftstruct),
 					md = checkmessage(md,['riftstruct should be NaN since numrifts is 0!']);
 				end
 			end
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   rifts parameters:'));
 
-			fielddisplay(obj,'riftstruct','structure containing all rift information (vertices coordinates, segments, type of melange, ...)');
-			fielddisplay(obj,'riftproperties','');
+			fielddisplay(self,'riftstruct','structure containing all rift information (vertices coordinates, segments, type of melange, ...)');
+			fielddisplay(self,'riftproperties','');
 
 		end % }}}
-		function marshall(obj,md,fid) % {{{
+		function marshall(self,md,fid) % {{{
 
 			%Process rift info
-			if isempty(obj.riftstruct) | isnans(obj.riftstruct),
+			if isempty(self.riftstruct) | isnans(self.riftstruct),
 				numrifts=0;
 			else
-				numrifts=numel(obj.riftstruct);
+				numrifts=numel(self.riftstruct);
 			end
 			numpairs=0;
 			for i=1:numrifts,
-				numpairs=numpairs+size(obj.riftstruct(i).penaltypairs,1);
+				numpairs=numpairs+size(self.riftstruct(i).penaltypairs,1);
 			end
 
 			% 2 for nodes + 2 for elements+ 2 for  normals + 1 for length + 1 for fill + 1 for friction + 1 for fraction + 1 for fractionincrement + 1 for state.
 			data=zeros(numpairs,12);
 			count=1;
 			for i=1:numrifts,
-				numpairsforthisrift=size(obj.riftstruct(i).penaltypairs,1);
-				data(count:count+numpairsforthisrift-1,1:7)=obj.riftstruct(i).penaltypairs;
-				data(count:count+numpairsforthisrift-1,8)=obj.riftstruct(i).fill;
-				data(count:count+numpairsforthisrift-1,9)=obj.riftstruct(i).friction;
-				data(count:count+numpairsforthisrift-1,10)=obj.riftstruct(i).fraction;
-				data(count:count+numpairsforthisrift-1,11)=obj.riftstruct(i).fractionincrement;
-				data(count:count+numpairsforthisrift-1,12)=obj.riftstruct(i).state;
+				numpairsforthisrift=size(self.riftstruct(i).penaltypairs,1);
+				data(count:count+numpairsforthisrift-1,1:7)=self.riftstruct(i).penaltypairs;
+				data(count:count+numpairsforthisrift-1,8)=self.riftstruct(i).fill;
+				data(count:count+numpairsforthisrift-1,9)=self.riftstruct(i).friction;
+				data(count:count+numpairsforthisrift-1,10)=self.riftstruct(i).fraction;
+				data(count:count+numpairsforthisrift-1,11)=self.riftstruct(i).fractionincrement;
+				data(count:count+numpairsforthisrift-1,12)=self.riftstruct(i).state;
 				count=count+numpairsforthisrift;
 			end
 
Index: ../trunk-jpl/src/m/classes/SMBhenning.m
===================================================================
--- ../trunk-jpl/src/m/classes/SMBhenning.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/SMBhenning.m	(revision 19040)
@@ -8,7 +8,7 @@
 		smbref = NaN;
 	end
 	methods
-		function obj = SMBhenning(varargin) % {{{
+		function self = SMBhenning(varargin) % {{{
 			switch nargin
 				case 0
 				otherwise
@@ -28,7 +28,7 @@
 			end
 
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 			if ismember(MasstransportAnalysisEnum(),analyses),
 				md = checkfield(md,'fieldname','surfaceforcings.smbref','timeseries',1,'NaN',1);
@@ -37,16 +37,16 @@
 				md = checkfield(md,'fieldname','surfaceforcings.smbref','size',[md.mesh.numberofvertices 1],'NaN',1);
 			end
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   surface forcings parameters:'));
-			fielddisplay(obj,'smbref','reference smb from which deviation is calculated [m/yr ice eq]');
+			fielddisplay(self,'smbref','reference smb from which deviation is calculated [m/yr ice eq]');
 		end % }}}
-		function marshall(obj,md,fid) % {{{
+		function marshall(self,md,fid) % {{{
 
 			yts=365.0*24.0*3600.0;
 
 			WriteData(fid,'enum',SurfaceforcingsEnum(),'data',SMBhenningEnum(),'format','Integer');
-			WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','smbref','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
+			WriteData(fid,'object',self,'class','surfaceforcings','fieldname','smbref','format','DoubleMat','mattype',1,'scale',1./yts,'timeserieslength',md.mesh.numberofvertices+1);
 		end % }}}
 	end
 end
Index: ../trunk-jpl/src/m/classes/seaiceatm.m
===================================================================
--- ../trunk-jpl/src/m/classes/seaiceatm.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/seaiceatm.m	(revision 19040)
@@ -13,28 +13,28 @@
 		wind_vy            = NaN;
 	end
 	methods
-		function obj = seaiceatm(varargin) % {{{
+		function self = seaiceatm(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 			%air density (kg/m^3)
-			obj.rho_air=1.3;
+			self.rho_air=1.3;
 
 			%By default, we apply the full stress
-			obj.air_coef = 1.;
+			self.air_coef = 1.;
 
 			%drag coefficients (different from Hibler 0.0012)
-			obj.air_lin_drag_coef  = 0.;
-			obj.air_quad_drag_coef = 0.003;
+			self.air_lin_drag_coef  = 0.;
+			self.air_quad_drag_coef = 0.003;
 
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 			md = checkfield(md,'fieldname','surfaceforcings.rho_air','NaN',1,'>',0.,'numel',1);
 			md = checkfield(md,'fieldname','surfaceforcings.air_coef','NaN',1,'>=',0.,'<=',1,'numel',1);
 			md = checkfield(md,'fieldname','surfaceforcings.air_lin_drag_coef','NaN',1,'>=',0.,'numel',1);
@@ -42,24 +42,24 @@
 			md = checkfield(md,'fieldname','surfaceforcings.wind_vx','NaN',1,'size',[md.mesh.numberofvertices 1]);
 			md = checkfield(md,'fieldname','surfaceforcings.wind_vy','NaN',1,'size',[md.mesh.numberofvertices 1]);
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   Atmospheric forcings for sea ice:'));
 			disp(sprintf('\n     tau_a = air_coef*rho_air*(air_lin_drag_coef+air_quad_drag_coef*|v_wind|)*v_wind\n'));
-			fielddisplay(obj,'rho_air','air density [kg/m^3]');
-			fielddisplay(obj,'air_coef','atmospheric stress spin up coefficient (between 0 and 1)');
-			fielddisplay(obj,'air_lin_drag_coef','air linear drag coefficient (no unit)');
-			fielddisplay(obj,'air_quad_drag_coef','air quadratic drag coefficient [s/m]');
-			fielddisplay(obj,'wind_vx','wind speed x-component at 10 m elevation [m/s]');
-			fielddisplay(obj,'wind_vy','wind speed y-component at 10 m elevation [m/s]');
+			fielddisplay(self,'rho_air','air density [kg/m^3]');
+			fielddisplay(self,'air_coef','atmospheric stress spin up coefficient (between 0 and 1)');
+			fielddisplay(self,'air_lin_drag_coef','air linear drag coefficient (no unit)');
+			fielddisplay(self,'air_quad_drag_coef','air quadratic drag coefficient [s/m]');
+			fielddisplay(self,'wind_vx','wind speed x-component at 10 m elevation [m/s]');
+			fielddisplay(self,'wind_vy','wind speed y-component at 10 m elevation [m/s]');
 		end % }}}
-		function marshall(obj,md,fid) % {{{
+		function marshall(self,md,fid) % {{{
 			WriteData(fid,'enum',SurfaceforcingsEnum(),'data',SeaiceatmEnum(),'format','Integer');
-			WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','rho_air','format','Double');
-			WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','air_coef','format','Double');
-			WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','air_lin_drag_coef','format','Double');
-			WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','air_quad_drag_coef','format','Double');
-			WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','wind_vx','format','DoubleMat','mattype',1);
-			WriteData(fid,'object',obj,'class','surfaceforcings','fieldname','wind_vy','format','DoubleMat','mattype',1);
+			WriteData(fid,'object',self,'class','surfaceforcings','fieldname','rho_air','format','Double');
+			WriteData(fid,'object',self,'class','surfaceforcings','fieldname','air_coef','format','Double');
+			WriteData(fid,'object',self,'class','surfaceforcings','fieldname','air_lin_drag_coef','format','Double');
+			WriteData(fid,'object',self,'class','surfaceforcings','fieldname','air_quad_drag_coef','format','Double');
+			WriteData(fid,'object',self,'class','surfaceforcings','fieldname','wind_vx','format','DoubleMat','mattype',1);
+			WriteData(fid,'object',self,'class','surfaceforcings','fieldname','wind_vy','format','DoubleMat','mattype',1);
 		end % }}}
 	end
 end
Index: ../trunk-jpl/src/m/classes/spheremesh.m
===================================================================
--- ../trunk-jpl/src/m/classes/spheremesh.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/spheremesh.m	(revision 19040)
@@ -21,24 +21,24 @@
 		average_vertex_connectivity = 0;
 	end
 	methods
-		function obj = spheremesh(varargin) % {{{
+		function self = spheremesh(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				otherwise
 					error('constructor not supported');
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 			%the connectivity is the avergaded number of nodes linked to a
 			%given node through an edge. This connectivity is used to initially
 			%allocate memory to the stiffness matrix. A value of 16 seems to
 			%give a good memory/time ration. This value can be checked in
 			%trunk/test/Miscellaneous/runme.m
-			obj.average_vertex_connectivity=25;
+			self.average_vertex_connectivity=25;
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 			md = checkfield(md,'fieldname','spheremesh.x','NaN',1,'size',[md.spheremesh.numberofvertices 1]);
 			md = checkfield(md,'fieldname','spheremesh.y','NaN',1,'size',[md.spheremesh.numberofvertices 1]);
@@ -56,41 +56,41 @@
 			md = checkfield(md,'fieldname','spheremesh.numberofvertices','>',0);
 			md = checkfield(md,'fieldname','spheremesh.elementconnectivity','size',[md.spheremesh.numberofelements 3],'NaN',1);
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   Mesh:')); 
 
 			disp(sprintf('\n      Elements and vertices:'));
-			fielddisplay(obj,'numberofelements','number of elements');
-			fielddisplay(obj,'numberofvertices','number of vertices');
-			fielddisplay(obj,'elements','vertex indices of the mesh elements');
-			fielddisplay(obj,'x','vertices x coordinate [m]');
-			fielddisplay(obj,'y','vertices y coordinate [m]');
-			fielddisplay(obj,'z','vertices z coordinate [m]');
-			fielddisplay(obj,'r','vertices r coordinate [m]');
-			fielddisplay(obj,'theta','vertices theta coordinate [degrees]');
-			fielddisplay(obj,'phi','vertices phi coordinate [degrees]');
+			fielddisplay(self,'numberofelements','number of elements');
+			fielddisplay(self,'numberofvertices','number of vertices');
+			fielddisplay(self,'elements','vertex indices of the mesh elements');
+			fielddisplay(self,'x','vertices x coordinate [m]');
+			fielddisplay(self,'y','vertices y coordinate [m]');
+			fielddisplay(self,'z','vertices z coordinate [m]');
+			fielddisplay(self,'r','vertices r coordinate [m]');
+			fielddisplay(self,'theta','vertices theta coordinate [degrees]');
+			fielddisplay(self,'phi','vertices phi coordinate [degrees]');
 
 			disp(sprintf('\n      Properties:'));
-			fielddisplay(obj,'numberoflayers','number of extrusion layers');
+			fielddisplay(self,'numberoflayers','number of extrusion layers');
 
-			fielddisplay(obj,'vertexconnectivity','list of vertices connected to vertex_i');
-			fielddisplay(obj,'elementconnectivity','list of vertices connected to element_i');
-			fielddisplay(obj,'average_vertex_connectivity','average number of vertices connected to one vertex');
+			fielddisplay(self,'vertexconnectivity','list of vertices connected to vertex_i');
+			fielddisplay(self,'elementconnectivity','list of vertices connected to element_i');
+			fielddisplay(self,'average_vertex_connectivity','average number of vertices connected to one vertex');
 
 		end % }}}
-		function marshall(obj,md,fid) % {{{
-			WriteData(fid,'object',obj,'fieldname','x','format','DoubleMat','mattype',1);
-			WriteData(fid,'object',obj,'fieldname','y','format','DoubleMat','mattype',1);
-			WriteData(fid,'object',obj,'fieldname','z','format','DoubleMat','mattype',1);
-			WriteData(fid,'object',obj,'fieldname','r','format','DoubleMat','mattype',1);
-			WriteData(fid,'object',obj,'fieldname','theta','format','DoubleMat','mattype',1);
-			WriteData(fid,'object',obj,'fieldname','phi','format','DoubleMat','mattype',1);
-			WriteData(fid,'object',obj,'fieldname','elements','format','DoubleMat','mattype',2);
-			WriteData(fid,'object',obj,'fieldname','numberoflayers','format','Integer');
-			WriteData(fid,'object',obj,'fieldname','numberofelements','format','Integer');
-			WriteData(fid,'object',obj,'fieldname','numberofvertices','format','Integer');
-			WriteData(fid,'object',obj,'fieldname','elementconnectivity','format','DoubleMat','mattype',3);
-			WriteData(fid,'object',obj,'fieldname','average_vertex_connectivity','format','Integer');
+		function marshall(self,md,fid) % {{{
+			WriteData(fid,'object',self,'fieldname','x','format','DoubleMat','mattype',1);
+			WriteData(fid,'object',self,'fieldname','y','format','DoubleMat','mattype',1);
+			WriteData(fid,'object',self,'fieldname','z','format','DoubleMat','mattype',1);
+			WriteData(fid,'object',self,'fieldname','r','format','DoubleMat','mattype',1);
+			WriteData(fid,'object',self,'fieldname','theta','format','DoubleMat','mattype',1);
+			WriteData(fid,'object',self,'fieldname','phi','format','DoubleMat','mattype',1);
+			WriteData(fid,'object',self,'fieldname','elements','format','DoubleMat','mattype',2);
+			WriteData(fid,'object',self,'fieldname','numberoflayers','format','Integer');
+			WriteData(fid,'object',self,'fieldname','numberofelements','format','Integer');
+			WriteData(fid,'object',self,'fieldname','numberofvertices','format','Integer');
+			WriteData(fid,'object',self,'fieldname','elementconnectivity','format','DoubleMat','mattype',3);
+			WriteData(fid,'object',self,'fieldname','average_vertex_connectivity','format','Integer');
 		end % }}}
 	end
 end
Index: ../trunk-jpl/src/m/classes/masscon.m
===================================================================
--- ../trunk-jpl/src/m/classes/masscon.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/masscon.m	(revision 19040)
@@ -18,47 +18,47 @@
 	end
 	
 	methods
-		function obj = masscon(varargin) % {{{
+		function self = masscon(varargin) % {{{
 			if nargin==0,
-				obj=setdefaultparameters(obj);
+				self=setdefaultparameters(self);
 			else
 				%use provided options to change fields
 				options=pairoptions(varargin{:});
 
 				%get name
-				obj.name=getfieldvalue(options,'name','');
-				obj.levelset=getfieldvalue(options,'levelset');
-				obj.definitionenum=getfieldvalue(options,'definitionenum');
+				self.name=getfieldvalue(options,'name','');
+				self.levelset=getfieldvalue(options,'levelset');
+				self.definitionenum=getfieldvalue(options,'definitionenum');
 
 			end
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
-			if ~ischar(obj.name),
+			if ~ischar(self.name),
 				error('masscon error message: ''name'' field should be a string!');
 			end
 			
-			md = checkfield(md,'fieldname','obj.definitionenum','field',obj.definitionenum,'values',[Outputdefinition1Enum,Outputdefinition2Enum,Outputdefinition3Enum,Outputdefinition4Enum,Outputdefinition5Enum,Outputdefinition6Enum,Outputdefinition7Enum,Outputdefinition8Enum,Outputdefinition9Enum,Outputdefinition10Enum]);
+			md = checkfield(md,'fieldname','self.definitionenum','field',self.definitionenum,'values',[Outputdefinition1Enum,Outputdefinition2Enum,Outputdefinition3Enum,Outputdefinition4Enum,Outputdefinition5Enum,Outputdefinition6Enum,Outputdefinition7Enum,Outputdefinition8Enum,Outputdefinition9Enum,Outputdefinition10Enum]);
 
-			md = checkfield(md,'fieldname','obj.levelset','field',obj.levelset,'timeseries',1,'NaN',1);
+			md = checkfield(md,'fieldname','self.levelset','field',self.levelset,'timeseries',1,'NaN',1);
 
 		end % }}}
-		function md = disp(obj) % {{{
+		function md = disp(self) % {{{
 		
 			disp(sprintf('   Misfit:\n'));
 
-			fielddisplay(obj,'name','identifier for this masscon response');
-			fielddisplay(obj,'definitionenum','enum that identifies this output definition uniquely, from Outputdefinition[1-10]Enum');
-			fielddisplay(obj,'levelset','levelset vectorial field which identifies the boundaries of the masscon');
+			fielddisplay(self,'name','identifier for this masscon response');
+			fielddisplay(self,'definitionenum','enum that identifies this output definition uniquely, from Outputdefinition[1-10]Enum');
+			fielddisplay(self,'levelset','levelset vectorial field which identifies the boundaries of the masscon');
 
 		end % }}}
-		function md = marshall(obj,md,fid) % {{{
+		function md = marshall(self,md,fid) % {{{
 
-		WriteData(fid,'object',obj,'fieldname','name','format','String');
-		WriteData(fid,'object',obj,'fieldname','definitionenum','format','Integer');
-		WriteData(fid,'object',obj,'fieldname','levelset','format','DoubleMat','mattype',1);
+		WriteData(fid,'object',self,'fieldname','name','format','String');
+		WriteData(fid,'object',self,'fieldname','definitionenum','format','Integer');
+		WriteData(fid,'object',self,'fieldname','levelset','format','DoubleMat','mattype',1);
 
 		end % }}}
 	end
Index: ../trunk-jpl/src/m/classes/masstransport.m
===================================================================
--- ../trunk-jpl/src/m/classes/masstransport.m	(revision 19039)
+++ ../trunk-jpl/src/m/classes/masstransport.m	(revision 19040)
@@ -15,7 +15,7 @@
 		 requested_outputs      = {};
 	end
 	methods (Static)
-		function obj = loadobj(obj) % {{{
+		function self = loadobj(self) % {{{
 			% This function is directly called by matlab when a model object is
 			% loaded. If the input is a struct it is an old version of this class and
 			% old fields must be recovered (make sure they are in the deprecated
@@ -33,18 +33,17 @@
 				% This has been fixed in MATLAB 7.9 (R2009b) and later versions
 			end
 
-			if isstruct(obj)
+			if isstruct(self)
 				disp('Recovering masstransport from older version');
-				objstruct = obj;
-				obj = structtoobj(masstransport(),objstruct);
+				self = structtoobj(masstransport(),self);
 			end
 		end% }}}
 	end
 	methods
-		function obj = masstransport(varargin) % {{{
+		function self = masstransport(varargin) % {{{
 			switch nargin
 				case 0
-					obj=setdefaultparameters(obj);
+					self=setdefaultparameters(self);
 				case 1
 					inputstruct=varargin{1};
 					list1 = properties('masstransport');
@@ -52,7 +51,7 @@
 					for i=1:length(list1)
 						fieldname = list1{i};
 						if ismember(fieldname,list2),
-							obj.(fieldname) = inputstruct.(fieldname);
+							self.(fieldname) = inputstruct.(fieldname);
 						end
 					end
 				otherwise
@@ -64,24 +63,24 @@
 			list = {'Thickness','Surface','Base'};
 
 		end % }}}
-		function obj = setdefaultparameters(obj) % {{{
+		function self = setdefaultparameters(self) % {{{
 
 			%Type of stabilization to use 0:nothing 1:artificial_diffusivity 3:Discontinuous Galerkin
-			obj.stabilization=1;
+			self.stabilization=1;
 
 			%Factor applied to compute the penalties kappa=max(stiffness matrix)*10^penalty_factor
-			obj.penalty_factor=3;
+			self.penalty_factor=3;
 
 			%Minimum ice thickness that can be used
-			obj.min_thickness=1;
+			self.min_thickness=1;
 
 			%Hydrostatic adjustment
-			obj.hydrostatic_adjustment='Absolute';
+			self.hydrostatic_adjustment='Absolute';
 
 			%default output
-			obj.requested_outputs={'default'};
+			self.requested_outputs={'default'};
 		end % }}}
-		function md = checkconsistency(obj,md,solution,analyses) % {{{
+		function md = checkconsistency(self,md,solution,analyses) % {{{
 
 			%Early return
 			if ~ismember(MasstransportAnalysisEnum(),analyses) |  (solution==TransientSolutionEnum() & md.transient.ismasstransport==0), return; end
@@ -94,38 +93,38 @@
 			md = checkfield(md,'fieldname','masstransport.requested_outputs','stringrow',1);
 
 		end % }}}
-		function disp(obj) % {{{
+		function disp(self) % {{{
 			disp(sprintf('   Masstransport solution parameters:'));
-			fielddisplay(obj,'spcthickness','thickness constraints (NaN means no constraint) [m]');
-			fielddisplay(obj,'isfreesurface','do we use free surfaces (FS only) are mass conservation');
-			fielddisplay(obj,'min_thickness','minimum ice thickness allowed [m]');
-			fielddisplay(obj,'hydrostatic_adjustment','adjustment of ice shelves surface and bed elevations: ''Incremental'' or ''Absolute'' ');
-			fielddisplay(obj,'stabilization','0: no, 1: artificial_diffusivity, 2: streamline upwinding, 3: discontinuous Galerkin, 4: Flux Correction Transport');
+			fielddisplay(self,'spcthickness','thickness constraints (NaN means no constraint) [m]');
+			fielddisplay(self,'isfreesurface','do we use free surfaces (FS only) are mass conservation');
+			fielddisplay(self,'min_thickness','minimum ice thickness allowed [m]');
+			fielddisplay(self,'hydrostatic_adjustment','adjustment of ice shelves surface and bed elevations: ''Incremental'' or ''Absolute'' ');
+			fielddisplay(self,'stabilization','0: no, 1: artificial_diffusivity, 2: streamline upwinding, 3: discontinuous Galerkin, 4: Flux Correction Transport');
 
 			disp(sprintf('\n      %s','Penalty options:'));
-			fielddisplay(obj,'penalty_factor','offset used by penalties: penalty = Kmax*10^offset');
-			fielddisplay(obj,'vertex_pairing','pairs of vertices that are penalized');
-			fielddisplay(obj,'requested_outputs','additional outputs requested');
+			fielddisplay(self,'penalty_factor','offset used by penalties: penalty = Kmax*10^offset');
+			fielddisplay(self,'vertex_pairing','pairs of vertices that are penalized');
+			fielddisplay(self,'requested_outputs','additional outputs requested');
 
 		end % }}}
-		function marshall(obj,md,fid) % {{{
+		function marshall(self,md,fid) % {{{
 
 			yts=365.*24.*3600.;
 
-			WriteData(fid,'object',obj,'fieldname','spcthickness','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
-			WriteData(fid,'object',obj,'fieldname','isfreesurface','format','Boolean');
-			WriteData(fid,'object',obj,'fieldname','min_thickness','format','Double');
-			WriteData(fid,'data',StringToEnum(obj.hydrostatic_adjustment),'format','Integer','enum',MasstransportHydrostaticAdjustmentEnum());
-			WriteData(fid,'object',obj,'fieldname','stabilization','format','Integer');
-			WriteData(fid,'object',obj,'fieldname','vertex_pairing','format','DoubleMat','mattype',3);
-			WriteData(fid,'object',obj,'fieldname','penalty_factor','format','Double');
+			WriteData(fid,'object',self,'fieldname','spcthickness','format','DoubleMat','mattype',1,'timeserieslength',md.mesh.numberofvertices+1);
+			WriteData(fid,'object',self,'fieldname','isfreesurface','format','Boolean');
+			WriteData(fid,'object',self,'fieldname','min_thickness','format','Double');
+			WriteData(fid,'data',StringToEnum(self.hydrostatic_adjustment),'format','Integer','enum',MasstransportHydrostaticAdjustmentEnum());
+			WriteData(fid,'object',self,'fieldname','stabilization','format','Integer');
+			WriteData(fid,'object',self,'fieldname','vertex_pairing','format','DoubleMat','mattype',3);
+			WriteData(fid,'object',self,'fieldname','penalty_factor','format','Double');
 			
 			%process requested outputs
-			outputs = obj.requested_outputs;
+			outputs = self.requested_outputs;
 			pos  = find(ismember(outputs,'default'));
 			if ~isempty(pos),
 				outputs(pos) = [];                         %remove 'default' from outputs
-				outputs      = [outputs defaultoutputs(obj,md)]; %add defaults
+				outputs      = [outputs defaultoutputs(self,md)]; %add defaults
 			end
 			WriteData(fid,'data',outputs,'enum',MasstransportRequestedOutputsEnum,'format','StringArray');
 		end % }}}
