Ignore:
Timestamp:
09/19/13 17:05:07 (11 years ago)
Author:
ymipsl
Message:

Add unstructured grid management.

YM

File:
1 edited

Legend:

Unmodified
Added
Removed

  • XIOS/trunk/src/output/nc4_data_output.cpp

    r448 r449  
    5757      void CNc4DataOutput::writeDomain_(CDomain* domain) 
    5858      { 
     59         if (domain->type == CDomain::type_attr::unstructured) 
     60         { 
     61           writeUnstructuredDomain(domain) ; 
     62           return ; 
     63         } 
     64          
    5965         CContext* context = CContext::getCurrent() ; 
    6066         CContextServer* server=context->server ; 
    … …  
    7076                             ? domain->name.getValue() : domain->getId(); 
    7177         StdString appendDomid  = (singleDomain) ? "" : "_"+domid ; 
    72           
    73          bool isCurvilinear = domain->isCurvilinear ; 
     78 
     79 
    7480         StdString dimXid, dimYid ; 
    75          if (isCurvilinear) 
    76          { 
    77            dimXid     = StdString("x").append(appendDomid); 
    78            dimYid     = StdString("y").append(appendDomid); 
    79          } 
    80          else 
    81          { 
    82            dimXid     = StdString("lon").append(appendDomid); 
    83            dimYid     = StdString("lat").append(appendDomid); 
     81          
     82         switch (domain->type) 
     83         { 
     84           case CDomain::type_attr::curvilinear : 
     85             dimXid     = StdString("x").append(appendDomid); 
     86             dimYid     = StdString("y").append(appendDomid); 
     87             break ; 
     88           case CDomain::type_attr::regular : 
     89             dimXid     = StdString("lon").append(appendDomid); 
     90             dimYid     = StdString("lat").append(appendDomid); 
     91             break; 
     92           case CDomain::type_attr::unstructured : 
     93             dimXid     = StdString("cell").append(appendDomid); 
     94             break; 
    8495         }             
    8596          
    86          string lonid,latid ; 
     97         string lonid,latid,bounds_lonid,bounds_latid ; 
    8798/* 
    8899         StdString lonid_loc = (server->intraCommSize > 1) 
    … …  
    106117               } 
    107118 
    108                if (isCurvilinear) 
    109                { 
    110                  dim0.push_back(dimYid); dim0.push_back(dimXid); 
    111                  lonid = StdString("nav_lon").append(appendDomid); 
    112                  latid = StdString("nav_lat").append(appendDomid); 
     119               switch (domain->type) 
     120               { 
     121                 case CDomain::type_attr::curvilinear : 
     122                   dim0.push_back(dimYid); dim0.push_back(dimXid); 
     123                   lonid = StdString("nav_lon").append(appendDomid); 
     124                   latid = StdString("nav_lat").append(appendDomid); 
     125                   break ; 
     126                 case CDomain::type_attr::regular : 
     127                   lonid = StdString("lon").append(appendDomid); 
     128                   latid = StdString("lat").append(appendDomid); 
     129                   dim0.push_back(dimYid); 
     130                   dim1.push_back(dimXid); 
     131                   break; 
     132                 case CDomain::type_attr::unstructured : 
     133                   lonid = StdString("lon").append(appendDomid); 
     134                   latid = StdString("lat").append(appendDomid); 
     135                   bounds_lonid=string("bounds_lon").append(appendDomid); 
     136                   bounds_latid=string("bounds_lat").append(appendDomid); 
     137                   dim0.push_back(dimXid); 
     138                   break; 
     139               } 
     140                 
     141               if (domain->type == CDomain::type_attr::unstructured) 
     142               { 
     143                 SuperClassWriter::addDimension(dimXid, domain->nj_glo); 
    113144               } 
    114145               else 
    115146               { 
    116                  lonid = StdString("lon").append(appendDomid); 
    117                  latid = StdString("lat").append(appendDomid); 
    118                  dim0.push_back(dimYid); 
    119                  dim1.push_back(dimXid); 
    120                } 
    121  
    122                SuperClassWriter::addDimension(dimXid, domain->zoom_ni_srv); 
    123                SuperClassWriter::addDimension(dimYid, domain->zoom_nj_srv); 
     147                 SuperClassWriter::addDimension(dimXid, domain->zoom_ni_srv); 
     148                 SuperClassWriter::addDimension(dimYid, domain->zoom_nj_srv); 
     149               } 
     150                
    124151               if (server->intraCommSize > 1) 
    125152               { 
    126                   this->writeLocalAttributes(domain->zoom_ibegin_srv, 
    127                                              domain->zoom_ni_srv, 
    128                                              domain->zoom_jbegin_srv, 
    129                                              domain->zoom_nj_srv, 
    130                                              appendDomid); 
     153                  if (domain->type != CDomain::type_attr::unstructured) 
     154                  { 
     155                    this->writeLocalAttributes(domain->zoom_ibegin_srv, 
     156                                               domain->zoom_ni_srv, 
     157                                               domain->zoom_jbegin_srv, 
     158                                               domain->zoom_nj_srv, 
     159                                               appendDomid); 
    131160                   
    132                   if (singleDomain) this->writeLocalAttributes_IOIPSL(domain->zoom_ibegin_srv, 
    133                                              domain->zoom_ni_srv, 
    134                                              domain->zoom_jbegin_srv, 
    135                                              domain->zoom_nj_srv, 
    136                                              domain->ni_glo,domain->nj_glo, 
    137                                              server->intraCommRank,server->intraCommSize); 
    138                } 
    139                 
    140                if (isCurvilinear) 
    141                { 
    142                   SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
    143                   SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0); 
    144                } 
    145                else 
    146                { 
    147                   SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
    148                   SuperClassWriter::addVariable(lonid, NC_FLOAT, dim1); 
    149                } 
    150                this->writeAxisAttributes 
    151                   (lonid, "X", "longitude", "Longitude", "degrees_east", domid); 
    152                this->writeAxisAttributes 
    153                   (latid, "Y", "latitude", "Latitude", "degrees_north", domid); 
     161                    if (singleDomain) this->writeLocalAttributes_IOIPSL(domain->zoom_ibegin_srv, 
     162                                               domain->zoom_ni_srv, 
     163                                               domain->zoom_jbegin_srv, 
     164                                               domain->zoom_nj_srv, 
     165                                               domain->ni_glo,domain->nj_glo, 
     166                                               server->intraCommRank,server->intraCommSize); 
     167                 } 
     168               } 
     169                
     170               switch (domain->type) 
     171               { 
     172                 case CDomain::type_attr::curvilinear : 
     173                   SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
     174                   SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0); 
     175                   break ; 
     176                  case CDomain::type_attr::regular : 
     177                    SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
     178                    SuperClassWriter::addVariable(lonid, NC_FLOAT, dim1); 
     179                    break ; 
     180                  case CDomain::type_attr::unstructured : 
     181                    SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
     182                    SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0); 
     183               } 
     184                
     185               this->writeAxisAttributes(lonid, "X", "longitude", "Longitude", "degrees_east", domid); 
     186               this->writeAxisAttributes(latid, "Y", "latitude", "Latitude", "degrees_north", domid); 
    154187 
    155188               dim0.clear(); 
    156                dim0.push_back(dimYid); 
     189               if (domain->type != CDomain::type_attr::unstructured) dim0.push_back(dimYid); 
    157190               dim0.push_back(dimXid); 
    158191 
    … …  
    173206 
    174207               SuperClassWriter::definition_end(); 
    175                if (isCurvilinear) 
    176                { 
    177   
    178                  SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0); 
    179                  SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0); 
    180 // supress mask               if (server->intraCommSize > 1) SuperClassWriter::writeData(mask, maskid); 
    181                } 
    182                else 
    183                { 
    184                   CArray<double,1> lat = domain->latvalue_srv(Range(fromStart,toEnd,domain->zoom_ni_srv)) ; 
    185                   SuperClassWriter::writeData(CArray<double,1>(lat.copy()), latid, isCollective, 0); 
    186                   CArray<double,1> lon=domain->lonvalue_srv(Range(0,domain->zoom_ni_srv-1)) ; 
    187                   SuperClassWriter::writeData(CArray<double,1>(lon.copy()), lonid, isCollective, 0); 
     208 
     209               switch (domain->type) 
     210               { 
     211                 case CDomain::type_attr::curvilinear : 
     212                   SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0); 
     213                   SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0); 
     214                   break;  
     215                 case CDomain::type_attr::regular : 
     216                   CArray<double,1> lat = domain->latvalue_srv(Range(fromStart,toEnd,domain->zoom_ni_srv)) ; 
     217                   SuperClassWriter::writeData(CArray<double,1>(lat.copy()), latid, isCollective, 0); 
     218                   CArray<double,1> lon=domain->lonvalue_srv(Range(0,domain->zoom_ni_srv-1)) ; 
     219                   SuperClassWriter::writeData(CArray<double,1>(lon.copy()), lonid, isCollective, 0); 
     220                   break; 
    188221               } 
    189222               SuperClassWriter::definition_start(); 
    … …  
    197230 
    198231                
    199                if (isCurvilinear) 
    200                { 
    201                   dim0.push_back(dimYid); dim0.push_back(dimXid); 
    202                   lonid = StdString("nav_lon").append(appendDomid); 
    203                   latid = StdString("nav_lat").append(appendDomid); 
    204                   SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
    205                   SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0); 
    206                } 
    207                else 
    208                { 
    209                   dim0.push_back(dimYid); 
    210                   dim1.push_back(dimXid); 
    211                   lonid = StdString("lon").append(appendDomid); 
    212                   latid = StdString("lat").append(appendDomid); 
    213                   SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
    214                   SuperClassWriter::addVariable(lonid, NC_FLOAT, dim1); 
     232               switch (domain->type) 
     233               { 
     234                 case CDomain::type_attr::curvilinear : 
     235                   dim0.push_back(dimYid); dim0.push_back(dimXid); 
     236                   lonid = StdString("nav_lon").append(appendDomid); 
     237                   latid = StdString("nav_lat").append(appendDomid); 
     238                   SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
     239                   SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0); 
     240                   break; 
     241 
     242                 case CDomain::type_attr::regular : 
     243                   dim0.push_back(dimYid); 
     244                   dim1.push_back(dimXid); 
     245                   lonid = StdString("lon").append(appendDomid); 
     246                   latid = StdString("lat").append(appendDomid); 
     247                   SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
     248                   SuperClassWriter::addVariable(lonid, NC_FLOAT, dim1); 
     249                   break; 
    215250               } 
    216251               this->writeAxisAttributes 
    … …  
    221256 
    222257               SuperClassWriter::definition_end(); 
    223                if (isCurvilinear) 
    224                { 
    225                  std::vector<StdSize> start(2) ;  
    226                  std::vector<StdSize> count(2) ; 
    227                  if (domain->isEmpty()) 
     258               switch (domain->type) 
     259               { 
     260                 case CDomain::type_attr::curvilinear : 
    228261                 { 
    229                    start[0]=0 ; start [1]=0 ;  
    230                    count[0]=0 ; count[1]=0 ;  
     262                   std::vector<StdSize> start(2) ;  
     263                   std::vector<StdSize> count(2) ; 
     264                   if (domain->isEmpty()) 
     265                   { 
     266                     start[0]=0 ; start [1]=0 ;  
     267                     count[0]=0 ; count[1]=0 ;  
     268                   } 
     269                   else 
     270                   { 
     271                     start[1]=domain->zoom_ibegin_srv-domain->zoom_ibegin.getValue() ; start [0]=domain->zoom_jbegin_srv-domain->zoom_jbegin.getValue() ;  
     272                     count[1]=domain->zoom_ni_srv ; count[0]=domain->zoom_nj_srv ;  
     273                   } 
     274                  
     275                   SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0,&start,&count); 
     276                   SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0,&start,&count); 
     277                   break; 
    231278                 } 
    232                  else 
     279                 case CDomain::type_attr::regular : 
    233280                 { 
    234                    start[1]=domain->zoom_ibegin_srv-domain->zoom_ibegin.getValue() ; start [0]=domain->zoom_jbegin_srv-domain->zoom_jbegin.getValue() ;  
    235                    count[1]=domain->zoom_ni_srv ; count[0]=domain->zoom_nj_srv ;  
    236                  } 
    237                   
    238                  SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0,&start,&count); 
    239                  SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0,&start,&count); 
    240                } 
    241                else 
    242                { 
    243                  std::vector<StdSize> start(1) ;  
    244                  std::vector<StdSize> count(1) ; 
    245                  if (domain->isEmpty()) 
    246                  { 
    247                    start[0]=0 ;   
    248                    count[0]=0 ;   
    249                    SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0,&start,&count); 
    250                    SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0,&start,&count);                 } 
    251                  else 
    252                  { 
    253                    start[0]=domain->zoom_jbegin_srv-domain->zoom_jbegin.getValue() ;  
    254                    count[0]=domain->zoom_nj_srv ;  
    255                    CArray<double,1> lat = domain->latvalue_srv(Range(fromStart,toEnd,domain->zoom_ni_srv)) ; 
    256                    SuperClassWriter::writeData(CArray<double,1>(lat.copy()), latid, isCollective, 0,&start,&count); 
    257  
    258                    start[0]=domain->zoom_ibegin_srv-domain->zoom_ibegin.getValue() ;  
    259                    count[0]=domain->zoom_ni_srv ;  
    260                    CArray<double,1> lon=domain->lonvalue_srv(Range(0,domain->zoom_ni_srv-1)) ; 
    261                    SuperClassWriter::writeData(CArray<double,1>(lon.copy()), lonid, isCollective, 0,&start,&count); 
     281                   std::vector<StdSize> start(1) ;  
     282                   std::vector<StdSize> count(1) ; 
     283                   if (domain->isEmpty()) 
     284                   { 
     285                     start[0]=0 ;   
     286                     count[0]=0 ;   
     287                     SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0,&start,&count); 
     288                     SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0,&start,&count);                 } 
     289                   else 
     290                   { 
     291                     start[0]=domain->zoom_jbegin_srv-domain->zoom_jbegin.getValue() ;  
     292                     count[0]=domain->zoom_nj_srv ;  
     293                     CArray<double,1> lat = domain->latvalue_srv(Range(fromStart,toEnd,domain->zoom_ni_srv)) ; 
     294                     SuperClassWriter::writeData(CArray<double,1>(lat.copy()), latid, isCollective, 0,&start,&count); 
     295 
     296                     start[0]=domain->zoom_ibegin_srv-domain->zoom_ibegin.getValue() ;  
     297                     count[0]=domain->zoom_ni_srv ;  
     298                     CArray<double,1> lon=domain->lonvalue_srv(Range(0,domain->zoom_ni_srv-1)) ; 
     299                     SuperClassWriter::writeData(CArray<double,1>(lon.copy()), lonid, isCollective, 0,&start,&count); 
     300                   } 
     301                   break; 
    262302                 } 
    263303               } 
    … …  
    273313      } 
    274314 
     315      void CNc4DataOutput::writeUnstructuredDomain(CDomain* domain) 
     316      { 
     317         CContext* context = CContext::getCurrent() ; 
     318         CContextServer* server=context->server ; 
     319          
     320         if (domain->IsWritten(this->filename)) return; 
     321         domain->checkAttributes(); 
     322          
     323         if (domain->isEmpty())  
     324           if (SuperClass::type==MULTI_FILE) return ; 
     325 
     326         std::vector<StdString> dim0, dim1; 
     327         StdString domid     = (!domain->name.isEmpty()) 
     328                             ? domain->name.getValue() : domain->getId(); 
     329         StdString appendDomid  = (singleDomain) ? "" : "_"+domid ; 
     330 
     331 
     332         StdString dimXid = StdString("cell").append(appendDomid); 
     333         StdString dimVertId = StdString("nvertex").append(appendDomid); 
     334         
     335         string lonid,latid,bounds_lonid,bounds_latid ; 
     336 
     337         switch (SuperClass::type) 
     338         { 
     339            case (MULTI_FILE) : 
     340            { 
     341               lonid = StdString("lon").append(appendDomid); 
     342               latid = StdString("lat").append(appendDomid); 
     343               dim0.push_back(dimXid); 
     344 
     345               SuperClassWriter::addDimension(dimXid, domain->zoom_nj_srv); 
     346               SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
     347               SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0); 
     348                
     349               bounds_lonid = StdString("bounds_lon").append(appendDomid); 
     350               bounds_latid = StdString("bounds_lat").append(appendDomid); 
     351               
     352                
     353               this->writeAxisAttributes(lonid, "X", "longitude", "Longitude", "degrees_east", domid); 
     354               if (domain->hasBounds) SuperClassWriter::addAttribute("bounds",bounds_lonid, &lonid); 
     355               this->writeAxisAttributes(latid, "Y", "latitude", "Latitude", "degrees_north", domid); 
     356               if (domain->hasBounds) SuperClassWriter::addAttribute("bounds",bounds_latid, &latid); 
     357               if (domain->hasBounds) SuperClassWriter::addDimension(dimVertId, domain->nvertex); 
     358               dim0.clear(); 
     359               if (domain->hasBounds) 
     360               {  
     361                 dim0.push_back(dimXid); 
     362                 dim0.push_back(dimVertId); 
     363                 SuperClassWriter::addVariable(bounds_lonid, NC_FLOAT, dim0); 
     364                 SuperClassWriter::addVariable(bounds_latid, NC_FLOAT, dim0); 
     365               } 
     366                
     367               dim0.clear(); 
     368               dim0.push_back(dimXid); 
     369 
     370               SuperClassWriter::definition_end(); 
     371 
     372               SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0); 
     373               SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0); 
     374                
     375               if (domain->hasBounds) 
     376               {  
     377                 SuperClassWriter::writeData(domain->bounds_lon_srv, bounds_lonid, isCollective, 0); 
     378                 SuperClassWriter::writeData(domain->bounds_lat_srv, bounds_latid, isCollective, 0); 
     379               } 
     380               SuperClassWriter::definition_start(); 
     381               break ; 
     382            } 
     383 
     384            case (ONE_FILE) : 
     385            { 
     386               lonid = StdString("lon").append(appendDomid); 
     387               latid = StdString("lat").append(appendDomid); 
     388               bounds_lonid = StdString("bounds_lon").append(appendDomid); 
     389               bounds_latid = StdString("bounds_lat").append(appendDomid); 
     390               dim0.push_back(dimXid); 
     391               SuperClassWriter::addDimension(dimXid, domain->nj_glo); 
     392               SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
     393               SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0); 
     394               this->writeAxisAttributes(lonid, "X", "longitude", "Longitude", "degrees_east", domid); 
     395               if (domain->hasBounds) SuperClassWriter::addAttribute("bounds",bounds_lonid, &lonid); 
     396               this->writeAxisAttributes(latid, "Y", "latitude", "Latitude", "degrees_north", domid);                                            
     397               if (domain->hasBounds) SuperClassWriter::addAttribute("bounds",bounds_latid, &latid); 
     398               if (domain->hasBounds) SuperClassWriter::addDimension(dimVertId, domain->nvertex); 
     399               dim0.clear(); 
     400                
     401               if (domain->hasBounds)  
     402               { 
     403                 dim0.push_back(dimXid); 
     404                 dim0.push_back(dimVertId); 
     405                 SuperClassWriter::addVariable(bounds_lonid, NC_FLOAT, dim0); 
     406                 SuperClassWriter::addVariable(bounds_latid, NC_FLOAT, dim0); 
     407               } 
     408                
     409               SuperClassWriter::definition_end(); 
     410                
     411               std::vector<StdSize> start(1), startBounds(2) ;  
     412               std::vector<StdSize> count(1), countBounds(2) ; 
     413               if (domain->isEmpty()) 
     414               { 
     415                 start[0]=0 ;   
     416                 count[0]=0 ;   
     417                 startBounds[0]=0 ;   
     418                 countBounds[0]=domain->nvertex ; 
     419                 startBounds[1]=0 ;   
     420                 countBounds[1]=0 ;   
     421               } 
     422               else 
     423               { 
     424                 start[0]=domain->zoom_jbegin_srv-domain->zoom_jbegin ;  
     425                 count[0]=domain->zoom_nj_srv ;  
     426                 startBounds[0]=0 ;   
     427                 countBounds[0]=domain->nvertex ; 
     428                 startBounds[1]=domain->zoom_jbegin_srv-domain->zoom_jbegin ;  
     429                 countBounds[1]=domain->zoom_nj_srv ;    
     430               } 
     431               SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0,&start,&count); 
     432               SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0,&start,&count); 
     433               if (domain->hasBounds)  
     434               { 
     435                 SuperClassWriter::writeData(domain->bounds_lon_srv, bounds_lonid, isCollective, 0,&start,&count); 
     436                 SuperClassWriter::writeData(domain->bounds_lat_srv, bounds_latid, isCollective, 0,&startBounds,&countBounds); 
     437               } 
     438  
     439                
     440               SuperClassWriter::definition_start(); 
     441 
     442               break; 
     443            }            
     444            default : 
     445               ERROR("CNc4DataOutput::writeDomain(domain)", 
     446                     << "[ type = " << SuperClass::type << "]" 
     447                     << " not implemented yet !"); 
     448         } 
     449         domain->addRelFile(this->filename); 
     450      } 
    275451      //-------------------------------------------------------------- 
    276452 
    … …  
    334510     void CNc4DataOutput::writeTimeDimension_(void) 
    335511     { 
    336        SuperClassWriter::addDimension(string("time_counter")); 
     512       SuperClassWriter::addDimension("time_counter"); 
    337513     } 
    338514      //-------------------------------------------------------------- 
    … …  
    355531         StdString appendDomid  = (singleDomain) ? "" : "_"+domid ; 
    356532  
    357          bool isCurvilinear = domain->isCurvilinear ;  
     533//         bool isCurvilinear = domain->isCurvilinear ;  
     534//         bool isCurvilinear = (domain->type == CDomain::type_attr::curvilinear) ; 
    358535          
    359536         StdString dimXid,dimYid ; 
    360537         
    361          if (isCurvilinear) 
    362          { 
    363            dimXid     = StdString("x").append(appendDomid); 
    364            dimYid     = StdString("y").append(appendDomid); 
    365          } 
    366          else 
    367          { 
    368            dimXid     = StdString("lon").append(appendDomid); 
    369            dimYid     = StdString("lat").append(appendDomid); 
    370          } 
     538         switch (domain->type) 
     539         { 
     540           case CDomain::type_attr::curvilinear : 
     541             dimXid     = StdString("x").append(appendDomid); 
     542             dimYid     = StdString("y").append(appendDomid); 
     543             break ; 
     544           case CDomain::type_attr::regular : 
     545             dimXid     = StdString("lon").append(appendDomid); 
     546             dimYid     = StdString("lat").append(appendDomid); 
     547             break ; 
     548           case CDomain::type_attr::unstructured : 
     549             dimXid     = StdString("cell").append(appendDomid); 
     550             break ; 
     551        } 
    371552          
    372553/*  
    … …  
    388569                        ( field->prec.getValue() == 4)) 
    389570                        ? NC_FLOAT : NC_DOUBLE; 
    390          bool wtime   = !(!field->operation.isEmpty() && 
    391                          ( field->operation.getValue().compare("once") == 0)); 
     571         bool wtime   = !(!field->operation.isEmpty() && field->foperation->timeType() == func::CFunctor::once); 
    392572                          
    393573         if (wtime) 
    394574         { 
    395             StdOStringStream oss; 
    396             oss << "time_" << field->operation.getValue() 
    397                 << "_" << field->getRelFile()->output_freq.getValue(); 
    398  
    399             coodinates.push_back(oss.str()); 
     575             
     576            //StdOStringStream oss; 
     577           // oss << "time_" << field->operation.getValue() 
     578           //     << "_" << field->getRelFile()->output_freq.getValue(); 
     579          //oss  
     580            if (field->foperation->timeType() == func::CFunctor::instant) coodinates.push_back(string("time_instant")); 
     581            else if (field->foperation->timeType() == func::CFunctor::centered) coodinates.push_back(string("time_centered")); 
    400582            dims.push_back(timeid); 
    401583         } 
    … …  
    409591         } 
    410592 
    411          if (isCurvilinear) 
    412          { 
    413             coodinates.push_back(StdString("nav_lat").append(appendDomid)); 
    414             coodinates.push_back(StdString("nav_lon").append(appendDomid)); 
    415          } 
    416          else 
    417          { 
     593         switch (domain->type) 
     594         { 
     595           case CDomain::type_attr::curvilinear : 
     596             coodinates.push_back(StdString("nav_lon").append(appendDomid)); 
     597             coodinates.push_back(StdString("nav_lat").append(appendDomid)); 
     598             break; 
     599           case CDomain::type_attr::regular :              
     600           case CDomain::type_attr::unstructured :    
     601            coodinates.push_back(StdString("lon").append(appendDomid)); 
    418602            coodinates.push_back(StdString("lat").append(appendDomid)); 
    419             coodinates.push_back(StdString("lon").append(appendDomid)); 
    420          } 
    421  
    422          switch (SuperClass::type) 
    423          { 
    424             case (MULTI_FILE) : 
    425             { 
    426                dims.push_back(dimYid); 
    427                dims.push_back(dimXid); 
    428                break ; 
    429             } 
    430             case (ONE_FILE) : 
    431             { 
    432                dims.push_back(dimYid); 
    433                dims.push_back(dimXid); 
    434                break; 
    435             } 
    436             default : 
    437                ERROR("CNc4DataOutput::writeDomain(domain)", 
    438                      << "[ type = " << SuperClass::type << "]" 
    439                      << " not implemented yet !"); 
    440          } 
     603             break; 
     604         } 
     605 
     606         if ( domain->type == CDomain::type_attr::curvilinear || type == CDomain::type_attr::regular)dims.push_back(dimYid); 
     607         dims.push_back(dimXid); 
    441608           
    442609         SuperClassWriter::addVariable(fieldid, type, dims); 
    … …  
    567734                              
    568735         StdOStringStream oss; 
    569          oss << "time_" << field->operation.getValue() 
    570              << "_" << field->getRelFile()->output_freq.getValue(); 
     736         string timeAxisId ; 
     737         if (field->foperation->timeType() == func::CFunctor::instant)  timeAxisId="time_instant" ; 
     738         else if (field->foperation->timeType() == func::CFunctor::centered)  timeAxisId="time_centered" ; 
     739 
    571740              
    572741         CArray<double,1> time_data(1) ; 
    573          
    574         bool wtime   = !(!field->operation.isEmpty() && 
    575                          ( field->operation.getValue().compare("once") == 0)); 
     742         CArray<double,1> time_counter(1) ; 
     743                 
     744        bool wtime   = !(!field->operation.isEmpty() && (field->foperation->timeType() == func::CFunctor::once)); 
    576745                                  
    577746        if (wtime) 
    578747        { 
    579           if (field->operation.getValue()=="instant") time_data(0) = Time(*field->last_Write_srv) 
    580                                                                       -Time(context->calendar->getTimeOrigin()); 
    581           else time_data(0) = (Time(*field->last_Write_srv)+Time(*field->lastlast_Write_srv))/2 
    582                                 -Time(context->calendar->getTimeOrigin()); 
     748          time_counter(0)= (Time(*field->last_Write_srv)+Time(*field->lastlast_Write_srv))/2 -Time(context->calendar->getTimeOrigin()); 
     749          if (field->foperation->timeType() == func::CFunctor::instant)  
     750            time_data(0) = Time(*field->last_Write_srv)-Time(context->calendar->getTimeOrigin()); 
     751          else if (field->foperation->timeType() == func::CFunctor::centered) time_data(0) = time_counter(0); 
     752           
    583753         } 
    584754          
    … …  
    599769              { 
    600770                 SuperClassWriter::writeData(field_data3D, fieldid, isCollective, field->getNStep()-1); 
    601                  if (wtime) SuperClassWriter::writeData(time_data, oss.str(), isCollective, field->getNStep()-1); 
     771                 if (wtime)  
     772                 { 
     773                   SuperClassWriter::writeData(time_data, timeAxisId, isCollective, field->getNStep()-1); 
     774                   SuperClassWriter::writeData(time_counter, string("time_counter"), isCollective, field->getNStep()-1); 
     775                 } 
    602776                 break ; 
    603777              } 
    … …  
    618792                 } 
    619793                 SuperClassWriter::writeData(field_data3D, fieldid, isCollective, field->getNStep()-1,&start,&count ); 
    620                  if (wtime) SuperClassWriter::writeTimeAxisData(time_data, oss.str(), isCollective, field->getNStep()-1,isRoot ); 
     794                 if (wtime)  
     795                 { 
     796                   SuperClassWriter::writeTimeAxisData(time_data, timeAxisId, isCollective, field->getNStep()-1,isRoot ); 
     797                   SuperClassWriter::writeTimeAxisData(time_counter, string("time_counter"), isCollective, field->getNStep()-1,isRoot ); 
     798                 } 
    621799                 break; 
    622800              } 
    … …  
    634812              { 
    635813                SuperClassWriter::writeData(field_data2D, fieldid, isCollective, field->getNStep()-1); 
    636                 if (wtime) SuperClassWriter::writeData(time_data, oss.str(), isCollective, field->getNStep()-1); 
     814                if (wtime)  
     815                { 
     816                  SuperClassWriter::writeData(time_data, timeAxisId, isCollective, field->getNStep()-1); 
     817                  SuperClassWriter::writeData(time_counter, string("time_counter"), isCollective, field->getNStep()-1); 
     818                } 
    637819                break; 
    638820              } 
    … …  
    653835 
    654836                 SuperClassWriter::writeData(field_data2D, fieldid, isCollective, field->getNStep()-1,&start,&count); 
    655                  if (wtime) SuperClassWriter::writeTimeAxisData(time_data, oss.str(), isCollective, field->getNStep()-1,isRoot); 
     837                 if (wtime)  
     838                 { 
     839                   SuperClassWriter::writeTimeAxisData(time_data, timeAxisId, isCollective, field->getNStep()-1,isRoot); 
     840                   SuperClassWriter::writeTimeAxisData(time_counter, string("time_counter"), isCollective, field->getNStep()-1,isRoot); 
     841                 }                    
    656842                 break;  
    657843               
    … …  
    669855         StdOStringStream oss; 
    670856          
    671          if (field->operation.getValue().compare("once") == 0) return ; 
    672                           
    673          oss << "time_" << field->operation.getValue() 
    674              << "_" << field->getRelFile()->output_freq.getValue(); 
    675  
     857//         if (field->operation.getValue().compare("once") == 0) return ; 
     858         if (field->foperation->timeType() == func::CFunctor::once) return ; 
     859                                 
     860//         oss << "time_" << field->operation.getValue() 
     861//             << "_" << field->getRelFile()->output_freq.getValue(); 
     862          
     863         string  axisid ;    
     864         if (field->foperation->timeType() == func::CFunctor::centered) axisid="time_centered" ; 
     865         else if (field->foperation->timeType() == func::CFunctor::instant) axisid="time_instant" ; 
     866          
    676867         std::vector<StdString> dims; 
    677          StdString axisid = oss.str(); 
     868//         StdString axisid = oss.str(); 
    678869         StdString timeid = StdString("time_counter"); 
    679870 
    … …  
    682873         { 
    683874            SuperClassWriter::addVariable(axisid, NC_DOUBLE, dims); 
     875             
    684876            CDate timeOrigin=cal->getTimeOrigin() ; 
    685877//            StdOStringStream oss2; 
    … …  
    693885                strTimeOrigin); 
    694886         } 
     887 
     888         dims.clear() ; 
     889         axisid = "time_counter" ; 
     890         timeid = "time_counter" ; 
     891 
     892         dims.push_back(timeid); 
     893         if (!SuperClassWriter::varExist(axisid)) 
     894         { 
     895            SuperClassWriter::addVariable(axisid, NC_DOUBLE, dims); 
     896            SuperClassWriter::addAttribute("axis", string("T"), &axisid); 
     897            CDate timeOrigin=cal->getTimeOrigin() ; 
     898            StdString strTimeOrigin=timeOrigin.toString() ; 
     899            this->writeTimeAxisAttributes 
     900               (axisid, cal->getType(), 
     901                StdString("seconds since ").append(strTimeOrigin), 
     902                strTimeOrigin); 
     903         }          
     904          
    695905 
    696906      } 
Note: See TracChangeset for help on using the changeset viewer.