Index: /issm/trunk-jpl/src/m/contrib/defleurian/netCDF/export_netCDF.py
===================================================================
--- /issm/trunk-jpl/src/m/contrib/defleurian/netCDF/export_netCDF.py	(revision 21234)
+++ /issm/trunk-jpl/src/m/contrib/defleurian/netCDF/export_netCDF.py	(revision 21235)
@@ -1,4 +1,4 @@
 from netCDF4 import Dataset, stringtochar
-import numpy
+import numpy as np
 import time
 import collections
@@ -26,5 +26,5 @@
 	Duration=md.timestepping.final_time-md.timestepping.start_time
 	if Duration>0 and md.timestepping.time_step*md.settings.output_frequency>0:
-		StepNum=Duration/(md.timestepping.time_step*md.settings.output_frequency)
+		StepNum=int(Duration/(md.timestepping.time_step*md.settings.output_frequency))
 	else:
 		StepNum=1
@@ -32,5 +32,5 @@
 	Dimension1=NCData.createDimension('Dimension1',md.mesh.numberofelements)
 	Dimension2=NCData.createDimension('Dimension2',md.mesh.numberofvertices)
-	Dimension3=NCData.createDimension('Dimension3',numpy.shape(md.mesh.elements)[1])
+	Dimension3=NCData.createDimension('Dimension3',np.shape(md.mesh.elements)[1])
 	Dimension4=NCData.createDimension('Dimension4',StepNum)
 	Dimension5=NCData.createDimension('Dimension5',2)
@@ -40,5 +40,5 @@
 						 len(Dimension3):'Dimension3',
 						 len(Dimension4):'Dimension4',
-						 len(Dimension5):'Dimension6'}
+						 len(Dimension5):'Dimension5'}
 
 	#get all model classes and create respective groups
@@ -54,8 +54,9 @@
 				NCgroup.__setattr__('classtype', "results")
 				Subgroup=NCgroup.createGroup(str(supfield))
-				Subgroup.__setattr__('classtype',str(supfield))
+				#Subgroup.__setattr__('classtype',md.results.__dict__[supfield].__class__.__name__)
+				Subgroup.__setattr__('classtype',md.results.__class__.__name__)
 				if type(md.results.__dict__[supfield])==list:#the solution have several timestep
 					#get last timesteps and output frequency
-					last_step = numpy.size(md.results.__dict__[supfield])
+					last_step = np.size(md.results.__dict__[supfield])
 					step_freq = md.settings.output_frequency
 					#grab first time step
@@ -70,13 +71,11 @@
 					for field in subfields:
 						if str(field)!='errlog' and str(field)!='outlog' and str(field)!='SolutionType':
-							print 'Treating '+str(group)+'.'+str(supfield)+'.'+str(field)
 							Var=md.results.__dict__[supfield].__dict__[field]
 							DimDict=CreateVar(NCData,Var,field,NCgroup,DimDict,False)
 				else:
-					print 'Result format not suported'
+					print ('Result format not suported')
 		else:
 			
 			for field in fields:
-				print 'Treating ' +str(group)+'.'+str(field)
 				NCgroup.__setattr__('classtype', md.__dict__[group].__class__.__name__)
 				Var=md.__dict__[group].__dict__[field]
@@ -96,5 +95,5 @@
 		val_shape=dict.keys(var)
 	except TypeError:
-		val_shape=numpy.shape(var)
+		val_shape=np.shape(var)
 
 
@@ -104,12 +103,10 @@
 							'int64':'i8'}
 		
-	val_dim=numpy.shape(val_shape)[0]
+	val_dim=np.shape(val_shape)[0]
 	#Now define and fill up variable
 	#treating scalar string or bool as atribute
-	if val_type==str or val_type==bool:
+	if val_type==str or val_type==unicode or val_type==bool:
 		Group.__setattr__(str(field), str(var))
-
 	#treating list as string table
-	#matlab does not recognise strings so we have to settle down with char arrays
 	elif val_type==list:
 		dimensions,DimDict=GetDim(NCData,var,val_shape,DimDict,val_dim,istime)
