Changeset 21247


Ignore:
Timestamp:
10/06/16 09:22:31 (8 years ago)
Author:
bdef
Message:

BUG:update to netCDF export import after clearing the nightly runs

Location:
issm/trunk-jpl/src/m
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • issm/trunk-jpl/src/m/contrib/defleurian/netCDF/export_netCDF.py

    r21235 r21247  
    2424
    2525        #gather geometry and timestepping as dimensions
    26         Duration=md.timestepping.final_time-md.timestepping.start_time
    27         if Duration>0 and md.timestepping.time_step*md.settings.output_frequency>0:
    28                 StepNum=int(Duration/(md.timestepping.time_step*md.settings.output_frequency))
    29         else:
     26        try:
     27                StepNum=np.shape(dict.values(md.results.__dict__))[1]
     28        except IndexError:
    3029                StepNum=1
    31                
    32         Dimension1=NCData.createDimension('Dimension1',md.mesh.numberofelements)
    33         Dimension2=NCData.createDimension('Dimension2',md.mesh.numberofvertices)
    34         Dimension3=NCData.createDimension('Dimension3',np.shape(md.mesh.elements)[1])
    35         Dimension4=NCData.createDimension('Dimension4',StepNum)
    36         Dimension5=NCData.createDimension('Dimension5',2)
    37 
    38         DimDict = {len(Dimension1):'Dimension1',
    39                                                  len(Dimension2):'Dimension2',
    40                                                  len(Dimension3):'Dimension3',
    41                                                  len(Dimension4):'Dimension4',
    42                                                  len(Dimension5):'Dimension5'}
     30        Dimension1=NCData.createDimension('DimNum1',StepNum)#time is first
     31        DimDict={len(Dimension1):'DimNum1'}
     32        dimindex=1
     33
     34        dimlist=[2,md.mesh.numberofelements,md.mesh.numberofvertices,np.shape(md.mesh.elements)[1]]
     35        for i in range(0,4):
     36                if dimlist[i] not in DimDict.keys():
     37                        dimindex+=1
     38                        NewDim=NCData.createDimension('DimNum'+str(dimindex),dimlist[i])
     39                        DimDict[len(NewDim)]='DimNum'+str(dimindex)
    4340
    4441        #get all model classes and create respective groups
     42        typelist=[bool,str,unicode,int,float,complex,numpy.ndarray,collections.OrderedDict]
    4543        groups=dict.keys(md.__dict__)
    4644        for group in groups:
     
    4947                fields=dict.keys(md.__dict__[group].__dict__)
    5048
    51                 #Special treatment for the results
    52                 if str(group)=='results':
    53                         for supfield in fields:#looping on the different solutions
    54                                 NCgroup.__setattr__('classtype', "results")
    55                                 Subgroup=NCgroup.createGroup(str(supfield))
    56                                 #Subgroup.__setattr__('classtype',md.results.__dict__[supfield].__class__.__name__)
    57                                 Subgroup.__setattr__('classtype',md.results.__class__.__name__)
    58                                 if type(md.results.__dict__[supfield])==list:#the solution have several timestep
    59                                         #get last timesteps and output frequency
    60                                         last_step = np.size(md.results.__dict__[supfield])
    61                                         step_freq = md.settings.output_frequency
    62                                         #grab first time step
    63                                         subfields=dict.keys(md.results.__dict__[supfield].__getitem__(0).__dict__)
    64                                         for field in subfields:
    65                                                 if str(field)!='errlog' and str(field)!='outlog' and str(field)!='SolutionType':
    66                                                         Var=md.results.__dict__[supfield].__getitem__(0).__dict__[field]
    67                                                         DimDict=CreateVar(NCData,Var,field,Subgroup,DimDict,True,last_step,step_freq,md,supfield)
    68                                        
    69                                 elif type(md.results.__dict__[supfield])==results:#only one timestep
    70                                         subfields=dict.keys(md.results.__dict__[supfield].__dict__)
    71                                         for field in subfields:
    72                                                 if str(field)!='errlog' and str(field)!='outlog' and str(field)!='SolutionType':
    73                                                         Var=md.results.__dict__[supfield].__dict__[field]
    74                                                         DimDict=CreateVar(NCData,Var,field,NCgroup,DimDict,False)
     49                #looping on fields
     50                for field in fields:
     51                        #Special treatment for list fields
     52                        if type(md.__dict__[group].__dict__[field])==list:
     53                                StdList=False
     54                                if len(md.__dict__[group].__dict__[field])==0:
     55                                        StdList=True
    7556                                else:
    76                                         print ('Result format not suported')
    77                 else:
    78                        
    79                         for field in fields:
     57                                        StdList=type(md.__dict__[group].__dict__[field][0]) in typelist
     58
     59                                if StdList: #this is a standard or empty list just proceed
     60                                        NCgroup.__setattr__('classtype', md.__dict__[group].__class__.__name__)
     61                                        Var=md.__dict__[group].__dict__[field]
     62                                        DimDict=CreateVar(NCData,Var,field,NCgroup,DimDict,False)
     63                                else: #this is a list of fields, specific treatment needed
     64                                        Listsize=len(md.__dict__[group].__dict__[field])
     65                                        NCgroup.__setattr__('classtype', md.__dict__[group].__class__.__name__)
     66                                        Subgroup=NCgroup.createGroup(str(field))
     67                                        Subgroup.__setattr__('classtype',md.__dict__[group].__dict__[field].__class__.__name__)
     68                                        for listindex in range(0,Listsize):
     69                                                try:
     70                                                        Listgroup=Subgroup.createGroup(str(md.__dict__[group].__dict__[field].__getitem__(listindex).__dict__['name']))
     71                                                except KeyError:
     72                                                        for naming in ['step']:
     73                                                                Listgroup=Subgroup.createGroup(str(md.__dict__[group].__dict__[field].__getitem__(listindex).__dict__[naming]))
     74                                                except AttributeError:
     75                                                        Listgroup=Subgroup.createGroup(str(md.__dict__[group].__dict__[field].__class__.__name__)+str(listindex))
     76                                                Listgroup.__setattr__('classtype',md.__dict__[group].__dict__[field].__getitem__(listindex).__class__.__name__)
     77                                                try:
     78                                                        subfields=dict.keys(md.__dict__[group].__dict__[field].__getitem__(listindex).__dict__)
     79                                                except AttributeError:
     80                                                        subfields=dict.keys(md.__dict__[group].__dict__[field].__getitem__(listindex))
     81                                                for subfield in subfields:
     82                                                        try:
     83                                                                Var=md.__dict__[group].__dict__[field].__getitem__(listindex).__dict__[subfield]
     84                                                        except AttributeError:
     85                                                                Var=md.__dict__[group].__dict__[field].__getitem__(listindex)[subfield]
     86                                                        DimDict=CreateVar(NCData,Var,subfield,Listgroup,DimDict,False,md.__dict__[group],field,listindex)
     87                        #No subgroup, we directly treat the variable
     88                        elif type(md.__dict__[group].__dict__[field]) in typelist:
    8089                                NCgroup.__setattr__('classtype', md.__dict__[group].__class__.__name__)
    8190                                Var=md.__dict__[group].__dict__[field]
    8291                                DimDict=CreateVar(NCData,Var,field,NCgroup,DimDict,False)
     92                        else:
     93                                NCgroup.__setattr__('classtype', str(group))
     94                                Subgroup=NCgroup.createGroup(str(field))
     95                                Subgroup.__setattr__('classtype',md.__dict__[group].__class__.__name__)
     96                                subfields=dict.keys(md.__dict__[group].__dict__[field].__dict__)
     97                                for subfield in subfields:
     98                                        if str(subfield)!='errlog' and str(subfield)!='outlog' and str(subfield)!='SolutionType':
     99                                                Var=md.__dict__[group].__dict__[field].__dict__[subfield]
     100                                                DimDict=CreateVar(NCData,Var,subfield,Subgroup,DimDict,False)
     101                               
    83102        NCData.close()
    84103
     
    97116                val_shape=np.shape(var)
    98117
    99 
    100118        TypeDict = {float:'f8',
    101119                                                        'float64':'f8',
    102120                                                        int:'i8',
    103                                                         'int64':'i8'}
     121                                                        'int64':'i8',
     122                                                        str:'str',
     123                                                        dict:'str'}
    104124               
    105125        val_dim=np.shape(val_shape)[0]
     
    111131        elif val_type==list:
    112132                dimensions,DimDict=GetDim(NCData,var,val_shape,DimDict,val_dim,istime)
    113                 ncvar = Group.createVariable(str(field),'str',dimensions,zlib=True)
    114                 for elt in range(0,val_dim):
    115                         try:
     133                #try to get the type from the first element
     134                try:
     135                        nctype=TypeDict[type(var[0])]
     136                except IndexError:
     137                        nctype='str' #most probably an empty list take str for that
     138                ncvar = Group.createVariable(str(field),nctype,dimensions,zlib=True)
     139                if val_shape==0:
     140                        ncvar= []
     141                else:                   
     142                        for elt in range(0,val_shape[0]):
    116143                                ncvar[elt] = var[elt]
    117                         except IndexError:
    118                                 ncvar= []
    119144        #treating bool tables as string tables
    120145        elif val_type=='bool':
     
    135160                ncvar = Group.createVariable(str(field),TypeDict[val_type],dimensions,zlib=True)
    136161                if istime:
    137                         last=step_args[0]
    138                         md=step_args[2]
    139                         supfield=step_args[3]
     162                        md=step_args[0]
     163                        supfield=step_args[1]
     164                        index=step_args[2]
    140165                        vartab=var
    141                         for time in range(0,last,1):
    142                                 if time!=0:
    143                                         timevar=md.results.__dict__[supfield].__getitem__(time).__dict__[field]
    144                                         vartab=np.column_stack((vartab,timevar))
    145                         try:
    146                                 ncvar[:,:]=vartab[:,:]
     166                        timevar=md.__dict__[supfield].__getitem__(index).__dict__[field]
     167                        try:
     168                                ncvar[:,:]=timevar[:,:]
    147169                        except ValueError:
    148                                 ncvar[:]=vartab.T[:]
     170                                ncvar[:]=timevar.T[:]
    149171                else:
    150172                        try:
     
    170192                                if (shape[dim])>0:
    171193                                        index=len(DimDict)+1
    172                                         NewDim=NCData.createDimension('Dimension'+str(index),(shape[dim]))
    173                                         DimDict[len(NewDim)]='Dimension'+str(index)
     194                                        NewDim=NCData.createDimension('DimNum'+str(index),(shape[dim]))
     195                                        DimDict[len(NewDim)]='DimNum'+str(index)
    174196                                        output=output+[str(DimDict[shape[dim]])]
    175197                elif type(shape[0])==str:#dealling with a dictionnary
    176198                        try:
    177199                                #dimension5 is 2 to treat with dict
    178                                 output=[str(DimDict[np.shape(shape)[0]])]+['Dimension5']
     200                                output=[str(DimDict[np.shape(shape)[0]])]+[DimDict[2]]
    179201                        except KeyError:
    180202                                index=len(DimDict)+1
    181                                 NewDim=NCData.createDimension('Dimension'+str(index),np.shape(shape)[0])
    182                                 DimDict[len(NewDim)]='Dimension'+str(index)
    183                                 output=[str(DimDict[np.shape(dict.keys(var))[0]])]+['Dimension5']
     203                                NewDim=NCData.createDimension('DimNum'+str(index),np.shape(shape)[0])
     204                                DimDict[len(NewDim)]='DimNum'+str(index)
     205                                output=[str(DimDict[np.shape(dict.keys(var))[0]])]+[DimDict[2]]
    184206                        break
    185207        if istime:
    186                 output=output+['Dimension4']
     208                output=output+['DimNum1']
    187209        return tuple(output), DimDict
  • issm/trunk-jpl/src/m/io/loadvars.py

    r21236 r21247  
    7878                        NCFile=Dataset(filename,mode='r')
    7979                        NCFile.close()
    80                         classtype,classtree=netCDFread(filename)
    81                         nvdict['md']=model()
    82                         module=map(__import__,dict.values(classtype))
    83                         for i,mod in enumerate(dict.keys(classtype)):
    84 #                               print('treating md.{}'.format(mod))
    85                                 if np.size(classtree[mod])>1:
    86                                         if classtree[mod][0]=='results':
    87                                                 #treating results (Dimension4 is time)
    88                                                 resdim=len(NCFile.dimensions['Dimension4'])
    89                                                 curclass=NCFile.groups[classtree[mod][0]].groups[classtree[mod][1]]
    90                                                 nvdict['md'].__dict__[classtree[mod][0]].__dict__[classtree[mod][1]] = [getattr(module[i],classtype[mod])()]
    91                                                 if resdim>1:
    92                                                         for t in range(1,resdim):
    93                                                                 nvdict['md'].__dict__[classtree[mod][0]].__dict__[classtree[mod][1]].append(getattr(module[i],classtype[mod])())
    94                                                 Tree=nvdict['md'].__dict__[classtree[mod][0]].__dict__[classtree[mod][1]][:]
    95                                         else:
    96                                                 curclass=NCFile.groups[classtree[mod][0]].groups[classtree[mod][1]]
    97                                                 nvdict['md'].__dict__[classtree[mod][0]].__dict__[classtree[mod][1]] = getattr(module[i],classtype[mod])()
    98                                                 Tree=nvdict['md'].__dict__[classtree[mod][0]].__dict__[classtree[mod][1]]
    99                                 else:
    100                                         curclass=NCFile.groups[classtree[mod][0]]
    101                                         nvdict['md'].__dict__[mod] = getattr(module[i],classtype[mod])()
    102                                         Tree=nvdict['md'].__dict__[classtree[mod][0]]
    103                                 for var in curclass.variables:
    104                                         #print('    treating {}'.format(var))
    105                                         varval=curclass.variables[str(var)]
    106                                         vardim=varval.ndim
    107                                         try:
    108                                                 val_type=str(varval.dtype)
    109                                         except AttributeError:
    110                                                 val_type=type(varval)
    111                                         if vardim==0:
    112                                                 try:
    113                                                         Tree.__dict__[str(var)]=varval.getValue()
    114                                                         if varval.getValue()=='True':
    115                                                                 Tree.__dict__[str(var)]=True
    116                                                         elif varval.getValue()=='False':
    117                                                                 Tree.__dict__[str(var)]=False
    118                                                 except IndexError:
    119                                                         Tree.__dict__[str(var)]=[]
    120                                         elif vardim==1:
    121                                                 if varval.dtype==str:
    122                                                         if varval.shape==1:
    123                                                                 Tree.__dict__[str(var)]=str(varval[0])
    124                                                         if 'True' in varval[:] or 'False' in varval[:]:
    125                                                                 Tree.__dict__[str(var)]=np.asarray(varval[:],dtype=bool)
    126                                                 else:
    127                                                         if classtree[mod][0]=='results' and resdim>1:
    128                                                                 for t in range(0,resdim):
    129                                                                         Tree[t].__dict__[str(var)]=varval[t]
    130                                                         else:
    131                                                                 Tree.__dict__[str(var)]=varval[:]
    132                                         elif vardim==2:
    133                                                 #dealling with dict
    134                                                 if varval.dtype==str:
    135                                                         Tree.__dict__[str(var)]=dict(zip(varval[:,0], varval[:,1]))
    136                                                 else:
    137                                                         if classtree[mod][0]=='results' and resdim>1:
    138                                                                 for t in range(0,resdim):
    139                                                                         Tree[t].__dict__[str(var)]=varval[:,t]
    140                                                         else:
    141                                                                 Tree.__dict__[str(var)]=varval[:,:]
    142                                         elif vardim==3:
    143                                                 if classtree[mod][0]=='results' and resdim>1:
    144                                                         for t in range(0,resdim):
    145                                                                 Tree[t].__dict__[str(var)]=varval[:,:,t]
    146                                                 else:
    147                                                         Tree.__dict__[str(var)]=varval[:,:,:]
    148                                         else:
    149                                                 print 'table dimension greater than 3 not implemented yet'
    150                                 for attr in curclass.ncattrs():
    151                                         #print('    treating {}'.format(attr))
    152                                         if classtree[mod][0]!='results' and attr!='classtype': #no attributes in results
    153                                                 Tree.__dict__[str(attr)]=str(curclass.getncattr(attr))
    154                                                 if curclass.getncattr(attr)=='True':
    155                                                         Tree.__dict__[str(attr)]=True
    156                                                 elif curclass.getncattr(attr)=='False':
    157                                                         Tree.__dict__[str(attr)]=False
    158 
    15980                except RuntimeError:
    16081                        raise IOError("File '%s' not found." % filename)
    16182
     83                classtype,classtree=netCDFread(filename)
     84                nvdict['md']=model()
     85                NCFile=Dataset(filename,mode='r')
     86                for mod in dict.keys(classtype):
     87                        if np.size(classtree[mod])>1:
     88                                curclass=NCFile.groups[classtree[mod][0]].groups[classtree[mod][1]]
     89                                if classtype[mod][0]=='list':
     90                                        keylist=[key for key in curclass.groups]
     91                                        listtype=curclass.groups[keylist[0]].classtype
     92                                        if listtype=='dict':
     93                                                nvdict['md'].__dict__[classtree[mod][0]].__dict__[classtree[mod][1]] = [{} for i in range(max(1,len(curclass.groups)))]
     94                                        else:
     95                                                nvdict['md'].__dict__[classtree[mod][0]].__dict__[classtree[mod][1]] = [getattr(__import__(listtype),listtype)() for i in range(max(1,len(curclass.groups)))]
     96                                        Tree=nvdict['md'].__dict__[classtree[mod][0]].__dict__[classtree[mod][1]][:]
     97                                else:
     98                                        nvdict['md'].__dict__[classtree[mod][0]].__dict__[classtree[mod][1]] = getattr(classtype[mod][1],classtype[mod][0])()
     99                                        Tree=nvdict['md'].__dict__[classtree[mod][0]].__dict__[classtree[mod][1]]
     100                        else:
     101                                curclass=NCFile.groups[classtree[mod][0]]
     102                                nvdict['md'].__dict__[mod] = getattr(classtype[mod][1],classtype[mod][0])()
     103                                Tree=nvdict['md'].__dict__[classtree[mod][0]]
     104                        #treating groups that are lists
     105                        for i in range(0,max(1,len(curclass.groups))):
     106                                if len(curclass.groups)>0:
     107                                        listclass=curclass.groups[keylist[i]]
     108                                else:
     109                                        listclass=curclass
     110                                for var in listclass.variables:
     111                                        if var not in ['errlog','outlog']:
     112                                                varval=listclass.variables[str(var)]
     113                                                vardim=varval.ndim
     114                                                try:
     115                                                        val_type=str(varval.dtype)
     116                                                except AttributeError:
     117                                                        val_type=type(varval)
     118                                                if vardim==0:
     119                                                        if type(Tree)==list:
     120                                                                t=int(keylist[i][-1])-1
     121                                                                if listtype=='dict':
     122                                                                        Tree[t][str(var)]=varval.getValue()
     123                                                                else:
     124                                                                        Tree[t].__dict__[str(var)]=varval.getValue()
     125                                                        else:
     126                                                                try:
     127                                                                        Tree.__dict__[str(var)]=varval.getValue()
     128                                                                        if varval.getValue()=='True':
     129                                                                                Tree.__dict__[str(var)]=True
     130                                                                        elif varval.getValue()=='False':
     131                                                                                Tree.__dict__[str(var)]=False
     132                                                                except IndexError:
     133                                                                        Tree.__dict__[str(var)]=[]
     134                                                elif vardim==1:
     135                                                        if varval.dtype==str:
     136                                                                if varval.shape[0]==1:
     137                                                                        Tree.__dict__[str(var)]=[str(varval[0]),]
     138                                                                elif 'True' in varval[:] or 'False' in varval[:]:
     139                                                                        Tree.__dict__[str(var)]=np.asarray([V=='True' for V in varval[:]],dtype=bool)
     140                                                                else:
     141                                                                        Tree.__dict__[str(var)]=[str(vallue) for vallue in varval[:]]
     142                                                        else:
     143                                                                if type(Tree)==list:
     144                                                                        t=int(keylist[i][-1])-1
     145                                                                        if listtype=='dict':
     146                                                                                Tree[t][str(var)]=varval[:]
     147                                                                        else:
     148                                                                                Tree[t].__dict__[str(var)]=varval[:]
     149                                                                else:
     150                                                                        try:
     151                                                                                #some thing specifically require a list
     152                                                                                mdtype=type(Tree.__dict__[str(var)])
     153                                                                        except KeyError:
     154                                                                                print 'not defined yet'
     155                                                                                mdtype=float
     156                                                                        if mdtype==list:
     157                                                                                Tree.__dict__[str(var)]=[mdval for mdval in varval[:]]
     158                                                                        else:
     159                                                                                Tree.__dict__[str(var)]=varval[:]
     160                                                elif vardim==2:
     161                                                        #dealling with dict
     162                                                        if varval.dtype==str:
     163                                                                Tree.__dict__[str(var)]=dict(zip(varval[:,0], varval[:,1]))
     164                                                        else:
     165                                                                if type(Tree)==list:
     166                                                                        t=int(keylist[i][-1])-1
     167                                                                        if listtype=='dict':
     168                                                                                Tree[t][str(var)]=varval[:,:]
     169                                                                        else:
     170                                                                                Tree[t].__dict__[str(var)]=varval[:,:]
     171                                                                else:
     172                                                                        Tree.__dict__[str(var)]=varval[:,:]
     173                                                elif vardim==3:
     174                                                        if type(Tree)==list:
     175                                                                t=int(keylist[i][-1])-1
     176                                                                if listtype=='dict':
     177                                                                        Tree[t][str(var)]=varval[:,:,:]
     178                                                                else:
     179                                                                        Tree[t].__dict__[str(var)]=varval[:,:,:]
     180                                                        else:
     181                                                                Tree.__dict__[str(var)]=varval[:,:,:]
     182                                                else:
     183                                                        print 'table dimension greater than 3 not implemented yet'
     184                                for attr in listclass.ncattrs():
     185                                        if  attr!='classtype': #classtype is for treatment, don't get it back
     186                                                if type(Tree)==list:
     187                                                        t=int(keylist[i][-1])-1
     188                                                        if listtype=='dict':
     189                                                                Tree[t][str(attr)]=str(listclass.getncattr(attr))
     190                                                        else:
     191                                                                Tree[t].__dict__[str(attr)]=str(listclass.getncattr(attr))
     192                                                else:
     193                                                        Tree.__dict__[str(attr)]=str(listclass.getncattr(attr))
     194                                                        if listclass.getncattr(attr)=='True':
     195                                                                Tree.__dict__[str(attr)]=True
     196                                                        elif listclass.getncattr(attr)=='False':
     197                                                                Tree.__dict__[str(attr)]=False
     198                NCFile.close()
    162199        if   len(args) >= 2 and isinstance(args[1],(str,unicode)):    # (value)
    163200                value=[nvdict[name] for name in args[1:]]
     
    173210
    174211def netCDFread(filename):
    175         def walktree(data):
    176                 keys = data.groups.keys()
    177                 for key in keys:
    178                         yield [str(key)]
    179                         for children in walktree(data.groups[str(key)]):
    180                                 child=[str(key)]
    181                                 child.append(str(children[0]))
    182                                 yield child
    183212        print ('Opening {} for reading '.format(filename))
    184213        NCData=Dataset(filename, 'r')
    185214        class_dict={}
    186215        class_tree={}
     216
     217        for group in NCData.groups:
     218                if len(NCData.groups[group].groups)>0:
     219                        for subgroup in NCData.groups[group].groups:
     220                                classe=str(group)+'.'+str(subgroup)
     221                                class_dict[classe]=[str(getattr(NCData.groups[group].groups[subgroup],'classtype')),]
     222                                if class_dict[classe][0] not in ['dict','list']:
     223                                        class_dict[classe].append(__import__(class_dict[classe][0]))
     224                                class_tree[classe]=[group,subgroup]
     225                else:
     226                        classe=str(group)
     227                        class_dict[classe]=[str(getattr(NCData.groups[group],'classtype')),]
     228                        if class_dict[classe][0] not in ['dict','list']:
     229                                class_dict[classe].append(__import__(class_dict[classe][0]))
     230                        class_tree[classe]=[group,]
    187231       
    188         for children in walktree(NCData):
    189                 classe=str(children[0])
    190                 if np.size(children)>1:
    191                         for name in children[1:]:
    192                                 classe=classe+'.'+name
    193                         class_dict[classe]=str(getattr(NCData.groups[children[0]].groups[children[1]],'classtype'))
    194                 else:
    195                         class_dict[classe]=str(getattr(NCData.groups[classe],'classtype'))
    196                 class_tree[classe]=children
    197 
     232        NCData.close()
    198233        return class_dict,class_tree
Note: See TracChangeset for help on using the changeset viewer.