NCHelper.hpp

Go to the documentation of this file.

//-------------------------------------------------------------------------
// Filename      : NCHelper.hpp
//
// Purpose       : Climate NC file helper
//
// Creator       : Danqing Wu
//-------------------------------------------------------------------------

#ifndef NCHELPER_HPP
#define NCHELPER_HPP

#include "ReadNC.hpp"

namespace moab {

class NCHelper
{
public:
  NCHelper(ReadNC* readNC, int fileId, const FileOptions& opts, EntityHandle fileSet)
:_readNC(readNC), _fileId(fileId), _opts(opts), _fileSet(fileSet),
  nTimeSteps(0), nLevels(1), tDim(-1), levDim(-1) {}
  virtual ~NCHelper() {}

  static NCHelper* get_nc_helper(ReadNC* readNC, int fileId, const FileOptions& opts, EntityHandle fileSet);

  virtual ErrorCode init_mesh_vals() = 0;
  virtual ErrorCode check_existing_mesh() = 0;
  virtual ErrorCode create_mesh(Range& faces) = 0;
  virtual ErrorCode read_variables(std::vector<std::string>& var_names, std::vector<int>& tstep_nums) = 0;
  virtual std::string get_mesh_type_name() = 0;

  ErrorCode create_conventional_tags(const std::vector<int>& tstep_nums);

protected:
  ErrorCode read_variable_setup(std::vector<std::string>& var_names,
                                            std::vector<int>& tstep_nums,
                                            std::vector<ReadNC::VarData>& vdatas,
                                            std::vector<ReadNC::VarData>& vsetdatas);

  ErrorCode read_variable_to_set(std::vector<ReadNC::VarData>& vdatas, std::vector<int>& tstep_nums);

  ErrorCode convert_variable(ReadNC::VarData& var_data, int tstep_num);

  ErrorCode read_coordinate(const char* var_name, int lmin, int lmax,
                            std::vector<double>& cvals);

  ErrorCode get_tag_to_set(ReadNC::VarData& var_data, int tstep_num, Tag& tagh);

  ErrorCode get_tag_to_nonset(ReadNC::VarData& var_data, int tstep_num, Tag& tagh, int num_lev);

  ErrorCode create_attrib_string(const std::map<std::string, ReadNC::AttData>& attMap,
                                 std::string& attString,
                                 std::vector<int>& attLen);

  ErrorCode create_dummy_variables();

private:
  ErrorCode read_variable_to_set_allocate(std::vector<ReadNC::VarData>& vdatas, std::vector<int>& tstep_nums);

protected:
  ReadNC* _readNC;

  int _fileId;
  const FileOptions& _opts;
  EntityHandle _fileSet;

  int nTimeSteps, nLevels;

  std::vector<double> tVals, levVals;

  int tDim, levDim;

  std::set<std::string> ignoredVarNames;

  std::set<std::string> dummyVarNames;
};

class ScdNCHelper : public NCHelper
{
public:
  ScdNCHelper(ReadNC* readNC, int fileId, const FileOptions& opts, EntityHandle fileSet)
: NCHelper(readNC, fileId, opts, fileSet),
  iDim(-1), jDim(-1), iCDim(-1), jCDim(-1)
  {
    for (unsigned int i = 0; i < 6; i++) {
      gDims[i] = -1;
      lDims[i] = -1;
      gCDims[i] = -1;
      lCDims[i] = -1;
    }

    locallyPeriodic[0] = locallyPeriodic[1] = locallyPeriodic[2] = 0;
    globallyPeriodic[0] = globallyPeriodic[1] = globallyPeriodic[2] = 0;
  }
  virtual ~ScdNCHelper() {}

private:
  virtual ErrorCode check_existing_mesh();
  virtual ErrorCode create_mesh(Range& faces);
  virtual ErrorCode read_variables(std::vector<std::string>& var_names, std::vector<int>& tstep_nums);

