source: XMLIO_V2/dev/dev_rv/src/output/onetcdf4.hpp @ 141

#ifndef __XMLIO_INETCDF4__
#define __XMLIO_INETCDF4__

/// xmlioserver headers ///
#include "xmlioserver_spl.hpp"
#include "exception.hpp"
#include "array.hpp"
#include "mask.hpp"
#include "../data_output.hpp"
#include "manager/mpi_manager.hpp"

#include <mpi.h>
#include <netcdf.h>

#ifndef UNLIMITED_DIM
   #define UNLIMITED_DIM (size_t)(-1)
#endif  //UNLIMITED_DIM

namespace xmlioserver
{
   namespace io
   {
      /// ////////////////////// Déclarations ////////////////////// ///
      class CONetCDF4
         : public virtual CDataOutput
      {
         public :

            /// Définition de type ///
            typedef std::vector<StdString> CONetCDF4Path;

            /// Constructeurs ///
            CONetCDF4(const StdString & filename, bool exist, const MPI_Comm * comm = NULL);
            CONetCDF4(const StdString & filename, bool exist, const comm::MPIComm * comm);

            CONetCDF4(const CONetCDF4 & onetcdf4);       // Not implemented.
            CONetCDF4(const CONetCDF4 * const onetcdf4); // Not implemented.


            /// Initialisation ///
            void initialize(const StdString & filename, bool exist, const MPI_Comm * comm);
            void definition_start(void);
            void definition_end(void);

            /// Mutateurs ///
            void setCurrentPath(const CONetCDF4Path & path);

            int addGroup(const StdString & name);
            int addDimension(const StdString& name, const StdSize size = UNLIMITED_DIM);
            int addVariable(const StdString & name, nc_type type,
                                    const std::vector<StdString> & dim);
            template <class T>
               void addAttribute
                  (const StdString & name, const T & value, const StdString * varname = NULL);

            /// Ecriture des données ///
            template <class T>
               void writeData(const ARRAY(T, 1) data, const StdString & name,
                              bool collective, StdSize record,
                              const std::vector<StdSize> * start = NULL,
                              const std::vector<StdSize> * count = NULL);

            void writeData(const boost::shared_ptr<CMask> data, const StdString & name);

            /// Accesseur ///
            const CONetCDF4Path & getCurrentPath(void) const;

            /// Destructeur ///
            virtual ~CONetCDF4(void);

         protected :

            /// Ecriture ///
            virtual void writeField_ (const boost::shared_ptr<tree::CField>  field)  = 0;
            virtual void writeDomain_(const boost::shared_ptr<tree::CDomain> domain) = 0;
            virtual void writeAxis_  (const boost::shared_ptr<tree::CAxis>   axis)   = 0;

            /// Accesseurs ///
            int getCurrentGroup(void);
            int getGroup(const CONetCDF4Path & path);
            int getVariable(const StdString & varname);
            int getDimension(const StdString & dimname);
            std::vector<StdSize> getDimensions(const StdString & varname);
            int getUnlimitedDimension(void);

         private :

            void getWriteDataInfos(const StdString & name, StdSize record, StdSize & array_size,
                                   std::vector<StdSize> & sstart,
                                   std::vector<StdSize> & scount,
                                   const std::vector<StdSize> * start,
                                   const std::vector<StdSize> * count);

            /// Vérification des erreurs NetCDF ///
            void CheckError(int status);

            /// Propriétés privées ///
            CONetCDF4Path path;
            int ncidp;
            bool wmpi;

      }; // class CONetCDF4

   } // namespace io
} // namespace xmlioserver

#endif //__XMLIO_INETCDF4__