Index: issm/trunk-jpl/src/m/io/loadvars.py
===================================================================
--- issm/trunk-jpl/src/m/io/loadvars.py	(revision 26968)
+++ issm/trunk-jpl/src/m/io/loadvars.py	(revision 27264)
@@ -55,4 +55,5 @@
 
     timeindex = False
+    SteadySols = ['ThermalSolution', 'HydrologySolution', 'StressbalanceSolution']
 
     for key, value in kwargs.items():
@@ -105,6 +106,10 @@
                     #here we have a more NC approach with time being a dimension
                     listtype = split(r'\.', classtype[mod][0])[1]
-                    print(listtype)
-                    if len(NCFile.dimensions['Time']) == 1:
+                    try:
+                        soltype = str(getattr(curclass, 'SolutionType'))
+                    except AttributeError:
+                        #might be an older format try that instead :
+                        soltype = str(getattr(curclass, 'sOLUTIONtYPE'))
+                    if len(NCFile.dimensions['Time']) == 1 or soltype in SteadySols:
                         nvdict['md'].__dict__[classtree[mod][0]].__dict__[classtree[mod][1]] = getattr(classtype[mod][1], listtype)()
                         Tree = nvdict['md'].__dict__[classtree[mod][0]].__dict__[classtree[mod][1]]
@@ -148,4 +153,7 @@
                     Tree = nvdict['md'].__dict__[classtree[mod][0]].__dict__[defname][defindex - 1]
                 #}}}
+                elif classtype[mod][0] == 'collections.OrderedDict':  #Treating multiple toolkits {{{
+                    nvdict['md'].__dict__[classtree[mod][0]].__dict__[classtree[mod][1]] = getattr(classtype[mod][1], 'OrderedDict')
+                    Tree = nvdict['md'].__dict__[classtree[mod][0]].__dict__[classtree[mod][1]]
                 else:
                     if verbose > 0:
@@ -184,6 +192,10 @@
             else:
                 groupclass = [curclass]
-            #==== We deal with Variables {{{
             for groupindex, listclass in enumerate(groupclass):
+                try:
+                    soltype = str(getattr(listclass, 'SolutionType'))
+                except AttributeError:
+                    soltype = 'NoSol'
+                #==== We deal with Variables {{{
                 for var in listclass.variables:
                     if not resname or var == resname:
@@ -217,9 +229,11 @@
                                         else:
                                             print('table dimension greater than 3 not implemented yet')
+                                    elif soltype in SteadySols:
+                                        Tree.__dict__[str(var)] = varval[:].data
                                     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
+                                        incomplete = 'Time' not in varval.dimensions and soltype not in SteadySols
                                         if incomplete:
                                             try:
@@ -230,22 +244,27 @@
                                                 #just one step, so no dimension, we just put it on the first solutionstep
                                                 timelist = [0]
+                                        elif soltype in SteadySols:
+                                            timelist = [0]
                                         else:
                                             timelist = np.arange(0, len(NCFile.dimensions['Time']))
-                                        for t in timelist:
-                                            if verbose > 5:
-                                                print("filing step {} for {}".format(t, var))
-                                            if vardim == 0:
-                                                Tree[t].__dict__[str(var)] = varval[:].data
-                                            elif vardim == 1:
-                                                stepval = ma.masked_array(varval[t].data, mask=np.where(np.isnan(varval[t]), 1, 0))
-                                                Tree[t].__dict__[str(var)] = ma.compressed(stepval)
-                                            elif vardim == 2:
-                                                stepval = ma.masked_array(varval[t, :].data, mask=np.where(np.isnan(varval[t, :]), 1, 0))
-                                                Tree[t].__dict__[str(var)] = ma.compressed(stepval)
-                                            elif vardim == 3:
-                                                stepval = ma.masked_array(varval[t, :, :].data, mask=np.where(np.isnan(varval[t, :, :]), 1, 0))
-                                                Tree[t].__dict__[str(var)] = ma.compressed(stepval).reshape((stepval.count(0)[0], stepval.count(1)[0]))
-                                            else:
-                                                print('table dimension greater than 3 not implemented yet')
+                                        if soltype in SteadySols:
+                                            Tree.__dict__[str(var)] = varval[:].data
+                                        else:
+                                            for t in timelist:
+                                                if verbose > 5:
+                                                    print("filing step {} for {}".format(t, var))
+                                                if vardim == 0:
+                                                    Tree[t].__dict__[str(var)] = varval[:].data
+                                                elif vardim == 1:
+                                                    stepval = ma.masked_array(varval[t].data, mask=np.where(np.isnan(varval[t]), 1, 0))
+                                                    Tree[t].__dict__[str(var)] = ma.compressed(stepval)
+                                                elif vardim == 2:
+                                                    stepval = ma.masked_array(varval[t, :].data, mask=np.where(np.isnan(varval[t, :]), 1, 0))
+                                                    Tree[t].__dict__[str(var)] = ma.compressed(stepval)
+                                                elif vardim == 3:
+                                                    stepval = ma.masked_array(varval[t, :, :].data, mask=np.where(np.isnan(varval[t, :, :]), 1, 0))
+                                                    Tree[t].__dict__[str(var)] = ma.compressed(stepval).reshape((stepval.count(0)[0], stepval.count(1)[0]))
+                                                else:
+                                                    print('table dimension greater than 3 not implemented yet')
                                     else:
                                         if verbose > 0:
@@ -315,5 +334,17 @@
                                             Tree.__dict__[str(var)] = varval[:, :].data
                                 elif vardim == 3:
-                                    Tree.__dict__[str(var)] = varval[:, :, :].data
+                                    if varval.dtype == "|S1":  #that is for matlab chararcter arrays
+                                        #most likely that is a toolkit dictionar so should be treated as such
+                                        #first we convert the character table to strings
+                                        stringtable = []
+                                        for i in range(np.shape(varval)[0]):
+                                            stringtable.append([chartostring(varval[i, 0, :]), chartostring(varval[i, 1, :])])
+                                        stringtable = np.asarray(stringtable, dtype=str)
+                                        Tree.__dict__[str(var)] = OrderedDict([('toolkit', str(varval[np.where(stringtable[:, 0] == 'toolkit')[0][0], 1]))])
+                                        strings1 = [str(arg[0]) for arg in stringtable if arg[0] != 'toolkits']
+                                        strings2 = [str(arg[1]) for arg in stringtable if arg[0] != 'toolkits']
+                                        Tree.__dict__[str(var)].update(list(zip(strings1, strings2)))
+                                    else:
+                                        Tree.__dict__[str(var)] = varval[:, :, :].data
                                 else:
                                     print('table dimension greater than 3 not implemented yet')
@@ -387,9 +418,10 @@
                 if class_dict[classe][0] not in ['dict', 'list', 'cell']:
                     modulename = split(r'\.', class_dict[classe][0])[0]
-                    if modulename == "giaivins":
-                        print("WARNING: module {} does not exist anymore and is skipped".format(modulename))
-                    else:
+                    try:
                         class_dict[classe].append(import_module(modulename))
                         class_tree[classe] = [group, ]
+                    except ModuleNotFoundError:
+                        print("WARNING: module {} does not exist anymore and is skipped".format(modulename))
+
             except AttributeError:
                 print(('group {} is empty'.format(group)))