  ErrorCode read_scd_variable_to_nonset_allocate(std::vector<ReadNC::VarData>& vdatas,
                                                 std::vector<int>& tstep_nums);
  ErrorCode read_scd_variable_to_nonset(std::vector<ReadNC::VarData>& vdatas,
                                        std::vector<int>& tstep_nums);

  ErrorCode create_quad_coordinate_tag();

  template <typename T> ErrorCode kji_to_jik(size_t ni, size_t nj, size_t nk, void* dest, T* source)
  {
    size_t nik = ni * nk, nij = ni * nj;
    T* tmp_data = reinterpret_cast<T*>(dest);
    for (std::size_t j = 0; j != nj; j++)
      for (std::size_t i = 0; i != ni; i++)
        for (std::size_t k = 0; k != nk; k++)
          tmp_data[j*nik + i*nk + k] = source[k*nij + j*ni + i];
    return MB_SUCCESS;
  }

protected:
  int gDims[6];

  int lDims[6];

  int gCDims[6];

  int lCDims[6];

  std::vector<double> ilVals, jlVals;

  std::vector<double> ilCVals, jlCVals;

  int iDim, jDim;

  int iCDim, jCDim;

  int locallyPeriodic[3];

  int globallyPeriodic[3];
};

class UcdNCHelper : public NCHelper
{
public:
  UcdNCHelper(ReadNC* readNC, int fileId, const FileOptions& opts, EntityHandle fileSet)
: NCHelper(readNC, fileId, opts, fileSet),
  nCells(0), nEdges(0), nVertices(0),
  nLocalCells(0), nLocalEdges(0), nLocalVertices(0),
  cDim(-1), eDim(-1), vDim(-1) {}
  virtual ~UcdNCHelper() {}

private:
  virtual ErrorCode read_variables(std::vector<std::string>& var_names,
                                   std::vector<int> &tstep_nums);

  virtual ErrorCode read_ucd_variable_to_nonset_allocate(std::vector<ReadNC::VarData>& vdatas,
                                                         std::vector<int>& tstep_nums) = 0;
#ifdef PNETCDF_FILE
  virtual ErrorCode read_ucd_variable_to_nonset_async(std::vector<ReadNC::VarData>& vdatas,
                                                      std::vector<int>& tstep_nums) = 0;
#else
  virtual ErrorCode read_ucd_variable_to_nonset(std::vector<ReadNC::VarData>& vdatas,
                                                std::vector<int>& tstep_nums) = 0;
#endif

protected:
  template <typename T> ErrorCode kji_to_jik_stride(size_t , size_t nj, size_t nk, void* dest, T* source, Range& localGid)
  {
    std::size_t idxInSource = 0; // Position of the start of the stride
    // For each subrange, we will transpose a matrix of size
    // subrange*nj*nk (subrange takes the role of ni)
    T* tmp_data = reinterpret_cast<T*>(dest);
    for (Range::pair_iterator pair_iter = localGid.pair_begin();
        pair_iter != localGid.pair_end(); ++pair_iter) {
      std::size_t size_range = pair_iter->second - pair_iter->first + 1;
      std::size_t nik = size_range * nk, nij = size_range * nj;
      for (std::size_t j = 0; j != nj; j++)
        for (std::size_t i = 0; i != size_range; i++)
          for (std::size_t k = 0; k != nk; k++)
            tmp_data[idxInSource + j*nik + i*nk + k] = source[idxInSource + k*nij + j*size_range + i];
      idxInSource += (size_range*nj*nk);
    }
    return MB_SUCCESS;
  }

  int nCells;
  int nEdges;
  int nVertices;

  int nLocalCells;
  int nLocalEdges;
  int nLocalVertices;

  std::vector<double> xVertVals, yVertVals, zVertVals;

  int cDim, eDim, vDim;

  Range localGidCells, localGidEdges, localGidVerts;
};

} // namespace moab

#endif