Changeset 19080


Ignore:
Timestamp:
02/03/15 11:06:34 (10 years ago)
Author:
bdef
Message:

NEW: finishing export_netCDF in m

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

Legend:

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

    r19055 r19080  
    1 
    21function export_netCDF(md,filename)     
    32       
     
    1514  end
    1615        %open file and write description
    17         mode = netcdf.getConstant('NETCDF4');
    18         mode = bitor(mode,netcdf.getConstant('NOCLOBBER'));%NOCLOBBER to avoid overwrite
     16        mode = netcdf.getConstant('NC_NETCDF4');
     17        mode = bitor(mode,netcdf.getConstant('NC_NOCLOBBER'));%NOCLOBBER to avoid overwrite
    1918        ncid = netcdf.create(filename,mode);
    2019        netcdf.putAtt(ncid,netcdf.getConstant('NC_GLOBAL'),'Title',['Results for run ' md.miscellaneous.name]);
     
    3332        DimSize(2).index=netcdf.defDim(ncid,'VertNum',md.mesh.numberofvertices);
    3433        DimSize(3).index=netcdf.defDim(ncid,'VertperElt',size(md.mesh.elements,2));
     34        DimSize(4).index=netcdf.defDim(ncid,'Time',StepNum);
     35        DimSize(5).index=netcdf.defDim(ncid,'StringLength',20);
     36        DimSize(6).index=netcdf.defDim(ncid,'StructLength',2);
    3537       
    3638        for i=1:length(DimSize),
     
    4547        groups=fieldnames(md);
    4648        for i=1:length(groups),
    47                 %disp(sprintf('group name in tree %s ',groups{i}));
     49                disp(sprintf('group name in tree %s ',groups{i}));
    4850                groupID=netcdf.defGrp(ncid,groups{i});
    4951                %In each group gather the fields of the class
     
    5254                if strcmp(groups(i),'results'),
    5355                        for j=1:length(groupfields)%looping on the different solutions
    54                                 %disp(sprintf('=====Field name in tree %s ',groupfields{j}));
     56                                                                                                                                 %disp(sprintf('=====Field name in tree %s ',groupfields{j}));
    5557                                if length(md.results.(groupfields{j}))>1,
    5658                                        %the solution have several timestep get last timesteps and output frequency
    5759                                        last_step = length(md.results.(groupfields{j}));
    58                                         step_freq = md.settings.output_frequency;
    5960                                        %grab first time step
    6061                                        subfields=fields(md.results.(groupfields{j})(1));
     
    6263                                                netcdf.putAtt(groupID,netcdf.getConstant('NC_GLOBAL'),'classtype','results');
    6364                                                if ~strcmp(subfields(k),'errlog') && ~strcmp(subfields(k),'outlog') && ~strcmp(subfields(k),'SolutionType'),
    64                                                         disp(sprintf('==========SubField name in tree %s ',subfields{k}));
    65                                                         Var=md.results.(groupfields{1})(1).(subfields{k});
    66                                                         [truc,DimSize,DimValue]=DefCreateVar(ncid,Var,groupID,subfields{k},DimSize,DimValue);
    67                                                         %CreateVar(Var,True,last_step,step_freq)
     65                                                        %disp(sprintf('==========SubField name in tree %s ',subfields{k}));
     66                                                        Var=md.results.(groupfields{j})(1).(subfields{k});
     67                                                        [DimSize,DimValue]=DefCreateVar(ncid,Var,groupID,subfields{k},DimSize,DimValue,true,last_step,md,groupfields{j});
    6868                              end
    6969                      end
     
    7272                                        subfields=fields(md.results.(groupfields{j}));
    7373                                        for k=1:length(subfields),
    74                                                 disp(sprintf('==========SubField name in tree %s ',subfields{k}));
    75                                                 netcdf.putAtt(groupID,netcdf.getConstant('GLOBAL'),'classtype','results');
     74                                                %disp(sprintf('==========SubField name in tree %s ',subfields{k}));
     75                                                netcdf.putAtt(groupID,netcdf.getConstant('NC_GLOBAL'),'classtype','results');
    7676                                                if ~strcmp(subfields(k),'errlog') && ~strcmp(subfields(k),'outlog') && ~strcmp(subfields(k),'SolutionType'),
    7777                                                        Var=md.results.(groupfields{1})(1).(subfields{k});
    78                                                         [truc,DimSize,DimValue]=DefCreateVar(ncid,Var,groupID,subfields{k},DimSize,DimValue);
     78                                                        [DimSize,DimValue]=DefCreateVar(ncid,Var,groupID,subfields{k},DimSize,DimValue,false);
    7979                              end
    8080                      end
     
    8585                else
    8686                        for j=1:length(groupfields),
    87                                 disp(sprintf('=====Field name in tree %s ',groupfields{j}));
    88                                 netcdf.putAtt(groupID,netcdf.getConstant('GLOBAL'),'classtype',class(md.(groups{i})));
     87                                %disp(sprintf('=====Field name in tree %s ',groupfields{j}));
     88                                netcdf.putAtt(groupID,netcdf.getConstant('NC_GLOBAL'),'classtype',class(md.(groups{i})));
    8989                                Var=md.(groups{i}).(groupfields{j});
    90                                 [truc,DimSize,DimValue]=DefCreateVar(ncid,Var,groupID,groupfields{j},DimSize,DimValue);
     90                                [DimSize,DimValue]=DefCreateVar(ncid,Var,groupID,groupfields{j},DimSize,DimValue,false);
    9191            end
    9292          end   
     
    9595end
    9696
    97 function [varclass,DimSize,DimValue]=DefCreateVar(ncid,Var,groupID,field,DimSize,DimValue)
     97function [DimSize,DimValue]=DefCreateVar(ncid,Var,groupID,field,DimSize,DimValue,istime,last,md,midfield)
    9898        varclass=class(Var);
    9999        varsize=size(Var);
     
    105105                        LogicString='False';
    106106        end
    107                 netcdf.putAtt(groupID,netcdf.getConstant('GLOBAL'),field,LogicString);
     107                netcdf.putAtt(groupID,netcdf.getConstant('NC_GLOBAL'),field,LogicString);
    108108        elseif isa(Var,'char'),
    109                 netcdf.putAtt(groupID,netcdf.getConstant('GLOBAL'),field,Var);
     109                netcdf.putAtt(groupID,netcdf.getConstant('NC_GLOBAL'),field,Var);
    110110        elseif isa(Var,'double'), %dealing with arrays
    111                 [dims,DimSize,DimValue]=GetDims(ncid,Var,groupID,field,DimSize,DimValue);
    112                 varid = netcdf.defVar(groupID,field,'double',dims);
    113                 if length(Var)==0,
    114                         netcdf.putVar(groupID,varid,NaN);
    115                 else
    116                         netcdf.putVar(groupID,varid,Var);
    117         end
     111                [dims,DimSize,DimValue]=GetDims(ncid,Var,groupID,field,DimSize,DimValue,istime);
     112                varid = netcdf.defVar(groupID,field,'NC_DOUBLE',dims);
     113                if istime,
     114                        VarTab=Var;
     115                        for i=2:last,
     116                                TimeVar=md.results.(midfield)(i).(field);
     117                                VarTab=[VarTab TimeVar];
     118            end
     119                        netcdf.putVar(groupID,varid,VarTab);
     120                else
     121                        if length(Var)==0,
     122                                netcdf.putVar(groupID,varid,NaN);
     123                        else
     124                                netcdf.putVar(groupID,varid,Var);
     125            end
     126          end
    118127        elseif isa(Var,'cell'),
    119                 disp(sprintf('no support for class %s for field %s so far',varclass,field));
     128                [dims,DimSize,DimValue]=GetDims(ncid,Var,groupID,field,DimSize,DimValue,istime);
     129                %dirty hack to be able to pass strings
     130                varid = netcdf.defVar(groupID,field,'NC_CHAR',dims);
     131                for i=1:length(Var),
     132                        startpoint=zeros(size(Var));
     133                        startpoint(:,i)=i-1;
     134                        if length(Var)>1,
     135                                endpoint=[min(length(Var{i}),20) 1];
     136                        else
     137                                endpoint=min(length(Var{i}),20);
     138            end
     139                        if length(Var{i})>20,
     140                                netcdf.putVar(groupID,varid,startpoint,endpoint,Var{i}(1:20))
     141                        else
     142                                netcdf.putVar(groupID,varid,startpoint,endpoint,Var{i})
     143            end
     144          end
    120145        elseif isa(Var,'struct'),
    121                 disp(sprintf('no support for class %s for field %s so far',varclass,field));
     146                %Start by getting the structure fields and size
     147                locfields=fields(Var);
     148                [dims,DimSize,DimValue]=GetDims(ncid,Var,groupID,locfields,DimSize,DimValue,istime);
     149                varid = netcdf.defVar(groupID,field,'NC_CHAR',dims);
     150                for i=1:length(locfields),
     151                        for j=1:2,
     152                                if j==1,
     153                                        startpoint=[0,0,i-1];
     154                                        CharVar=locfields{i};
     155                                else
     156                                        startpoint=[0,1,i-1];
     157                                        if isa(Var.(locfields{i}),'char'),
     158                                                CharVar=Var.(locfields{i});
     159                                        else
     160                                                CharVar=num2str(Var.(locfields{i}));
     161                      end
     162                    end
     163                                endpoint=[min(length(CharVar),20),1,1];
     164                                if length(CharVar)>20,
     165                                        netcdf.putVar(groupID,varid,startpoint,endpoint,CharVar(1:20))
     166                                else
     167                                        netcdf.putVar(groupID,varid,startpoint,endpoint,CharVar)
     168                    end
     169            end
     170          end
    122171        else
    123172                disp(sprintf('no support for class %s of field %s',varclass,field));
     
    126175end
    127176
    128 function [dims,DimSize,DimValue]=GetDims(ncid,Var,groupID,field,DimSize,DimValue)
     177function [dims,DimSize,DimValue]=GetDims(ncid,Var,groupID,field,DimSize,DimValue,istime)
    129178        dims=[];
    130         varlength=length(Var);
    131         varsize=size(Var);
    132         MatOrVec=varsize>1; %checking if we have a matrix (1 1) are vector (1 0)
    133         for i=1:sum(MatOrVec), %loop on the number of (non 1) dimensions
    134                 currentdim=varsize(i);
    135                 dimexist=DimValue==currentdim;
    136                 if sum(dimexist)==0, %dimension is new to us, need to create it
    137                         dimname=strcat(field,int2str(i));
    138                         dimindex=length(DimSize)+1;
    139                         DimSize(dimindex).index=netcdf.defDim(ncid,dimname,currentdim);
    140                         [DimSize(dimindex).name,DimSize(dimindex).value]=netcdf.inqDim(ncid,DimSize(dimindex).index);
     179        %specific treatment for structures
     180        if isa(Var,'struct')
     181                varsize=size(field); %we pass here the fields of the current structure
     182                MatOrVec=varsize>1; %checking if we have a matrix (1 1) or vector (1 0)
     183                for i=1:sum(MatOrVec), %loop on the number of (non 1) dimensions
     184                        currentdim=varsize(i);
     185                        dimexist=DimValue==currentdim;
     186                        if sum(dimexist)==0, %dimension is new to us, need to create it
     187                                dimname=strcat(field{1},int2str(i));
     188                                dimindex=length(DimSize)+1;
     189                                DimSize(dimindex).index=netcdf.defDim(ncid,dimname,currentdim);
     190                                [DimSize(dimindex).name,DimSize(dimindex).value]=netcdf.inqDim(ncid,DimSize(dimindex).index);
     191                                dims(i)=DimSize(dimindex).index;
     192                                DimValue(dimindex)=currentdim;
     193                        else
     194                                dimindex=find(dimexist);
     195                                if DimSize(dimindex).value~=currentdim,
     196                                        error('Indexation problem with the dimension structure')
     197                    end
     198            end
    141199                        dims(i)=DimSize(dimindex).index;
    142                         DimValue(dimindex)=currentdim;
    143                 else
    144                         dimindex=find(dimexist);
    145                         if DimSize(dimindex).value~=currentdim,
    146                                 error('Indexation problem with the dimension structure')
    147           end
    148           end
    149                 dims(i)=DimSize(dimindex).index;
     200          end
     201                dims=[DimSize(6).index dims];
     202        else
     203                %with a cell array need to grab the transposed size to work
     204                if isa(Var,'cell'),
     205                        varsize=size(Var');
     206                else
     207                        varsize=size(Var);
     208    end
     209                MatOrVec=varsize>1; %checking if we have a matrix (1 1) or vector (1 0)
     210                for i=1:sum(MatOrVec), %loop on the number of (non 1) dimensions
     211                        currentdim=varsize(i);
     212                        dimexist=DimValue==currentdim;
     213                        if sum(dimexist)==0, %dimension is new to us, need to create it
     214                                dimname=strcat(field,int2str(i));
     215                                dimindex=length(DimSize)+1;
     216                                DimSize(dimindex).index=netcdf.defDim(ncid,dimname,currentdim);
     217                                [DimSize(dimindex).name,DimSize(dimindex).value]=netcdf.inqDim(ncid,DimSize(dimindex).index);
     218                                dims(i)=DimSize(dimindex).index;
     219                                DimValue(dimindex)=currentdim;
     220                        else
     221                                dimindex=find(dimexist);
     222                                if DimSize(dimindex).value~=currentdim,
     223                                        error('Indexation problem with the dimension structure')
     224                    end
     225            end
     226                        dims(i)=DimSize(dimindex).index;
     227    end
     228  end
     229        if istime,
     230                dims=[dims DimSize(4).index];%adding the time dimension if necessary
     231  end
     232        %if we have a cell variable we need to add a stringlength dimension
     233        if isa(Var,'cell') || isa(Var,'struct'),
     234                dims=[DimSize(5).index dims];
    150235  end
    151236end
  • issm/trunk-jpl/src/m/contrib/netCDF/export_netCDF.py

    r19055 r19080  
    8888                                        if time!=0:
    8989                                                timevar=md.results.__dict__[supfield].__getitem__(time).__dict__[field]
    90 #                                               print 'Treating '+str(group)+'.'+str(supfield)+'.'+str(field)+' for time '+str(time)
     90                                                print 'Treating '+str(group)+'.'+str(supfield)+'.'+str(field)+' for time '+str(time)
    9191                                                vartab=numpy.column_stack((vartab,timevar))
     92                                print numpy.shape(vartab)
    9293                                try:
    9394                                        ncvar[:,:]=vartab[:,:]
     
    129130        VertNum=NCData.createDimension('VertNum',md.mesh.numberofvertices)
    130131        VertperElt=NCData.createDimension('VertperElt',numpy.shape(md.mesh.elements)[1])
     132        Time=NCData.createDimension('Time',StepNum)
     133        DictDim=NCData.createDimension('DictDim',2)
    131134
    132135        DimDict = {len(EltNum):'EltNum',
    133136                                                 len(VertNum):'VertNum',
    134                                                  len(VertperElt):'VertperElt'}
     137                                                 len(VertperElt):'VertperElt',
     138                                                 len(Time):'Time',
     139                                                 len(DictDim):'DictDim'}
    135140
    136141        TypeDict = {float:'f8',
Note: See TracChangeset for help on using the changeset viewer.