vtkCGNSReader.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-FileCopyrightText: Copyright 2013-2014 Mickael Philit
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef vtkCGNSReader_h
#define vtkCGNSReader_h
 
#include "vtkIOCGNSReaderModule.h" // for export macro
#include "vtkMultiBlockDataSetAlgorithm.h"
#include "vtkNew.h" // for vtkNew.
 
#include <map>    // for std::map
#include <set>    // for std::set
#include <string> // for std::string
 
namespace CGNSRead
{
VTK_ABI_NAMESPACE_BEGIN
class vtkCGNSMetaData;
VTK_ABI_NAMESPACE_END
}
 
VTK_ABI_NAMESPACE_BEGIN
class vtkDataArraySelection;
class vtkInformationStringKey;
class vtkMultiProcessController;
 
class VTKIOCGNSREADER_EXPORT vtkCGNSReader : public vtkMultiBlockDataSetAlgorithm
{
public:
  static vtkCGNSReader* New();
  vtkTypeMacro(vtkCGNSReader, vtkMultiBlockDataSetAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  enum DataArrayLocation
  {
    CELL_DATA = 0,
    FACE_DATA
  };


  vtkSetClampMacro(DataLocation, int, vtkCGNSReader::CELL_DATA, vtkCGNSReader::FACE_DATA);
  vtkGetMacro(DataLocation, int);


  vtkSetStdStringFromCharMacro(FileName);
  vtkGetCharFromStdStringMacro(FileName);

  int CanReadFile(VTK_FILEPATH const char* filename);

  vtkDataArraySelection* GetBaseSelection();

  vtkDataArraySelection* GetFamilySelection();

  vtkGetMacro(CellDataArraySelection, vtkDataArraySelection*);

  vtkGetMacro(FaceDataArraySelection, vtkDataArraySelection*);

  vtkGetMacro(PointDataArraySelection, vtkDataArraySelection*);


  int GetBaseArrayStatus(const char* name);
  void SetBaseArrayStatus(const char* name, int status);
  void DisableAllBases();
  void EnableAllBases();
  int GetNumberOfBaseArrays();
  const char* GetBaseArrayName(int index);


  int GetNumberOfFamilyArrays();
  const char* GetFamilyArrayName(int index);
  void SetFamilyArrayStatus(const char* name, int status);
  int GetFamilyArrayStatus(const char* name);
  void EnableAllFamilies();
  void DisableAllFamilies();


  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();


  int GetNumberOfFaceArrays();
  const char* GetFaceArrayName(int index);
  int GetFaceArrayStatus(const char* name);
  void SetFaceArrayStatus(const char* name, int status);
  void DisableAllFaceArrays();
  void EnableAllFaceArrays();


  vtkSetMacro(DoublePrecisionMesh, int);
  vtkGetMacro(DoublePrecisionMesh, int);
  vtkBooleanMacro(DoublePrecisionMesh, int);


  vtkSetMacro(LoadBndPatch, bool);
  vtkGetMacro(LoadBndPatch, bool);
  vtkBooleanMacro(LoadBndPatch, bool);


  vtkSetMacro(LoadSurfacePatch, bool);
  vtkGetMacro(LoadSurfacePatch, bool);
  vtkBooleanMacro(LoadSurfacePatch, bool);


  vtkSetMacro(LoadMesh, bool);
  vtkGetMacro(LoadMesh, bool);
  vtkBooleanMacro(LoadMesh, bool);


  vtkSetMacro(Use3DVector, bool);
  vtkGetMacro(Use3DVector, bool);
  vtkBooleanMacro(Use3DVector, bool);


  vtkSetMacro(FlipFaceNormals, bool);
  vtkGetMacro(FlipFaceNormals, bool);
  vtkBooleanMacro(FlipFaceNormals, bool);


  vtkSetMacro(CreateEachSolutionAsBlock, int);
  vtkGetMacro(CreateEachSolutionAsBlock, int);
  vtkBooleanMacro(CreateEachSolutionAsBlock, int);


  vtkSetMacro(IgnoreFlowSolutionPointers, bool);
  vtkGetMacro(IgnoreFlowSolutionPointers, bool);
  vtkBooleanMacro(IgnoreFlowSolutionPointers, bool);


  vtkSetMacro(UseUnsteadyPattern, bool);
  vtkGetMacro(UseUnsteadyPattern, bool);
  vtkBooleanMacro(UseUnsteadyPattern, bool);


  vtkSetMacro(UnsteadySolutionStartTimestep, int);
  vtkGetMacro(UnsteadySolutionStartTimestep, int);


  vtkSetMacro(DistributeBlocks, bool);
  vtkGetMacro(DistributeBlocks, bool);
  vtkBooleanMacro(DistributeBlocks, bool);


  void SetCacheMesh(bool enable);
  vtkGetMacro(CacheMesh, bool);
  vtkBooleanMacro(CacheMesh, bool);


  void SetCacheConnectivity(bool enable);
  vtkGetMacro(CacheConnectivity, bool);
  vtkBooleanMacro(CacheConnectivity, bool);


  void SetController(vtkMultiProcessController* c);
  vtkGetObjectMacro(Controller, vtkMultiProcessController);

  void Broadcast(vtkMultiProcessController* ctrl);

  static vtkInformationStringKey* FAMILY();
 
protected:
  vtkCGNSReader();
  ~vtkCGNSReader() override;
 
  int FillOutputPortInformation(int port, vtkInformation* info) override;
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  int RequestInformation(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
 
  int GetCurvilinearZone(
    int base, int zone, int cell_dim, int phys_dim, void* zsize, vtkMultiBlockDataSet* mbase);
 
  int GetUnstructuredZone(
    int base, int zone, int cell_dim, int phys_dim, void* zsize, vtkMultiBlockDataSet* mbase);

  int ReadUserDefinedData(int zone, vtkMultiBlockDataSet* mbase);
 
  vtkMultiProcessController* Controller = nullptr;
  vtkIdType ProcRank = 0;
  vtkIdType ProcSize = 1;
 
  vtkNew<vtkDataArraySelection> BaseSelection;
  vtkNew<vtkDataArraySelection> FamilySelection;
 
  vtkNew<vtkDataArraySelection> CellDataArraySelection;
  vtkNew<vtkDataArraySelection> FaceDataArraySelection;
  vtkNew<vtkDataArraySelection> PointDataArraySelection;
 
private:
  vtkCGNSReader(const vtkCGNSReader&) = delete;
  void operator=(const vtkCGNSReader&) = delete;
 
  std::string FileName;
  int DataLocation = vtkCGNSReader::CELL_DATA;
  bool LoadBndPatch = false;
  bool LoadSurfacePatch = false;
  bool LoadMesh = true;
  int DoublePrecisionMesh = 1;
  int CreateEachSolutionAsBlock = 0;
  bool IgnoreFlowSolutionPointers = false;
  bool UseUnsteadyPattern = false;
  bool DistributeBlocks = true;
  bool CacheMesh = false;
  bool CacheConnectivity = false;
  bool Use3DVector = true;
  bool FlipFaceNormals = false;
  int UnsteadySolutionStartTimestep = 0;
 
  // For internal cgio calls (low level IO)
  int cgioNum;          // cgio file reference
  double rootId;        // id of root node
  double currentZoneId; // id of node currently being read (zone)
 
  unsigned int NumberOfBases = 0;
  int ActualTimeStep = 0;
 
  class vtkPrivate;
  vtkPrivate* Internals;
  friend class vtkPrivate;
};
 
VTK_ABI_NAMESPACE_END
#endif // vtkCGNSReader_h