vtkDGCell.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkDGCell_h
#define vtkDGCell_h

#include "vtkFiltersCellGridModule.h" // For export macro.

#include "vtkCellAttribute.h"      // For CellTypeInfo.
#include "vtkCellGridResponders.h" // For vtkCellGridResponders::TagSet.
#include "vtkCellMetadata.h"
#include "vtkDGOperatorEntry.h" // For GetOperatorEntry API.
#include "vtkDataArray.h"       // for vtkDataArray::PrintValues
#include "vtkStringToken.h"     // For vtkStringToken::Hash.
#include "vtkVector.h"          // For GetSignedParametricDistance, GetParametricCenterOfSide APIs.

#include <vector> // for side connectivity

VTK_ABI_NAMESPACE_BEGIN

class vtkCellAttribute;
class vtkCellGrid;
class vtkDataArray;
class vtkDataSetAttributes;
class vtkTypeFloat32Array;
class vtkTypeInt32Array;

class VTKFILTERSCELLGRID_EXPORT vtkDGCell : public vtkCellMetadata
{
public:
  using OperatorMap = std::unordered_map<vtkStringToken, // operator name
    std::unordered_map<vtkStringToken,                   // function space
      std::unordered_map<vtkStringToken,                 // basis name
        std::unordered_map<int,                          // order or -1
          std::unordered_map<vtkStringToken,             // cell type-name
            vtkDGOperatorEntry>>>>>;

  enum Shape : int
  {
    Vertex,        
    Edge,          
    Triangle,      
    Quadrilateral, 
    Tetrahedron,   
    Hexahedron,    
    Wedge,         
    Pyramid,       

    None 
    // It is probably more efficient to create a new cell type for arbitrary shapes
    // than to attempt generalizing vtkDGCell, but for the sake of completeness:
    // Polygon       //!< We may one day support an n-sided polygonal face.
    // Polyhedron    //!< We may one day support an n-faced polyhedral volume with polygonal sides.
  };

  struct Source
  {
    Source() = default;
    Source(const Source&) = default;
    Source(vtkDataArray* conn, vtkIdType off, bool blank, Shape shape, int sideType);
    Source(vtkDataArray* conn, vtkIdType off, bool blank, Shape shape, int sideType, int selnType,
      vtkDataArray* nodalGhostMarks);
    Source& operator=(const Source&) = default;
    virtual ~Source() = default;

    friend ostream& operator<<(ostream& os, const Source& source)
    {
      os << "vtkDGCell::Source(" << &source << ")\n";
      source.Connectivity->PrintValues(os);
      os << "Connectivity: " << source.Connectivity << '\n';
      os << "NodalGhostMarks: " << source.NodalGhostMarks << '\n';
      os << "Offset: " << source.Offset << '\n';
      os << "Blanked: " << (source.Blanked ? "T\n" : "F\n");
      os << "SourceShape: " << source.SourceShape << '\n';
      os << "SideType: " << source.SideType << '\n';
      os << "SelectionType: " << source.SelectionType << '\n';
      return os;
    }

    vtkDataArray* Connectivity{ nullptr };

    vtkDataArray* NodalGhostMarks{ nullptr };

    vtkIdType Offset{ 0 };

    bool Blanked{ false };

    Shape SourceShape{ Shape::None };

    int SideType{ -1 };

    int SelectionType{ -1 };
  };

  vtkTypeMacro(vtkDGCell, vtkCellMetadata);
  vtkInheritanceHierarchyOverrideMacro(vtkDGCell);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  Source& GetCellSpec() { return this->CellSpec; }

  std::vector<Source>& GetSideSpecs() { return this->SideSpecs; }

  const Source& GetCellSource(int sideType = -1) const;
  Source& GetCellSource(int sideType = -1);

  std::size_t GetNumberOfCellSources() const { return this->SideSpecs.size(); }

  vtkDataArray* GetCellSourceConnectivity(int sideType = -1) const;
  vtkDataArray* GetCellSourceNodalGhostMarks(int sideType = -1) const;
  vtkIdType GetCellSourceOffset(int sideType = -1) const;
  bool GetCellSourceIsBlanked(int sideType = -1) const;
  Shape GetCellSourceShape(int sideType = -1) const;
  int GetCellSourceSideType(int sideType = -1) const;
  int GetCellSourceSelectionType(int sideType = -1) const;

  vtkIdType GetNumberOfCells() override;

  void ShallowCopy(vtkCellMetadata* other) override;
  void DeepCopy(vtkCellMetadata* other) override;

  virtual double GetSignedParametricDistance(const vtkVector3d& rst) const = 0;

  bool IsInside(const vtkVector3d& rst, double tolerance = 1e-6) const
  {
    return this->GetSignedParametricDistance(rst) <= std::abs(tolerance);
  }

  static int GetShapeCornerCount(Shape shape);
  static int GetShapeDimension(Shape shape);
  static vtkStringToken GetShapeName(Shape shape);
  static Shape GetShapeEnum(vtkStringToken shapeName);

  virtual Shape GetShape() const = 0;

  virtual int GetDimension() const { return vtkDGCell::GetShapeDimension(this->GetShape()); }

  virtual int GetNumberOfCorners() const
  {
    return vtkDGCell::GetShapeCornerCount(this->GetShape());
  }

  virtual const std::array<double, 3>& GetCornerParameter(int corner) const = 0;

  virtual vtkVector3d GetParametricCenterOfSide(int sideId) const;

  virtual int GetNumberOfSideTypes() const = 0;

  virtual std::pair<int, int> GetSideRangeForType(int sideType) const = 0;

  int* GetSideRangeForSideType(int sideType) VTK_SIZEHINT(2);

  virtual std::pair<int, int> GetSideRangeForDimension(int dimension) const;

  int* GetSideRangeForSideDimension(int sideDimension) VTK_SIZEHINT(2);

  virtual int GetNumberOfSidesOfDimension(int dimension) const = 0;

  virtual Shape GetSideShape(int side) const = 0;

  virtual int GetSideTypeForShape(Shape s) const;

  virtual const std::vector<vtkIdType>& GetSideConnectivity(int side) const = 0;

  virtual const std::vector<vtkIdType>& GetSidesOfSide(int side) const = 0;

  virtual vtkTypeFloat32Array* GetReferencePoints() const = 0;

  virtual vtkTypeInt32Array* GetSideConnectivity() const = 0;

  virtual vtkTypeInt32Array* GetSideOffsetsAndShapes() const = 0;

  void FillReferencePoints(vtkTypeFloat32Array* arr) const;

  void FillSideConnectivity(vtkTypeInt32Array* arr) const;

  void FillSideOffsetsAndShapes(vtkTypeInt32Array* arr) const;

  vtkCellGridResponders::TagSet GetAttributeTags(
    vtkCellAttribute* attribute, bool inheritedTypes = false);

  vtkDGOperatorEntry GetOperatorEntry(
    vtkStringToken opName, const vtkCellAttribute::CellTypeInfo& attributeInfo);

  static OperatorMap& GetOperators();

protected:
  vtkDGCell();
  ~vtkDGCell() override;

  Source CellSpec;
  std::vector<Source> SideSpecs;

private:
  vtkDGCell(const vtkDGCell&) = delete;
  void operator=(const vtkDGCell&) = delete;
};

VTK_ABI_NAMESPACE_END
#endif