vtkIOSSReader.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-FileCopyrightText: Copyright (c) Sandia Corporation
// SPDX-License-Identifier: BSD-3-Clause

#ifndef vtkIOSSReader_h
#define vtkIOSSReader_h

#include "vtkDeprecation.h"  // for VTK_DEPRECATED_IN_9_6_0
#include "vtkIOIOSSModule.h" // for export macros
#include "vtkNew.h"          // for vtkNew
#include "vtkReaderAlgorithm.h"

#include <map> // for std::map

VTK_ABI_NAMESPACE_BEGIN
class vtkDataArraySelection;
class vtkDataAssembly;
class vtkIOSSReaderInternal;
class vtkMultiProcessController;
class vtkStringArray;

class VTKIOIOSS_EXPORT vtkIOSSReader : public vtkReaderAlgorithm
{
public:
  static vtkIOSSReader* New();
  vtkTypeMacro(vtkIOSSReader, vtkReaderAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;


  void AddFileName(VTK_FILEPATH const char* fname);
  void ClearFileNames();
  VTK_FILEPATH const char* GetFileName(int index) const;
  int GetNumberOfFileNames() const;

  void SetFileName(VTK_FILEPATH const char* fname);


  vtkSetStringMacro(DatabaseTypeOverride);
  vtkGetStringMacro(DatabaseTypeOverride);


  void SetCatalystConduitChannelName(const std::string& newString);
  std::string GetCatalystConduitChannelName();


  void SetDisplacementMagnitude(double magnitude);
  double GetDisplacementMagnitude();


  void SetGroupNumericVectorFieldComponents(bool value);
  bool GetGroupNumericVectorFieldComponents();
  vtkBooleanMacro(GroupNumericVectorFieldComponents, bool);


  void SetGroupAlphabeticVectorFieldComponents(bool value);
  bool GetGroupAlphabeticVectorFieldComponents();
  vtkBooleanMacro(GroupAlphabeticVectorFieldComponents, bool);


  void SetFieldSuffixSeparator(const char* value);
  std::string GetFieldSuffixSeparator();


  void SetScanForRelatedFiles(bool value);
  vtkGetMacro(ScanForRelatedFiles, bool);
  vtkBooleanMacro(ScanForRelatedFiles, bool);


  vtkSetVector2Macro(FileRange, int);
  vtkGetVector2Macro(FileRange, int);
  vtkSetClampMacro(FileStride, int, 1, VTK_INT_MAX);
  vtkGetMacro(FileStride, int);


  void SetCaching(bool value);
  vtkGetMacro(Caching, bool);
  vtkBooleanMacro(Caching, bool);


  void SetMergeExodusEntityBlocks(bool value);
  vtkGetMacro(MergeExodusEntityBlocks, bool);
  vtkBooleanMacro(MergeExodusEntityBlocks, bool);


  void SetElementAndSideIds(bool value);
  vtkGetMacro(ElementAndSideIds, bool);
  vtkBooleanMacro(ElementAndSideIds, bool);


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


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


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


  void SetRemoveUnusedPoints(bool);
  vtkGetMacro(RemoveUnusedPoints, bool);
  vtkBooleanMacro(RemoveUnusedPoints, bool);


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


  VTK_DEPRECATED_IN_9_6_0("Use vtkDataArraySelection* GetGlobalFieldSelection() instead")
  virtual void SetReadGlobalFields(bool value);
  VTK_DEPRECATED_IN_9_6_0("Use vtkDataArraySelection* GetGlobalFieldSelection() instead")
  virtual bool GetReadGlobalFields();
  VTK_DEPRECATED_IN_9_6_0("Use vtkDataArraySelection* GetGlobalFieldSelection() instead")
  virtual void ReadGlobalFieldsOn();
  VTK_DEPRECATED_IN_9_6_0("Use vtkDataArraySelection* GetGlobalFieldSelection() instead")
  virtual void ReadGlobalFieldsOff();


  void SetReadAllFilesToDetermineStructure(bool);
  vtkGetMacro(ReadAllFilesToDetermineStructure, bool);
  vtkBooleanMacro(ReadAllFilesToDetermineStructure, bool);


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


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


  void AddProperty(const char* name, int value);
  void AddProperty(const char* name, double value);
  void AddProperty(const char* name, void* value);
  void AddProperty(const char* name, const char* value);
  void RemoveProperty(const char* name);
  void ClearProperties();

  enum EntityType
  {
    NODEBLOCK = 0,
    EDGEBLOCK = 1,
    FACEBLOCK = 2,
    ELEMENTBLOCK = 3,
    STRUCTUREDBLOCK = 4,
    NODESET = 5,
    EDGESET = 6,
    FACESET = 7,
    ELEMENTSET = 8,
    SIDESET = 9,
    NUMBER_OF_ENTITY_TYPES = 10,

    BLOCK_START = NODEBLOCK,
    BLOCK_END = NODESET,
    SET_START = NODESET,
    SET_END = NUMBER_OF_ENTITY_TYPES,
    ENTITY_START = NODEBLOCK,
    ENTITY_END = NUMBER_OF_ENTITY_TYPES,
  };

  static bool GetEntityTypeIsBlock(int type) { return (type >= BLOCK_START && type < BLOCK_END); }
  static bool GetEntityTypeIsSet(int type) { return (type >= SET_START && type < SET_END); }
  static const char* GetDataAssemblyNodeNameForEntityType(int type);
  static const char* GetMergedEntityNameForEntityType(int type);

  vtkDataArraySelection* GetEntitySelection(int type);
  vtkDataArraySelection* GetNodeBlockSelection() { return this->GetEntitySelection(NODEBLOCK); }
  vtkDataArraySelection* GetEdgeBlockSelection() { return this->GetEntitySelection(EDGEBLOCK); }
  vtkDataArraySelection* GetFaceBlockSelection() { return this->GetEntitySelection(FACEBLOCK); }
  vtkDataArraySelection* GetElementBlockSelection()
  {
    return this->GetEntitySelection(ELEMENTBLOCK);
  }
  vtkDataArraySelection* GetStructuredBlockSelection()
  {
    return this->GetEntitySelection(STRUCTUREDBLOCK);
  }
  vtkDataArraySelection* GetNodeSetSelection() { return this->GetEntitySelection(NODESET); }
  vtkDataArraySelection* GetEdgeSetSelection() { return this->GetEntitySelection(EDGESET); }
  vtkDataArraySelection* GetFaceSetSelection() { return this->GetEntitySelection(FACESET); }
  vtkDataArraySelection* GetElementSetSelection() { return this->GetEntitySelection(ELEMENTSET); }
  vtkDataArraySelection* GetSideSetSelection() { return this->GetEntitySelection(SIDESET); }

  vtkDataArraySelection* GetFieldSelection(int type);
  vtkDataArraySelection* GetNodeBlockFieldSelection() { return this->GetFieldSelection(NODEBLOCK); }
  vtkDataArraySelection* GetEdgeBlockFieldSelection() { return this->GetFieldSelection(EDGEBLOCK); }
  vtkDataArraySelection* GetFaceBlockFieldSelection() { return this->GetFieldSelection(FACEBLOCK); }
  vtkDataArraySelection* GetElementBlockFieldSelection()
  {
    return this->GetFieldSelection(ELEMENTBLOCK);
  }
  vtkDataArraySelection* GetStructuredBlockFieldSelection()
  {
    return this->GetFieldSelection(STRUCTUREDBLOCK);
  }
  vtkDataArraySelection* GetNodeSetFieldSelection() { return this->GetFieldSelection(NODESET); }
  vtkDataArraySelection* GetEdgeSetFieldSelection() { return this->GetFieldSelection(EDGESET); }
  vtkDataArraySelection* GetFaceSetFieldSelection() { return this->GetFieldSelection(FACESET); }
  vtkDataArraySelection* GetElementSetFieldSelection()
  {
    return this->GetFieldSelection(ELEMENTSET);
  }
  vtkDataArraySelection* GetSideSetFieldSelection() { return this->GetFieldSelection(SIDESET); }
  vtkDataArraySelection* GetGlobalFieldSelection();

  void RemoveAllEntitySelections();
  void RemoveAllFieldSelections();
  void RemoveAllSelections()
  {
    this->RemoveAllEntitySelections();
    this->RemoveAllFieldSelections();
  }


  const std::map<std::string, vtkTypeInt64>& GetEntityIdMap(int type) const;
  const std::map<std::string, vtkTypeInt64>& GetNodeBlockIdMap() const
  {
    return this->GetEntityIdMap(NODEBLOCK);
  }
  const std::map<std::string, vtkTypeInt64>& GetEdgeBlockIdMap() const
  {
    return this->GetEntityIdMap(EDGEBLOCK);
  }
  const std::map<std::string, vtkTypeInt64>& GetFaceBlockIdMap() const
  {
    return this->GetEntityIdMap(FACEBLOCK);
  }
  const std::map<std::string, vtkTypeInt64>& GetElementBlockIdMap() const
  {
    return this->GetEntityIdMap(ELEMENTBLOCK);
  }
  const std::map<std::string, vtkTypeInt64>& GetStructuredBlockIdMap() const
  {
    return this->GetEntityIdMap(STRUCTUREDBLOCK);
  }
  const std::map<std::string, vtkTypeInt64>& GetNodeSetIdMap() const
  {
    return this->GetEntityIdMap(NODESET);
  }
  const std::map<std::string, vtkTypeInt64>& GetEdgeSetIdMap() const
  {
    return this->GetEntityIdMap(EDGESET);
  }
  const std::map<std::string, vtkTypeInt64>& GetFaceSetIdMap() const
  {
    return this->GetEntityIdMap(FACESET);
  }
  const std::map<std::string, vtkTypeInt64>& GetElementSetIdMap() const
  {
    return this->GetEntityIdMap(ELEMENTSET);
  }
  const std::map<std::string, vtkTypeInt64>& GetSideSetIdMap() const
  {
    return this->GetEntityIdMap(SIDESET);
  }


  vtkStringArray* GetEntityIdMapAsString(int type) const;
  vtkStringArray* GetNodeBlockIdMapAsString() const
  {
    return this->GetEntityIdMapAsString(NODEBLOCK);
  }
  vtkStringArray* GetEdgeBlockIdMapAsString() const
  {
    return this->GetEntityIdMapAsString(EDGEBLOCK);
  }
  vtkStringArray* GetFaceBlockIdMapAsString() const
  {
    return this->GetEntityIdMapAsString(FACEBLOCK);
  }
  vtkStringArray* GetElementBlockIdMapAsString() const
  {
    return this->GetEntityIdMapAsString(ELEMENTBLOCK);
  }
  vtkStringArray* GetStructuredBlockIdMapAsString() const
  {
    return this->GetEntityIdMapAsString(STRUCTUREDBLOCK);
  }
  vtkStringArray* GetNodeSetIdMapAsString() const { return this->GetEntityIdMapAsString(NODESET); }
  vtkStringArray* GetEdgeSetIdMapAsString() const { return this->GetEntityIdMapAsString(EDGESET); }
  vtkStringArray* GetFaceSetIdMapAsString() const { return this->GetEntityIdMapAsString(FACESET); }
  vtkStringArray* GetElementSetIdMapAsString() const
  {
    return this->GetEntityIdMapAsString(ELEMENTSET);
  }
  vtkStringArray* GetSideSetIdMapAsString() const { return this->GetEntityIdMapAsString(SIDESET); }


  vtkDataAssembly* GetAssembly();

  vtkGetMacro(AssemblyTag, int);


  bool AddSelector(const char* selector);
  void ClearSelectors();
  void SetSelector(const char* selector);


  int GetNumberOfSelectors() const;
  const char* GetSelector(int index) const;


  int ReadMetaData(vtkInformation* metadata) override;
  int ReadMesh(int piece, int npieces, int nghosts, int timestep, vtkDataObject* output) override;
  int ReadPoints(int, int, int, int, vtkDataObject*) override { return 1; }
  int ReadArrays(int, int, int, int, vtkDataObject*) override { return 1; }

  vtkMTimeType GetMTime() override;

  static bool DoTestFilePatternMatching();

  vtkTypeBool ProcessRequest(
    vtkInformation* request, vtkInformationVector** inInfo, vtkInformationVector* outInfo) override;

  static vtkInformationIntegerKey* ENTITY_ID();

protected:
  friend class vtkIOSSReaderInternal;

  vtkIOSSReader();
  ~vtkIOSSReader() override;

  // For use by vtkIOSSReaderInternal.
  std::map<std::string, vtkTypeInt64>& GetEntityIdMap(int type);

  int FillOutputPortInformation(int port, vtkInformation* info) override;

  static vtkInformationIntegerKey* ENTITY_TYPE();

  int AssemblyTag;
  vtkIOSSReaderInternal* Internals;

private:
  vtkIOSSReader(const vtkIOSSReader&) = delete;
  void operator=(const vtkIOSSReader&) = delete;
  vtkNew<vtkDataArraySelection> EntitySelection[NUMBER_OF_ENTITY_TYPES];
  vtkNew<vtkDataArraySelection> EntityFieldSelection[NUMBER_OF_ENTITY_TYPES];
  vtkNew<vtkDataArraySelection> GlobalFieldSelection;
  std::map<std::string, vtkTypeInt64> EntityIdMap[NUMBER_OF_ENTITY_TYPES + 1];
  vtkNew<vtkStringArray> EntityIdMapStrings[NUMBER_OF_ENTITY_TYPES + 1];

  vtkMultiProcessController* Controller;
  bool Caching;
  bool MergeExodusEntityBlocks;
  bool ElementAndSideIds;
  bool GenerateFileId;
  bool ScanForRelatedFiles;
  bool ReadIds;
  bool RemoveUnusedPoints;
  bool ApplyDisplacements;
  bool ReadAllFilesToDetermineStructure;
  bool ReadQAAndInformationRecords;
  char* DatabaseTypeOverride;
  int FileRange[2];
  int FileStride;
  bool IncludeGhostNodes;
};

VTK_ABI_NAMESPACE_END
#endif