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