Changeset 19097


Ignore:
Timestamp:
02/11/15 11:47:25 (10 years ago)
Author:
bdef
Message:

CHG: changing function organisation

File:
1 edited

Legend:

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

    r19096 r19097  
    88from os import path, remove
    99
    10 def netCDFExp(md,filename):
    11 
    12         #defining some sub-functions
    13         #retriev the dimension tuple from a dictionnary
    14         def GetDim(var,shape,i,istime):
    15                 output=[]
    16                 for dim in range(0,i): #loop on the dimensions
    17                         if type(shape[0])==int:
    18                                 try:
    19                                         output=output+[str(DimDict[shape[dim]])] #test if the dimension allready exist
    20                                 except KeyError: #if not create it
    21                                         if (shape[dim])>1:
    22                                                 index=len(DimDict)+1
    23                                                 NewDim=NCData.createDimension('Dimension'+str(index),(shape[dim]))
    24                                                 DimDict[len(NewDim)]='Dimension'+str(index)
    25                                                 output=output+[str(DimDict[shape[dim]])]
    26                                                 print 'Defining dimension ' +str(shape[dim]) +' for '+str(field)+str(dim)
    27                         elif type(shape[0])==str:#dealling with a dictionnary
    28                                 try:
    29                                         output=[str(DimDict[numpy.shape(shape)[0]])]+['DictDim']
    30                                 except KeyError:
    31                                         index=len(DimDict)+1
    32                                         NewDim=NCData.createDimension('Dimension'+str(index),numpy.shape(shape)[0])
    33                                         DimDict[len(NewDim)]='Dimension'+str(index)
    34                                         output=[str(DimDict[numpy.shape(dict.keys(var))[0]])]+['Dimension5']
    35                                         print 'Defining dimension ' +str(numpy.shape(shape)[0]) +' for '+str(field)
    36                                 break
    37                 if istime:
    38                         output=output+['Dimension4']
    39                 return tuple(output)
    40         #============================================================================
    41 
    42   #Define the variables
    43         def CreateVar(var,Group,istime,*step_args):
    44                 #grab type
    45                 try:
    46                         val_type=str(var.dtype)
    47                 except AttributeError:
    48                         val_type=type(var)
    49                 #grab dimension
    50                 try:
    51                         val_shape=dict.keys(var)
    52                 except TypeError:
    53                         val_shape=numpy.shape(var)
    54 
    55                 val_dim=numpy.shape(val_shape)[0]
    56                 #Now define and fill up variable
    57 
    58                 #treating scalar string or bool as atribute
    59                 if val_type==str or val_type==bool:
    60                         Group.__setattr__(str(field), str(var))
    61 
    62                 #treating list as string table
    63                 elif val_type==list:
    64                         ncvar = Group.createVariable(str(field),str,GetDim(var,val_shape,val_dim,istime),zlib=True)
    65                         for elt in range(0,val_dim):
    66                                 try:
    67                                         ncvar[elt] = var[elt]
    68                                 except IndexError:
    69                                         ncvar[0]= " "
    70                 #treating bool tables as string tables
    71                 elif val_type=='bool':
    72                         ncvar = Group.createVariable(str(field),str,GetDim(var,val_shape,val_dim,istime),zlib=True)
    73                         for elt in range(0,val_shape[0]):
    74                                 ncvar[elt] = str(var[elt])
    75                 #treating dictionaries as string tables of dim 2
    76                 elif val_type==collections.OrderedDict:
    77                         ncvar = Group.createVariable(str(field),str,GetDim(var,val_shape,val_dim,istime),zlib=True)
    78                         for elt in range(0,val_dim):
    79                                 ncvar[elt,0]=dict.keys(var)[elt]
    80                                 ncvar[elt,1]=str(dict.values(var)[elt]) #converting to str to avoid potential problems
    81                 #Now dealing with numeric variables
    82                 else:
    83                         ncvar = Group.createVariable(str(field),TypeDict[val_type],GetDim(var,val_shape,val_dim,istime),zlib=True)
    84                        
    85                         if istime:
    86                                 last=step_args[0]
    87                                 freq=step_args[1]
    88                                 vartab=var
    89                                 for time in range(freq-1,last,freq):
    90                                         if time!=0:
    91                                                 timevar=md.results.__dict__[supfield].__getitem__(time).__dict__[field]
    92                                                 print 'Treating '+str(group)+'.'+str(supfield)+'.'+str(field)+' for time '+str(time)
    93                                                 vartab=numpy.column_stack((vartab,timevar))
    94                                 print numpy.shape(vartab)
    95                                 try:
    96                                         ncvar[:,:]=vartab[:,:]
    97                                 except ValueError:
    98                                         ncvar[:]=vartab.T[:]
    99                         else:
    100                                 try:
    101                                         nan_val=numpy.isnan(var)
    102                                         if nan_val.all():
    103                                                 ncvar [:] = 'NaN'
    104                                         else:
    105                                                 ncvar[:] = var
    106                                 except TypeError: #type does not accept nan, get vallue of the variable
    107                                         ncvar[:] = var
    108         #============================================================================
    109        
     10def export_netCDF(md,filename):
    11011        #Now going on Real treatment
    11112        if path.exists(filename):
     
    14142                                                 len(Dimension5):'Dimension5'}
    14243
    143         TypeDict = {float:'f8',
    144                                                         'float64':'f8',
    145                                                         int:'i8',
    146                                                         'int64':'i8'}
    147        
    14844        #get all model classes and create respective groups
    14945        groups=dict.keys(md.__dict__)
     
    16864                                                if str(field)!='errlog' and str(field)!='outlog' and str(field)!='SolutionType':
    16965                                                        Var=md.results.__dict__[supfield].__getitem__(0).__dict__[field]
    170                                                         CreateVar(Var,Subgroup,True,last_step,step_freq)
     66                                                        DimDict=CreateVar(NCData,Var,field,Subgroup,DimDict,True,last_step,step_freq,md,supfield)
    17167                                       
    17268                                elif type(md.results.__dict__[supfield])==results:#only one timestep
     
    17470                                        for field in subfields:
    17571                                                if str(field)!='errlog' and str(field)!='outlog' and str(field)!='SolutionType':
    176 #                                                       print 'Treating '+str(group)+'.'+str(supfield)+'.'+str(field)
     72                                                        print 'Treating '+str(group)+'.'+str(supfield)+'.'+str(field)
    17773                                                        Var=md.results.__dict__[supfield].__dict__[field]
    178                                                         CreateVar(Var,Subgroup,False)
     74                                                        DimDict=CreateVar(NCData,Var,field,NCgroup,DimDict,False)
    17975                                else:
    18076                                        print 'Result format not suported'
     
    18278                       
    18379                        for field in fields:
    184 #                               print 'Treating ' +str(group)+'.'+str(field)
     80                                print 'Treating ' +str(group)+'.'+str(field)
    18581                                NCgroup.__setattr__('classtype', md.__dict__[group].__class__.__name__)
    18682                                Var=md.__dict__[group].__dict__[field]
    187                                 CreateVar(Var,NCgroup,False)
     83                                DimDict=CreateVar(NCData,Var,field,NCgroup,DimDict,False)
    18884        NCData.close()
    18985
     86#============================================================================
     87#Define the variables
     88def CreateVar(NCData,var,field,Group,DimDict,istime,*step_args):
     89        #grab type
     90        try:
     91                val_type=str(var.dtype)
     92        except AttributeError:
     93                val_type=type(var)
     94                #grab dimension
     95        try:
     96                val_shape=dict.keys(var)
     97        except TypeError:
     98                val_shape=numpy.shape(var)
    19099
     100
     101        TypeDict = {float:'f8',
     102                                                        'float64':'f8',
     103                                                        int:'i8',
     104                                                        'int64':'i8'}
     105               
     106        val_dim=numpy.shape(val_shape)[0]
     107        #Now define and fill up variable
     108        #treating scalar string or bool as atribute
     109        if val_type==str or val_type==bool:
     110                Group.__setattr__(str(field), str(var))
     111
     112        #treating list as string table
     113        #matlab does not recognise strings so we have to settle down with char arrays
     114        elif val_type==list:
     115                dimensions,DimDict=GetDim(NCData,var,val_shape,DimDict,val_dim,istime)
     116                ncvar = Group.createVariable(str(field),str,dimensions,zlib=True)
     117                for elt in range(0,val_dim):
     118                        try:
     119                                ncvar[elt] = var[elt]
     120                        except IndexError:
     121                                ncvar[0]= " "
     122                                #treating bool tables as string tables
     123        elif val_type=='bool':
     124                dimensions,DimDict=GetDim(NCData,var,val_shape,DimDict,val_dim,istime)
     125                ncvar = Group.createVariable(str(field),str,dimensions,zlib=True)
     126                for elt in range(0,val_shape[0]):
     127                        ncvar[elt] = str(var[elt])
     128                        #treating dictionaries as string tables of dim 2
     129        elif val_type==collections.OrderedDict:
     130                dimensions,DimDict=GetDim(NCData,var,val_shape,DimDict,val_dim,istime)
     131                ncvar = Group.createVariable(str(field),str,dimensions,zlib=True)
     132                for elt in range(0,val_dim):
     133                        ncvar[elt,0]=dict.keys(var)[elt]
     134                        ncvar[elt,1]=str(dict.values(var)[elt]) #converting to str to avoid potential problems
     135                        #Now dealing with numeric variables
     136        else:
     137                dimensions,DimDict=GetDim(NCData,var,val_shape,DimDict,val_dim,istime)
     138                ncvar = Group.createVariable(str(field),TypeDict[val_type],dimensions,zlib=True)
     139               
     140                if istime:
     141                        last=step_args[0]
     142                        freq=step_args[1]
     143                        md=step_args[2]
     144                        supfield=step_args[3]
     145                        vartab=var
     146                        for time in range(freq-1,last,freq):
     147                                if time!=0:
     148                                        timevar=md.results.__dict__[supfield].__getitem__(time).__dict__[field]
     149                                        print 'Treating results.'+str(supfield)+'.'+str(field)+' for time '+str(time)
     150                                        vartab=numpy.column_stack((vartab,timevar))
     151                        print numpy.shape(vartab)
     152                        try:
     153                                ncvar[:,:]=vartab[:,:]
     154                        except ValueError:
     155                                ncvar[:]=vartab.T[:]
     156                else:
     157                        try:
     158                                nan_val=numpy.isnan(var)
     159                                if nan_val.all():
     160                                        ncvar [:] = 'NaN'
     161                                else:
     162                                        ncvar[:] = var
     163                        except TypeError: #type does not accept nan, get vallue of the variable
     164                                ncvar[:] = var
     165        return DimDict
     166
     167#============================================================================
     168#retriev the dimension tuple from a dictionnary
     169def GetDim(NCData,var,shape,DimDict,i,istime):
     170        output=[]
     171        for dim in range(0,i): #loop on the dimensions
     172                if type(shape[0])==int:
     173                        try:
     174                                output=output+[str(DimDict[shape[dim]])] #test if the dimension allready exist
     175                        except KeyError: #if not create it
     176                                if (shape[dim])>1:
     177                                        index=len(DimDict)+1
     178                                        NewDim=NCData.createDimension('Dimension'+str(index),(shape[dim]))
     179                                        DimDict[len(NewDim)]='Dimension'+str(index)
     180                                        output=output+[str(DimDict[shape[dim]])]
     181                                        print 'Defining dimension ' +'Dimension'+str(index)
     182                elif type(shape[0])==str:#dealling with a dictionnary
     183                        try:
     184                                output=[str(DimDict[numpy.shape(shape)[0]])]+['DictDim']
     185                        except KeyError:
     186                                index=len(DimDict)+1
     187                                NewDim=NCData.createDimension('Dimension'+str(index),numpy.shape(shape)[0])
     188                                DimDict[len(NewDim)]='Dimension'+str(index)
     189                                output=[str(DimDict[numpy.shape(dict.keys(var))[0]])]+['Dimension5']
     190                                print 'Defining dimension ' +'Dimension'+str(index)
     191                        break
     192        if istime:
     193                output=output+['Dimension4']
     194        return tuple(output), DimDict
Note: See TracChangeset for help on using the changeset viewer.