source: XIOS/dev/branch_yushan_merged/src/io/onetcdf4.cpp @ 1157

Last change on this file since 1157 was 1157, checked in by yushan, 5 years ago

branch re-merged with trunk @1156

  • Property copyright set to
    Software name : XIOS (Xml I/O Server)
    http://forge.ipsl.jussieu.fr/ioserver
    Creation date : January 2009
    Licence : CeCCIL version2
    see license file in root directory : Licence_CeCILL_V2-en.txt
    or http://www.cecill.info/licences/Licence_CeCILL_V2-en.html
    Holder : CEA/LSCE (Laboratoire des Sciences du CLimat et de l'Environnement)
    CNRS/IPSL (Institut Pierre Simon Laplace)
    Project Manager : Yann Meurdesoif
    yann.meurdesoif@cea.fr
File size: 22.8 KB
Line 
1#include <fstream>
2
3#include "onetcdf4.hpp"
4#include "group_template.hpp"
5#include "netcdf.hpp"
6#include "netCdfInterface.hpp"
7#include "netCdfException.hpp"
8#include "timer.hpp"
9// mpi_std.hpp
10
11namespace xios
12{
13      /// ////////////////////// Définitions ////////////////////// ///
14
15      CONetCDF4::CONetCDF4(const StdString& filename, bool append, bool useClassicFormat, bool useCFConvention, 
16                           const MPI_Comm* comm, bool multifile, const StdString& timeCounterName)
17        : path()
18        , wmpi(false)
19        , useClassicFormat(useClassicFormat)
20        , useCFConvention(useCFConvention)
21      {
22         this->initialize(filename, append, useClassicFormat, useCFConvention, comm, multifile, timeCounterName);
23      }
24
25      //---------------------------------------------------------------
26
27      CONetCDF4::~CONetCDF4(void)
28      {
29      }
30
31      ///--------------------------------------------------------------
32
33      void CONetCDF4::initialize(const StdString& filename, bool append, bool useClassicFormat, bool useCFConvention, 
34                                 const MPI_Comm* comm, bool multifile, const StdString& timeCounterName)
35      {
36         this->useClassicFormat = useClassicFormat;
37         this->useCFConvention = useCFConvention;
38
39         int mode = useClassicFormat ? 0 : NC_NETCDF4;
40
41         // Don't use parallel mode if there is only one process
42         if (comm)
43         {
44            int commSize = 0;
45            MPI_Comm_size(*comm, &commSize);
46            if (commSize <= 1)
47               comm = NULL;
48         }
49         wmpi = comm && !multifile;
50
51         if (wmpi)
52            mode |= useClassicFormat ? NC_PNETCDF : NC_MPIIO;
53
54         // If the file does not exist, we always create it
55         if (!append || !std::ifstream(filename.c_str()))
56         {
57            CTimer::get("Files : create").resume();
58            if (wmpi)
59               CNetCdfInterface::createPar(filename, mode, *comm, MPI_INFO_NULL_STD, this->ncidp);
60            else
61               CNetCdfInterface::create(filename, mode, this->ncidp);
62            CTimer::get("Files : create").suspend();
63 
64            this->appendMode = false;
65         }
66         else
67         {
68            mode |= NC_WRITE;
69            CTimer::get("Files : open").resume();
70            if (wmpi)
71               //CNetCdfInterface::openPar(filename, mode, static_cast<MPI_Comm>(comm->mpi_comm), MPI_INFO_NULL_STD, this->ncidp);
72               CNetCdfInterface::openPar(filename, mode, *comm, MPI_INFO_NULL_STD, this->ncidp);
73            else
74               CNetCdfInterface::open(filename, mode, this->ncidp);
75            CTimer::get("Files : open").suspend();
76            this->appendMode = true;
77         }
78
79         // If the classic NetCDF format is used, we enable the "no-fill mode" globally.
80         // This is done per variable for the NetCDF4 format.
81         if (useClassicFormat)
82            CNetCdfInterface::setFill(this->ncidp, false);
83
84         this->timeCounterName = timeCounterName;
85      }
86
87      void CONetCDF4::close()
88      {
89        CTimer::get("Files : close").resume();
90        CNetCdfInterface::close(this->ncidp);
91        CTimer::get("Files : close").suspend();
92      }
93
94      //---------------------------------------------------------------
95
96      void CONetCDF4::definition_start(void)
97      {
98         CNetCdfInterface::reDef(this->ncidp);
99      }
100
101      //---------------------------------------------------------------
102
103      void CONetCDF4::definition_end(void)
104      {
105         CNetCdfInterface::endDef(this->ncidp);
106      }
107
108      //---------------------------------------------------------------
109
110      int CONetCDF4::getCurrentGroup(void)
111      {
112         return this->getGroup(this->getCurrentPath());
113      }
114
115      //---------------------------------------------------------------
116
117      int CONetCDF4::getGroup(const CONetCDF4Path& path)
118      {
119         int retvalue = this->ncidp;
120
121         CONetCDF4Path::const_iterator it = path.begin(), end = path.end();
122
123         for (; it != end; it++)
124         {
125            const StdString& groupid = *it;
126            CNetCdfInterface::inqNcId(retvalue, groupid, retvalue);
127         }
128         return retvalue;
129      }
130
131      //---------------------------------------------------------------
132
133      int CONetCDF4::getVariable(const StdString& varname)
134      {
135         int varid = 0;
136         int grpid = this->getCurrentGroup();
137         CNetCdfInterface::inqVarId(grpid, varname, varid);
138         return varid;
139      }
140
141      //---------------------------------------------------------------
142
143      int CONetCDF4::getDimension(const StdString& dimname)
144      {
145         int dimid = 0;
146         int grpid = this->getCurrentGroup();
147         CNetCdfInterface::inqDimId(grpid, dimname, dimid);
148         return dimid;
149      }
150
151      //---------------------------------------------------------------
152
153      int CONetCDF4::getUnlimitedDimension(void)
154      {
155         int dimid = 0;
156         int grpid = this->getCurrentGroup();
157         CNetCdfInterface::inqUnLimDim(grpid, dimid);
158         return dimid;
159      }
160
161      StdString CONetCDF4::getUnlimitedDimensionName(void)
162      {
163         int grpid = this->getGroup(path);
164         int dimid = this->getUnlimitedDimension();
165
166         StdString dimname;
167         if (dimid != -1)
168           CNetCdfInterface::inqDimName(grpid, dimid, dimname);
169         return dimname;
170      }
171
172      //---------------------------------------------------------------
173
174      std::vector<StdSize> CONetCDF4::getDimensions(const StdString& varname)
175      {
176         StdSize size = 0;
177         std::vector<StdSize> retvalue;
178         int grpid = this->getCurrentGroup();
179         int varid = this->getVariable(varname);
180         int nbdim = 0, *dimid = NULL;
181
182         CNetCdfInterface::inqVarNDims(grpid, varid, nbdim);
183         dimid = new int[nbdim]();
184         CNetCdfInterface::inqVarDimId(grpid, varid, dimid);
185
186         for (int i = 0; i < nbdim; i++)
187         {
188            CNetCdfInterface::inqDimLen(grpid, dimid[i], size);
189            if (size == NC_UNLIMITED)
190                size = UNLIMITED_DIM;
191            retvalue.push_back(size);
192         }
193         delete [] dimid;
194         return retvalue;
195      }
196
197      std::vector<std::string> CONetCDF4::getDimensionsIdList(const std::string* _varname)
198      {
199         int nDimNull = 0;
200         int nbdim = 0, *dimid = NULL;
201         int grpid = this->getCurrentGroup();
202         int varid = (_varname != NULL) ? this->getVariable(*_varname) : NC_GLOBAL;
203         std::vector<std::string> retvalue;
204
205         if (_varname != NULL)
206         {
207            CNetCdfInterface::inqVarNDims(grpid, varid, nbdim);
208            dimid = new int[nbdim]();
209            CNetCdfInterface::inqVarDimId(grpid, varid, dimid);
210         }
211         else
212         {
213            CNetCdfInterface::inqDimIds(grpid, nbdim, NULL, 1);
214            dimid = new int[nbdim]();
215            CNetCdfInterface::inqDimIds(grpid, nDimNull, dimid, 1);
216         }
217
218         for (int i = 0; i < nbdim; i++)
219         {
220            std::string dimname;
221            CNetCdfInterface::inqDimName(grpid, dimid[i], dimname);
222            retvalue.push_back(dimname);
223         }
224         delete [] dimid;
225
226         return retvalue;
227      }
228
229      //---------------------------------------------------------------
230
231      void CONetCDF4::getTimeAxisBounds(CArray<double,2>& timeAxisBounds, const StdString& name, bool collective)
232      {
233        int grpid = this->getCurrentGroup();
234        int varid = this->getVariable(name);
235
236        std::vector<StdSize> start(2), count(2);
237        start[0] = 0;
238        // Find out how many temporal records have been written already to the file we are opening
239        int ncUnlimitedDimId;
240        CNetCdfInterface::inqUnLimDim(this->ncidp, ncUnlimitedDimId);
241        CNetCdfInterface::inqDimLen(this->ncidp, ncUnlimitedDimId, count[0]);
242        start[1] = 0;
243        count[1] = 2;
244
245        timeAxisBounds.resize(count[1], count[0]);
246
247        if (this->wmpi && collective)
248          CNetCdfInterface::varParAccess(grpid, varid, NC_COLLECTIVE);
249        if (this->wmpi && !collective)
250          CNetCdfInterface::varParAccess(grpid, varid, NC_INDEPENDENT);
251
252        CNetCdfInterface::getVaraType(grpid, varid, &start[0], &count[0], timeAxisBounds.dataFirst());
253      }
254
255      void CONetCDF4::getTimeAxisBounds(CArray<double,2>& timeAxisBounds, const StdString& name, bool collective, size_t record)
256      {
257        int grpid = this->getCurrentGroup();
258        int varid = this->getVariable(name);
259
260        std::vector<StdSize> start(2), count(2);
261        start[0] = record;
262        count[0] = 1 ;
263        start[1] = 0;
264        count[1] = 2;
265
266        timeAxisBounds.resize(2, 1);
267
268        if (this->wmpi && collective)
269          CNetCdfInterface::varParAccess(grpid, varid, NC_COLLECTIVE);
270        if (this->wmpi && !collective)
271          CNetCdfInterface::varParAccess(grpid, varid, NC_INDEPENDENT);
272
273        CNetCdfInterface::getVaraType(grpid, varid, &start[0], &count[0], timeAxisBounds.dataFirst());
274      }
275
276
277
278      const CONetCDF4::CONetCDF4Path& CONetCDF4::getCurrentPath(void) const
279      { return this->path; }
280
281      void CONetCDF4::setCurrentPath(const CONetCDF4Path& path)
282      { this->path = path; }
283
284      //---------------------------------------------------------------
285
286      int CONetCDF4::addGroup(const StdString& name)
287      {
288         int retvalue = 0;
289         int grpid = this->getCurrentGroup();
290         CNetCdfInterface::defGrp(grpid, name, retvalue);
291         return retvalue;
292      }
293
294      //---------------------------------------------------------------
295
296      int CONetCDF4::addDimension(const StdString& name, const StdSize size)
297      {
298         int retvalue = 0;
299         int grpid = this->getCurrentGroup();
300         if (size != UNLIMITED_DIM)
301            CNetCdfInterface::defDim(grpid, name, size, retvalue);
302         else
303            CNetCdfInterface::defDim(grpid, name, NC_UNLIMITED, retvalue);
304         return retvalue;
305      }
306
307      //---------------------------------------------------------------
308
309      int CONetCDF4::addVariable(const StdString& name, nc_type type,
310                                 const std::vector<StdString>& dim)
311      {
312         int varid = 0;
313         std::vector<int> dimids;
314         std::vector<StdSize> dimsizes;
315         int dimSize = dim.size();
316         
317         StdSize size;
318         StdSize totalSize;
319         StdSize maxSize = 1024 * 1024 * 256; // == 2GB/8 if output double
320
321         int grpid = this->getCurrentGroup();
322
323         std::vector<StdString>::const_iterator it = dim.begin(), end = dim.end();
324
325         for (int idx = 0; it != end; it++, ++idx)
326         {
327            const StdString& dimid = *it;
328            dimids.push_back(this->getDimension(dimid));
329            CNetCdfInterface::inqDimLen(grpid, this->getDimension(dimid), size);
330            if (size == NC_UNLIMITED) size = 1;
331            dimsizes.push_back(size);
332         }
333
334         CNetCdfInterface::defVar(grpid, name, type, dimids.size(), &dimids[0], varid);
335
336         // The classic NetCDF format does not support chunking nor fill parameters
337         if (!useClassicFormat)
338         {
339            // set chunksize : size of one record
340            // but must not be > 2GB (netcdf or HDF5 problem)
341            totalSize = 1;
342            for (vector<StdSize>::reverse_iterator it = dimsizes.rbegin(); it != dimsizes.rend(); ++it)
343            {
344              totalSize *= *it;
345              if (totalSize >= maxSize) *it = 1;
346            }
347            int storageType = (0 == dimSize) ? NC_CONTIGUOUS : NC_CHUNKED;
348            CNetCdfInterface::defVarChunking(grpid, varid, storageType, &dimsizes[0]);
349            CNetCdfInterface::defVarFill(grpid, varid, true, NULL);
350         }
351
352         return varid;
353      }
354
355      //---------------------------------------------------------------
356
357      void CONetCDF4::setCompressionLevel(const StdString& varname, int compressionLevel)
358      {
359         if (compressionLevel < 0 || compressionLevel > 9)
360           ERROR("void CONetCDF4::setCompressionLevel(const StdString& varname, int compressionLevel)",
361                 "Invalid compression level for variable \"" << varname << "\", the value should range between 0 and 9.");
362         if (compressionLevel && wmpi)
363           ERROR("void CONetCDF4::setCompressionLevel(const StdString& varname, int compressionLevel)",
364                 "Impossible to use compression for variable \"" << varname << "\" when using parallel mode.");
365
366         int grpid = this->getCurrentGroup();
367         int varid = this->getVariable(varname);
368         CNetCdfInterface::defVarDeflate(grpid, varid, compressionLevel);
369      }
370
371      //---------------------------------------------------------------
372
373      template <>
374      void CONetCDF4::addAttribute(const StdString& name, const StdString& value, const StdString* varname)
375      {
376         int grpid = this->getCurrentGroup();
377         int varid = (varname == NULL) ? NC_GLOBAL : this->getVariable(*varname);
378         CNetCdfInterface::putAttType(grpid, varid, name, value.size(), value.c_str());
379      }
380
381      //---------------------------------------------------------------
382
383      template <>
384      void CONetCDF4::addAttribute(const StdString& name, const double& value, const StdString* varname)
385      {
386         int grpid = this->getCurrentGroup();
387         int varid = (varname == NULL) ? NC_GLOBAL : this->getVariable(*varname);
388         CNetCdfInterface::putAttType(grpid, varid, name, 1, &value);
389      }
390
391      template <>
392      void CONetCDF4::addAttribute(const StdString& name, const CArray<double,1>& value, const StdString* varname)
393      {
394         int grpid = this->getCurrentGroup();
395         int varid = (varname == NULL) ? NC_GLOBAL : this->getVariable(*varname);
396         CNetCdfInterface::putAttType(grpid, varid, name, value.numElements(), value.dataFirst());
397      }
398      //---------------------------------------------------------------
399
400      template <>
401      void CONetCDF4::addAttribute(const StdString& name, const float& value, const StdString* varname)
402      {
403         int grpid = this->getCurrentGroup();
404         int varid = (varname == NULL) ? NC_GLOBAL : this->getVariable(*varname);
405         CNetCdfInterface::putAttType(grpid, varid, name, 1, &value);
406      }
407
408      template <>
409      void CONetCDF4::addAttribute(const StdString& name, const CArray<float,1>& value, const StdString* varname)
410      {
411         int grpid = this->getCurrentGroup();
412         int varid = (varname == NULL) ? NC_GLOBAL : this->getVariable(*varname);
413         CNetCdfInterface::putAttType(grpid, varid, name, value.numElements(), value.dataFirst());
414      }
415
416      //---------------------------------------------------------------
417
418      template <>
419      void CONetCDF4::addAttribute(const StdString& name, const int& value, const StdString* varname)
420      {
421         int grpid = this->getCurrentGroup();
422         int varid = (varname == NULL) ? NC_GLOBAL : this->getVariable(*varname);
423         CNetCdfInterface::putAttType(grpid, varid, name, 1, &value);
424      }
425
426      template <>
427      void CONetCDF4::addAttribute(const StdString& name, const CArray<int,1>& value, const StdString* varname)
428      {
429         int grpid = this->getCurrentGroup();
430         int varid = (varname == NULL) ? NC_GLOBAL : this->getVariable(*varname);
431         CNetCdfInterface::putAttType(grpid, varid, name, value.numElements(), value.dataFirst());
432      }
433
434      template <>
435      void CONetCDF4::addAttribute(const StdString& name, const short int& value, const StdString* varname)
436      {
437         int grpid = this->getCurrentGroup();
438         int varid = (varname == NULL) ? NC_GLOBAL : this->getVariable(*varname);
439         CNetCdfInterface::putAttType(grpid, varid, name, 1, &value);
440      }
441
442      template <>
443      void CONetCDF4::addAttribute(const StdString& name, const CArray<short int,1>& value, const StdString* varname)
444      {
445         int grpid = this->getCurrentGroup();
446         int varid = (varname == NULL) ? NC_GLOBAL : this->getVariable(*varname);
447         CNetCdfInterface::putAttType(grpid, varid, name, value.numElements(), value.dataFirst());
448      }
449
450      template <>
451      void CONetCDF4::addAttribute(const StdString& name, const long int& value, const StdString* varname)
452      {
453         int grpid = this->getCurrentGroup();
454         int varid = (varname == NULL) ? NC_GLOBAL : this->getVariable(*varname);
455         CNetCdfInterface::putAttType(grpid, varid, name, 1, &value);
456      }
457
458      template <>
459      void CONetCDF4::addAttribute(const StdString& name, const CArray<long int,1>& value, const StdString* varname)
460      {
461         int grpid = this->getCurrentGroup();
462         int varid = (varname == NULL) ? NC_GLOBAL : this->getVariable(*varname);
463         CNetCdfInterface::putAttType(grpid, varid, name, value.numElements(), value.dataFirst());
464      }
465
466      //---------------------------------------------------------------
467
468      void CONetCDF4::getWriteDataInfos(const StdString& name, StdSize record, StdSize& array_size,
469                                        std::vector<StdSize>& sstart,
470                                        std::vector<StdSize>& scount,
471                                        const std::vector<StdSize>* start,
472                                        const std::vector<StdSize>* count)
473      {
474         std::vector<std::size_t> sizes  = this->getDimensions(name);
475         if (sizes.size()==0) 
476         {
477            array_size=1 ;
478            sstart.push_back(0);
479            scount.push_back(1);
480         }
481         else
482         {
483           std::vector<std::string> iddims = this->getDimensionsIdList (&name);
484           std::vector<std::size_t>::const_iterator
485           it  = sizes.begin(), end = sizes.end();
486           int i = 0;
487
488           if (iddims.begin()->compare(timeCounterName) == 0)
489           {
490             sstart.push_back(record);
491             scount.push_back(1);
492              if ((start == NULL) &&
493                  (count == NULL)) i++;
494              it++;
495           }
496
497           for (;it != end; it++)
498           {
499              if ((start != NULL) && (count != NULL))
500              {
501                 sstart.push_back((*start)[i]);
502                 scount.push_back((*count)[i]);
503                 array_size *= (*count)[i];
504                 i++;
505              }
506              else
507              {
508                 sstart.push_back(0);
509                 scount.push_back(sizes[i]);
510                 array_size *= sizes[i];
511                 i++;
512              }
513           }
514
515         }
516      }
517
518
519      template <>
520      void CONetCDF4::writeData_(int grpid, int varid,
521                                 const std::vector<StdSize>& sstart,
522                                 const std::vector<StdSize>& scount, const double* data)
523      {
524         CNetCdfInterface::putVaraType(grpid, varid, &sstart[0], &scount[0], data);
525      }
526
527      //---------------------------------------------------------------
528
529      template <>
530      void CONetCDF4::writeData_(int grpid, int varid,
531                                 const std::vector<StdSize>& sstart,
532                                 const std::vector<StdSize>& scount, char* data)
533      {
534          CNetCdfInterface::putVaraType(grpid, varid, &sstart[0], &scount[0], data);
535      }
536     
537      template <>
538
539      void CONetCDF4::writeData_(int grpid, int varid,
540                                 const std::vector<StdSize>& sstart,
541                                 const std::vector<StdSize>& scount, const int* data)
542      {
543         CNetCdfInterface::putVaraType(grpid, varid, &sstart[0], &scount[0], data);
544      }
545
546      //---------------------------------------------------------------
547
548      template <>
549      void CONetCDF4::writeData_(int grpid, int varid,
550                                 const std::vector<StdSize>& sstart,
551                                 const std::vector<StdSize>& scount, const float* data)
552      {
553         CNetCdfInterface::putVaraType(grpid, varid, &sstart[0], &scount[0], data);
554      }
555
556      //---------------------------------------------------------------
557
558      void CONetCDF4::writeData(const CArray<int, 2>& data, const StdString& name)
559      {
560         int grpid = this->getCurrentGroup();
561         int varid = this->getVariable(name);
562         StdSize array_size = 1;
563         std::vector<StdSize> sstart, scount;
564
565         this->getWriteDataInfos(name, 0, array_size,  sstart, scount, NULL, NULL);
566
567         this->writeData_(grpid, varid, sstart, scount, data.dataFirst());
568
569      }
570
571      void CONetCDF4::writeTimeAxisData(const CArray<double, 1>& data, const StdString& name,
572                                        bool collective, StdSize record, bool isRoot)
573      {
574         int grpid = this->getCurrentGroup();
575         int varid = this->getVariable(name);
576
577         map<int,size_t>::iterator it=timeAxis.find(varid);
578         if (it == timeAxis.end()) timeAxis[varid] = record;
579         else
580         {
581           if (it->second >= record) return;
582           else it->second =record;
583         }
584
585         StdSize array_size = 1;
586         std::vector<StdSize> sstart, scount;
587
588         if (this->wmpi && collective)
589            CNetCdfInterface::varParAccess(grpid, varid, NC_COLLECTIVE);
590         if (this->wmpi && !collective)
591            CNetCdfInterface::varParAccess(grpid, varid, NC_INDEPENDENT);
592
593         this->getWriteDataInfos(name, record, array_size,  sstart, scount, NULL, NULL);
594         this->writeData_(grpid, varid, sstart, scount, data.dataFirst());
595       }
596
597      void CONetCDF4::writeTimeAxisDataBounds(const CArray<double, 1>& data, const StdString& name,
598                                        bool collective, StdSize record, bool isRoot)
599      {
600         int grpid = this->getCurrentGroup();
601         int varid = this->getVariable(name);
602
603         map<int,size_t>::iterator it=timeAxis.find(varid);
604         if (it == timeAxis.end()) timeAxis[varid] = record;
605         else
606         {
607           if (it->second >= record) return;
608           else it->second =record;
609         }
610
611         StdSize array_size = 1;
612         std::vector<StdSize> sstart, scount;
613
614         if (this->wmpi && collective)
615            CNetCdfInterface::varParAccess(grpid, varid, NC_COLLECTIVE);
616         if (this->wmpi && !collective)
617            CNetCdfInterface::varParAccess(grpid, varid, NC_INDEPENDENT);
618
619         this->getWriteDataInfos(name, record, array_size,  sstart, scount, NULL, NULL);
620         this->writeData_(grpid, varid, sstart, scount, data.dataFirst());
621       }
622
623
624      //---------------------------------------------------------------
625
626      bool CONetCDF4::varExist(const StdString& varname)
627      {
628         int grpid = this->getCurrentGroup();
629         return CNetCdfInterface::isVarExisted(grpid, varname);
630      }
631
632      bool CONetCDF4::dimExist(const StdString& dimname)
633      {
634         int grpid = this->getCurrentGroup();
635         return CNetCdfInterface::isDimExisted(grpid, dimname);
636      }
637
638      void CONetCDF4::sync(void)
639      {
640         CNetCdfInterface::sync(this->ncidp);
641      }
642      ///--------------------------------------------------------------
643 } // namespace xios
Note: See TracBrowser for help on using the repository browser.