mdal_cf.hpp

/*
 MDAL - Mesh Data Abstraction Library (MIT License)
 Copyright (C) 2018 Peter Petrik (zilolv at gmail dot com)
*/
 
#ifndef MDAL_CF_HPP
#define MDAL_CF_HPP
 
#include <string>
#include <vector>
#include <map>
#include <stddef.h>
#include <set>
 
#include "mdal_data_model.hpp"
#include "mdal.h"
#include "mdal_utils.hpp"
#include "mdal_netcdf.hpp"
#include "mdal_driver.hpp"
 
namespace MDAL
{
  class CFDimensions
  {
    public:
      enum Type
      {
        UnknownType = 0, 
        Vertex, 
        Edge, 
        Face2DEdge, 
        Face, 
        Volume3D, 
        StackedFace3D, 
        Time, 
        MaxVerticesInFace 
      };
 
      Type type( int ncid ) const;
      size_t size( Type type ) const;
      void setDimension( Type type, size_t count, int ncid = -1 );
      bool isDatasetType( Type type ) const;
 
    private:
      std::map<Type, size_t> mCount;
      std::map<int, Type> mNcId;
  };
 
  struct CFDatasetGroupInfo
  {
    enum TimeLocation
    {
      NoTimeDimension = 0, 
      TimeDimensionFirst, 
      TimeDimensionLast, 
    };
    std::string name; 
    CFDimensions::Type outputType;
    bool isVector;
    bool isPolar;
    bool isInvertedDirection;
    TimeLocation timeLocation;
    size_t nTimesteps;
    size_t nValues;
    int ncid_x; 
    int ncid_y; 
    Metadata metadata;
    Classification classification_x;
    Classification classification_y;
  };
  typedef std::map<std::string, CFDatasetGroupInfo> cfdataset_info_map; // name -> DatasetInfo
 
  class CFDataset2D: public Dataset2D
  {
    public:
      CFDataset2D( DatasetGroup *parent,
                   double fill_val_x,
                   double fill_val_y,
                   int ncid_x,
                   int ncid_y,
                   Classification classification_x,
                   Classification classification_y,
                   CFDatasetGroupInfo::TimeLocation timeLocation,
                   size_t timesteps,
                   size_t values,
                   size_t ts,
                   std::shared_ptr<NetCDFFile> ncFile
                 );
      virtual ~CFDataset2D() override;
 
      virtual size_t scalarData( size_t indexStart, size_t count, double *buffer ) override;
      virtual size_t vectorData( size_t indexStart, size_t count, double *buffer ) override;
 
    protected:
      double mFillValX;
      double mFillValY;
      int mNcidX; 
      int mNcidY; 
      Classification mClassificationX; 
      Classification mClassificationY; 
      CFDatasetGroupInfo::TimeLocation mTimeLocation;
      size_t mTimesteps;
      size_t mValues;
      size_t mTs;
      std::shared_ptr<NetCDFFile> mNcFile;
  };
 
  class DriverCF: public Driver
  {
    public:
      DriverCF( const std::string &name,
                const std::string &longName,
                const std::string &filters,
                const int capabilities );
      virtual ~DriverCF() override;
      bool canReadMesh( const std::string &uri ) override;
      std::unique_ptr< Mesh > load( const std::string &fileName, const std::string &meshName = "" ) override;
 
    protected:
      virtual CFDimensions populateDimensions( ) = 0;
      virtual void populateElements( Vertices &vertices, Edges &edges, Faces &faces ) = 0;
      virtual void addBedElevation( MDAL::MemoryMesh *mesh ) = 0;
      virtual std::string getCoordinateSystemVariableName() = 0;
      virtual std::set<std::string> ignoreNetCDFVariables() = 0;
      virtual void parseNetCDFVariableMetadata( int varid,
          std::string &variableName,
          std::string &name,
          bool *is_vector,
          bool *isPolar,
          bool *invertedDirection,
          bool *is_x ) = 0;
      virtual std::vector<std::pair<double, double> > parseClassification( int varid ) const = 0;
      virtual std::string getTimeVariableName() const = 0;
      virtual std::shared_ptr<MDAL::Dataset> create2DDataset(
        std::shared_ptr<MDAL::DatasetGroup> group,
        size_t ts,
        const MDAL::CFDatasetGroupInfo &dsi,
        double fill_val_x, double fill_val_y );
 
      virtual std::shared_ptr<MDAL::Dataset> create3DDataset(
        std::shared_ptr<MDAL::DatasetGroup> group,
        size_t ts,
        const MDAL::CFDatasetGroupInfo &dsi,
        double fill_val_x, double fill_val_y );
 
      virtual DateTime defaultReferenceTime() const;
 
      void setProjection( MDAL::Mesh *m );
      cfdataset_info_map parseDatasetGroupInfo();
 
      DateTime parseTime( std::vector<RelativeTimestamp> &times );
      void addDatasetGroups( Mesh *mesh,
                             const std::vector<RelativeTimestamp> &times,
                             const cfdataset_info_map &dsinfo_map, const DateTime &referenceTime );
 
      std::string mFileName;
      std::string mRequestedMeshName;
      std::shared_ptr<NetCDFFile> mNcFile;
      CFDimensions mDimensions;
  };
 
} // namespace MDAL
 
#endif // MDAL_CF_HPP