@@ -119,6 +116,6 @@
 				ncvar[elt] = var[elt]
 			except IndexError:
-				ncvar[0]= " "
-				#treating bool tables as string tables
+				ncvar= []
+	#treating bool tables as string tables
 	elif val_type=='bool':
 		dimensions,DimDict=GetDim(NCData,var,val_shape,DimDict,val_dim,istime)
@@ -126,5 +123,5 @@
 		for elt in range(0,val_shape[0]):
 			ncvar[elt] = str(var[elt])
-			#treating dictionaries as string tables of dim 2
+	#treating dictionaries as tables of strings
 	elif val_type==collections.OrderedDict:
 		dimensions,DimDict=GetDim(NCData,var,val_shape,DimDict,val_dim,istime)
@@ -133,21 +130,17 @@
 			ncvar[elt,0]=dict.keys(var)[elt]
 			ncvar[elt,1]=str(dict.values(var)[elt]) #converting to str to avoid potential problems
-			#Now dealing with numeric variables
+	#Now dealing with numeric variables
 	else:
 		dimensions,DimDict=GetDim(NCData,var,val_shape,DimDict,val_dim,istime)
 		ncvar = Group.createVariable(str(field),TypeDict[val_type],dimensions,zlib=True)
-		
 		if istime:
 			last=step_args[0]
-			freq=step_args[1]
 			md=step_args[2]
 			supfield=step_args[3]
 			vartab=var
-			for time in range(freq-1,last,freq):
+			for time in range(0,last,1):
 				if time!=0:
 					timevar=md.results.__dict__[supfield].__getitem__(time).__dict__[field]
-					print 'Treating results.'+str(supfield)+'.'+str(field)+' for time '+str(time)
-					vartab=numpy.column_stack((vartab,timevar))
-				#print numpy.shape(vartab)
+					vartab=np.column_stack((vartab,timevar))
 			try:
 				ncvar[:,:]=vartab[:,:]
@@ -156,5 +149,5 @@
 		else:
 			try:
-				nan_val=numpy.isnan(var)
+				nan_val=np.isnan(var)
 				if nan_val.all():
 					ncvar [:] = 'NaN'
@@ -171,23 +164,22 @@
 	#grab dimension
 	for dim in range(0,i): #loop on the dimensions
-		if type(shape[0])==int: 
+		if type(shape[0])==int:
 			try:
 				output=output+[str(DimDict[shape[dim]])] #test if the dimension allready exist
 			except KeyError: #if not create it
-				if (shape[dim])>1:
+				if (shape[dim])>0:
 					index=len(DimDict)+1
 					NewDim=NCData.createDimension('Dimension'+str(index),(shape[dim]))
 					DimDict[len(NewDim)]='Dimension'+str(index)
 					output=output+[str(DimDict[shape[dim]])]
-					#print 'Defining dimension ' +'Dimension'+str(index)
 		elif type(shape[0])==str:#dealling with a dictionnary
 			try:
-				output=[str(DimDict[numpy.shape(shape)[0]])]+['DictDim']
+				#dimension5 is 2 to treat with dict
+				output=[str(DimDict[np.shape(shape)[0]])]+['Dimension5']
 			except KeyError:
 				index=len(DimDict)+1
-				NewDim=NCData.createDimension('Dimension'+str(index),numpy.shape(shape)[0])
+				NewDim=NCData.createDimension('Dimension'+str(index),np.shape(shape)[0])
 				DimDict[len(NewDim)]='Dimension'+str(index)
-				output=[str(DimDict[numpy.shape(dict.keys(var))[0]])]+['Dimension5']
-				#print 'Defining dimension ' +'Dimension'+str(index)
+				output=[str(DimDict[np.shape(dict.keys(var))[0]])]+['Dimension5']
 			break
 	if istime:
Index: /issm/trunk-jpl/src/m/io/loadmodel.py
===================================================================
--- /issm/trunk-jpl/src/m/io/loadmodel.py	(revision 21234)
+++ /issm/trunk-jpl/src/m/io/loadmodel.py	(revision 21235)
@@ -1,4 +1,5 @@
 from loadvars import loadvars
 from whichdb import whichdb
