Index: /issm/trunk-jpl/src/m/io/loadmodel.py
===================================================================
--- /issm/trunk-jpl/src/m/io/loadmodel.py	(revision 26871)
+++ /issm/trunk-jpl/src/m/io/loadmodel.py	(revision 26872)
@@ -9,5 +9,5 @@
 
 
-def loadmodel(path, singletime=None):
+def loadmodel(path, singletime=None, singleres=None):
     """LOADMODEL - load a model
 
@@ -31,5 +31,5 @@
     #       try:
     #recover model on file and name it md
-    struc = loadvars(path, singletime=singletime)
+    struc = loadvars(path, singletime=singletime, singleres=singleres)
     name = [key for key in list(struc.keys())]
     if len(name) > 1:
Index: /issm/trunk-jpl/src/m/io/loadvars.py
===================================================================
--- /issm/trunk-jpl/src/m/io/loadvars.py	(revision 26871)
+++ /issm/trunk-jpl/src/m/io/loadvars.py	(revision 26872)
@@ -31,5 +31,5 @@
     filename = ''
     nvdict = {}
-    debug = False  # print messages if true
+    debug = True  # print messages if true
 
     if len(args) >= 1 and isinstance(args[0], str):
@@ -58,4 +58,6 @@
         if key == 'singletime':
             timeindex = value
+        if key == 'singleres':
+            resname = value
 
     if whichdb(filename):   #We used python pickle for the save
@@ -184,126 +186,126 @@
             for groupindex, listclass in enumerate(groupclass):
                 for var in listclass.variables:
-                    if var not in ['errlog', 'outlog']:
-                        varval = listclass.variables[str(var)]
-                        vardim = varval.ndim
-                        if debug:
-                            print("    ==> treating var {} of dimension {}".format(var, vardim))
-                        #There is a special treatment for results to account for its specific structure
-                        #that is the new export version where time is a named dimension
-                        NewFormat = 'Time' in NCFile.dimensions
-                        if type(Tree) == list:  # and NewFormat:
-                            if timeindex:
-                                if NewFormat:
-                                    if vardim == 1:
+                    if not resname or var == resname:
+                        if var not in ['errlog', 'outlog']:
+                            varval = listclass.variables[str(var)]
+                            vardim = varval.ndim
+                            if debug:
+                                print("    ==> treating var {} of dimension {}".format(var, vardim))
+                            #There is a special treatment for results to account for its specific structure
+                            #that is the new export version where time is a named dimension
+                            NewFormat = 'Time' in NCFile.dimensions
+                            if type(Tree) == list:  # and NewFormat:
+                                if timeindex:
+                                    if NewFormat:
+                                        if vardim == 1:
+                                            try:
+                                                Tree[0].__dict__[str(var)] = varval[timeindex].data
+                                            except IndexError:
+                                                print('WARNING: No data on index {} for {} reverting to last time.'.format(timeindex, str(var)))
+                                                Tree[0].__dict__[str(var)] = varval[-1].data
+                                        elif vardim == 2:
+                                            Tree[0].__dict__[str(var)] = varval[timeindex, :].data
+                                        elif vardim == 3:
+                                            Tree[0].__dict__[str(var)] = varval[timeindex, :, :].data
+                                        else:
+                                            print('table dimension greater than 3 not implemented yet')
+                                    else:  #old format had step sorted in difeerent group so last group is last time
+                                        Tree[0].__dict__[str(var)] = varval[:].data
+                                else:
+                                    if NewFormat:
+                                        incomplete = 'Time' not in varval.dimensions
+                                        if incomplete:
+                                            try:
+                                                chosendim = varval.dimensions[0]
+                                                timelist = np.arange(0, len(NCFile.dimensions[chosendim]))
+                                                print('WARNING, {} is not present on every times, we chose {}({}) as the dimension to write it with'.format(var, chosendim, len(NCFile.dimensions[chosendim])))
+                                            except IndexError:
+                                                #just one step, so no dimension, we just put it on the first solutionstep
+                                                timelist = [0]
+                                        else:
+                                            timelist = np.arange(0, len(NCFile.dimensions['Time']))
+                                        for t in timelist:
+                                            if debug:
+                                                print("filing step {} for {}".format(t, var))
+                                            if vardim == 0:
+                                                Tree[t].__dict__[str(var)] = varval[:].data
+                                            elif vardim == 1:
+                                                Tree[t].__dict__[str(var)] = varval[t].data
+                                            elif vardim == 2:
+                                                Tree[t].__dict__[str(var)] = varval[t, :].data
+                                            elif vardim == 3:
+                                                Tree[t].__dict__[str(var)] = varval[t, :, :].data
+                                            else:
+                                                print('table dimension greater than 3 not implemented yet')
+                                    else:
+                                        if debug:
+                                            print("filing step {} for {}".format(groupindex, var))
+                                        Tree[groupindex].__dict__[str(var)] = varval[:].data
+                            else:
+                                if vardim == 0:  #that is a scalar
+                                    if str(varval[0]) in ['', '--', 'emptycell']:  #no value
+                                        Tree.__dict__[str(var)] = []
+                                    elif varval[0] == 'True':  #treatin bool
+                                        Tree.__dict__[str(var)] = True
+                                    elif varval[0] == 'False':  #treatin bool
+                                        Tree.__dict__[str(var)] = False
+                                    else:
+                                        Tree.__dict__[str(var)] = varval[0].item()
+
+                                elif vardim == 1:  #that is a vector
+                                    if debug:
+                                        print("   for variable {} type is {}".format(str(var), varval.dtype))
+                                    if varval.dtype == str:
+                                        if varval.shape[0] == 1:
+                                            Tree.__dict__[str(var)] = [str(varval[0]), ]
+                                        elif 'True' in varval[:] or 'False' in varval[:]:
+                                            Tree.__dict__[str(var)] = np.asarray([V == 'True' for V in varval[:]], dtype=bool)
+                                        else:
+                                            Tree.__dict__[str(var)] = [str(vallue) for vallue in varval[:]]
+                                    elif varval.dtype == "|S1":  #that is for matlab chararcter arrays
+                                        stringlist = chartostring(varval[:])
+                                        Tree.__dict__[str(var)] = [stringlist.tolist(), ]
+                                    else:
                                         try:
-                                            Tree[0].__dict__[str(var)] = varval[timeindex].data
-                                        except IndexError:
-                                            print('WARNING: No data on index {} for {} reverting to last time.'.format(timeindex, str(var)))
-                                            Tree[0].__dict__[str(var)] = varval[-1].data
-
-                                    elif vardim == 2:
-                                        Tree[0].__dict__[str(var)] = varval[timeindex, :].data
-                                    elif vardim == 3:
-                                        Tree[0].__dict__[str(var)] = varval[timeindex, :, :].data
+                                            #some thing specifically require a list
+                                            mdtype = type(Tree.__dict__[str(var)])
+                                        except KeyError:
+                                            mdtype = float
+                                        if mdtype == list:
+                                            Tree.__dict__[str(var)] = [mdval for mdval in varval[:]]
+                                        else:
+                                            Tree.__dict__[str(var)] = varval[:].data
+
+                                elif vardim == 2:
+                                    #dealling with dict
+                                    if debug:
+                                        print("   for variable {} type is {}".format(str(var), varval.dtype))
+                                    if varval.dtype == str:  #that is for dictionaries
+                                        if any(varval[:, 0] == 'toolkit'):  #toolkit definition have to be first
+                                            Tree.__dict__[str(var)] = OrderedDict([('toolkit', str(varval[np.where(varval[:, 0] == 'toolkit')[0][0], 1]))])
+                                            strings1 = [str(arg[0]) for arg in varval if arg[0] != 'toolkits']
+                                            strings2 = [str(arg[1]) for arg in varval if arg[0] != 'toolkits']
+                                            Tree.__dict__[str(var)].update(list(zip(strings1, strings2)))
+                                        else:
+                                            strings1 = [str(arg[0]) for arg in varval]
+                                            strings2 = [str(arg[1]) for arg in varval]
+                                            Tree.__dict__[str(var)] = OrderedDict(list(zip(strings1, strings2)))
+                                    elif varval.dtype == "|S1":  #that is for matlab chararcter arrays
+                                        stringlist = chartostring(varval[:, :])
+                                        stringlist = [string.strip() for string in stringlist]
+                                        Tree.__dict__[str(var)] = stringlist
                                     else:
-                                        print('table dimension greater than 3 not implemented yet')
-                                else:  #old format had step sorted in difeerent group so last group is last time
-                                    Tree[0].__dict__[str(var)] = varval[:].data
-                            else:
-                                if NewFormat:
-                                    incomplete = 'Time' not in varval.dimensions
-                                    if incomplete:
-                                        try:
-                                            chosendim = varval.dimensions[0]
-                                            timelist = np.arange(0, len(NCFile.dimensions[chosendim]))
-                                            print('WARNING, {} is not present on every times, we chose {}({}) as the dimension to write it with'.format(var, chosendim, len(NCFile.dimensions[chosendim])))
-                                        except IndexError:
-                                            #just one step, so no dimension, we just put it on the first solutionstep
-                                            timelist = [0]
-                                    else:
-                                        timelist = np.arange(0, len(NCFile.dimensions['Time']))
-                                    for t in timelist:
-                                        if debug:
-                                            print("filing step {} for {}".format(t, var))
-                                        if vardim == 0:
-                                            Tree[t].__dict__[str(var)] = varval[:].data
-                                        elif vardim == 1:
-                                            Tree[t].__dict__[str(var)] = varval[t].data
-                                        elif vardim == 2:
-                                            Tree[t].__dict__[str(var)] = varval[t, :].data
-                                        elif vardim == 3:
-                                            Tree[t].__dict__[str(var)] = varval[t, :, :].data
-                                        else:
-                                            print('table dimension greater than 3 not implemented yet')
+                                        if type(Tree) == list:
+                                            t = indexlist[i]
+                                            if listtype == 'dict':
+                                                Tree[t][str(var)] = varval[:, :].data
+                                            else:
+                                                Tree[t].__dict__[str(var)] = varval[:, :].data
+                                        else:
+                                            Tree.__dict__[str(var)] = varval[:, :].data
+                                elif vardim == 3:
+                                    Tree.__dict__[str(var)] = varval[:, :, :].data
                                 else:
-                                    if debug:
-                                        print("filing step {} for {}".format(groupindex, var))
-                                    Tree[groupindex].__dict__[str(var)] = varval[:].data
-                        else:
-                            if vardim == 0:  #that is a scalar
-                                if str(varval[0]) in ['', '--', 'emptycell']:  #no value
-                                    Tree.__dict__[str(var)] = []
-                                elif varval[0] == 'True':  #treatin bool
-                                    Tree.__dict__[str(var)] = True
-                                elif varval[0] == 'False':  #treatin bool
-                                    Tree.__dict__[str(var)] = False
-                                else:
-                                    Tree.__dict__[str(var)] = varval[0].item()
-
-                            elif vardim == 1:  #that is a vector
-                                if debug:
-                                    print("   for variable {} type is {}".format(str(var), varval.dtype))
-                                if varval.dtype == str:
-                                    if varval.shape[0] == 1:
-                                        Tree.__dict__[str(var)] = [str(varval[0]), ]
-                                    elif 'True' in varval[:] or 'False' in varval[:]:
-                                        Tree.__dict__[str(var)] = np.asarray([V == 'True' for V in varval[:]], dtype=bool)
-                                    else:
-                                        Tree.__dict__[str(var)] = [str(vallue) for vallue in varval[:]]
-                                elif varval.dtype == "|S1":  #that is for matlab chararcter arrays
-                                    stringlist = chartostring(varval[:])
-                                    Tree.__dict__[str(var)] = [stringlist.tolist(), ]
-                                else:
-                                    try:
-                                        #some thing specifically require a list
-                                        mdtype = type(Tree.__dict__[str(var)])
-                                    except KeyError:
-                                        mdtype = float
-                                    if mdtype == list:
-                                        Tree.__dict__[str(var)] = [mdval for mdval in varval[:]]
-                                    else:
-                                        Tree.__dict__[str(var)] = varval[:].data
-
-                            elif vardim == 2:
-                                #dealling with dict
-                                if debug:
-                                    print("   for variable {} type is {}".format(str(var), varval.dtype))
-                                if varval.dtype == str:  #that is for dictionaries
-                                    if any(varval[:, 0] == 'toolkit'):  #toolkit definition have to be first
-                                        Tree.__dict__[str(var)] = OrderedDict([('toolkit', str(varval[np.where(varval[:, 0] == 'toolkit')[0][0], 1]))])
-                                        strings1 = [str(arg[0]) for arg in varval if arg[0] != 'toolkits']
-                                        strings2 = [str(arg[1]) for arg in varval if arg[0] != 'toolkits']
-                                        Tree.__dict__[str(var)].update(list(zip(strings1, strings2)))
-                                    else:
-                                        strings1 = [str(arg[0]) for arg in varval]
-                                        strings2 = [str(arg[1]) for arg in varval]
-                                        Tree.__dict__[str(var)] = OrderedDict(list(zip(strings1, strings2)))
-                                elif varval.dtype == "|S1":  #that is for matlab chararcter arrays
-                                    stringlist = chartostring(varval[:, :])
-                                    stringlist = [string.strip() for string in stringlist]
-                                    Tree.__dict__[str(var)] = stringlist
-                                else:
-                                    if type(Tree) == list:
-                                        t = indexlist[i]
-                                        if listtype == 'dict':
-                                            Tree[t][str(var)] = varval[:, :].data
-                                        else:
-                                            Tree[t].__dict__[str(var)] = varval[:, :].data
-                                    else:
-                                        Tree.__dict__[str(var)] = varval[:, :].data
-                            elif vardim == 3:
-                                Tree.__dict__[str(var)] = varval[:, :, :].data
-                            else:
-                                print('table dimension greater than 3 not implemented yet')
+                                    print('table dimension greater than 3 not implemented yet')
                 # }}}
                 #==== And with atribute {{{
