ReadNC.hpp

Go to the documentation of this file.

//-------------------------------------------------------------------------
// Filename      : ReadNC.hpp
//
// Purpose       : Climate NC file reader
//
// Creator       : Tim Tautges
//-------------------------------------------------------------------------
 
#ifndef READNC_HPP
#define READNC_HPP
 
#ifndef IS_BUILDING_MB
#error "ReadNC.hpp isn't supposed to be included into an application"
#endif
 
#include <vector>
#include <map>
#include <set>
#include <string>
 
#include "moab/ReaderIface.hpp"
#include "moab/ScdInterface.hpp"
#include "DebugOutput.hpp"
 
#ifdef MOAB_HAVE_MPI
#include "moab_mpi.h"
#include "moab/ParallelComm.hpp"
#endif
 
#ifdef MOAB_HAVE_PNETCDF
#include "pnetcdf.h"
#define NCFUNC( func ) ncmpi_##func
 
//! Collective I/O mode get
#define NCFUNCAG( func ) ncmpi_get##func##_all
 
//! Independent I/O mode get
#define NCFUNCG( func ) ncmpi_get##func
 
//! Nonblocking get (request aggregation), used so far only for ucd mesh
#define NCFUNCREQG( func ) ncmpi_iget##func
 
#define NCDF_SIZE MPI_Offset
#define NCDF_DIFF MPI_Offset
#else
#include "netcdf.h"
#define NCFUNC( func )   nc_##func
#define NCFUNCAG( func ) nc_get##func
#define NCFUNCG( func )  nc_get##func
#define NCDF_SIZE        size_t
#define NCDF_DIFF        ptrdiff_t
#endif
 
namespace moab
{
 
class ReadUtilIface;
class ScdInterface;
class NCHelper;
 
//! Output Exodus File for VERDE
class ReadNC : public ReaderIface
{
    friend class NCHelper;
    friend class ScdNCHelper;
    friend class UcdNCHelper;
    friend class NCHelperEuler;
    friend class NCHelperFV;
    friend class NCHelperDomain;
    friend class NCHelperScrip;
    friend class NCHelperHOMME;
    friend class NCHelperMPAS;
    friend class NCHelperESMF;
    friend class NCHelperGCRM;
 
  public:
    static ReaderIface* factory( Interface* );
 
    enum NCFormatType
    {
        NC_FORMAT_UNKNOWN_TYPE = 0,
        NC_FORMAT_MPAS         = 1,
        NC_FORMAT_SCRIP        = 2,
        NC_FORMAT_ESMF         = 3,
        NC_FORMAT_DOMAIN       = 4,
        NC_FORMAT_HOMME        = 5,
        NC_FORMAT_GCRM         = 6,
        NC_FORMAT_EULER        = 7,
        NC_FORMAT_FV           = 8
    };
 
    //! Load an NC file
    ErrorCode load_file( const char* file_name,
                         const EntityHandle* file_set,
                         const FileOptions& opts,
                         const SubsetList* subset_list = nullptr,
                         const Tag* file_id_tag        = nullptr );
 
    //! Constructor
    explicit ReadNC( Interface* impl = nullptr );
 
    //! Destructor
    virtual ~ReadNC();
 
    virtual ErrorCode read_tag_values( const char* file_name,
                                       const char* tag_name,
                                       const FileOptions& opts,
                                       std::vector< int >& tag_values_out,
                                       const SubsetList* subset_list = nullptr );
 
    //! ENTLOCNSEDGE for north/south edge
    //! ENTLOCWEEDGE for west/east edge
    enum EntityLocation
    {
        ENTLOCVERT = 0,
        ENTLOCNSEDGE,
        ENTLOCEWEDGE,
        ENTLOCFACE,
        ENTLOCSET,
        ENTLOCEDGE,
        ENTLOCREGION
    };
 
  private:
    class AttData
    {
      public:
        AttData() : attId( -1 ), attLen( 0 ), attVarId( -2 ) {}
        int attId;
        NCDF_SIZE attLen;
        int attVarId;
        nc_type attDataType;
        std::string attName;
    };
 
    class VarData
    {
      public:
        VarData() : varId( -1 ), numAtts( -1 ), entLoc( ENTLOCSET ), numLev( 0 ), sz( 0 ), has_tsteps( false ) {}
        int varId;
        int numAtts;
        nc_type varDataType;
        std::vector< int > varDims;  // The dimension indices making up this multi-dimensional variable
        std::map< std::string, AttData > varAtts;
        std::string varName;
        std::vector< Tag > varTags;  // Tags created for this variable, e.g. one tag per timestep
        std::vector< void* > varDatas;
        std::vector< NCDF_SIZE > readStarts;  // Starting index for reading data values along each dimension
        std::vector< NCDF_SIZE > readCounts;  // Number of data values to be read along each dimension
        int entLoc;
        int numLev;
        int sz;
        bool has_tsteps;  // Indicate whether timestep numbers are appended to tag names
    };
 
    ReadUtilIface* readMeshIface;
 
    //! Read the header information
    ErrorCode read_header();
 
    //! Get all global attributes in the file
    ErrorCode get_attributes( int var_id,
                              int num_atts,
                              std::map< std::string, AttData >& atts,
                              const char* prefix = "" );
 
    //! Get all dimensions in the file
    ErrorCode get_dimensions( int file_id, std::vector< std::string >& dim_names, std::vector< int >& dim_lens );
 
    //! Get the variable names and other info defined for this file
    ErrorCode get_variables();
 
    ErrorCode parse_options( const FileOptions& opts,
                             std::vector< std::string >& var_names,
                             std::vector< int >& tstep_nums,
                             std::vector< double >& tstep_vals );
 
    //------------member variables ------------//
 
    //! Interface instance
    Interface* mbImpl;
 
    //! File name
    std::string fileName;
 
    //! File numbers assigned by netcdf
    int fileId;
 
    //! Dimension names
    std::vector< std::string > dimNames;
 
    //! Dimension lengths
    std::vector< int > dimLens;
 
    //! Global attribs
    std::map< std::string, AttData > globalAtts;
 
    //! Variable info
    std::map< std::string, VarData > varInfo;
 
    //! Cached tags for reading. Note that all these tags are defined when the
    //! core is initialized.
    Tag mGlobalIdTag;
 
    //! This is a pointer to the file id tag that is passed from ReadParallel
    //! it gets deleted at the end of resolve sharing, but it will have same data
    //! as the global id tag
    //! global id tag is preserved, and is needed later on.
    const Tag* mpFileIdTag;
 
    //! Debug stuff
    DebugOutput dbgOut;
 
    //! Are we reading in parallel?
    bool isParallel;
 
    //! Partitioning method
    int partMethod;
 
    //! Scd interface
    ScdInterface* scdi;
 
    //! Parallel data object, to be cached with ScdBox
    ScdParData parData;
 
#ifdef MOAB_HAVE_MPI
    ParallelComm* myPcomm;
#endif
 
    //! Read options
    bool noMesh;
    bool noVars;
    bool spectralMesh;
    bool noMixedElements;
    bool noEdges;
    bool culling;
    bool repartition; // with zoltan rcb
    int gatherSetRank;
    int tStepBase;
    int trivialPartitionShift;
 
    //! Helper class instance
    NCHelper* myHelper;
};
 
}  // namespace moab
 
#endif