vtkMPASReader.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-FileCopyrightText: Copyright (c) 2002-2005 Los Alamos National Laboratory
// SPDX-License-Identifier: BSD-3-Clause-Sandia-LANL-California-USGov
#ifndef vtkMPASReader_h
#define vtkMPASReader_h
 
#include "vtkIONetCDFModule.h" // For export macro
#include "vtkUnstructuredGridAlgorithm.h"
 
#include <string> // for std::string
 
VTK_ABI_NAMESPACE_BEGIN
class vtkCallbackCommand;
class vtkDataArraySelection;
class vtkDoubleArray;
class vtkStringArray;
 
class VTKIONETCDF_EXPORT vtkMPASReader : public vtkUnstructuredGridAlgorithm
{
public:
  static vtkMPASReader* New();
  vtkTypeMacro(vtkMPASReader, vtkUnstructuredGridAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
 
  vtkSetFilePathMacro(FileName);
  vtkGetFilePathMacro(FileName);
 
 
  vtkGetMacro(MaximumCells, int);
 
 
  vtkGetMacro(MaximumPoints, int);
 
 
  virtual int GetNumberOfCellVars();
  virtual int GetNumberOfPointVars();
 
 
  vtkUnstructuredGrid* GetOutput();
  vtkUnstructuredGrid* GetOutput(int idx);
 
 
  vtkSetMacro(UseDimensionedArrayNames, bool);
  vtkGetMacro(UseDimensionedArrayNames, bool);
  vtkBooleanMacro(UseDimensionedArrayNames, bool);
 
 
  int GetNumberOfPointArrays();
  const char* GetPointArrayName(int index);
  int GetPointArrayStatus(const char* name);
  void SetPointArrayStatus(const char* name, int status);
  void DisableAllPointArrays();
  void EnableAllPointArrays();
 
  int GetNumberOfCellArrays();
  const char* GetCellArrayName(int index);
  int GetCellArrayStatus(const char* name);
  void SetCellArrayStatus(const char* name, int status);
  void DisableAllCellArrays();
  void EnableAllCellArrays();
 
 
  vtkIdType GetNumberOfDimensions();
  std::string GetDimensionName(int idx);
  vtkStringArray* GetAllDimensions();
  int GetDimensionCurrentIndex(const std::string& dim);
  void SetDimensionCurrentIndex(const std::string& dim, int idx);
  int GetDimensionSize(const std::string& dim);
 
 
  vtkSetMacro(VerticalDimension, std::string);
  vtkGetMacro(VerticalDimension, std::string);
 
 
  void SetVerticalLevel(int level);
  int GetVerticalLevel();
 
  vtkGetVector2Macro(VerticalLevelRange, int);
 
  vtkSetMacro(LayerThickness, int);
  vtkGetMacro(LayerThickness, int);
  vtkGetVector2Macro(LayerThicknessRange, int);
 
  void SetCenterLon(int val);
  vtkGetVector2Macro(CenterLonRange, int);
 
  vtkSetMacro(ProjectLatLon, bool);
  vtkGetMacro(ProjectLatLon, bool);
 
  vtkSetMacro(IsAtmosphere, bool);
  vtkGetMacro(IsAtmosphere, bool);
 
  vtkSetMacro(IsZeroCentered, bool);
  vtkGetMacro(IsZeroCentered, bool);
 
  vtkSetMacro(ShowMultilayerView, bool);
  vtkGetMacro(ShowMultilayerView, bool);
 
  static int CanReadFile(VTK_FILEPATH const char* filename);
 
  vtkMTimeType GetMTime() override;
 
protected:
  vtkMPASReader();
  ~vtkMPASReader() override;
  void ReleaseNcData();
  void DestroyData();
 
  char* FileName; // First field part file giving path
 
  size_t NumberOfTimeSteps; // Temporal domain
  double DTime;             // The current time
 
  // Observer to modify this object when array selections are modified
  vtkCallbackCommand* SelectionObserver;
 
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  int RequestInformation(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
 
  static void SelectionCallback(
    vtkObject* caller, unsigned long eid, void* clientdata, void* calldata);
 
  // Selected field of interest
  vtkDataArraySelection* PointDataArraySelection;
  vtkDataArraySelection* CellDataArraySelection;
 
  void UpdateDimensions(bool force = false);
 
  std::string VerticalDimension;
  int VerticalLevelRange[2];
 
  int LayerThickness;
  int LayerThicknessRange[2];
 
  int CenterLon;
  int CenterLonRange[2];
 
  enum GeometryType
  {
    Spherical,
    Projected,
    Planar
  };
 
  GeometryType Geometry;
 
  bool ProjectLatLon; // User option
  bool OnASphere;     // Data file attribute
  bool IsAtmosphere;
  bool IsZeroCentered;
  bool ShowMultilayerView;
 
  bool IncludeTopography;
  bool DoBugFix;
  double CenterRad;
 
  bool UseDimensionedArrayNames;
 
  // geometry
  size_t MaximumNVertLevels;
  size_t NumberOfCells;
  size_t NumberOfPoints;
  int CellOffset;
  size_t PointOffset;
  size_t PointsPerCell;
  size_t CurrentExtraPoint; // current extra point
  size_t CurrentExtraCell;  // current extra cell
  double* PointX;           // x coord of point
  double* PointY;           // y coord of point
  double* PointZ;           // z coord of point
  size_t ModNumPoints;
  size_t ModNumCells;
  int* OrigConnections;   // original connections
  int* ModConnections;    // modified connections
  size_t* CellMap;        // maps from added cell to original cell #
  size_t* PointMap;       // maps from added point to original point #
  int* MaximumLevelPoint; //
  int MaximumCells;       // max cells
  int MaximumPoints;      // max points
 
  void SetDefaults();
  int GetNcDims();
  int GetNcAtts();
  int CheckParams();
  int GetNcVars(const char* cellDimName, const char* pointDimName);
  int ReadAndOutputGrid();
  int BuildVarArrays();
  int AllocSphericalGeometry();
  int AllocProjectedGeometry();
  int AllocPlanarGeometry();
  void ShiftLonData();
  int AddMirrorPoint(int index, double dividerX, double offset);
  void FixPoints();
  int EliminateXWrap();
  void OutputPoints();
  void OutputCells();
  unsigned char GetCellType();
 
  vtkDataArray* LoadPointVarData(int variable);
  vtkDataArray* LoadCellVarData(int variable);
  vtkDataArray* LookupPointDataArray(int varIdx);
  vtkDataArray* LookupCellDataArray(int varIdx);
 
  void LoadTimeFieldData(vtkUnstructuredGrid* dataset);
 
private:
  vtkMPASReader(const vtkMPASReader&) = delete;
  void operator=(const vtkMPASReader&) = delete;
 
  class Internal;
  Internal* Internals;
};
 
VTK_ABI_NAMESPACE_END
#endif