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(UsePrimaryGrid, bool);
  vtkGetMacro(UsePrimaryGrid, 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];

  bool ProjectLatLon;  // User option
  bool UsePrimaryGrid; // User option
  bool OnASphere;      // Data file attribute
  bool IsAtmosphere;
  bool IsZeroCentered;
  bool ShowMultilayerView;

  bool IncludeTopography;
  bool DoBugFix;
  double CenterRad;

  bool UseDimensionedArrayNames;

private:
  enum GeometryType
  {
    SphericalDual,
    SphericalPrimary,
    ProjectedDual,
    ProjectedPrimary,
    Planar
  };

  GeometryType Geometry;

  // geometry
  size_t MaximumNVertLevels;
  size_t NumberOfCells;
  size_t NumberOfPoints;
  int CellOffset;
  size_t PointOffset;
  size_t PointsPerCell;
  int MaximumCells;
  int MaximumPoints;

  struct LoadState;

  void SetDefaults();
  int GetNcDims();
  int GetNcAtts();
  int CheckParams();
  int GetNcVars(const char* cellDimName, const char* pointDimName);
  int ReadAndOutputGrid(LoadState& state);
  int BuildVarArrays();
  int AllocSphericalDualGeometry(LoadState& state);
  int AllocSphericalPrimaryGeometry(LoadState& state);
  int AllocProjectedDualGeometry(LoadState& state);
  int AllocProjectedPrimaryGeometry(LoadState& state);
  int AllocPlanarGeometry(LoadState& state);
  void ShiftLonData(LoadState& state);
  int AddMirrorPoint(LoadState& state, int index, double dividerX, double offset);
  void FixPoints(LoadState& state);
  int EliminateXWrap(LoadState& state);
  void OutputPoints(LoadState& state);
  void OutputCells(LoadState& state);
  unsigned char GetCellType(int numPoints);

  vtkDataArray* LoadPointVarData(LoadState& state, int variable);
  vtkDataArray* LoadCellVarData(LoadState& state, int variable);
  vtkDataArray* LookupPointDataArray(int varIdx);
  vtkDataArray* LookupCellDataArray(int varIdx);

  void LoadTimeFieldData(vtkUnstructuredGrid* dataset);

  vtkMPASReader(const vtkMPASReader&) = delete;
  void operator=(const vtkMPASReader&) = delete;

  class Internal;
  Internal* Internals;
};

VTK_ABI_NAMESPACE_END
#endif