source: XIOS/trunk/src/output/netCdfInterface.cpp @ 501

Last change on this file since 501 was 501, checked in by ymipsl, 8 years ago

Add licence copyright to all file ond directory src using the command :
svn propset -R copyright -F header_licence src

XIOS is now officialy under CeCILL licence

YM

  • 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: 25.7 KB
Line 
1/*!
2   \file netCdfInterface.cpp
3   \author Ha NGUYEN
4   \date 08 Oct 2014
5   \since 03 Oct 2014
6
7   \brief Wrapper of netcdf functions.
8 */
9
10 #include "netCdfInterface.hpp"
11 #include "netCdfException.hpp"
12
13 namespace xios
14 {
15   /*!
16   This function creates a new netcdf file and return its id
17   \param [in] fileName Name of the file
18   \param [in] cMode create mode
19   \param [in/out] ncId id of the created file
20   \return Status code
21   */
22   int CNetCdfInterface::create(const StdString& fileName, int cMode, int& ncId)
23   {
24     int status = nc_create((fileName.c_str()), cMode, &ncId);
25     if (NC_NOERR != status)
26     {
27       StdString errormsg(nc_strerror(status));
28       StdStringStream sstr;
29       sstr << "Error in calling function : nc_create((fileName.c_str()), cMode, &ncId) " << std::endl
30            << errormsg << std::endl
31            << "Unable to create file, given its name : " << fileName
32            << "and its creation mode " << creationMode2String(cMode) << std::endl;
33       StdString e = sstr.str();
34       throw CNetCdfException(e);
35     }
36
37     return status;
38   }
39
40   /*!
41   This function creates a new netcdf file on parallel file system
42   \param [in] fileName Name of the file
43   \param [in] cMode create mode
44   \param [in] comm MPI communicator
45   \param [in] info MPI information
46   \param [in/out] ncId id of the created file
47   \return Status code
48   */
49   int CNetCdfInterface::createPar(const StdString& fileName, int cMode, MPI_Comm comm, MPI_Info info, int& ncId)
50   {
51     int status = ::nc_create_par((fileName.c_str()), cMode, comm, info, &ncId);
52     if (NC_NOERR != status)
53     {
54       StdString errormsg(nc_strerror(status));
55       StdStringStream sstr;
56       sstr << "Error in calling function : nc_create_par((fileName.c_str()), cMode, comm, info, &ncId) " << std::endl
57            << errormsg << std::endl
58            << "Unable to create file on parallel filesys, given its name : " << std::endl
59            << "and its creation mode " << creationMode2String(cMode) << std::endl;
60       StdString e = sstr.str();
61       throw CNetCdfException(e);
62     }
63
64     return status;
65   }
66
67   /*!
68   This function opens a netcdf file, given its name and open mode, return its id
69   \param [in] fileName Name of the file
70   \param [in] oMode open mode
71   \param [in/out] ncId id of the opening file
72   \return Status code
73   */
74   int CNetCdfInterface::open(const StdString& fileName, int oMode, int& ncId)
75   {
76     int status = nc_open((fileName.c_str()), oMode, &ncId);
77     if (NC_NOERR != status)
78     {
79       StdString errormsg(nc_strerror(status));
80       StdStringStream sstr;
81       sstr << "Error in calling function : nc_open((fileName.c_str()), oMode, &ncId) "<< std::endl
82            << errormsg << std::endl
83            << "Unable to open file, given its name : " << fileName
84            << "and its open mode " << openMode2String(oMode) << std::endl;
85       StdString e = sstr.str();
86       throw CNetCdfException(e);
87     }
88
89     return status;
90   }
91
92
93   /*!
94   This function opens a new netcdf file on parallel file system
95   \param [in] fileName Name of the file
96   \param [in] oMode open mode
97   \param [in] comm MPI communicator
98   \param [in] info MPI information
99   \param [in/out] ncId id of the opened file
100   \return Status code
101   */
102   int CNetCdfInterface::openPar(const StdString& fileName, int oMode, MPI_Comm comm, MPI_Info info, int& ncId)
103   {
104     int status = ::nc_open_par((fileName.c_str()), oMode, comm, info, &ncId);
105     if (NC_NOERR != status)
106     {
107       StdString errormsg(nc_strerror(status));
108       StdStringStream sstr;
109       sstr << "Error in calling function " << "nc_open_par((fileName.c_str()), oMode, comm, info, &ncId) " << std::endl
110            << errormsg << std::endl
111            << "Unable to open file on parallel filesys, given its name : " << fileName
112            << "and its open mode " << openMode2String(oMode) << std::endl;
113       StdString e = sstr.str();
114       throw CNetCdfException(e);
115     }
116
117     return status;
118   }
119
120   /*!
121   This function closes a netcdf file, given its id
122   \param [in] ncId id of the opening netcdf file
123   \return Status code
124   */
125   int CNetCdfInterface::close(int ncId)
126   {
127     int status = nc_close(ncId);
128     if (NC_NOERR != status)
129     {
130       StdString errormsg(nc_strerror(status));
131       StdStringStream sstr;
132       sstr << "Error in calling function " << "nc_close(ncId)" << std::endl
133            << errormsg << std::endl
134            << "Unable to close file, given its id : " << ncId << std::endl;
135       StdString e = sstr.str();
136       throw CNetCdfException(e);
137     }
138
139     return status;
140   }
141
142   /*!
143   This function put a netcdf file into define mode, given its id
144   \param [in] ncId id of the opening netcdf file to be put into define mode
145   \return Status code
146   */
147   int CNetCdfInterface::reDef(int ncId)
148   {
149     int status = nc_redef(ncId);
150     if (NC_NOERR != status)
151     {
152       StdString errormsg(nc_strerror(status));
153       StdStringStream sstr;
154       sstr << "Error in calling function " << "nc_redef(ncId)" << std::endl
155         << errormsg << std::endl
156         << "Unable to put this file into define mode given its id : " << ncId << std::endl;
157       StdString e = sstr.str();
158       throw CNetCdfException(e);
159     }
160
161     return status;
162   }
163
164   /*!
165   This function ends a netcdf file define mode, given its id
166   \param [in] ncId id of the opening netcdf file to be put into define mode
167   \return Status code
168   */
169   int CNetCdfInterface::endDef(int ncId)
170   {
171     int status = nc_enddef(ncId);
172     if (NC_NOERR != status)
173     {
174       StdString errormsg(nc_strerror(status));
175       StdStringStream sstr;
176
177       sstr << "Error in calling function " << "nc_enddef(ncId)" << std::endl
178            << errormsg << std::endl
179            << "Unable to end define mode of this file, given its id : " << ncId << std::endl;
180       StdString e = sstr.str();
181       throw CNetCdfException(e);
182     }
183
184     return status;
185   }
186
187   /*!
188   This function makes a request to netcdf with ncid and group name then return ncid of the named group
189   \param [in] ncid Groupd id (or File Id)
190   \param [in] grpName Name of the desired group (or file)
191   \param [in/out] grpId Group id if the group is found
192   \return Status code
193   */
194   int CNetCdfInterface::inqNcId(int ncid, const StdString& grpName, int& grpId)
195   {
196     int status = nc_inq_ncid(ncid, (grpName.c_str()), &grpId);
197     if (NC_NOERR != status)
198     {
199       StdString errormsg(nc_strerror(status));
200       StdStringStream sstr;
201
202       sstr << "Error in calling function " << "nc_inq_ncid(ncid, (grpName.c_str()), &grpId)" << std::endl
203            << errormsg << std::endl
204            << "Unable to get id of a group (File), given its name : " << grpName << std::endl;
205       StdString e = sstr.str();
206       throw CNetCdfException(e);
207     }
208
209     return status;
210   }
211
212
213   /*!
214   This function makes a request to netcdf with ncid and variable name then return ncid of the named variable
215   \param [in] ncid Groupd id (or File Id)
216   \param [in] varName Name of the desired variable
217   \param [in/out] varId Variable id if this variable is found
218   \return Status code
219   */
220   int CNetCdfInterface::inqVarId(int ncid,const StdString& varName, int& varId)
221   {
222     int status = nc_inq_varid(ncid, (varName.c_str()), &varId);
223     if (NC_NOERR != status)
224     {
225       StdString errormsg(nc_strerror(status));
226       StdStringStream sstr;
227
228       sstr << "Error in calling function : nc_inq_varid(ncid, (varName.c_str()), &varId)" << std::endl
229            << (errormsg) << std::endl
230            << "Unable to get id of variable with name : " << varName << std::endl;
231       StdString e = sstr.str();
232       throw CNetCdfException(e);
233     }
234
235     return status;
236   }
237
238  /*!
239   This function makes a request to netcdf with a netCdf dimension name then return ncid of the named dimension
240   \param [in] ncid Groupd id (or File Id)
241   \param [in] dimName Name of the desired dimension
242   \param [in/out] dimId Dimension id if this dimension is found
243   \return Status code
244   */
245   int CNetCdfInterface::inqDimId(int ncid,const StdString& dimName, int& dimId)
246   {
247     int status = nc_inq_dimid(ncid, (dimName.c_str()), &dimId);
248     if (NC_NOERR != status)
249     {
250       StdString errormsg(nc_strerror(status));
251       StdStringStream sstr;
252
253       sstr << "Error in calling function " << "nc_inq_dimid(ncid, (dimName.c_str()), &dimId)" << std::endl
254            << errormsg << std::endl
255            << "Unable to get id of dimension, given its name : " << dimName << std::endl;
256       StdString e = sstr.str();
257       throw CNetCdfException(e);
258     }
259
260     return status;
261   }
262
263  /*!
264   This function makes a request to netcdf with a netCdf dimension name then return ncid of the named dimension
265   \param [in] ncid Groupd id (or File Id)
266   \param [in/out] dimId Dimension id if this dimension is found
267   \return Status code
268   */
269   int CNetCdfInterface::inqUnLimDim(int ncid, int& dimId)
270   {
271     int status = nc_inq_unlimdim(ncid, &dimId);
272     if (NC_NOERR != status)
273     {
274       StdString errormsg(nc_strerror(status));
275       StdStringStream sstr;
276
277       sstr << "Error in calling function " << "nc_inq_dimid" << std::endl
278         << errormsg << std::endl
279         << "Unable to get id of unlimited dimension " << std::endl;
280       StdString e = sstr.str();
281       throw CNetCdfException(e);
282    }
283
284     return status;
285   }
286
287  /*!
288   This function makes a request to netcdf, returns name of a dimension, given its id
289   \param [in] ncid Groupd id (or File Id)
290   \param [in] dimId Id of desired dimension
291   \param [in/out] dimName Name of desired dimension
292   \return Status code
293   */
294   int CNetCdfInterface::inqDimName(int ncid, int dimId, StdString& dimName)
295   {
296     char fullNameIn[NC_MAX_NAME +1];
297     int status = nc_inq_dimname(ncid, dimId, fullNameIn);
298     if (NC_NOERR != status)
299     {
300       StdString errormsg(nc_strerror(status));
301       StdStringStream sstr;
302
303       sstr << "Error in calling function " << "nc_inq_dimname(ncid, dimId, fullNameIn)" << std::endl
304            << errormsg << std::endl
305            << "Unable to get dimension name from its id : " << dimId << std::endl;
306       StdString e = sstr.str();
307       throw CNetCdfException(e);
308     }
309     dimName = StdString(fullNameIn);
310     return status;
311   }
312
313  /*!
314   This function makes a request to netcdf, returns length of a dimension, given its id
315   \param [in] ncid Groupd id (or File Id)
316   \param [in] dimId Id of desired dimension
317   \param [in/out] dimLen Length of desired dimension
318   \return Status code
319   */
320   int CNetCdfInterface::inqDimLen(int ncid, int dimId, StdSize& dimLen)
321   {
322     int status = nc_inq_dimlen(ncid, dimId, &dimLen);
323     if (NC_NOERR != status)
324     {
325       StdString errormsg(nc_strerror(status));
326       StdStringStream sstr;
327
328       sstr << "Error in calling function " << "nc_inq_dimlen(ncid, dimId, &dimLen)" << std::endl
329            << errormsg << std::endl
330            << "Unable to get dimension length from its id: " << dimId << std::endl;
331       StdString e = sstr.str();
332       throw CNetCdfException(e);
333     }
334
335     return status;
336   }
337
338  /*!
339   This function makes a request to netcdf, returns number of dimensions of a variable, given its id
340   \param [in] ncid Groupd id (or File Id)
341   \param [in] varId Id of variable
342   \param [in/out] ndims number of dimension of the variable
343   \return Status code
344   */
345   int CNetCdfInterface::inqVarNDims(int ncid, int varId, int& nDims)
346   {
347     int status = nc_inq_varndims(ncid, varId, &nDims);
348     if (NC_NOERR != status)
349     {
350       StdString errormsg(nc_strerror(status));
351       StdStringStream sstr;
352
353       sstr << "Error in calling function " << "nc_inq_varndims(ncid, varId, &nDims)" << std::endl
354            << errormsg << std::endl
355            << "Unable to get the number of dimension of variable with Id : " << varId << std::endl;
356       StdString e = sstr.str();
357       throw CNetCdfException(e);
358     }
359
360     return status;
361   }
362
363  /*!
364   This function makes a request to netcdf, returns a list of dimension ID describing the shape of the variable, given its id
365   \param [in] ncid Groupd id (or File Id)
366   \param [in] varId Id of variable
367   \param [in/out] dimIds list of dimension of the variable
368   \return Status code
369   */
370   int CNetCdfInterface::inqVarDimId(int ncid, int varId, int* dimIds)
371   {
372     int status = nc_inq_vardimid(ncid, varId, dimIds);
373     if (NC_NOERR != status)
374     {
375       StdString errormsg(nc_strerror(status));
376       StdStringStream sstr;
377
378       sstr << "Error in calling function " << "nc_inq_vardimid(ncid, varId, dimIds)" << std::endl
379            << errormsg << std::endl
380            << "Unable to get list of dimension id of the variable with id " << varId << std::endl;
381       StdString e = sstr.str();
382       throw CNetCdfException(e);
383     }
384
385     return status;
386   }
387
388   /*!
389   This function makes a request to netcdf, to find all dimension in a group
390   \param [in] ncid Groupd id (or File Id)
391   \param [in/out] nDims number of list of dimension
392   \param [in/out] dimIds list of dimension in a group or any of its parent
393   \param [in] includeParents number of parents
394   \return Status code
395   */
396   int CNetCdfInterface::inqDimIds(int ncid, int& nDims, int* dimIds, int includeParents)
397   {
398     int status = nc_inq_dimids(ncid, &nDims, dimIds, includeParents);
399     if (NC_NOERR != status)
400     {
401       StdString errormsg(nc_strerror(status));
402       StdStringStream sstr;
403
404       sstr << "Error in calling function " << "nc_inq_dimids(ncid, &nDims, dimIds, includeParents)" << std::endl;
405       sstr << errormsg << std::endl;
406       sstr << "Unable to retrieve number of dimension in the group with id : " << ncid << std::endl;
407       sstr << "With number of Parents " << includeParents << std::endl;
408       StdString e = sstr.str();
409       throw CNetCdfException(e);
410     }
411
412     return status;
413   }
414
415   /*!
416   This function makes a request to netcdf with a id of a prent groupd and then return id of the created group, given its name
417   \param [in] parentNcid Id of parent groupd(or File Id)
418   \param [in] grpName Name of the desired group
419   \param [in/out] grpId Group id if this group is created sucessfully
420   \return Status code
421   */
422   int CNetCdfInterface::defGrp(int parentNcid, const StdString& grpName, int& grpId)
423   {
424     int status = nc_def_grp(parentNcid, (grpName.c_str()), &grpId);
425     if (NC_NOERR != status)
426     {
427       StdString errormsg(nc_strerror(status));
428       StdStringStream sstr;
429
430       sstr << "Error in calling function " << "nc_def_grp(parentNcid, (grpName.c_str()), &grpId)" << std::endl;
431       sstr << errormsg << std::endl;
432       sstr << "Unable to create group Id, given its name : " << grpName << std::endl;
433       StdString e = sstr.str();
434       throw CNetCdfException(e);
435     }
436
437     return status;
438   }
439
440   /*!
441   This function makes a request to netcdf, add a new dimension to an open netcdf in define mode
442   \param [in] ncid Id of groupd(or File Id)
443   \param [in] dimName Name of the desired dimension
444   \param [in/out] grpId Group id if this group is created sucessfully
445   \return Status code
446   */
447   int CNetCdfInterface::defDim(int ncid, const StdString& dimName, StdSize dimLen, int& dimId)
448   {
449     int status = nc_def_dim(ncid, (dimName.c_str()), dimLen, &dimId);
450     if (NC_NOERR != status)
451     {
452       StdString errormsg(nc_strerror(status));
453       StdStringStream sstr;
454
455       sstr << "Error in calling function " << "nc_def_dim(ncid, (dimName.c_str()), dimLen, &dimId)" << std::endl;
456       sstr << errormsg << std::endl;
457       sstr << "Unable to create dimension with name : " << dimName
458            << " and with length " << dimLen << std::endl;
459       StdString e = sstr.str();
460       throw CNetCdfException(e);
461     }
462
463     return status;
464   }
465
466   /*!
467   This function makes a request to netcdf with its id, to add a new variable to an open netCdf in define mode,
468   return a variable id, given its name, type, the number of dimensions and list of dimension id
469   \param [in] ncid Id of groupd(or File Id)
470   \param [in] varName Name of the desired dimension
471   \param [in] xtypes One of the set of predefined netCDF data types
472   \param [in] nDims Number of dimension for the variable
473   \param [in] dimIds List of ndims dimension ids corresponding to the variable dimensions
474   \param [in/out] varId Variable id if it is added sucessfully
475   \return Status code
476   */
477   int CNetCdfInterface::defVar(int ncid,const StdString& varName, nc_type xtype,
478                                int nDims, const int dimIds[], int& varId)
479   {
480     int status = nc_def_var(ncid, (varName.c_str()), xtype, nDims, dimIds, &varId);
481     if (NC_NOERR != status)
482     {
483       StdString errormsg(nc_strerror(status));
484       StdStringStream sstr;
485
486       sstr << "Error in calling function " << " nc_def_var(ncid, (varName.c_str()), xtype, nDims, dimIds, &varId)" << std::endl;
487       sstr << errormsg << std::endl;
488       sstr << "Unable to add a new variable with name : " << varName
489            << " with type " << xtype
490            << " and number of dimension " << nDims << std::endl;
491       StdString e = sstr.str();
492       throw CNetCdfException(e);
493     }
494
495     return status;
496   }
497
498   /*!
499   This function makes a request to netcdf with a ncid, to set the chunking size of a variable,
500   given variable id and type of storage
501   \param [in] ncid Id groupd(or File Id)
502   \param [in] varId Id of the variable
503   \param [in] storage Type of storage (It can be : NC_CONTIGUOUS, NC_CHUNKED)
504   \param [in/out] chunkSize array list of chunk sizes
505   \return Status code
506   */
507   int CNetCdfInterface::defVarChunking(int ncid, int varId, int storage, StdSize chunkSize[])
508   {
509     int status = nc_def_var_chunking(ncid, varId, storage, chunkSize);
510     if (NC_NOERR != status)
511     {
512       StdString errormsg(nc_strerror(status));
513       StdStringStream sstr;
514
515       sstr << "Error in calling function " << "nc_def_var_chunking(ncid, varId, storage, chunkSize)" << std::endl;
516       sstr << errormsg << std::endl;
517       sstr << "Unable to set chunk size of the variable with id : " << varId
518         << " and storage type " << storage << std::endl;
519       StdString e = sstr.str();
520       throw CNetCdfException(e);
521     }
522
523     return status;
524   }
525
526   /*!
527   This function makes a request to netcdf with a ncid, to set the fill parameters for a variable,
528   given variable id and type of fill
529   \param [in] ncid Id groupd(or File Id)
530   \param [in] varId Id of the variable
531   \param [in] noFill turn on/off nofill mode on a variable
532   \param [in/out] fillValue
533   \return Status code
534   */
535   int CNetCdfInterface::defVarFill(int ncid, int varId, int noFill, void* fillValue)
536   {
537     int status = nc_def_var_fill(ncid, varId, noFill, fillValue);
538     if (NC_NOERR != status)
539     {
540       StdString errormsg(nc_strerror(status));
541       StdStringStream sstr;
542
543       sstr << "Error in calling function " << "nc_def_var_fill(ncid, varId, noFill, fillValue)" << std::endl;
544       sstr << errormsg << std::endl;
545       sstr << "Unable to set fill parameters of the variable with id : " << varId
546         << " and fill option " << noFill << std::endl;
547       StdString e = sstr.str();
548       throw CNetCdfException(e);
549     }
550
551     return status;
552   }
553
554   /*!
555   This function makes a request to netcdf with a ncid, to change the way read/write operations are performed
556   collectively or independently on the variable.
557   \param [in] ncid Id groupd(or File Id)
558   \param [in] varId Id of the variable
559   \param [in] noFill turn on/off nofill mode on a variable
560   \param [in/out] fillValue
561   \return Status code
562   */
563   int CNetCdfInterface::varParAccess(int ncid, int varId, int access)
564   {
565     int status = nc_var_par_access(ncid, varId, access);
566     if (NC_NOERR != status)
567     {
568       StdString errormsg(nc_strerror(status));
569       StdStringStream sstr;
570
571       sstr << "Error in calling function " << "nc_var_par_access(ncid, varId, access)" << std::endl;
572       sstr << errormsg << std::endl;
573       sstr << "Unable to change read/write option of the variable with id : " << varId << std::endl;
574       StdString e = sstr.str();
575       throw CNetCdfException(e);
576     }
577
578     return status;
579   }
580
581   /*!
582   This function makes a synchronisation of the disk copy of a netCDF dataset.
583   \param [in] ncid Id groupd(or File Id)
584   \return Status code
585   */
586   int CNetCdfInterface::sync(int ncid)
587   {
588     int status = nc_sync(ncid);
589     if (NC_NOERR != status)
590     {
591       StdString errormsg(nc_strerror(status));
592       StdStringStream sstr;
593
594       sstr << "Error in calling function " << "nc_sync(ncid)" << std::endl;
595       sstr << errormsg << std::endl;
596       sstr << "Unable to make a synchronization of a netCDF file with id : " << ncid << std::endl;
597       StdString e = sstr.str();
598       throw CNetCdfException(e);
599     }
600
601     return status;
602   }
603
604   /*!
605   This function makes a request to netcdf with its id, to add or change a variable attribute or gloabl attribute,
606   given its name, type, number of values provided for attribute
607   \param [in] ncid Id of groupd(or File Id)
608   \param [in] varId Id of the variable
609   \param [in] attrName Name of the attribute
610   \param [in] xtypes One of the set of predefined netCDF data types
611   \param [in] numVal Number of values
612   \param [in] op Array of values provided for attribute
613   \return Status code
614   */
615   int CNetCdfInterface::putAtt(int ncid, int varId, const StdString& attrName, nc_type xtype,
616                                StdSize numVal, const void* op)
617   {
618     int status = nc_put_att(ncid, varId, (attrName.c_str()), xtype, numVal, op);
619     if (NC_NOERR != status)
620     {
621       StdString errormsg(nc_strerror(status));
622       StdStringStream sstr;
623
624       sstr << "Error in calling function " << "nc_put_att(ncid, varId, (attrName.c_str()), xtype, numVal, op)" << std::endl;
625       sstr << errormsg << std::endl;
626       sstr << "Unable to set attribute " << attrName << " for a variable with id : " << varId
627            << " with number of attribute  " << numVal
628            << " with type " << xtype << std::endl;
629       StdString e = sstr.str();
630       throw CNetCdfException(e);
631     }
632
633     return status;
634   }
635
636   // Some specilization of putAttributeType
637  template<>
638  int CNetCdfInterface::ncPutAttType(int ncid, int varid, const char* attrName,
639                                   StdSize numVal, const double* op)
640  {
641    return (nc_put_att_double(ncid, varid, attrName, NC_DOUBLE, numVal, op));
642  }
643
644  template<>
645  int CNetCdfInterface::ncPutAttType(int ncid, int varid, const char* attrName,
646                                     StdSize numVal, const float* op)
647  {
648    return (nc_put_att_float(ncid, varid, attrName, NC_FLOAT, numVal, op));
649  }
650
651  template<>
652  int CNetCdfInterface::ncPutAttType(int ncid, int varid, const char* attrName,
653                                     StdSize numVal, const int* op)
654  {
655    return (nc_put_att_int(ncid, varid, attrName, NC_INT, numVal, op));
656  }
657
658  template<>
659  int CNetCdfInterface::ncPutAttType(int ncid, int varid, const char* attrName,
660                                     StdSize numVal, const long* op)
661  {
662    return (nc_put_att_long(ncid, varid, attrName, NC_LONG, numVal, op));
663  }
664
665  template<>
666  int CNetCdfInterface::ncPutAttType(int ncid, int varid, const char* attrName,
667                                     StdSize numVal, const short* op)
668  {
669    return (nc_put_att_short(ncid, varid, attrName, NC_SHORT, numVal, op));
670  }
671
672
673  // Some specilization of putVariableType
674  template<>
675  int CNetCdfInterface::ncPutVaraType(int ncid, int varid, const StdSize* start, const StdSize* count, const double* op)
676  {
677    return (nc_put_vara_double(ncid, varid, start, count, op));
678  }
679
680  template<>
681  int CNetCdfInterface::ncPutVaraType(int ncid, int varid, const StdSize* start, const StdSize* count, const float* op)
682  {
683    return (nc_put_vara_float(ncid, varid, start, count, op));
684  }
685
686  template<>
687  int CNetCdfInterface::ncPutVaraType(int ncid, int varid, const StdSize* start, const StdSize* count, const int* op)
688  {
689    return (nc_put_vara_int(ncid, varid, start, count, op));
690  }
691
692   /*!
693   This function verifies an existence of a variable by using its name.
694   Be careful, althoug false means variable doens't exist, it could show that netCDF file doesn't either
695   \param [in] ncid Id of groupd(or File Id)
696   \param [in] attrName Name of the variable
697   \return Existence of variable
698   */
699  bool CNetCdfInterface::isVarExisted(int ncId, const StdString& varName)
700  {
701     int varId = 0;
702     return (NC_NOERR == (nc_inq_varid(ncId, varName.c_str(), &varId)));
703  }
704
705  StdString CNetCdfInterface::openMode2String(int oMode)
706  {
707    StdString modeMes;
708    switch (oMode)
709    {
710    case NC_NOWRITE:
711      modeMes = StdString("NC_NOWRITE : Opening netCDF file with read-only access with buffering and caching access");
712      break;
713    case NC_SHARE:
714      modeMes = StdString("NC_SHARE : Several processes can read the file concurrently");
715      break;
716    case NC_WRITE:
717      modeMes = StdString("NC_WRITE : NetCDF file is readable and writable");
718      break;
719    default:
720      modeMes = StdString("In the composed opening mode");
721      break;
722    return modeMes;
723    }
724  }
725
726  StdString CNetCdfInterface::creationMode2String(int cMode)
727  {
728    StdString modeMes;
729    switch (cMode)
730    {
731    case NC_NOCLOBBER:
732      modeMes = StdString("NC_NOCLOBBER : Not overwrite an exisiting netCDF file ");
733      break;
734    case NC_SHARE:
735      modeMes = StdString("NC_SHARE : Several processes can read from and write into the file concurrently");
736      break;
737    case NC_64BIT_OFFSET:
738      modeMes = StdString("NC_64BIT_OFFSET : NetCDF file is 64-bit offset");
739      break;
740    case NC_NETCDF4:
741      modeMes = StdString("NC_NETCDF4 : NetCDF file is HDF5/NetCDF-4");
742      break;
743    case NC_CLASSIC_MODEL:
744      modeMes = StdString("NC_CLASSIC_MODEL : NetCDF file is classical model");
745      break;
746    default:
747      modeMes = StdString("In the composed creation mode");
748      break;
749    return modeMes;
750    }
751  }
752
753 }
Note: See TracBrowser for help on using the repository browser.