Ignore:
Timestamp:
10/21/11 19:01:35 (13 years ago)
Author:
ymipsl
Message:

reprise en main de la version de H. Ozdoba. Correction de différentes erreurs de conception et bug.
Version NEMO operationnel en client/server, interoperabilita avec OASIS, reconstition de fichiers via netcdf4/HDF5

YM

File:
1 edited

Legend:

Unmodified
Added
Removed

  • XMLIO_V2/dev/common/src/xmlio/output/nc4_data_output.cpp

    r278 r286  
    2929 
    3030      CNc4DataOutput::CNc4DataOutput 
    31          (const StdString & filename, bool exist, bool multigroup, MPI_Comm comm_server) 
     31         (const StdString & filename, bool exist, MPI_Comm comm_server,bool multifile) 
    3232            : SuperClass() 
    33             , SuperClassWriter(filename, exist, &comm_server) 
     33            , SuperClassWriter(filename, exist, &comm_server,multifile) 
    3434            , comm_server(comm_server) 
    3535            , filename(filename) 
    3636      { 
    3737         StdString timeid = StdString("time_counter"); 
    38          SuperClass::type = (multigroup) ? MULTI_GROUP : ONE_FILE; 
     38 
     39         SuperClass::type = (multifile) ? MULTI_FILE : ONE_FILE; 
     40          
    3941         if (!exist) 
    4042            SuperClassWriter::addDimension(timeid); 
    4143      } 
    4244 
    43       CNc4DataOutput::CNc4DataOutput 
    44          (const StdString & filename, bool exist, bool multigroup, comm::MPIComm comm_server, bool) 
    45             : SuperClass() 
    46             , SuperClassWriter(filename, exist, &comm_server, true) 
    47             , filename(filename) 
    48       { 
    49          StdString timeid = StdString("time_counter"); 
    50          SuperClass::type = (multigroup) ? MULTI_GROUP : ONE_FILE; 
    51          if (!exist) 
    52             SuperClassWriter::addDimension(timeid); 
    53       } 
    5445 
    5546      CNc4DataOutput::~CNc4DataOutput(void) 
    … …  
    7061         domain->checkAttributes(); 
    7162          
    72          if (domain->isEmpty()) return; 
     63//         if (domain->isEmpty()) return; 
    7364 
    7465         std::vector<StdString> dim0, dim1; 
    … …  
    9081         bool isCurvilinear = (domain->lonvalue.getValue()->size() == ssize); 
    9182 
    92          if (comm::CMPIManager::GetCommSize(CXIOSManager::Comm_Server) > 1) 
    93          { 
    94             SuperClassWriter::addDimension(lonid, domain->zoom_ni.getValue()); 
    95             SuperClassWriter::addDimension(latid, domain->zoom_nj.getValue()); 
    96          } 
    97  
    98          if (isCurvilinear) 
    99          { 
    100             dim0.push_back(latid_loc); dim0.push_back(lonid_loc); 
    101             lonid = StdString("nav_lon_").append(domid); 
    102             latid = StdString("nav_lat_").append(domid); 
    103          } 
    104          else 
    105          { 
    106             dim0.push_back(latid_loc); 
    107             dim1.push_back(lonid_loc); 
    108          } 
    10983         switch (SuperClass::type) 
    11084         { 
    11185            case (MULTI_FILE) : 
    11286            { 
     87               if (domain->isEmpty()) return; 
     88                
     89               if (comm::CMPIManager::GetCommSize(CXIOSManager::Comm_Server) > 1) 
     90               { 
     91                 SuperClassWriter::addDimension(lonid, domain->zoom_ni.getValue()); 
     92                 SuperClassWriter::addDimension(latid, domain->zoom_nj.getValue()); 
     93               } 
     94 
     95               if (isCurvilinear) 
     96               { 
     97                 dim0.push_back(latid_loc); dim0.push_back(lonid_loc); 
     98                 lonid = StdString("nav_lon_").append(domid); 
     99                 latid = StdString("nav_lat_").append(domid); 
     100               } 
     101               else 
     102               { 
     103                 dim0.push_back(latid_loc); 
     104                 dim1.push_back(lonid_loc); 
     105               } 
     106 
    113107               SuperClassWriter::addDimension(lonid_loc, domain->zoom_ni_loc.getValue()); 
    114108               SuperClassWriter::addDimension(latid_loc, domain->zoom_nj_loc.getValue()); 
    … …  
    133127               } 
    134128               this->writeAxisAttributes 
    135                   (latid, "X", "longitude", "Longitude", "degrees_east", domid); 
     129                  (lonid, "X", "longitude", "Longitude", "degrees_east", domid); 
    136130               this->writeAxisAttributes 
    137                   (lonid, "Y", "latitude", "Latitude", "degrees_north", domid); 
     131                  (latid, "Y", "latitude", "Latitude", "degrees_north", domid); 
    138132 
    139133               dim0.clear(); 
    … …  
    164158               break; 
    165159            } 
     160            case (ONE_FILE) : 
     161            { 
     162               SuperClassWriter::addDimension(lonid, domain->zoom_ni.getValue()); 
     163               SuperClassWriter::addDimension(latid, domain->zoom_nj.getValue()); 
     164 
     165                
     166               if (isCurvilinear) 
     167               { 
     168                  dim0.push_back(latid); dim0.push_back(lonid); 
     169                  lonid = StdString("nav_lon_").append(domid); 
     170                  latid = StdString("nav_lat_").append(domid); 
     171                  SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
     172                  SuperClassWriter::addVariable(lonid, NC_FLOAT, dim0); 
     173               } 
     174               else 
     175               { 
     176                  dim0.push_back(latid); 
     177                  dim1.push_back(lonid); 
     178                  SuperClassWriter::addVariable(latid, NC_FLOAT, dim0); 
     179                  SuperClassWriter::addVariable(lonid, NC_FLOAT, dim1); 
     180               } 
     181               this->writeAxisAttributes 
     182                  (latid, "X", "longitude", "Longitude", "degrees_east", domid); 
     183               this->writeAxisAttributes 
     184                  (lonid, "Y", "latitude", "Latitude", "degrees_north", domid); 
     185 
     186 
     187               SuperClassWriter::definition_end(); 
     188               std::vector<StdSize> start(2) ;  
     189               std::vector<StdSize> count(2) ; 
     190               if (domain->isEmpty()) 
     191               { 
     192                 start[0]=0 ; start [1]=0 ;  
     193                 count[0]=0 ; count[1]=0 ;  
     194               } 
     195               else 
     196               { 
     197                 start[1]=domain->zoom_ibegin_loc.getValue()+domain->ibegin.getValue()-1-domain->zoom_ibegin.getValue() ; start [0]=domain->zoom_jbegin_loc.getValue()+domain->jbegin.getValue()-1-domain->zoom_jbegin.getValue() ;  
     198                 count[1]=domain->zoom_ni_loc.getValue() ; count[0]=domain->zoom_nj_loc.getValue() ;  
     199               } 
     200                
     201               SuperClassWriter::writeData(domain->latvalue.getValue(), latid, true, 0,&start,&count); 
     202               SuperClassWriter::writeData(domain->lonvalue.getValue(), lonid, true, 0,&start,&count); 
     203               SuperClassWriter::definition_start(); 
     204 
     205               break; 
     206            }            
    166207            default : 
    167208               ERROR("CNc4DataOutput::writeDomain(domain)", 
    … …  
    183224         SuperClassWriter::addDimension(axisid, axis->size.getValue()); 
    184225         dims.push_back(axisid); 
    185  
     226          
    186227         switch (SuperClass::type) 
    187228         { 
     229            case (MULTI_FILE ) : 
     230            {} 
    188231            case (ONE_FILE) : 
    189             case (MULTI_FILE) : 
    190232            { 
    191233               SuperClassWriter::addVariable(axisid, NC_FLOAT, dims); 
    … …  
    228270         boost::shared_ptr<CDomain> domain = 
    229271            CObjectFactory::GetObject<CDomain>(grid->domain_ref.getValue()); 
    230              
    231          if (domain->isEmpty()) return; 
     272            
     273         if (domain->isEmpty())  
     274           if (SuperClass::type==MULTI_FILE) return ; 
    232275 
    233276         StdString timeid    = StdString("time_counter"); 
    … …  
    291334               dims.push_back(latid_loc); 
    292335               dims.push_back(lonid_loc); 
    293                SuperClassWriter::addVariable(fieldid, type, dims); 
    294  
    295                if (!field->standard_name.isEmpty()) 
    296                   SuperClassWriter::addAttribute 
    297                      ("standard_name",  field->standard_name.getValue(), &fieldid); 
    298  
    299                if (!field->long_name.isEmpty()) 
    300                   SuperClassWriter::addAttribute 
    301                      ("long_name", field->long_name.getValue(), &fieldid); 
    302  
    303                if (!field->unit.isEmpty()) 
    304                   SuperClassWriter::addAttribute 
    305                      ("units", field->unit.getValue(), &fieldid); 
    306                       
    307                SuperClassWriter::addAttribute 
    308                      ("online_operation", field->operation.getValue(), &fieldid); 
    309                       
    310                if (wtime) 
    311                { 
    312                   SuperClassWriter::addAttribute 
    313                         ("interval_operation", field->freq_op.getValue(), &fieldid); 
    314                   SuperClassWriter::addAttribute 
    315                         ("interval_write", field->getRelFile()->output_freq.getValue(), &fieldid); 
    316                } 
    317                 
    318                if (!field->default_value.isEmpty()) 
    319                { 
    320                   double default_value = field->default_value.getValue(); 
    321                   float fdefault_value = (float)default_value; 
    322                   if (type == NC_DOUBLE) 
    323                      SuperClassWriter::setDefaultValue(fieldid, &default_value); 
    324                   else 
    325                      SuperClassWriter::setDefaultValue(fieldid, &fdefault_value); 
    326                } 
    327                else 
    328                { 
    329                   double * default_value = NULL; 
    330                   SuperClassWriter::setDefaultValue(fieldid, default_value); 
    331                }              
    332  
    333                {  // Ecriture des coordonnées 
    334                 
    335                   StdString coordstr; //boost::algorithm::join(coodinates, " ") 
    336                   std::vector<StdString>::iterator  
    337                      itc = coodinates.begin(), endc = coodinates.end(); 
    338                    
    339                   for (; itc!= endc; itc++) 
    340                   { 
    341                      StdString & coord = *itc; 
    342                      if (itc+1 != endc) 
    343                            coordstr.append(coord).append(" "); 
    344                      else  coordstr.append(coord); 
    345                   } 
    346  
    347                   SuperClassWriter::addAttribute("coordinates", coordstr, &fieldid); 
    348  
    349                } 
    350  
     336               break ; 
     337            } 
     338            case (ONE_FILE) : 
     339            { 
     340               dims.push_back(latid); 
     341               dims.push_back(lonid); 
    351342               break; 
    352343            } 
    … …  
    356347                     << " not implemented yet !"); 
    357348         } 
     349           
     350         SuperClassWriter::addVariable(fieldid, type, dims); 
     351          
     352         if (!field->standard_name.isEmpty()) 
     353            SuperClassWriter::addAttribute 
     354               ("standard_name",  field->standard_name.getValue(), &fieldid); 
     355 
     356         if (!field->long_name.isEmpty()) 
     357            SuperClassWriter::addAttribute 
     358               ("long_name", field->long_name.getValue(), &fieldid); 
     359 
     360         if (!field->unit.isEmpty()) 
     361            SuperClassWriter::addAttribute 
     362               ("units", field->unit.getValue(), &fieldid); 
     363                
     364         SuperClassWriter::addAttribute 
     365               ("online_operation", field->operation.getValue(), &fieldid); 
     366                
     367         if (wtime) 
     368         { 
     369            SuperClassWriter::addAttribute 
     370                  ("interval_operation", field->freq_op.getValue(), &fieldid); 
     371            SuperClassWriter::addAttribute 
     372                  ("interval_write", field->getRelFile()->output_freq.getValue(), &fieldid); 
     373         } 
     374          
     375         if (!field->default_value.isEmpty()) 
     376         { 
     377            double default_value = field->default_value.getValue(); 
     378            float fdefault_value = (float)default_value; 
     379            if (type == NC_DOUBLE) 
     380               SuperClassWriter::setDefaultValue(fieldid, &default_value); 
     381            else 
     382               SuperClassWriter::setDefaultValue(fieldid, &fdefault_value); 
     383         } 
     384         else 
     385         { 
     386            double * default_value = NULL; 
     387            SuperClassWriter::setDefaultValue(fieldid, default_value); 
     388         }              
     389 
     390         {  // Ecriture des coordonnées 
     391          
     392            StdString coordstr; //boost::algorithm::join(coodinates, " ") 
     393            std::vector<StdString>::iterator  
     394               itc = coodinates.begin(), endc = coodinates.end(); 
     395             
     396            for (; itc!= endc; itc++) 
     397            { 
     398               StdString & coord = *itc; 
     399               if (itc+1 != endc) 
     400                     coordstr.append(coord).append(" "); 
     401               else  coordstr.append(coord); 
     402            } 
     403 
     404            SuperClassWriter::addAttribute("coordinates", coordstr, &fieldid); 
     405 
     406         } 
     407 
    358408      } 
    359409 
    … …  
    373423      } 
    374424 
     425      void CNc4DataOutput::closeFile_ (void) 
     426      { 
     427         std::cout<<"--> Close file "<<filename<<std::endl ; 
     428         SuperClassWriter::close() ; 
     429      } 
     430 
    375431      //--------------------------------------------------------------- 
    376432 
    … …  
    395451         boost::shared_ptr<CGrid> grid = 
    396452            CObjectFactory::GetObject<CGrid>(field->grid_ref.getValue()); 
     453         boost::shared_ptr<CDomain> domain = 
     454            CObjectFactory::GetObject<CDomain>(grid->domain_ref.getValue()); 
     455          
     456         if(SuperClass::type==MULTI_FILE) if (domain->isEmpty()) return; 
     457 
     458 
    397459         StdString fieldid   = (!field->name.isEmpty()) 
    398460                             ? field->name.getValue()  
    … …  
    412474         if (grid->hasAxis()) // 3D 
    413475         { 
     476            boost::shared_ptr<CAxis> axis = CObjectFactory::GetObject<CAxis>(grid->axis_ref.getValue()); 
    414477            ARRAY(double, 3) field_data3D (new CArray<double,3>(grid->getLocalShape()/*, boost::c_storage_order()*/));             
    415478            grid->outputField(field_data, field_data3D); 
    416             SuperClassWriter::writeData(field_data3D, fieldid, true, field->getNStep()-1); 
    417             SuperClassWriter::writeData(time_data, oss.str(), true, field->getNStep()-1); 
     479            switch (SuperClass::type) 
     480           { 
     481              case (MULTI_FILE) : 
     482              { 
     483                 SuperClassWriter::writeData(field_data3D, fieldid, true, field->getNStep()-1); 
     484                 SuperClassWriter::writeData(time_data, oss.str(), true, field->getNStep()-1); 
     485                 break ; 
     486              } 
     487              case (ONE_FILE) : 
     488              { 
     489                 std::vector<StdSize> start(3) ;  
     490                 std::vector<StdSize> count(3) ; 
     491                 if (domain->isEmpty()) 
     492                 { 
     493                   start[0]=0 ; start[1]=0 ; start[2]=0 ; 
     494                   count[0]=0 ; count[1]=0 ; start[2]=0 ; 
     495                 } 
     496                 else 
     497                 { 
     498//                 start[2]=domain->zoom_ibegin_loc.getValue()-domain->zoom_ibegin.getValue() ; start [1]=domain->zoom_jbegin_loc.getValue()-domain->zoom_jbegin.getValue() ; start[0]=0 ; 
     499                   start[2]=domain->zoom_ibegin_loc.getValue()+domain->ibegin.getValue()-1-domain->zoom_ibegin.getValue() ; start [1]=domain->zoom_jbegin_loc.getValue()+domain->jbegin.getValue()-1-domain->zoom_jbegin.getValue() ; start[0]=0 ;  
     500                   count[2]=domain->zoom_ni_loc.getValue() ; count[1]=domain->zoom_nj_loc.getValue() ; count[0] = axis->size.getValue(); 
     501                 } 
     502                 SuperClassWriter::writeData(field_data3D, fieldid, true, field->getNStep()-1,&start,&count ); 
     503                 SuperClassWriter::writeData(time_data, oss.str(), true, field->getNStep()-1 ); 
     504                 break; 
     505              } 
     506            } 
    418507             
    419508         } 
    … …  
    422511            ARRAY(double, 2) field_data2D (new CArray<double, 2>(grid->getLocalShape()/*, boost::c_storage_order()*/)); 
    423512            grid->outputField(field_data,  field_data2D); 
    424             SuperClassWriter::writeData(field_data2D, fieldid, true, field->getNStep()-1); 
    425             SuperClassWriter::writeData(time_data, oss.str(), true, field->getNStep()-1); 
     513            switch (SuperClass::type) 
     514            { 
     515              case (MULTI_FILE) : 
     516              { 
     517                SuperClassWriter::writeData(field_data2D, fieldid, true, field->getNStep()-1); 
     518                SuperClassWriter::writeData(time_data, oss.str(), true, field->getNStep()-1); 
     519                break; 
     520              } 
     521              case (ONE_FILE) : 
     522              { 
     523                 std::vector<StdSize> start(2) ;  
     524                 std::vector<StdSize> count(2) ; 
     525                 if (domain->isEmpty()) 
     526                 { 
     527                   start[0]=0 ; start[1]=0 ; 
     528                   count[0]=0 ; count[1]=0 ; 
     529                 } 
     530                 else 
     531                 { 
     532                   start[1]=domain->zoom_ibegin_loc.getValue()+domain->ibegin.getValue()-1-domain->zoom_ibegin.getValue() ; start [0]=domain->zoom_jbegin_loc.getValue()+domain->jbegin.getValue()-1-domain->zoom_jbegin.getValue() ;  
     533                   count[1]=domain->zoom_ni_loc.getValue() ; count[0]=domain->zoom_nj_loc.getValue() ;  
     534                 } 
     535                 SuperClassWriter::writeData(field_data2D, fieldid, true, field->getNStep()-1,&start,&count); 
     536                 SuperClassWriter::writeData(time_data, oss.str(), true, field->getNStep()-1); 
     537                 break; 
     538               
     539              } 
     540            } 
    426541         } 
    427542      } 
Note: See TracChangeset for help on using the changeset viewer.