source: XMLIO_V2/dev/dev_rv/src4/xmlio/netcdf/inetcdf4.hpp @ 229

Last change on this file since 229 was 229, checked in by hozdoba, 10 years ago
File size: 10.4 KB
Line 
1/* ************************************************************************** *
2 *      Copyright © IPSL/LSCE, XMLIOServer, Avril 2010 - Octobre 2011         *
3 * ************************************************************************** */
4
5#ifndef __INETCDF4_HPP__
6#define __INETCDF4_HPP__
7
8/**
9 * \file    inetcdf4.hpp
10 * \brief   Lecture des fichiers de données au format netCDF-4 (entête).
11 * \author  Hervé Ozdoba
12 * \version 0.4
13 * \date    15 Juin 2011
14 */
15
16#ifndef __XIOS_NO_EXTERN
17
18// M(essage) P(assing) I(nterface) headers
19#include <mpi.h>
20                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             
21// NetCDF headers
22#define MPI_INCLUDED
23#include <netcdf.h>
24
25// C++ standard headers
26#  include <vector>
27
28// boost Headers
29#include <boost/multi_array.hpp>
30
31#endif // __XIOS_NO_EXTERN
32
33// XMLIOServer headers
34#include "xmlioserver_spl.hpp"
35
36#ifndef UNLIMITED_DIM
37   #define UNLIMITED_DIM (size_t)(-1)
38#endif  //UNLIMITED_DIM
39
40// ////////////////////////////// Déclarations ///////////////////////////// //
41
42namespace xmlioserver
43{
44   /// \brief Espace de nommage permettant de traiter les Entrées/Sorties sous divers formats.
45   namespace io
46   {
47      /**
48       * \class CINetCDF4
49       * \brief Classe permettant de lire les fichiers de données au format netCDF-4.
50       */
51      class CINetCDF4
52      {
53         public : // Définition de type
54           
55            //! \brief Redéfinition de std::vector<std::string> pour simplification d'écriture.
56            typedef std::vector<std::string> CNetCDF4Path;
57           
58         public : // Constructeurs
59         
60            //! \brief Constructeur simple.
61            CINetCDF4(void); // NIY
62           
63            /*!
64             * \brief Constructeur à partir d'un nom de fichier au format netCDF4.
65             * \param _filename : un nom de fichier au format netCDF4.
66             */
67            explicit CINetCDF4(const std::string & _filename);
68           
69            /*!
70             * \brief Constructeur par copie .
71             * \param _inetcdf4 : référence de l'objet à copier.
72             */
73            CINetCDF4(const CINetCDF4 & _inetcdf4);// NIY
74           
75            /*!
76             * \brief Constructeur par copie.
77             * \param _inetcdf4_ptr : le pointeur sur l'objet à copier.
78             */
79            CINetCDF4(const CINetCDF4 * const _inetcdf4_ptr); // NIY
80           
81         public : // Destructeur
82         
83            //! \brief Destructeur de l'objet (le fichier est clos lors de son appel).
84            virtual ~CINetCDF4(void);
85           
86           
87               
88         public : // Accesseur de parcours (d'exploration)
89             
90            std::size_t getNbOfTimestep(void);
91           
92            std::string getUnlimitedDimensionName(void);
93             
94            std::map<std::string, std::size_t> 
95               getDimensions(const std::string * const _varname  = NULL); 
96           
97            std::vector<std::string> getDimensionsIdList (const std::string * _varname);
98           
99            std::vector<std::string> getAttributes(const std::string * const _varname  = NULL);           
100            std::vector<std::string> getGroups   (void);
101            std::vector<std::string> getVariables(void);
102           
103         public : // Mutateur
104           
105            void setCurrentPath(const CNetCDF4Path & _path);
106           
107         public : // Accesseurs
108           
109            const CNetCDF4Path & getCurrentPath(void) const;
110           
111         public : // Lecture
112           
113            template <class DataType>
114               void readAttribute
115                  (const std::string &     _attname,
116                   std::vector<DataType> & _value,
117                   const std::string *     _varname = NULL);
118           
119           void readAttribute
120                  (const std::string & _attname,
121                   std::string       & _value,
122                   const std::string * _varname = NULL);
123
124            template <class DataType, std::size_t ndim>
125               void readData( boost::multi_array<DataType, ndim> & _data,
126                              const std::string                  & _varname,
127                              std::size_t                          _record = 1,
128                              const std::vector<std::size_t>     * _start  = NULL,
129                              const std::vector<std::size_t>     * _count  = NULL);
130
131         protected : // Accesseurs protégés
132         
133            /*!
134             * \brief Retourne l'identifiant du groupe courant
135             * (le chemin est gardée en mémoire dans la variable path).
136             * \return  l'identifiant du groupe courant
137             * \see path
138             */
139            int getCurrentGroup(void);
140           
141            /*!
142             * \brief Retourne l'identifiant du groupe  dont le chemin est passé en argument.
143             * \param _path : Un chemin dans la structure de donnée netCDF.
144             * \return l'identifiant du groupe.
145             *
146             * <i> Exemple d'utilisation: </i>
147             * \code
148             * //> Retourne l'identifiant d'un group.
149             * CINetCDF4 ncinput(std::string("mon_fichier.nc"));
150             * CNetCDF4Path path;
151             * path.push_back("mes_donnees"); path.push_back("mes_tableaux");
152             * int groupid = ncinput.getGroup(path);
153             * \endcode
154             */
155            int getGroup(const CNetCDF4Path & _path);
156           
157            /*!
158             * \brief Retourne l'identifiant d'une variable dans le groupe courant.
159             * \param _varname : Le nom d'une variable dans le fichier de données.
160             * \return l'identifiant de la variable.
161             */
162            int getVariable(const std::string & _varname);
163           
164            /*!
165             * \brief Retourne l'identifiant d'une dimension dans le groupe courant.
166             * \param _dimname : Le nom d'une dimension dans le  fichier de données.
167             * \return l'identifiant de la dimension.
168             */
169            int getDimension(const std::string & _dimname);
170           
171            /*!
172             * \brief Retourne les dimensions d'une variable.
173             * \param _varname : Le nom d'une variable dans le  fichier de données.
174             * \return Un vecteur des dimensions associées à la variables
175             */
176            std::vector<std::size_t> getDimensions(const std::string & _varname);
177           
178            /*!
179             * \brief Retourne l'identifiant de la dimension non limité dans le fichier.
180             * \return l'identifiant de la dimension non limité ou <b>-1</b> s'il n'y en a pas.
181             */
182            int getUnlimitedDimension(void);
183           
184            /*!
185             * \brief Indique si une variable existe dans le groupe courant.
186             * \param _varname : Le nom d'une variable dans le  fichier de données.
187             * \return  <b>true</b> si la variable existe, <b>false</b> sinon.
188             */
189            bool varExist(const std::string & _varname);
190
191         private : // Obtention des informations de lecture
192           
193            void getReadDataInfos(const std::string              & _varname,
194                                  std::size_t                      _record, 
195                                  std::size_t                    & _array_size,
196                                  std::vector<std::size_t>       & _sstart,
197                                  std::vector<std::size_t>       & _scount,
198                                  const std::vector<std::size_t> * _start,
199                                  const std::vector<std::size_t> * _count);
200           
201         private : // Lecture
202             
203             template <class DataType>
204                void readData_(int                              _grpid,
205                               int                              _varid,
206                               const std::vector<std::size_t> & _sstart,
207                               const std::vector<std::size_t> & _scount,
208                               DataType                       * _data);
209             
210             template <class DataType>
211                void readAttribute_
212                        (const std::string & _attname,
213                         DataType          * _value,
214                         int                 _grpid,
215                         int                 _varid = NC_GLOBAL);
216             
217         private : // Vérification des erreurs NetCDF
218
219            /*!
220             * \brief Vérifie le code d'erreur retourné lors de l'appel d'une fonction
221             * dans la bibliothÚque netCDF afin de détecter les erreurs.
222             * \param _status : le code d'erreur retourné par l'appel d'une fonction netCDF.
223             * \remarks Tous les appels de fonction dans la bibliothÚque netCDF doivent être
224             * pris en charge par cette méthode statique.
225             *
226             * <i> Exemple d'utilisation: </i>
227             * \code
228             * //> Retourne l'identifiant d'une variable netCDF dont le nom est 'varname' dans le groupe grpid
229             * CheckError(nc_inq_varid (grpid, varname, varid));
230             * \endcode
231             */
232            static void CheckError(int _status) throw (CException);
233
234         public : // Propriétés privées
235         
236            std::vector<std::string> path; /*!< \brief Chemin vers le groupe de données en cours de lecture. */
237            int ncidp;                     /*!< \brief Identifiant de fichiers netCDF. */
238         
239      }; // class CINetCDF4
240   } // namespace io
241
242} // namespace xmlioserver
243
244#endif  // __INETCDF4_HPP__
Note: See TracBrowser for help on using the repository browser.