+from netCDF4 import Dataset
 
 def loadmodel(path):
@@ -17,19 +18,17 @@
 		pass
 	else:
-		raise IOError("loadmodel error message: file '%s' does not exist" % path)
+		try:
+			NCFile=Dataset(path,mode='r')
+			NCFile.close()
+			pass
+		except RuntimeError:
+			raise IOError("loadmodel error message: file '%s' does not exist" % path)
+		#	try:
+	#recover model on file and name it md
+	struc=loadvars(path)
+	name=[key for key in struc.iterkeys()]
+	if len(name)>1:
+		raise IOError("loadmodel error message: file '%s' contains several variables. Only one model should be present." % path)
 
-	try:
-		#recover model on file and name it md
-		struc=loadvars(path)
-
-		name=[key for key in struc.iterkeys()]
-		if len(name)>1:
-			raise IOError("loadmodel error message: file '%s' contains several variables. Only one model should be present." % path)
-
-		md=struc[name[0]]
-		return md
-
-	except Exception as me:
-		print me
-		raise IOError("could not load model '%s'" % path)
-
+	md=struc[name[0]]
+	return md
Index: /issm/trunk-jpl/src/m/io/loadvars.py
===================================================================
--- /issm/trunk-jpl/src/m/io/loadvars.py	(revision 21234)
+++ /issm/trunk-jpl/src/m/io/loadvars.py	(revision 21235)
@@ -1,5 +1,10 @@
 import shelve
 import os.path
+import numpy as np
+from netCDF4 import Dataset
+from netCDF4 import chartostring
+from os import path
 from whichdb import whichdb
+from model import *
 
 def loadvars(*args):
@@ -51,24 +56,107 @@
 	if whichdb(filename):
 		print "Loading variables from file '%s'." % filename
-	else:
-		raise IOError("File '%s' not found." % filename)
+		
+		my_shelf = shelve.open(filename,'r') # 'r' for read-only
+		if nvdict:
+			for name in nvdict.iterkeys():
+				try:
+					nvdict[name] = my_shelf[name]
+					print "Variable '%s' loaded." % name
+				except KeyError:
+					value = None
+					print "Variable '%s' not found." % name
 
-	my_shelf = shelve.open(filename,'r') # 'r' for read-only
-
-	if nvdict:
-		for name in nvdict.iterkeys():
-			try:
+		else:
+			for name in my_shelf.iterkeys():
 				nvdict[name] = my_shelf[name]
 				print "Variable '%s' loaded." % name
-			except KeyError:
-				value = None
-				print "Variable '%s' not found." % name
+
+		my_shelf.close()
 
 	else:
