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

Location:
XMLIO_V2/dev/common/src/xmlio/output
Files:
4 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      } 

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

    r219 r286  
    2727               (const StdString & filename, bool exist); 
    2828            CNc4DataOutput 
    29                (const StdString & filename, bool exist, bool multigroup, MPI_Comm comm_server); 
    30             CNc4DataOutput 
    31                (const StdString & filename, bool exist, bool multigroup, comm::MPIComm comm_server, bool); 
     29               (const StdString & filename, bool exist, MPI_Comm comm_server, bool multifile); 
    3230 
    3331            CNc4DataOutput(const CNc4DataOutput & dataoutput);       // Not implemented. 
    … …  
    4846            virtual void writeFieldData_ (const boost::shared_ptr<tree::CField>    field); 
    4947            virtual void writeFile_      (const boost::shared_ptr<tree::CFile>     file); 
     48            virtual void closeFile_      (void); 
    5049            virtual void writeTimeAxis_  (const boost::shared_ptr<tree::CField>    field, 
    5150                                          const boost::shared_ptr<date::CCalendar> cal); 

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

    r274 r286  
    11#include "onetcdf4.hpp" 
    22#include "group_template_impl.hpp" 
     3#include "mpi_manager.hpp" 
    34 
    45namespace xmlioserver 
    … …  
    910 
    1011      CONetCDF4::CONetCDF4 
    11          (const StdString & filename, bool exist, const MPI_Comm * comm) 
     12         (const StdString & filename, bool exist, const MPI_Comm * comm, bool multifile) 
    1213            : path() 
    1314      { 
    14          this->wmpi = (comm != NULL); 
    15          this->initialize(filename, exist, comm); 
    16       } 
    17        
    18       //--------------------------------------------------------------- 
    19        
    20       CONetCDF4::CONetCDF4 
    21          (const StdString & filename, bool exist, const comm::MPIComm * comm, bool) 
    22          : path() 
    23       { 
    24          this->wmpi = (comm != NULL); 
    25          MPI_Comm * null_comm = NULL; 
    26          if (comm == NULL) 
    27             this->initialize(filename, exist, null_comm); 
    28          else 
    29          { 
    30             MPI_Comm comm_c = MPI_Comm_f2c(*comm); 
    31             this->initialize(filename, exist, &comm_c); 
    32          } 
    33       } 
    34        
    35       //--------------------------------------------------------------- 
    36        
     15         this->wmpi = (comm != NULL) && !multifile; 
     16         this->initialize(filename, exist, comm,multifile); 
     17      } 
     18       
     19      //--------------------------------------------------------------- 
     20       
     21       
     22 
    3723      CONetCDF4::~CONetCDF4(void) 
    3824      { 
    39          CheckError(nc_close(this->ncidp)); 
     25//         CheckError(nc_close(this->ncidp)); 
    4026      } 
    4127 
    … …  
    4329 
    4430      void CONetCDF4::initialize 
    45          (const StdString & filename, bool exist, const MPI_Comm * comm) 
     31         (const StdString & filename, bool exist, const MPI_Comm * comm, bool multifile) 
    4632      { 
    4733         if (!exist) 
    … …  
    4935            if (comm != NULL) 
    5036            { 
    51                CheckError(nc_create_par 
    52                   (filename.c_str(), NC_NETCDF4|NC_MPIIO, *comm, MPI_INFO_NULL, &this->ncidp)); 
     37               if (!multifile) CheckError(nc_create_par(filename.c_str(), NC_NETCDF4|NC_MPIIO, *comm, MPI_INFO_NULL, &this->ncidp)); 
     38               else CheckError(nc_create(filename.c_str(), NC_NETCDF4, &this->ncidp)); 
    5339            } 
    5440            else CheckError(nc_create(filename.c_str(), NC_NETCDF4, &this->ncidp)); 
    … …  
    5743         { 
    5844            if (comm != NULL) 
    59                CheckError(nc_open_par 
    60                   (filename.c_str(), NC_NETCDF4|NC_MPIIO, *comm, MPI_INFO_NULL, &this->ncidp)); 
     45            { 
     46               if (!multifile) CheckError(nc_open_par(filename.c_str(), NC_NETCDF4|NC_MPIIO, *comm, MPI_INFO_NULL, &this->ncidp)); 
     47               else CheckError(nc_open(filename.c_str(), NC_NETCDF4, &this->ncidp)); 
     48            } 
    6149            else  CheckError(nc_open(filename.c_str(), NC_NETCDF4, &this->ncidp)); 
    6250         } 
     51      } 
     52       
     53      void CONetCDF4::close() 
     54      { 
     55        CheckError(nc_close(this->ncidp)); 
    6356      } 
    6457       
    … …  
    262255            dimids.push_back(this->getDimension(dimid)); 
    263256         } 
     257         std::cout<<"--> Var "<<name.c_str()<<std::endl ; 
    264258         CheckError(nc_def_var (grpid, name.c_str(), type, dimids.size(), &(dimids[0]), &retvalue)); 
    265259         return (retvalue); 
    … …  
    352346         } 
    353347          
    354           
     348//         if (iddims.begin()->compare(this->getUnlimitedDimensionName()) == 0) 
     349//         { 
     350//            if (array_size==0) scount[0]=0 ; 
     351//         }          
    355352//         for (StdSize u = 0; u < sstart.size(); u++) 
    356353//            std::cout << "(" << sstart[u] << "," << scount[u]  << ")" ; 
    … …  
    366363      { 
    367364         CheckError(nc_put_vara_double(grpid, varid, &(sstart[0]), &(scount[0]), data)); 
     365//         sync() ; 
    368366      } 
    369367       
    … …  
    376374      { 
    377375          CheckError(nc_put_vara_int(grpid, varid, &(sstart[0]), &(scount[0]), data)); 
     376//          sync() ; 
    378377      } 
    379378       
    … …  
    386385      { 
    387386          CheckError(nc_put_vara_float(grpid, varid, &(sstart[0]), &(scount[0]), data)); 
     387//          sync() ; 
    388388      } 
    389389 
    … …  
    410410      } 
    411411 
     412      void CONetCDF4::sync(void) 
     413      { 
     414         
     415         comm::CMPIManager::Barrier(comm::CMPIManager::GetCommServer()); 
     416         CheckError(nc_sync(this->ncidp)) ; 
     417      }  
    412418      ///-------------------------------------------------------------- 
    413419   } // namespace io 

  • XMLIO_V2/dev/common/src/xmlio/output/onetcdf4.hpp

    r266 r286  
    3535 
    3636            /// Constructeurs /// 
    37             CONetCDF4(const StdString & filename, bool exist, const MPI_Comm * comm = NULL); 
    38             CONetCDF4(const StdString & filename, bool exist, const comm::MPIComm * comm, bool); 
     37            CONetCDF4(const StdString & filename, bool exist, const MPI_Comm * comm = NULL, bool multifile=true); 
    3938 
    4039            CONetCDF4(const CONetCDF4 & onetcdf4);       // Not implemented. 
    … …  
    4342 
    4443            /// Initialisation /// 
    45             void initialize(const StdString & filename, bool exist, const MPI_Comm * comm); 
     44            void initialize(const StdString & filename, bool exist, const MPI_Comm * comm, bool multifile); 
     45            void close(void) ; 
     46            void sync(void) ; 
    4647            void definition_start(void); 
    4748            void definition_end(void); 
Note: See TracChangeset for help on using the changeset viewer.