VTK
vtkLagrangeWedge.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkLagrangeWedge.h
5 
6  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7  All rights reserved.
8  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9 
10  This software is distributed WITHOUT ANY WARRANTY; without even
11  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12  PURPOSE. See the above copyright notice for more information.
13 
14 =========================================================================*/
37 #ifndef vtkLagrangeWedge_h
38 #define vtkLagrangeWedge_h
39 
40 #include "vtkCommonDataModelModule.h" // For export macro
41 #include "vtkNonLinearCell.h"
42 #include "vtkSmartPointer.h" // For member variable.
43 #include "vtkCellType.h" // For GetCellType.
44 #include "vtkNew.h" // For member variable.
45 
46 class vtkCellData;
47 class vtkDoubleArray;
48 class vtkWedge;
49 class vtkIdList;
50 class vtkPointData;
51 class vtkPoints;
52 class vtkVector3d;
53 class vtkVector3i;
54 class vtkLagrangeCurve;
58 
59 class VTKCOMMONDATAMODEL_EXPORT vtkLagrangeWedge : public vtkNonLinearCell
60 {
61 public:
62  static vtkLagrangeWedge* New();
64  void PrintSelf(ostream& os, vtkIndent indent) override;
65 
66  int GetCellType() override { return VTK_LAGRANGE_WEDGE; }
67  int GetCellDimension() override { return 3; }
68  int RequiresInitialization() override { return 1; }
69  int GetNumberOfEdges() override { return 9; }
70  int GetNumberOfFaces() override { return 5; }
71  vtkCell* GetEdge(int edgeId) override;
72  vtkCell* GetFace(int faceId) override;
73 
74  void Initialize() override;
75 
76  int CellBoundary(int subId, const double pcoords[3], vtkIdList* pts) override;
77  int EvaluatePosition(const double x[3], double closestPoint[3],
78  int& subId, double pcoords[3],
79  double& dist2, double weights[]) override;
81  int& subId, const double pcoords[3], double x[3],
82  double* weights) override;
83  void Contour(
84  double value, vtkDataArray* cellScalars,
86  vtkCellArray* lines, vtkCellArray* polys,
87  vtkPointData* inPd, vtkPointData* outPd,
88  vtkCellData* inCd, vtkIdType cellId, vtkCellData* outCd) override;
89  void Clip(
90  double value, vtkDataArray* cellScalars,
92  vtkPointData* inPd, vtkPointData* outPd,
93  vtkCellData* inCd, vtkIdType cellId, vtkCellData* outCd,
94  int insideOut) override;
95  int IntersectWithLine(const double p1[3], const double p2[3], double tol, double& t,
96  double x[3], double pcoords[3], int& subId) override;
97  int Triangulate(int index, vtkIdList* ptIds, vtkPoints* pts) override;
99  int subId, const double pcoords[3], const double* values,
100  int dim, double* derivs) override;
101  double* GetParametricCoords() override;
102  int GetParametricCenter(double center[3]) override;
103 
104  double GetParametricDistance(const double pcoords[3]) override;
105 
106  const int* GetOrder();
107  int GetOrder(int i) { return this->GetOrder()[i]; }
108 
109  void InterpolateFunctions(const double pcoords[3], double* weights) override;
110  void InterpolateDerivs(const double pcoords[3], double* derivs) override;
111 
112  bool SubCellCoordinatesFromId(vtkVector3i& ijk, int subId);
113  bool SubCellCoordinatesFromId(int& i, int& j, int& k, int subId);
114  static int PointIndexFromIJK(int i, int j, int k, const int* order);
115  int PointIndexFromIJK(int i, int j, int k);
116  bool TransformApproxToCellParams(int subCell, double* pcoords);
117  bool TransformFaceToCellParams(int bdyFace, double* pcoords);
118 
119  static int GetNumberOfApproximatingWedges(const int* order);
121  { return vtkLagrangeWedge::GetNumberOfApproximatingWedges(this->GetOrder()); }
122 
123 protected:
125  ~vtkLagrangeWedge() override;
126 
128  void PrepareApproxData(vtkPointData* pd, vtkCellData* cd, vtkIdType cellId, vtkDataArray* cellScalars);
130  int subId, vtkDataArray* scalarsIn = nullptr, vtkDataArray* scalarsOut = nullptr);
131 
134 
135  int Order[4];
148 
149 private:
150  vtkLagrangeWedge(const vtkLagrangeWedge&) = delete;
151  void operator=(const vtkLagrangeWedge&) = delete;
152 };
153 
155 {
156  center[0] = center[1] = 1./3.;
157  center[2] = 0.5;
158  return 0;
159 }
160 
161 #endif // vtkLagrangeWedge_h
vtkPoints
represent and manipulate 3D points
Definition: vtkPoints.h:40
VTK_LAGRANGE_WEDGE
@ VTK_LAGRANGE_WEDGE
Definition: vtkCellType.h:113
vtkLagrangeWedge::GetCellDimension
int GetCellDimension() override
Return the topological dimensional of the cell (0,1,2, or 3).
Definition: vtkLagrangeWedge.h:67
vtkLagrangeWedge
A 3D cell that represents an arbitrary order Lagrange wedge.
Definition: vtkLagrangeWedge.h:60
vtkLagrangeWedge::IntersectWithLine
int IntersectWithLine(const double p1[3], const double p2[3], double tol, double &t, double x[3], double pcoords[3], int &subId) override
Intersect with a ray.
vtkLagrangeWedge::BdyQuad
vtkNew< vtkLagrangeQuadrilateral > BdyQuad
Definition: vtkLagrangeWedge.h:144
vtkLagrangeWedge::PointIndexFromIJK
static int PointIndexFromIJK(int i, int j, int k, const int *order)
vtkPointData
represent and manipulate point attribute data
Definition: vtkPointData.h:38
vtkLagrangeWedge::GetParametricCoords
double * GetParametricCoords() override
Return a contiguous array of parametric coordinates of the points defining this cell.
vtkX3D::value
@ value
Definition: vtkX3D.h:220
vtkIdType
int vtkIdType
Definition: vtkType.h:347
vtkLagrangeWedge::TmpPts
vtkNew< vtkPoints > TmpPts
Definition: vtkLagrangeWedge.h:142
vtkLagrangeWedge::SubCellCoordinatesFromId
bool SubCellCoordinatesFromId(vtkVector3i &ijk, int subId)
vtkLagrangeWedge::EvaluatePosition
int EvaluatePosition(const double x[3], double closestPoint[3], int &subId, double pcoords[3], double &dist2, double weights[]) override
Given a point x[3] return inside(=1), outside(=0) cell, or (-1) computational problem encountered; ev...
vtkLagrangeWedge::GetParametricDistance
double GetParametricDistance(const double pcoords[3]) override
Return the distance of the parametric coordinate provided to the cell.
vtkLagrangeWedge::GetQuadrilateralFace
vtkLagrangeQuadrilateral * GetQuadrilateralFace(int di, int dj)
vtkLagrangeWedge::PointParametricCoordinates
vtkSmartPointer< vtkPoints > PointParametricCoordinates
Definition: vtkLagrangeWedge.h:136
vtkSmartPointer< vtkPoints >
vtkLagrangeWedge::SubCellCoordinatesFromId
bool SubCellCoordinatesFromId(int &i, int &j, int &k, int subId)
vtkLagrangeWedge::RequiresInitialization
int RequiresInitialization() override
Some cells require initialization prior to access.
Definition: vtkLagrangeWedge.h:68
vtkLagrangeWedge::Contour
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
Generate contouring primitives.
vtkX3D::center
@ center
Definition: vtkX3D.h:230
vtkLagrangeWedge::Initialize
void Initialize() override
vtkDataArray
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:55
vtkLagrangeWedge::ApproxPD
vtkSmartPointer< vtkPointData > ApproxPD
Definition: vtkLagrangeWedge.h:138
vtkLagrangeWedge::TransformFaceToCellParams
bool TransformFaceToCellParams(int bdyFace, double *pcoords)
vtkLagrangeWedge::Triangulate
int Triangulate(int index, vtkIdList *ptIds, vtkPoints *pts) override
Generate simplices of proper dimension.
vtkLagrangeWedge::ApproxCD
vtkSmartPointer< vtkCellData > ApproxCD
Definition: vtkLagrangeWedge.h:139
vtkVector3i
Definition: vtkVector.h:443
vtkLagrangeWedge::Derivatives
void Derivatives(int subId, const double pcoords[3], const double *values, int dim, double *derivs) override
Compute derivatives given cell subId and parametric coordinates.
vtkLagrangeWedge::GetCellType
int GetCellType() override
Return the type of cell.
Definition: vtkLagrangeWedge.h:66
vtkLagrangeWedge::TmpIds
vtkNew< vtkIdList > TmpIds
Definition: vtkLagrangeWedge.h:143
vtkLagrangeWedge::GetNumberOfApproximatingWedges
static int GetNumberOfApproximatingWedges(const int *order)
vtkLagrangeWedge::TransformApproxToCellParams
bool TransformApproxToCellParams(int subCell, double *pcoords)
vtkWedge
a 3D cell that represents a linear wedge
Definition: vtkWedge.h:50
vtkCell
abstract class to specify cell behavior
Definition: vtkCell.h:60
vtkLagrangeWedge::GetNumberOfApproximatingWedges
int GetNumberOfApproximatingWedges()
Definition: vtkLagrangeWedge.h:120
vtkCellData
represent and manipulate cell attribute data
Definition: vtkCellData.h:39
vtkIndent
a simple class to control print indentation
Definition: vtkIndent.h:40
vtkCellArray
object to represent cell connectivity
Definition: vtkCellArray.h:51
vtkLagrangeWedge::CellBoundary
int CellBoundary(int subId, const double pcoords[3], vtkIdList *pts) override
Given parametric coordinates of a point, return the closest cell boundary, and whether the point is i...
vtkLagrangeWedge::GetNumberOfEdges
int GetNumberOfEdges() override
Return the number of edges in the cell.
Definition: vtkLagrangeWedge.h:69
vtkCellType.h
vtkLagrangeWedge::GetOrder
int GetOrder(int i)
Definition: vtkLagrangeWedge.h:107
vtkLagrangeQuadrilateral
Definition: vtkLagrangeQuadrilateral.h:39
vtkLagrangeWedge::Clip
void Clip(double value, vtkDataArray *cellScalars, vtkIncrementalPointLocator *locator, vtkCellArray *polys, vtkPointData *inPd, vtkPointData *outPd, vtkCellData *inCd, vtkIdType cellId, vtkCellData *outCd, int insideOut) override
Cut (or clip) the cell based on the input cellScalars and the specified value.
vtkSmartPointer.h
vtkIncrementalPointLocator
Abstract class in support of both point location and point insertion.
Definition: vtkIncrementalPointLocator.h:52
vtkIdList
list of point or cell ids
Definition: vtkIdList.h:37
vtkLagrangeWedge::GetParametricCenter
int GetParametricCenter(double center[3]) override
Return center of the cell in parametric coordinates.
Definition: vtkLagrangeWedge.h:154
vtkLagrangeTriangle
A 2D cell that represents an arbitrary order Lagrange triangle.
Definition: vtkLagrangeTriangle.h:53
vtkNew< vtkDoubleArray >
vtkLagrangeWedge::GetTriangularFace
vtkLagrangeTriangle * GetTriangularFace(int iAxis, int k)
vtkLagrangeInterpolation
Definition: vtkLagrangeInterpolation.h:35
vtkLagrangeWedge::PointIndexFromIJK
int PointIndexFromIJK(int i, int j, int k)
vtkLagrangeWedge::GetNumberOfFaces
int GetNumberOfFaces() override
Return the number of faces in the cell.
Definition: vtkLagrangeWedge.h:70
vtkLagrangeWedge::PrepareApproxData
void PrepareApproxData(vtkPointData *pd, vtkCellData *cd, vtkIdType cellId, vtkDataArray *cellScalars)
vtkLagrangeWedge::~vtkLagrangeWedge
~vtkLagrangeWedge() override
vtkLagrangeWedge::InterpolateDerivs
void InterpolateDerivs(const double pcoords[3], double *derivs) override
vtkX3D::order
@ order
Definition: vtkX3D.h:440
vtkLagrangeWedge::PrintSelf
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
vtkLagrangeWedge::EvaluateLocation
void EvaluateLocation(int &subId, const double pcoords[3], double x[3], double *weights) override
Determine global coordinate (x[3]) from subId and parametric coordinates.
vtkLagrangeWedge::Scalars
vtkNew< vtkDoubleArray > Scalars
Definition: vtkLagrangeWedge.h:141
vtkLagrangeWedge::BdyTri
vtkNew< vtkLagrangeTriangle > BdyTri
Definition: vtkLagrangeWedge.h:145
vtkLagrangeWedge::CellScalars
vtkNew< vtkDoubleArray > CellScalars
Definition: vtkLagrangeWedge.h:140
vtkNonLinearCell.h
vtkLagrangeWedge::GetFace
vtkCell * GetFace(int faceId) override
Return the face cell from the faceId of the cell.
vtkNew.h
vtkNonLinearCell
abstract superclass for non-linear cells
Definition: vtkNonLinearCell.h:37
vtkLagrangeWedge::Approx
vtkSmartPointer< vtkWedge > Approx
Definition: vtkLagrangeWedge.h:137
vtkLagrangeWedge::GetEdge
vtkCell * GetEdge(int edgeId) override
Return the edge cell from the edgeId of the cell.
vtkLagrangeWedge::vtkLagrangeWedge
vtkLagrangeWedge()
vtkLagrangeCurve
Definition: vtkLagrangeCurve.h:38
vtkLagrangeWedge::GetApproximateWedge
vtkWedge * GetApproximateWedge(int subId, vtkDataArray *scalarsIn=nullptr, vtkDataArray *scalarsOut=nullptr)
vtkLagrangeWedge::New
static vtkLagrangeWedge * New()
vtkLagrangeWedge::GetApprox
vtkWedge * GetApprox()
vtkCell::GetParametricCenter
virtual int GetParametricCenter(double pcoords[3])
Return center of the cell in parametric coordinates.
vtkDoubleArray
dynamic, self-adjusting array of double
Definition: vtkDoubleArray.h:42
vtkLagrangeWedge::BdyEdge
vtkNew< vtkLagrangeCurve > BdyEdge
Definition: vtkLagrangeWedge.h:146
vtkLagrangeWedge::Interp
vtkNew< vtkLagrangeInterpolation > Interp
Definition: vtkLagrangeWedge.h:147
vtkX3D::index
@ index
Definition: vtkX3D.h:246
vtkVector3d
Definition: vtkVector.h:463
vtkLagrangeWedge::GetOrder
const int * GetOrder()
vtkLagrangeWedge::InterpolateFunctions
void InterpolateFunctions(const double pcoords[3], double *weights) override