-		for name in my_shelf.iterkeys():
-			nvdict[name] = my_shelf[name]
-			print "Variable '%s' loaded." % name
+		try:
+			NCFile=Dataset(filename,mode='r')
+			NCFile.close()
+			classtype,classtree=netCDFread(filename)
+			nvdict['md']=model()
+			module=map(__import__,dict.values(classtype))
+			for i,mod in enumerate(dict.keys(classtype)):
+#				print('treating md.{}'.format(mod))
+				if np.size(classtree[mod])>1:
+					if classtree[mod][0]=='results':
+						#treating results (Dimension4 is time)
+						resdim=len(NCFile.dimensions['Dimension4'])
+						curclass=NCFile.groups[classtree[mod][0]].groups[classtree[mod][1]]
+						nvdict['md'].__dict__[classtree[mod][0]].__dict__[classtree[mod][1]] = [getattr(module[i],classtype[mod])()]
+						if resdim>1:
+							for t in range(1,resdim):
+								nvdict['md'].__dict__[classtree[mod][0]].__dict__[classtree[mod][1]].append(getattr(module[i],classtype[mod])())
+						Tree=nvdict['md'].__dict__[classtree[mod][0]].__dict__[classtree[mod][1]][:]
+					else:
+						curclass=NCFile.groups[classtree[mod][0]].groups[classtree[mod][1]]
+						nvdict['md'].__dict__[classtree[mod][0]].__dict__[classtree[mod][1]] = getattr(module[i],classtype[mod])()
+						Tree=nvdict['md'].__dict__[classtree[mod][0]].__dict__[classtree[mod][1]]
+				else:
+					curclass=NCFile.groups[classtree[mod][0]]
+					nvdict['md'].__dict__[mod] = getattr(module[i],classtype[mod])()
+					Tree=nvdict['md'].__dict__[classtree[mod][0]]
+				for var in curclass.variables:
+					#print('    treating {}'.format(var))
+					varval=curclass.variables[str(var)]
+					vardim=varval.ndim
+					try:
+						val_type=str(varval.dtype)
+					except AttributeError:
+						val_type=type(varval)
+					if vardim==0:
+						try:
+							Tree.__dict__[str(var)]=varval.getValue()
+							if varval.getValue()=='True':
+								Tree.__dict__[str(var)]=True
+							elif varval.getValue()=='False':
+								Tree.__dict__[str(var)]=False
+						except IndexError:
+							Tree.__dict__[str(var)]=[]
+					elif vardim==1:
+						if varval.dtype==str:
+							if varval.shape==1:
+								Tree.__dict__[str(var)]=varval[0]
+							if 'True' in varval[:] or 'False' in varval[:]:
+								Tree.__dict__[str(var)]=np.asarray(varval[:],dtype=bool)
+						else:
+							if classtree[mod][0]=='results' and resdim>1:
+								for t in range(0,resdim):
+									Tree[t].__dict__[str(var)]=varval[t]
+							else:
+								Tree.__dict__[str(var)]=varval[:]
+					elif vardim==2:
+						#dealling with dict
+						if varval.dtype==str:
+							Tree.__dict__[str(var)]=dict(zip(varval[:,0], varval[:,1]))
+						else:
+							if classtree[mod][0]=='results' and resdim>1:
+								for t in range(0,resdim):
+									Tree[t].__dict__[str(var)]=varval[:,t]
+							else:
+								Tree.__dict__[str(var)]=varval[:,:]
+					elif vardim==3:
+						if classtree[mod][0]=='results' and resdim>1:
+							for t in range(0,resdim):
+								Tree[t].__dict__[str(var)]=varval[:,:,t]
+						else:
+							Tree.__dict__[str(var)]=varval[:,:,:]
+					else:
+						print 'table dimension greater than 3 not implemented yet'
+				for attr in curclass.ncattrs():
+					#print('    treating {}'.format(attr))
+					if classtree[mod][0]!='results': #no attributes in results
+						Tree.__dict__[str(attr)]=curclass.getncattr(attr)
+						if curclass.getncattr(attr)=='True':
+							Tree.__dict__[str(attr)]=True
+						elif curclass.getncattr(attr)=='False':
+							Tree.__dict__[str(attr)]=False
 
-	my_shelf.close()
+		except RuntimeError:
+			raise IOError("File '%s' not found." % filename)
 
 	if   len(args) >= 2 and isinstance(args[1],(str,unicode)):    # (value)
@@ -83,2 +171,28 @@
 		return nvdict
 
+
+def netCDFread(filename):
+	def walktree(data):
+		keys = data.groups.keys()
+		for key in keys:
+			yield [str(key)]
+			for children in walktree(data.groups[str(key)]):
+				child=[str(key)]
+				child.append(str(children[0]))
+				yield child
+	print ('Opening {} for reading '.format(filename))
+	NCData=Dataset(filename, 'r')
+	class_dict={}
+	class_tree={}
+	
+	for children in walktree(NCData):
+		classe=str(children[0])
+		if np.size(children)>1:
+			for name in children[1:]:
+				classe=classe+'.'+name
+			class_dict[classe]=str(getattr(NCData.groups[children[0]].groups[children[1]],'classtype'))
+		else:
+			class_dict[classe]=str(getattr(NCData.groups[classe],'classtype'))
+		class_tree[classe]=children
+
+	return class_dict,class_tree