Grid.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Kitware Inc.
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef __GRID_H__
#define __GRID_H__
 
#include "vtkPVAdaptorsCamModule.h"
#include "vtkSmartPointer.h" // For smart pointers
 
#include <string> // for string
#include <vector> // for vector
 
class vtkCPDataDescription;
class vtkDataObject;
class vtkUnstructuredGrid;
 
namespace CamAdaptor
{
 
enum GridType
{
  RECTILINEAR,
  SPHERE,
  CUBE_SPHERE,
  GRID_TYPE_COUNT
};
 
template <GridType gridType>
class VTKPVADAPTORSCAM_EXPORT Grid
{
public:
  Grid();
  ~Grid();
 
  void Create();
  void SetMpiRank(int rank) { this->MpiRank = rank; }
  void SetChunkCapacity(int capacity) { this->ChunkCapacity = capacity; }
  void SetNCells2d(int ncells) { this->NCells2d = ncells; }
  void SetNLon(int nlon) { this->NLon = nlon; }
  void SetNLat(int nlat) { this->NLat = nlat; }
  void SetLev(int nlev, double* lev)
  {
    this->NLev = nlev;
    if (lev)
    {
      this->Lev = new double[nlev];
      std::copy(lev, lev + nlev, this->Lev);
    }
  }
  void AddPointsAndCells(double lonRad, double latRad);
 
  void SetAttributeValue(int chunkSize, double* lonRad, double* latRad, double* psScalar,
    double* tScalar, double* uScalar, double* vScalar);
 
  vtkSmartPointer<vtkUnstructuredGrid> GetGrid2d() const { return this->Grid2d; }
  vtkSmartPointer<vtkUnstructuredGrid> GetGrid3d() const { return this->Grid3d; }
  static bool SetToCoprocessor(vtkCPDataDescription* coprocessorData, const char* name,
    vtkSmartPointer<vtkUnstructuredGrid> grid);
 
  void SetLonStep(int step) { this->LonStep = step; }
  void SetLatStep(int step) { this->LatStep = step; }
  void SetCubeGridPoints(int ne, int np, int lonSize, double* lonRad, int latSize, double* latRad);
 
private:
  void PrintAddChunk(
    int* nstep, int* chunkCols, double* lonRad, double* latRad, double* psScalar, double* tScalar);
 
  vtkSmartPointer<vtkUnstructuredGrid> CreateGrid2d();
 
  vtkSmartPointer<vtkUnstructuredGrid> CreateGrid3d();
 
  double LevelToRadius(double level) const;
 
  void GetLevMinusPlus(int levIndex, double* levMinus, double* levPlus) const;
  void GetLatMinusPlus(int latIndex, double* latMinus, double* latPlus) const;
  void GetLonMinusPlus(int lonIndex, double* lonMinus, double* lonPlus) const;
 
  void GetValueIndex(double lonRad, double latRad, std::vector<std::vector<int>>& index) const;
 
  void GetCellPoints(const int index[3], double cellPoints[4][3]) const;
  void GetCellPoints(const int index[3], int level, double cell[8][3]) const;
 
  void GetPointIds(const int index[3], int pointIndexes[4]) const;
  void GetPointIds(const int index[3], int level, int pointIndexes[8]) const;
 
  int GetCellId(const int index[3]) const;
  int GetCellId(const int index[3], int level) const;
 
  size_t CubeToIndex(double side, const std::vector<double>& cubeCoordinates, double v[3],
    std::vector<std::vector<int>>& index) const;
 
  void IndexToCube(const std::vector<double>& cubeCoordinates, double index[3], double v[3]) const;
  void CubeToSpherical(double v[3], double* lonRad, double* latRad) const;
 
  void MinFaceIndex(int side, int index[3]) const;
 
  int MpiRank;          
  int ChunkCapacity;    
  int NCells2d;         
  int NLon, NLat, NLev; 
  double* Lev;          
  double Radius; 
  int Ne;        
  int Np;        
  double LonStep; 
  double LatStep; 
  class Internals;
  Internals* Impl;
 
  vtkSmartPointer<vtkUnstructuredGrid> Grid2d; // the grid
  int RankArrayIndex2d;                        // index of the rank array
  int CoordArrayIndex2d;                       // index of the coordinates array (lon x lat)
  int PSArrayIndex;                            
 
  vtkSmartPointer<vtkUnstructuredGrid> Grid3d; 
  int RankArrayIndex3d;                        
  int CoordArrayIndex3d;                       
  int TArrayIndex;                             
  int UArrayIndex;                             
  int VArrayIndex;                             
};
} // namespace CamAdaptor
#endif