mdal_tuflowfv.hpp

/*
 MDAL - Mesh Data Abstraction Library (MIT License)
 Copyright (C) 2019 Peter Petrik (zilolv at gmail dot com)
*/
 
#ifndef MDAL_TUFLOWFV_HPP
#define MDAL_TUFLOWFV_HPP
 
#include <string>
#include <memory>
#include <map>
#include <iostream>
#include <fstream>
 
#include "mdal_data_model.hpp"
#include "mdal_memory_data_model.hpp"
#include "mdal.h"
#include "mdal_driver.hpp"
#include "mdal_cf.hpp"
 
namespace MDAL
{
  namespace TuflowFVActiveFlag
  {
    size_t activeData( std::shared_ptr<NetCDFFile> ncFile,
                       size_t timestep,
                       size_t timestepsCount,
                       size_t facesCount,
                       int ncidActive,
                       size_t indexStart,
                       size_t count,
                       int *buffer );
  }
 
  class TuflowFVDataset2D: public CFDataset2D
  {
    public:
      TuflowFVDataset2D( DatasetGroup *parent,
                         double fillValX,
                         double fillValY,
                         int ncidX,
                         int ncidY,
                         Classification classificationX,
                         Classification classificationY,
                         int ncidActive,
                         CFDatasetGroupInfo::TimeLocation timeLocation,
                         size_t timesteps,
                         size_t values,
                         size_t ts,
                         std::shared_ptr<NetCDFFile> ncFile
                       );
      size_t activeData( size_t indexStart, size_t count, int *buffer ) override;
    private:
      int mNcidActive; 
  };
 
  class TuflowFVDataset3D: public Dataset3D
  {
    public:
      TuflowFVDataset3D( DatasetGroup *parent,
                         int ncidX,
                         int ncidY,
                         int ncidActive,
                         CFDatasetGroupInfo::TimeLocation timeLocation,
                         size_t timesteps,
                         size_t volumesCount,
                         size_t facesCount,
                         size_t levelFacesCount,
                         size_t ts,
                         size_t maximumLevelsCount,
                         std::shared_ptr<NetCDFFile> ncFile
                       );
      virtual ~TuflowFVDataset3D() override;
 
      size_t activeData( size_t indexStart, size_t count, int *buffer ) override;
      size_t verticalLevelCountData( size_t indexStart, size_t count, int *buffer ) override;
      size_t verticalLevelData( size_t indexStart, size_t count, double *buffer ) override;
      size_t faceToVolumeData( size_t indexStart, size_t count, int *buffer ) override;
      size_t scalarVolumesData( size_t indexStart, size_t count, double *buffer ) override;
      size_t vectorVolumesData( size_t indexStart, size_t count, double *buffer ) override;
 
    private:
      int mNcidX; 
      int mNcidY; 
      int mNcidActive; 
      size_t mTimesteps;
      size_t mFacesCount;
      size_t mLevelFacesCount;
      CFDatasetGroupInfo::TimeLocation mTimeLocation;
      size_t mTs;
      std::shared_ptr<NetCDFFile> mNcFile;
 
      int mNcidVerticalLevels = -1; 
      int mNcidVerticalLevelsZ = -1; 
      int mNcidActive2D = -1; 
      int mNcid3DTo2D = -1; 
      int mNcid2DTo3D = -1; 
  };
 
  class DriverTuflowFV: public DriverCF
  {
    public:
      DriverTuflowFV();
      ~DriverTuflowFV() override;
      DriverTuflowFV *create() override;
 
    private:
      CFDimensions populateDimensions( ) override;
      void populateElements( Vertices &vertices, Edges &, Faces &faces ) override;
      void addBedElevation( MemoryMesh *mesh ) override;
      std::string getCoordinateSystemVariableName() override;
      std::set<std::string> ignoreNetCDFVariables() override;
      void parseNetCDFVariableMetadata( int varid,
                                        std::string &variableName,
                                        std::string &name,
                                        bool *is_vector,
                                        bool *isPolar,
                                        bool *invertedDirection,
                                        bool *is_x ) override;
      std::vector<std::pair<double, double>> parseClassification( int varid ) const override;
      std::string getTimeVariableName() const override;
      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 ) override;
 
      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 ) override;
 
      void addBedElevationDatasetOnFaces();
      void populateVertices( MDAL::Vertices &vertices );
      void populateFaces( MDAL::Faces &faces );
      virtual DateTime defaultReferenceTime() const override;
 
      void calculateMaximumLevelCount();
      int mMaximumLevelsCount = -1;
  };
 
} // namespace MDAL
#endif //MDAL_TUFLOWFV_HPP