Changeset 488


Ignore:
Timestamp:
09/15/14 17:34:57 (7 years ago)
Author:
mhnguyen
Message:

Ticket 52: Adding some new variables (by default) into output file(s)

+) Add time_bounds dimension
+) Add time_counter_bounds
+) Add time_instant_bounds and/or time_centered_bounds depending on the context

Test
+) On Curie, test_client passed

Location:
XIOS/trunk/src/output
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • XIOS/trunk/src/output/nc4_data_output.cpp

    r472 r488  
    3737 
    3838         SuperClass::type = (multifile) ? MULTI_FILE : ONE_FILE; 
    39           
     39 
    4040 //        if (!exist) 
    4141//            SuperClassWriter::addDimension(timeid); 
     
    6262           return ; 
    6363         } 
    64           
     64 
    6565         CContext* context = CContext::getCurrent() ; 
    6666         CContextServer* server=context->server ; 
    67           
     67 
    6868         if (domain->IsWritten(this->filename)) return; 
    6969         domain->checkAttributes(); 
    70           
    71          if (domain->isEmpty())  
     70 
     71         if (domain->isEmpty()) 
    7272           if (SuperClass::type==MULTI_FILE) return ; 
    7373 
     
    7979 
    8080         StdString dimXid, dimYid ; 
    81           
     81 
    8282         switch (domain->type) 
    8383         { 
     
    9393             dimXid     = StdString("cell").append(appendDomid); 
    9494             break; 
    95          }             
    96           
     95         } 
     96 
    9797         string lonid,latid,bounds_lonid,bounds_latid ; 
    9898/* 
     
    110110            { 
    111111//               if (domain->isEmpty()) return; 
    112                 
     112 
    113113               if (server->intraCommSize > 1) 
    114114               { 
     
    138138                   break; 
    139139               } 
    140                  
     140 
    141141               if (domain->type == CDomain::type_attr::unstructured) 
    142142               { 
     
    148148                 SuperClassWriter::addDimension(dimYid, domain->zoom_nj_srv); 
    149149               } 
    150                 
     150 
    151151               if (server->intraCommSize > 1) 
    152152               { 
     
    158158                                               domain->zoom_nj_srv, 
    159159                                               appendDomid); 
    160                    
     160 
    161161                    if (singleDomain) this->writeLocalAttributes_IOIPSL(domain->zoom_ibegin_srv, 
    162162                                               domain->zoom_ni_srv, 
     
    167167                 } 
    168168               } 
    169                 
     169 
    170170               switch (domain->type) 
    171171               { 
     
    182182                    SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0); 
    183183               } 
    184                 
     184 
    185185               this->writeAxisAttributes(lonid, "X", "longitude", "Longitude", "degrees_east", domid); 
    186186               this->writeAxisAttributes(latid, "Y", "latitude", "Latitude", "degrees_north", domid); 
     
    202202// supress mask                     domain->data_jbegin.getValue()*/); 
    203203// supress mask               } 
    204                    
     204 
    205205               //SuperClassWriter::setDefaultValue(maskid, &dvm); 
    206206 
     
    212212                   SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0); 
    213213                   SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0); 
    214                    break;  
     214                   break; 
    215215                 case CDomain::type_attr::regular : 
    216216                   CArray<double,1> lat = domain->latvalue_srv(Range(fromStart,toEnd,domain->zoom_ni_srv)) ; 
     
    229229               SuperClassWriter::addDimension(dimYid, domain->zoom_nj.getValue()); 
    230230 
    231                 
     231 
    232232               switch (domain->type) 
    233233               { 
     
    260260                 case CDomain::type_attr::curvilinear : 
    261261                 { 
    262                    std::vector<StdSize> start(2) ;  
     262                   std::vector<StdSize> start(2) ; 
    263263                   std::vector<StdSize> count(2) ; 
    264264                   if (domain->isEmpty()) 
    265265                   { 
    266                      start[0]=0 ; start [1]=0 ;  
    267                      count[0]=0 ; count[1]=0 ;  
     266                     start[0]=0 ; start [1]=0 ; 
     267                     count[0]=0 ; count[1]=0 ; 
    268268                   } 
    269269                   else 
    270270                   { 
    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 ;  
     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 ; 
    273273                   } 
    274                   
     274 
    275275                   SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0,&start,&count); 
    276276                   SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0,&start,&count); 
     
    279279                 case CDomain::type_attr::regular : 
    280280                 { 
    281                    std::vector<StdSize> start(1) ;  
     281                   std::vector<StdSize> start(1) ; 
    282282                   std::vector<StdSize> count(1) ; 
    283283                   if (domain->isEmpty()) 
    284284                   { 
    285                      start[0]=0 ;   
    286                      count[0]=0 ;   
     285                     start[0]=0 ; 
     286                     count[0]=0 ; 
    287287                     SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0,&start,&count); 
    288288                     SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0,&start,&count);                 } 
    289289                   else 
    290290                   { 
    291                      start[0]=domain->zoom_jbegin_srv-domain->zoom_jbegin.getValue() ;  
    292                      count[0]=domain->zoom_nj_srv ;  
     291                     start[0]=domain->zoom_jbegin_srv-domain->zoom_jbegin.getValue() ; 
     292                     count[0]=domain->zoom_nj_srv ; 
    293293                     CArray<double,1> lat = domain->latvalue_srv(Range(fromStart,toEnd,domain->zoom_ni_srv)) ; 
    294294                     SuperClassWriter::writeData(CArray<double,1>(lat.copy()), latid, isCollective, 0,&start,&count); 
    295295 
    296                      start[0]=domain->zoom_ibegin_srv-domain->zoom_ibegin.getValue() ;  
    297                      count[0]=domain->zoom_ni_srv ;  
     296                     start[0]=domain->zoom_ibegin_srv-domain->zoom_ibegin.getValue() ; 
     297                     count[0]=domain->zoom_ni_srv ; 
    298298                     CArray<double,1> lon=domain->lonvalue_srv(Range(0,domain->zoom_ni_srv-1)) ; 
    299299                     SuperClassWriter::writeData(CArray<double,1>(lon.copy()), lonid, isCollective, 0,&start,&count); 
     
    304304               SuperClassWriter::definition_start(); 
    305305               break; 
    306             }            
     306            } 
    307307            default : 
    308308               ERROR("CNc4DataOutput::writeDomain(domain)", 
     
    317317         CContext* context = CContext::getCurrent() ; 
    318318         CContextServer* server=context->server ; 
    319           
     319 
    320320         if (domain->IsWritten(this->filename)) return; 
    321321         domain->checkAttributes(); 
    322           
    323          if (domain->isEmpty())  
     322 
     323         if (domain->isEmpty()) 
    324324           if (SuperClass::type==MULTI_FILE) return ; 
    325325 
     
    332332         StdString dimXid = StdString("cell").append(appendDomid); 
    333333         StdString dimVertId = StdString("nvertex").append(appendDomid); 
    334          
     334 
    335335         string lonid,latid,bounds_lonid,bounds_latid ; 
    336336 
     
    346346               SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
    347347               SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0); 
    348                 
     348 
    349349               bounds_lonid = StdString("bounds_lon").append(appendDomid); 
    350350               bounds_latid = StdString("bounds_lat").append(appendDomid); 
    351                
    352                 
     351 
     352 
    353353               this->writeAxisAttributes(lonid, "X", "longitude", "Longitude", "degrees_east", domid); 
    354354               if (domain->hasBounds) SuperClassWriter::addAttribute("bounds",bounds_lonid, &lonid); 
     
    358358               dim0.clear(); 
    359359               if (domain->hasBounds) 
    360                {  
     360               { 
    361361                 dim0.push_back(dimXid); 
    362362                 dim0.push_back(dimVertId); 
     
    364364                 SuperClassWriter::addVariable(bounds_latid, NC_FLOAT, dim0); 
    365365               } 
    366                 
     366 
    367367               dim0.clear(); 
    368368               dim0.push_back(dimXid); 
     
    372372               SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0); 
    373373               SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0); 
    374                 
     374 
    375375               if (domain->hasBounds) 
    376                {  
     376               { 
    377377                 SuperClassWriter::writeData(domain->bounds_lon_srv, bounds_lonid, isCollective, 0); 
    378378                 SuperClassWriter::writeData(domain->bounds_lat_srv, bounds_latid, isCollective, 0); 
     
    394394               this->writeAxisAttributes(lonid, "X", "longitude", "Longitude", "degrees_east", domid); 
    395395               if (domain->hasBounds) SuperClassWriter::addAttribute("bounds",bounds_lonid, &lonid); 
    396                this->writeAxisAttributes(latid, "Y", "latitude", "Latitude", "degrees_north", domid);                                            
     396               this->writeAxisAttributes(latid, "Y", "latitude", "Latitude", "degrees_north", domid); 
    397397               if (domain->hasBounds) SuperClassWriter::addAttribute("bounds",bounds_latid, &latid); 
    398398               if (domain->hasBounds) SuperClassWriter::addDimension(dimVertId, domain->nvertex); 
    399399               dim0.clear(); 
    400                 
    401                if (domain->hasBounds)  
     400 
     401               if (domain->hasBounds) 
    402402               { 
    403403                 dim0.push_back(dimXid); 
     
    406406                 SuperClassWriter::addVariable(bounds_latid, NC_FLOAT, dim0); 
    407407               } 
    408                 
     408 
    409409               SuperClassWriter::definition_end(); 
    410                 
    411                std::vector<StdSize> start(1), startBounds(2) ;  
     410 
     411               std::vector<StdSize> start(1), startBounds(2) ; 
    412412               std::vector<StdSize> count(1), countBounds(2) ; 
    413413               if (domain->isEmpty()) 
    414414               { 
    415                  start[0]=0 ;   
    416                  count[0]=0 ;   
    417                  startBounds[1]=0 ;   
     415                 start[0]=0 ; 
     416                 count[0]=0 ; 
     417                 startBounds[1]=0 ; 
    418418                 countBounds[1]=domain->nvertex ; 
    419                  startBounds[0]=0 ;   
    420                  countBounds[0]=0 ;   
     419                 startBounds[0]=0 ; 
     420                 countBounds[0]=0 ; 
    421421               } 
    422422               else 
    423423               { 
    424                  start[0]=domain->zoom_jbegin_srv-domain->zoom_jbegin ;  
    425                  count[0]=domain->zoom_nj_srv ;  
    426                  startBounds[0]=domain->zoom_jbegin_srv-domain->zoom_jbegin ;  
    427                  startBounds[1]=0 ;   
    428                  countBounds[0]=domain->zoom_nj_srv ;    
     424                 start[0]=domain->zoom_jbegin_srv-domain->zoom_jbegin ; 
     425                 count[0]=domain->zoom_nj_srv ; 
     426                 startBounds[0]=domain->zoom_jbegin_srv-domain->zoom_jbegin ; 
     427                 startBounds[1]=0 ; 
     428                 countBounds[0]=domain->zoom_nj_srv ; 
    429429                 countBounds[1]=domain->nvertex ; 
    430430               } 
    431431               SuperClassWriter::writeData(domain->latvalue_srv, latid, isCollective, 0,&start,&count); 
    432432               SuperClassWriter::writeData(domain->lonvalue_srv, lonid, isCollective, 0,&start,&count); 
    433                if (domain->hasBounds)  
     433               if (domain->hasBounds) 
    434434               { 
    435435                 SuperClassWriter::writeData(domain->bounds_lon_srv, bounds_lonid, isCollective, 0,&startBounds,&countBounds); 
    436436                 SuperClassWriter::writeData(domain->bounds_lat_srv, bounds_latid, isCollective, 0,&startBounds,&countBounds); 
    437437               } 
    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       } 
    451       //-------------------------------------------------------------- 
    452  
    453       void CNc4DataOutput::writeAxis_(CAxis* axis) 
    454       { 
    455          if (axis->IsWritten(this->filename)) return; 
    456          axis->checkAttributes(); 
    457          StdSize zoom_size=axis->zoom_size.getValue() ; 
    458          StdSize zoom_begin=axis->zoom_begin.getValue()-1 ; 
    459           
    460          std::vector<StdString> dims; 
    461          StdString axisid = (!axis->name.isEmpty()) 
    462                            ? axis->name.getValue() : axis->getId(); 
    463          SuperClassWriter::addDimension(axisid, zoom_size); 
    464          dims.push_back(axisid); 
    465           
    466          switch (SuperClass::type) 
    467          { 
    468             case (MULTI_FILE ) : 
    469             {} 
    470             case (ONE_FILE) : 
    471             { 
    472                SuperClassWriter::addVariable(axisid, NC_FLOAT, dims); 
    473  
    474                SuperClassWriter::addAttribute("axis", StdString("Z"), &axisid); 
    475  
    476                if (!axis->standard_name.isEmpty()) 
    477                   SuperClassWriter::addAttribute 
    478                      ("standard_name",  axis->standard_name.getValue(), &axisid); 
    479  
    480                if (!axis->long_name.isEmpty()) 
    481                   SuperClassWriter::addAttribute 
    482                      ("long_name", axis->long_name.getValue(), &axisid); 
    483  
    484                if (!axis->unit.isEmpty()) 
    485                   SuperClassWriter::addAttribute 
    486                      ("units", axis->unit.getValue(), &axisid); 
    487  
    488               if (!axis->positive.isEmpty()) 
    489                 if (axis->positive==CAxis::positive_attr::up) SuperClassWriter::addAttribute("positive", string("up"), &axisid); 
    490                 else   SuperClassWriter::addAttribute("positive", string("down"), &axisid); 
    491  
    492                SuperClassWriter::definition_end(); 
    493                 
    494                CArray<double,1> axis_value(zoom_size) ; 
    495                for(StdSize i = 0 ; i < zoom_size ; i++) axis_value(i)=axis->value(i+zoom_begin) ; 
    496                SuperClassWriter::writeData(axis_value, axisid, isCollective, 0); 
    497                 
     438 
     439 
    498440               SuperClassWriter::definition_start(); 
    499441 
     
    505447                     << " not implemented yet !"); 
    506448         } 
     449         domain->addRelFile(this->filename); 
     450      } 
     451      //-------------------------------------------------------------- 
     452 
     453      void CNc4DataOutput::writeAxis_(CAxis* axis) 
     454      { 
     455         if (axis->IsWritten(this->filename)) return; 
     456         axis->checkAttributes(); 
     457         StdSize zoom_size=axis->zoom_size.getValue() ; 
     458         StdSize zoom_begin=axis->zoom_begin.getValue()-1 ; 
     459 
     460         std::vector<StdString> dims; 
     461         StdString axisid = (!axis->name.isEmpty()) 
     462                           ? axis->name.getValue() : axis->getId(); 
     463         SuperClassWriter::addDimension(axisid, zoom_size); 
     464         dims.push_back(axisid); 
     465 
     466         switch (SuperClass::type) 
     467         { 
     468            case (MULTI_FILE ) : 
     469            {} 
     470            case (ONE_FILE) : 
     471            { 
     472               SuperClassWriter::addVariable(axisid, NC_FLOAT, dims); 
     473 
     474               SuperClassWriter::addAttribute("axis", StdString("Z"), &axisid); 
     475 
     476               if (!axis->standard_name.isEmpty()) 
     477                  SuperClassWriter::addAttribute 
     478                     ("standard_name",  axis->standard_name.getValue(), &axisid); 
     479 
     480               if (!axis->long_name.isEmpty()) 
     481                  SuperClassWriter::addAttribute 
     482                     ("long_name", axis->long_name.getValue(), &axisid); 
     483 
     484               if (!axis->unit.isEmpty()) 
     485                  SuperClassWriter::addAttribute 
     486                     ("units", axis->unit.getValue(), &axisid); 
     487 
     488              if (!axis->positive.isEmpty()) 
     489                if (axis->positive==CAxis::positive_attr::up) SuperClassWriter::addAttribute("positive", string("up"), &axisid); 
     490                else   SuperClassWriter::addAttribute("positive", string("down"), &axisid); 
     491 
     492               SuperClassWriter::definition_end(); 
     493 
     494               CArray<double,1> axis_value(zoom_size) ; 
     495               for(StdSize i = 0 ; i < zoom_size ; i++) axis_value(i)=axis->value(i+zoom_begin) ; 
     496               SuperClassWriter::writeData(axis_value, axisid, isCollective, 0); 
     497 
     498               SuperClassWriter::definition_start(); 
     499 
     500               break; 
     501            } 
     502            default : 
     503               ERROR("CNc4DataOutput::writeDomain(domain)", 
     504                     << "[ type = " << SuperClass::type << "]" 
     505                     << " not implemented yet !"); 
     506         } 
    507507         axis->addRelFile(this->filename); 
    508508     } 
    509       
     509 
    510510     void CNc4DataOutput::writeTimeDimension_(void) 
    511511     { 
    512512       SuperClassWriter::addDimension("time_counter"); 
     513       SuperClassWriter::addDimension("time_bounds", 2); 
    513514     } 
    514515      //-------------------------------------------------------------- 
     
    522523         CGrid* grid = field->grid; 
    523524         CDomain* domain = grid->domain; 
    524             
    525          if (domain->isEmpty())  
     525 
     526         if (domain->isEmpty()) 
    526527           if (SuperClass::type==MULTI_FILE) return ; 
    527528 
     
    530531                             ? domain->name.getValue() : domain->getId(); 
    531532         StdString appendDomid  = (singleDomain) ? "" : "_"+domid ; 
    532   
    533 //         bool isCurvilinear = domain->isCurvilinear ;  
     533 
     534//         bool isCurvilinear = domain->isCurvilinear ; 
    534535//         bool isCurvilinear = (domain->type == CDomain::type_attr::curvilinear) ; 
    535           
     536 
    536537         StdString dimXid,dimYid ; 
    537          
     538 
    538539         switch (domain->type) 
    539540         { 
     
    550551             break ; 
    551552        } 
    552           
    553 /*  
     553 
     554/* 
    554555         StdString lonid_loc = (server->intraCommSize > 1) 
    555556                             ? StdString("lon").append(appendDomid).append("_local") 
     
    564565//         unsigned int ssize = domain->zoom_ni_loc.getValue() * domain->zoom_nj_loc.getValue(); 
    565566//         bool isCurvilinear = (domain->lonvalue.getValue()->size() == ssize); 
    566 //          bool isCurvilinear = domain->isCurvilinear ;  
    567            
     567//          bool isCurvilinear = domain->isCurvilinear ; 
     568 
    568569         nc_type type ; 
    569570         if (field->prec.isEmpty()) type =  NC_FLOAT ; 
     
    572573           if (field->prec==2) type = NC_SHORT ; 
    573574           else if (field->prec==4)  type =  NC_FLOAT ; 
    574            else if (field->prec==8)   type =  NC_DOUBLE ;  
    575          } 
    576                       
     575           else if (field->prec==8)   type =  NC_DOUBLE ; 
     576         } 
     577 
    577578         bool wtime   = !(!field->operation.isEmpty() && field->foperation->timeType() == func::CFunctor::once); 
    578                           
     579 
    579580         if (wtime) 
    580581         { 
    581              
     582 
    582583            //StdOStringStream oss; 
    583584           // oss << "time_" << field->operation.getValue() 
    584585           //     << "_" << field->getRelFile()->output_freq.getValue(); 
    585           //oss  
     586          //oss 
    586587            if (field->foperation->timeType() == func::CFunctor::instant) coodinates.push_back(string("time_instant")); 
    587588            else if (field->foperation->timeType() == func::CFunctor::centered) coodinates.push_back(string("time_centered")); 
     
    603604             coodinates.push_back(StdString("nav_lat").append(appendDomid)); 
    604605             break; 
    605            case CDomain::type_attr::regular :              
    606            case CDomain::type_attr::unstructured :    
     606           case CDomain::type_attr::regular : 
     607           case CDomain::type_attr::unstructured : 
    607608            coodinates.push_back(StdString("lon").append(appendDomid)); 
    608609            coodinates.push_back(StdString("lat").append(appendDomid)); 
     
    612613         if ( domain->type == CDomain::type_attr::curvilinear || domain->type == CDomain::type_attr::regular)dims.push_back(dimYid); 
    613614         dims.push_back(dimXid); 
    614            
     615 
    615616         SuperClassWriter::addVariable(fieldid, type, dims); 
    616           
     617 
    617618         if (!field->standard_name.isEmpty()) 
    618619            SuperClassWriter::addAttribute 
     
    642643            SuperClassWriter::addAttribute 
    643644               ("add_offset", field->add_offset.getValue(), &fieldid); 
    644                                              
     645 
    645646         SuperClassWriter::addAttribute 
    646647               ("online_operation", field->operation.getValue(), &fieldid); 
    647648 
    648649        // write child variables as attributes 
    649          
    650          
     650 
     651 
    651652         vector<CVariable*> listVars = field->getAllVariables() ; 
    652653         for (vector<CVariable*>::iterator it = listVars.begin() ;it != listVars.end(); it++) writeAttribute_(*it, fieldid) ; 
    653654 
    654                 
     655 
    655656         if (wtime) 
    656657         { 
     
    665666            SuperClassWriter::addAttribute("interval_write", duration.toString(), &fieldid); 
    666667         } 
    667           
     668 
    668669         if (!field->default_value.isEmpty()) 
    669670         { 
     
    679680            double * default_value = NULL; 
    680681            SuperClassWriter::setDefaultValue(fieldid, default_value); 
    681          }              
     682         } 
    682683 
    683684         {  // Ecriture des coordonnées 
    684           
     685 
    685686            StdString coordstr; //boost::algorithm::join(coodinates, " ") 
    686             std::vector<StdString>::iterator  
     687            std::vector<StdString>::iterator 
    687688               itc = coodinates.begin(), endc = coodinates.end(); 
    688              
     689 
    689690            for (; itc!= endc; itc++) 
    690691            { 
     
    717718         else singleDomain=false ; 
    718719      } 
    719   
     720 
    720721      void CNc4DataOutput::writeAttribute_ (CVariable* var, const string& fieldId) 
    721722      { 
     
    724725        else if (var->hasId()) name=var->getId() ; 
    725726        else return ; 
    726          
    727         if (var->getVarType()==CVariable::t_int) addAttribute(name,var->getData<int>(),&fieldId) ;  
    728         else if (var->getVarType()==CVariable::t_short_int) addAttribute(name,var->getData<short int>(),&fieldId) ;  
    729         else if (var->getVarType()==CVariable::t_long_int) addAttribute(name,var->getData<long int>(),&fieldId) ;  
    730         else if (var->getVarType()==CVariable::t_float) addAttribute(name,var->getData<float>(),&fieldId) ;  
    731         else if (var->getVarType()==CVariable::t_double) addAttribute(name,var->getData<double>(),&fieldId) ;  
    732         else addAttribute(name,var->getData<string>(),&fieldId) ;  
     727 
     728        if (var->getVarType()==CVariable::t_int) addAttribute(name,var->getData<int>(),&fieldId) ; 
     729        else if (var->getVarType()==CVariable::t_short_int) addAttribute(name,var->getData<short int>(),&fieldId) ; 
     730        else if (var->getVarType()==CVariable::t_long_int) addAttribute(name,var->getData<long int>(),&fieldId) ; 
     731        else if (var->getVarType()==CVariable::t_float) addAttribute(name,var->getData<float>(),&fieldId) ; 
     732        else if (var->getVarType()==CVariable::t_double) addAttribute(name,var->getData<double>(),&fieldId) ; 
     733        else addAttribute(name,var->getData<string>(),&fieldId) ; 
    733734     } 
    734   
     735 
    735736     void CNc4DataOutput::writeAttribute_ (CVariable* var) 
    736737     { 
     
    739740        else if (var->hasId()) name=var->getId() ; 
    740741        else return ; 
    741          
    742         if (var->getVarType()==CVariable::t_int) addAttribute(name,var->getData<int>()) ;  
    743         else if (var->getVarType()==CVariable::t_short_int) addAttribute(name,var->getData<short int>()) ;  
    744         else if (var->getVarType()==CVariable::t_long_int) addAttribute(name,var->getData<long int>()) ;  
    745         else if (var->getVarType()==CVariable::t_float) addAttribute(name,var->getData<float>()) ;  
    746         else if (var->getVarType()==CVariable::t_double) addAttribute(name,var->getData<double>()) ;  
    747         else addAttribute(name,var->getData<string>()) ;  
    748      }      
    749   
     742 
     743        if (var->getVarType()==CVariable::t_int) addAttribute(name,var->getData<int>()) ; 
     744        else if (var->getVarType()==CVariable::t_short_int) addAttribute(name,var->getData<short int>()) ; 
     745        else if (var->getVarType()==CVariable::t_long_int) addAttribute(name,var->getData<long int>()) ; 
     746        else if (var->getVarType()==CVariable::t_float) addAttribute(name,var->getData<float>()) ; 
     747        else if (var->getVarType()==CVariable::t_double) addAttribute(name,var->getData<double>()) ; 
     748        else addAttribute(name,var->getData<string>()) ; 
     749     } 
     750 
    750751      void CNc4DataOutput::syncFile_ (void) 
    751752      { 
     
    773774         return (StdString(buffer)); 
    774775      } 
    775        
     776 
    776777      //--------------------------------------------------------------- 
    777        
     778 
    778779      void CNc4DataOutput::writeFieldData_ (CField*  field) 
    779780      { 
     
    784785         CGrid* grid = field->grid ; 
    785786         CDomain* domain = grid->domain ; 
    786           
     787 
    787788         if(SuperClass::type==MULTI_FILE || !isCollective) if (domain->isEmpty()) return; 
    788789 
    789790 
    790          StdString fieldid   = (!field->name.isEmpty())  
    791                              ? field->name.getValue()  
     791         StdString fieldid   = (!field->name.isEmpty()) 
     792                             ? field->name.getValue() 
    792793                             : field->getBaseFieldReference()->getId(); 
    793                               
     794 
    794795         StdOStringStream oss; 
    795796         string timeAxisId ; 
     
    797798         else if (field->foperation->timeType() == func::CFunctor::centered)  timeAxisId="time_centered" ; 
    798799 
    799               
     800         StdString timeBoundId("time_counter_bounds"); 
     801 
     802         StdString timeAxisBoundId; 
     803         if (field->foperation->timeType() == func::CFunctor::instant)  timeAxisBoundId="time_instant_bounds" ; 
     804         else if (field->foperation->timeType() == func::CFunctor::centered)  timeAxisBoundId="time_centered_bounds" ; 
     805 
    800806         CArray<double,1> time_data(1) ; 
    801807         CArray<double,1> time_counter(1) ; 
    802                  
     808         CArray<double,1> time_counter_bound(2); 
     809         CArray<double,1> time_data_bound(2); 
     810 
    803811        bool wtime   = !(!field->operation.isEmpty() && (field->foperation->timeType() == func::CFunctor::once)); 
    804                                   
     812 
    805813        if (wtime) 
    806814        { 
    807815          time_counter(0)= (Time(*field->last_Write_srv)+Time(*field->lastlast_Write_srv))/2 -Time(context->calendar->getTimeOrigin()); 
    808           if (field->foperation->timeType() == func::CFunctor::instant)  
     816          if (field->foperation->timeType() == func::CFunctor::instant) 
    809817            time_data(0) = Time(*field->last_Write_srv)-Time(context->calendar->getTimeOrigin()); 
    810818          else if (field->foperation->timeType() == func::CFunctor::centered) time_data(0) = time_counter(0); 
    811            
    812          } 
    813           
    814           
     819 
     820          time_counter_bound(0) = Time(*field->lastlast_Write_srv) - Time(context->calendar->getTimeOrigin()); 
     821          time_counter_bound(1) = Time(*field->last_Write_srv) - Time(context->calendar->getTimeOrigin()); 
     822          if (field->foperation->timeType() == func::CFunctor::instant) 
     823            time_data_bound(0) = time_data_bound(1) = Time(*field->last_Write_srv)-Time(context->calendar->getTimeOrigin()); 
     824          else if (field->foperation->timeType() == func::CFunctor::centered) 
     825          { 
     826            time_data_bound(0) = time_counter_bound(0); 
     827            time_data_bound(1) = time_counter_bound(1); 
     828          } 
     829         } 
     830 
    815831         bool isRoot ; 
    816832         if (server->intraCommRank==0) isRoot=true ; 
    817833         else isRoot=false ; 
    818            
     834 
    819835         if (!field->scale_factor.isEmpty() || !field->add_offset.isEmpty()) 
    820836         { 
     
    825841           field->scaleFactorAddOffset(scaleFactor,addOffset) ; 
    826842         } 
    827              
     843 
    828844         if (grid->hasAxis()) // 3D 
    829845         { 
     
    841857              { 
    842858                 SuperClassWriter::writeData(field_data3D, fieldid, isCollective, field->getNStep()-1); 
    843                  if (wtime)  
     859                 if (wtime) 
    844860                 { 
    845861                   SuperClassWriter::writeData(time_data, timeAxisId, isCollective, field->getNStep()-1); 
    846862                   SuperClassWriter::writeData(time_counter, string("time_counter"), isCollective, field->getNStep()-1); 
     863                   SuperClassWriter::writeData(time_counter_bound, timeBoundId, isCollective, field->getNStep()-1); 
     864                   SuperClassWriter::writeData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep()-1); 
    847865                 } 
    848866                 break ; 
     
    850868              case (ONE_FILE) : 
    851869              { 
    852                  std::vector<StdSize> start(3) ;  
     870                 std::vector<StdSize> start(3) ; 
    853871                 std::vector<StdSize> count(3) ; 
    854872                 if (domain->isEmpty()) 
     
    864882                 } 
    865883                 SuperClassWriter::writeData(field_data3D, fieldid, isCollective, field->getNStep()-1,&start,&count ); 
    866                  if (wtime)  
     884                 if (wtime) 
    867885                 { 
    868886                   SuperClassWriter::writeTimeAxisData(time_data, timeAxisId, isCollective, field->getNStep()-1,isRoot ); 
    869887                   SuperClassWriter::writeTimeAxisData(time_counter, string("time_counter"), isCollective, field->getNStep()-1,isRoot ); 
     888                   SuperClassWriter::writeTimeAxisData(time_counter_bound, timeBoundId, isCollective, field->getNStep()-1, isRoot ); 
     889                   SuperClassWriter::writeTimeAxisData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep()-1, isRoot); 
    870890                 } 
    871891                 break; 
    872892              } 
    873893            } 
    874              
     894 
    875895         } 
    876896         else // 2D 
     
    885905              { 
    886906                SuperClassWriter::writeData(field_data2D, fieldid, isCollective, field->getNStep()-1); 
    887                 if (wtime)  
     907                if (wtime) 
    888908                { 
    889909                  SuperClassWriter::writeData(time_data, timeAxisId, isCollective, field->getNStep()-1); 
    890910                  SuperClassWriter::writeData(time_counter, string("time_counter"), isCollective, field->getNStep()-1); 
     911                  SuperClassWriter::writeData(time_counter_bound, timeBoundId, isCollective, field->getNStep()-1); 
     912                  SuperClassWriter::writeData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep()-1); 
    891913                } 
    892914                break; 
     
    894916              case (ONE_FILE) : 
    895917              { 
    896                  std::vector<StdSize> start(2) ;  
     918                 std::vector<StdSize> start(2) ; 
    897919                 std::vector<StdSize> count(2) ; 
    898920                 if (domain->isEmpty()) 
     
    903925                 else 
    904926                 { 
    905                    start[1]=domain->zoom_ibegin_srv-domain->zoom_ibegin.getValue() ; start[0]=domain->zoom_jbegin_srv-domain->zoom_jbegin.getValue() ;  
     927                   start[1]=domain->zoom_ibegin_srv-domain->zoom_ibegin.getValue() ; start[0]=domain->zoom_jbegin_srv-domain->zoom_jbegin.getValue() ; 
    906928                   count[1]=domain->zoom_ni_srv ; count[0]=domain->zoom_nj_srv ; 
    907929                 } 
    908930 
    909931                 SuperClassWriter::writeData(field_data2D, fieldid, isCollective, field->getNStep()-1,&start,&count); 
    910                  if (wtime)  
     932                 if (wtime) 
    911933                 { 
    912934                   SuperClassWriter::writeTimeAxisData(time_data, timeAxisId, isCollective, field->getNStep()-1,isRoot); 
    913935                   SuperClassWriter::writeTimeAxisData(time_counter, string("time_counter"), isCollective, field->getNStep()-1,isRoot); 
    914                  }                    
    915                  break;  
    916                
     936                   SuperClassWriter::writeTimeAxisData(time_counter_bound, timeBoundId, isCollective, field->getNStep()-1, isRoot); 
     937                   SuperClassWriter::writeTimeAxisData(time_data_bound, timeAxisBoundId, isCollective, field->getNStep()-1, isRoot); 
     938                 } 
     939                 break; 
     940 
    917941              } 
    918942            } 
     
    927951      { 
    928952         StdOStringStream oss; 
    929           
     953 
    930954//         if (field->operation.getValue().compare("once") == 0) return ; 
    931955         if (field->foperation->timeType() == func::CFunctor::once) return ; 
    932                                  
     956 
    933957//         oss << "time_" << field->operation.getValue() 
    934958//             << "_" << field->getRelFile()->output_freq.getValue(); 
    935           
    936          string  axisid ;    
    937          if (field->foperation->timeType() == func::CFunctor::centered) axisid="time_centered" ; 
    938          else if (field->foperation->timeType() == func::CFunctor::instant) axisid="time_instant" ; 
    939           
     959 
     960//         StdString axisid = oss.str(); 
     961//         if (field->foperation->timeType() == func::CFunctor::centered) axisid="time_centered" ; 
     962//         else if (field->foperation->timeType() == func::CFunctor::instant) axisid="time_instant" ; 
     963 
     964         StdString axisid("time_centered") ; 
     965         StdString axisBoundId("time_centered_bounds"); 
     966         StdString timeid("time_counter"); 
     967         StdString timeBoundId("time_bounds"); 
     968 
     969         if (field->foperation->timeType() == func::CFunctor::instant) 
     970         { 
     971            axisid = "time_instant"; 
     972            axisBoundId = "time_instant_bounds"; 
     973         } 
     974 
     975         // Adding time_instant or time_centered 
    940976         std::vector<StdString> dims; 
    941 //         StdString axisid = oss.str(); 
    942          StdString timeid = StdString("time_counter"); 
    943  
    944977         dims.push_back(timeid); 
    945978         if (!SuperClassWriter::varExist(axisid)) 
    946979         { 
    947980            SuperClassWriter::addVariable(axisid, NC_DOUBLE, dims); 
    948              
     981 
    949982            CDate timeOrigin=cal->getTimeOrigin() ; 
    950 //            StdOStringStream oss2; 
     983            StdOStringStream oss2; 
    951984//            oss2<<initDate.getYear()<<"-"<<initDate.getMonth()<<"-"<<initDate.getDay()<<" " 
    952985//                <<initDate.getHour()<<"-"<<initDate.getMinute()<<"-"<<initDate.getSecond() ; 
    953 //            StdString strInitdate=oss2.str() ; 
     986            StdString strInitdate=oss2.str() ; 
    954987            StdString strTimeOrigin=timeOrigin.toString() ; 
    955988            this->writeTimeAxisAttributes 
    956989               (axisid, cal->getType(), 
    957990                StdString("seconds since ").append(strTimeOrigin), 
    958                 strTimeOrigin); 
    959          } 
    960  
     991                strTimeOrigin, axisBoundId); 
     992         } 
     993 
     994         // Adding time_instant_bounds or time_centered_bounds variables 
     995         if (!SuperClassWriter::varExist(axisBoundId)) 
     996         { 
     997            dims.clear() ; 
     998            dims.push_back(timeid); 
     999            dims.push_back(timeBoundId); 
     1000            SuperClassWriter::addVariable(axisBoundId, NC_DOUBLE, dims); 
     1001         } 
     1002 
     1003         // Adding time_counter 
     1004         axisid = "time_counter" ; 
     1005         axisBoundId = "time_counter_bounds" ; 
    9611006         dims.clear() ; 
    962          axisid = "time_counter" ; 
    963          timeid = "time_counter" ; 
    964  
    9651007         dims.push_back(timeid); 
    9661008         if (!SuperClassWriter::varExist(axisid)) 
     
    9701012            CDate timeOrigin=cal->getTimeOrigin() ; 
    9711013            StdString strTimeOrigin=timeOrigin.toString() ; 
     1014 
    9721015            this->writeTimeAxisAttributes 
    9731016               (axisid, cal->getType(), 
    9741017                StdString("seconds since ").append(strTimeOrigin), 
    975                 strTimeOrigin); 
    976          }          
    977           
    978  
     1018                strTimeOrigin, axisBoundId); 
     1019         } 
     1020 
     1021         // Adding time_counter_bound dimension 
     1022         if (!SuperClassWriter::varExist(axisBoundId)) 
     1023         { 
     1024            dims.clear(); 
     1025            dims.push_back(timeid); 
     1026            dims.push_back(timeBoundId); 
     1027            SuperClassWriter::addVariable(axisBoundId, NC_DOUBLE, dims); 
     1028         } 
    9791029      } 
    9801030 
    9811031      //--------------------------------------------------------------- 
    982        
     1032 
    9831033      void CNc4DataOutput::writeTimeAxisAttributes(const StdString & axis_name, 
    9841034                                                   const StdString & calendar, 
    9851035                                                   const StdString & units, 
    9861036                                                   const StdString & time_origin, 
     1037                                                   const StdString & time_bounds, 
    9871038                                                   const StdString & standard_name, 
    9881039                                                   const StdString & long_name, 
     
    9951046         SuperClassWriter::addAttribute("units",         units        , &axis_name); 
    9961047         SuperClassWriter::addAttribute("time_origin",   time_origin  , &axis_name); 
    997       } 
    998        
     1048         SuperClassWriter::addAttribute("bounds",        time_bounds  , &axis_name); 
     1049      } 
     1050 
    9991051      //--------------------------------------------------------------- 
    10001052 
     
    10141066 
    10151067      //--------------------------------------------------------------- 
    1016        
     1068 
    10171069      void CNc4DataOutput::writeLocalAttributes 
    10181070         (int ibegin, int ni, int jbegin, int nj, StdString domid) 
  • XIOS/trunk/src/output/nc4_data_output.hpp

    r472 r488  
    5454 
    5555         protected : 
    56             void writeUnstructuredDomain (CDomain* domain);          
     56            void writeUnstructuredDomain (CDomain* domain); 
    5757            void writeLocalAttributes(int ibegin, int ni, int jbegin, int nj, StdString domid); 
    5858            void writeLocalAttributes_IOIPSL(int ibegin, int ni, int jbegin, int nj, int ni_glo, int nj_glo, int rank, int size) ; 
     
    6161                                         const StdString & units, 
    6262                                         const StdString & time_origin, 
     63                                         const StdString & time_bounds   = StdString("bounds"), 
    6364                                         const StdString & standard_name = StdString("time"), 
    6465                                         const StdString & long_name     = StdString("Time axis"), 
Note: See TracChangeset for help on using the changeset viewer.