vtkTriQuadraticPyramid.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
 * \endverbatim
 *
 * @sa
 * vtkQuadraticEdge vtkBiQuadraticTriangle vtkQuadraticTetra
 * vtkQuadraticHexahedron vtkBiQuadraticQuad vtkQuadraticWedge
 *
 * @par Thanks:
 * The shape functions and derivatives could be implemented thanks to
 * the doctoral dissertation: R.S. Browning. A Second-Order 19-Node Pyramid
 * Finite Element Suitable for Lumped Mass Explicit Dynamic methods in
 * Nonlinear Solid Mechanics, University of Alabama at Birmingham.
 
    @par      Tests:
              @ref c2_vtk_t_vtkTriQuadraticPyramid "vtkTriQuadraticPyramid (Tests)"
 */
 
#ifndef vtkTriQuadraticPyramid_h
#define vtkTriQuadraticPyramid_h
 
#include "vtkCommonDataModelModule.h" // For export macro
#include "vtkNew.h"                   // initialize cells that are used for the implementation
#include "vtkNonLinearCell.h"
 
VTK_ABI_NAMESPACE_BEGIN
class vtkQuadraticEdge;
class vtkBiQuadraticQuad;
class vtkBiQuadraticTriangle;
class vtkTetra;
class vtkPyramid;
class vtkDoubleArray;
 
class VTKCOMMONDATAMODEL_EXPORT vtkTriQuadraticPyramid : public vtkNonLinearCell
{
public:
  static vtkTriQuadraticPyramid* New();
  vtkTypeMacro(vtkTriQuadraticPyramid, vtkNonLinearCell);
  void PrintSelf(ostream& os, vtkIndent indent) override;


  int GetCellType() override { return VTK_TRIQUADRATIC_PYRAMID; }
  int GetCellDimension() override { return 3; }
  int GetNumberOfEdges() override { return 8; }
  int GetNumberOfFaces() override { return 5; }
  vtkCell* GetEdge(int edgeId) override;
  vtkCell* GetFace(int faceId) override;
 
  int CellBoundary(int subId, const double pcoords[3], vtkIdList* pts) override;
  void Contour(double value, vtkDataArray* cellScalars, vtkIncrementalPointLocator* locator,
    vtkCellArray* verts, vtkCellArray* lines, vtkCellArray* polys, vtkPointData* inPd,
    vtkPointData* outPd, vtkCellData* inCd, vtkIdType cellId, vtkCellData* outCd) override;
  int EvaluatePosition(const double x[3], double closestPoint[3], int& subId, double pcoords[3],
    double& dist2, double weights[]) override;
  void EvaluateLocation(int& subId, const double pcoords[3], double x[3], double* weights) override;

  int IntersectWithLine(const double p1[3], const double p2[3], double tol, double& t, double x[3],
    double pcoords[3], int& subId) override;
 
  int TriangulateLocalIds(int index, vtkIdList* ptIds) override;
  void Derivatives(
    int subId, const double pcoords[3], const double* values, int dim, double* derivs) override;
  double* GetParametricCoords() override;

  void Clip(double value, vtkDataArray* cellScalars, vtkIncrementalPointLocator* locator,
    vtkCellArray* tets, vtkPointData* inPd, vtkPointData* outPd, vtkCellData* inCd,
    vtkIdType cellId, vtkCellData* outCd, int insideOut) override;

  int GetParametricCenter(double pcoords[3]) override;

  double GetParametricDistance(const double pcoords[3]) override;
 
  static void InterpolationFunctions(const double pcoords[3], double weights[19]);
  static void InterpolationDerivs(const double pcoords[3], double derivs[57]);

  void InterpolateFunctions(const double pcoords[3], double weights[19]) override
  {
    vtkTriQuadraticPyramid::InterpolationFunctions(pcoords, weights);
  }
  void InterpolateDerivs(const double pcoords[3], double derivs[57]) override
  {
    vtkTriQuadraticPyramid::InterpolationDerivs(pcoords, derivs);
  }


  void JacobianInverse(const double pcoords[3], double** inverse, double derivs[57]);


  static const vtkIdType* GetEdgeArray(vtkIdType edgeId);
  static const vtkIdType* GetFaceArray(vtkIdType faceId);
 
protected:
  vtkTriQuadraticPyramid();
  ~vtkTriQuadraticPyramid() override;
 
  vtkNew<vtkQuadraticEdge> Edge;
  vtkNew<vtkBiQuadraticTriangle> TriangleFace;
  vtkNew<vtkBiQuadraticTriangle> TriangleFace2;
  vtkNew<vtkBiQuadraticQuad> QuadFace;
  vtkNew<vtkTetra> Tetra;
  vtkNew<vtkPyramid> Pyramid;
  vtkNew<vtkDoubleArray> Scalars; // used to avoid New/Delete in contouring/clipping
 
private:
  vtkTriQuadraticPyramid(const vtkTriQuadraticPyramid&) = delete;
  void operator=(const vtkTriQuadraticPyramid&) = delete;
};
//----------------------------------------------------------------------------
// Return the center of the tri-quadratic pyramid in parametric coordinates.
//
inline int vtkTriQuadraticPyramid::GetParametricCenter(double pcoords[3])
{
  pcoords[0] = pcoords[1] = 0.5;
  // This is different compared to the last node, because the last node
  // is the centroid of the nodes 0-4, and not the centroid of the nodes 0-17.
  // So pcoords[2] is defined as followed to pass the requirement of TestGenericCell
  pcoords[2] = 283.0 / 456.0;
  return 0;
}
 
VTK_ABI_NAMESPACE_END
#endif