Intrepid2
|
A stateless class for operations on cell data. Provides methods for: More...
#include <Intrepid2_CellTools.hpp>
Public Member Functions | |
CellTools ()=default | |
Default constructor. | |
~CellTools ()=default | |
Destructor. | |
Static Public Member Functions | |
static bool | hasReferenceCell (const shards::CellTopology cellTopo) |
Checks if a cell topology has reference cell. | |
template<typename jacobianValueType , class ... jacobianProperties, typename pointValueType , class ... pointProperties, typename WorksetType , typename HGradBasisType > | |
static void | setJacobian (Kokkos::DynRankView< jacobianValueType, jacobianProperties... > jacobian, const Kokkos::DynRankView< pointValueType, pointProperties... > points, const WorksetType worksetCell, const Teuchos::RCP< HGradBasisType > basis, const int startCell=0, const int endCell=-1) |
Computes the Jacobian matrix DF of the reference-to-physical frame map F. | |
template<typename jacobianValueType , class ... jacobianProperties, typename BasisGradientsType , typename WorksetType > | |
static void | setJacobian (Kokkos::DynRankView< jacobianValueType, jacobianProperties... > jacobian, const WorksetType worksetCell, const BasisGradientsType gradients, const int startCell=0, const int endCell=-1) |
Computes the Jacobian matrix DF of the reference-to-physical frame map F. | |
template<typename jacobianValueType , class ... jacobianProperties, typename pointValueType , class ... pointProperties, typename worksetCellValueType , class ... worksetCellProperties> | |
static void | setJacobian (Kokkos::DynRankView< jacobianValueType, jacobianProperties... > jacobian, const Kokkos::DynRankView< pointValueType, pointProperties... > points, const Kokkos::DynRankView< worksetCellValueType, worksetCellProperties... > worksetCell, const shards::CellTopology cellTopo) |
Computes the Jacobian matrix DF of the reference-to-physical frame map F. | |
template<typename jacobianInvValueType , class ... jacobianInvProperties, typename jacobianValueType , class ... jacobianProperties> | |
static void | setJacobianInv (Kokkos::DynRankView< jacobianInvValueType, jacobianInvProperties... > jacobianInv, const Kokkos::DynRankView< jacobianValueType, jacobianProperties... > jacobian) |
Computes the inverse of the Jacobian matrix DF of the reference-to-physical frame map F. | |
template<typename jacobianDetValueType , class ... jacobianDetProperties, typename jacobianValueType , class ... jacobianProperties> | |
static void | setJacobianDet (Kokkos::DynRankView< jacobianDetValueType, jacobianDetProperties... > jacobianDet, const Kokkos::DynRankView< jacobianValueType, jacobianProperties... > jacobian) |
Computes the determinant of the Jacobian matrix DF of the reference-to-physical frame map F. | |
template<class PointScalar > | |
static Data< PointScalar, DeviceType > | allocateJacobianDet (const Data< PointScalar, DeviceType > &jacobian) |
Allocates and returns a Data container suitable for storing determinants corresponding to the Jacobians in the Data container provided. | |
template<class PointScalar > | |
static Data< PointScalar, DeviceType > | allocateJacobianInv (const Data< PointScalar, DeviceType > &jacobian) |
Allocates and returns a Data container suitable for storing inverses corresponding to the Jacobians in the Data container provided. | |
template<class PointScalar > | |
static void | setJacobianDet (Data< PointScalar, DeviceType > &jacobianDet, const Data< PointScalar, DeviceType > &jacobian) |
Computes determinants corresponding to the Jacobians in the Data container provided. | |
template<class PointScalar > | |
static void | setJacobianDetInv (Data< PointScalar, DeviceType > &jacobianDet, const Data< PointScalar, DeviceType > &jacobian) |
Computes reciprocals of determinants corresponding to the Jacobians in the Data container provided. | |
template<class PointScalar > | |
static void | setJacobianInv (Data< PointScalar, DeviceType > &jacobianInv, const Data< PointScalar, DeviceType > &jacobian) |
Computes determinants corresponding to the Jacobians in the Data container provided. | |
template<typename cellCenterValueType , class ... cellCenterProperties> | |
static void | getReferenceCellCenter (Kokkos::DynRankView< cellCenterValueType, cellCenterProperties... > cellCenter, const shards::CellTopology cell) |
Computes the Cartesian coordinates of reference cell barycenter. | |
template<typename cellVertexValueType , class ... cellVertexProperties> | |
static void | getReferenceVertex (Kokkos::DynRankView< cellVertexValueType, cellVertexProperties... > cellVertex, const shards::CellTopology cell, const ordinal_type vertexOrd) |
Retrieves the Cartesian coordinates of a reference cell vertex. | |
template<typename subcellVertexValueType , class ... subcellVertexProperties> | |
static void | getReferenceSubcellVertices (Kokkos::DynRankView< subcellVertexValueType, subcellVertexProperties... > subcellVertices, const ordinal_type subcellDim, const ordinal_type subcellOrd, const shards::CellTopology parentCell) |
Retrieves the Cartesian coordinates of all vertices of a reference subcell. | |
template<typename cellNodeValueType , class ... cellNodeProperties> | |
static void | getReferenceNode (Kokkos::DynRankView< cellNodeValueType, cellNodeProperties... > cellNode, const shards::CellTopology cell, const ordinal_type nodeOrd) |
Retrieves the Cartesian coordinates of a reference cell node. | |
template<typename subcellNodeValueType , class ... subcellNodeProperties> | |
static void | getReferenceSubcellNodes (Kokkos::DynRankView< subcellNodeValueType, subcellNodeProperties... > subcellNodes, const ordinal_type subcellDim, const ordinal_type subcellOrd, const shards::CellTopology parentCell) |
Retrieves the Cartesian coordinates of all nodes of a reference subcell. | |
template<typename refEdgeTangentValueType , class ... refEdgeTangentProperties> | |
static void | getReferenceEdgeTangent (Kokkos::DynRankView< refEdgeTangentValueType, refEdgeTangentProperties... > refEdgeTangent, const ordinal_type edgeOrd, const shards::CellTopology parentCell) |
Computes constant tangent vectors to edges of 2D or 3D reference cells. | |
template<typename refFaceTanValueType , class ... refFaceTanProperties> | |
static void | getReferenceFaceTangents (Kokkos::DynRankView< refFaceTanValueType, refFaceTanProperties... > refFaceTanU, Kokkos::DynRankView< refFaceTanValueType, refFaceTanProperties... > refFaceTanV, const ordinal_type faceOrd, const shards::CellTopology parentCell) |
Computes pairs of constant tangent vectors to faces of a 3D reference cells. | |
template<typename refSideNormalValueType , class ... refSideNormalProperties> | |
static void | getReferenceSideNormal (Kokkos::DynRankView< refSideNormalValueType, refSideNormalProperties... > refSideNormal, const ordinal_type sideOrd, const shards::CellTopology parentCell) |
Computes constant normal vectors to sides of 2D or 3D reference cells. | |
template<typename refFaceNormalValueType , class ... refFaceNormalProperties> | |
static void | getReferenceFaceNormal (Kokkos::DynRankView< refFaceNormalValueType, refFaceNormalProperties... > refFaceNormal, const ordinal_type faceOrd, const shards::CellTopology parentCell) |
Computes constant normal vectors to faces of 3D reference cell. | |
template<typename edgeTangentValueType , class ... edgeTangentProperties, typename worksetJacobianValueType , class ... worksetJacobianProperties> | |
static void | getPhysicalEdgeTangents (Kokkos::DynRankView< edgeTangentValueType, edgeTangentProperties... > edgeTangents, const Kokkos::DynRankView< worksetJacobianValueType, worksetJacobianProperties... > worksetJacobians, const ordinal_type worksetEdgeOrd, const shards::CellTopology parentCell) |
Computes non-normalized tangent vectors to physical edges in an edge workset ![]() | |
template<typename edgeTangentValueType , class ... edgeTangentProperties, typename worksetJacobianValueType , class ... worksetJacobianProperties, typename edgeOrdValueType , class ... edgeOrdProperties> | |
static void | getPhysicalEdgeTangents (Kokkos::DynRankView< edgeTangentValueType, edgeTangentProperties... > edgeTangents, const Kokkos::DynRankView< worksetJacobianValueType, worksetJacobianProperties... > worksetJacobians, const Kokkos::DynRankView< edgeOrdValueType, edgeOrdProperties... > worksetEdgeOrds, const shards::CellTopology parentCell) |
Computes non-normalized tangent vectors to physical edges in an edge workset ![]() | |
template<typename faceTanValueType , class ... faceTanProperties, typename worksetJacobianValueType , class ... worksetJacobianProperties> | |
static void | getPhysicalFaceTangents (Kokkos::DynRankView< faceTanValueType, faceTanProperties... > faceTanU, Kokkos::DynRankView< faceTanValueType, faceTanProperties... > faceTanV, const Kokkos::DynRankView< worksetJacobianValueType, worksetJacobianProperties... > worksetJacobians, const ordinal_type worksetFaceOrd, const shards::CellTopology parentCell) |
Computes non-normalized tangent vector pairs to physical faces in a face workset ![]() | |
template<typename faceTanValueType , class ... faceTanProperties, typename worksetJacobianValueType , class ... worksetJacobianProperties, typename faceOrdValueType , class ... faceOrdProperties> | |
static void | getPhysicalFaceTangents (Kokkos::DynRankView< faceTanValueType, faceTanProperties... > faceTanU, Kokkos::DynRankView< faceTanValueType, faceTanProperties... > faceTanV, const Kokkos::DynRankView< worksetJacobianValueType, worksetJacobianProperties... > worksetJacobians, const Kokkos::DynRankView< faceOrdValueType, faceOrdProperties... > worksetFaceOrds, const shards::CellTopology parentCell) |
Computes non-normalized tangent vector pairs to physical faces in a face workset ![]() | |
template<typename sideNormalValueType , class ... sideNormalProperties, typename worksetJacobianValueType , class ... worksetJacobianProperties> | |
static void | getPhysicalSideNormals (Kokkos::DynRankView< sideNormalValueType, sideNormalProperties... > sideNormals, const Kokkos::DynRankView< worksetJacobianValueType, worksetJacobianProperties... > worksetJacobians, const ordinal_type worksetSideOrd, const shards::CellTopology parentCell) |
Computes non-normalized normal vectors to physical sides in a side workset ![]() | |
template<typename sideNormalValueType , class ... sideNormalProperties, typename worksetJacobianValueType , class ... worksetJacobianProperties, typename edgeOrdValueType , class ... edgeOrdProperties> | |
static void | getPhysicalSideNormals (Kokkos::DynRankView< sideNormalValueType, sideNormalProperties... > sideNormals, const Kokkos::DynRankView< worksetJacobianValueType, worksetJacobianProperties... > worksetJacobians, const Kokkos::DynRankView< edgeOrdValueType, edgeOrdProperties... > worksetSideOrds, const shards::CellTopology parentCell) |
Computes non-normalized normal vectors to physical sides in a side workset ![]() | |
template<typename faceNormalValueType , class ... faceNormalProperties, typename worksetJacobianValueType , class ... worksetJacobianProperties> | |
static void | getPhysicalFaceNormals (Kokkos::DynRankView< faceNormalValueType, faceNormalProperties... > faceNormals, const Kokkos::DynRankView< worksetJacobianValueType, worksetJacobianProperties... > worksetJacobians, const ordinal_type worksetFaceOrd, const shards::CellTopology parentCell) |
Computes non-normalized normal vectors to physical faces in a face workset ![]() | |
template<typename faceNormalValueType , class ... faceNormalProperties, typename worksetJacobianValueType , class ... worksetJacobianProperties, typename faceOrdValueType , class ... faceOrdProperties> | |
static void | getPhysicalFaceNormals (Kokkos::DynRankView< faceNormalValueType, faceNormalProperties... > faceNormals, const Kokkos::DynRankView< worksetJacobianValueType, worksetJacobianProperties... > worksetJacobians, const Kokkos::DynRankView< faceOrdValueType, faceOrdProperties... > worksetFaceOrds, const shards::CellTopology parentCell) |
Computes non-normalized normal vectors to physical faces in a face workset ![]() | |
template<typename physPointValueType , class ... physPointProperties, typename refPointValueType , class ... refPointProperties, typename WorksetType , typename HGradBasisPtrType > | |
static void | mapToPhysicalFrame (Kokkos::DynRankView< physPointValueType, physPointProperties... > physPoints, const Kokkos::DynRankView< refPointValueType, refPointProperties... > refPoints, const WorksetType worksetCell, const HGradBasisPtrType basis) |
Computes F, the reference-to-physical frame map. | |
template<typename physPointValueType , class ... physPointProperties, typename refPointValueType , class ... refPointProperties, typename worksetCellValueType , class ... worksetCellProperties> | |
static void | mapToPhysicalFrame (Kokkos::DynRankView< physPointValueType, physPointProperties... > physPoints, const Kokkos::DynRankView< refPointValueType, refPointProperties... > refPoints, const Kokkos::DynRankView< worksetCellValueType, worksetCellProperties... > worksetCell, const shards::CellTopology cellTopo) |
Computes F, the reference-to-physical frame map. | |
template<typename refSubcellPointValueType , class ... refSubcellPointProperties, typename paramPointValueType , class ... paramPointProperties> | |
static void | mapToReferenceSubcell (Kokkos::DynRankView< refSubcellPointValueType, refSubcellPointProperties... > refSubcellPoints, const Kokkos::DynRankView< paramPointValueType, paramPointProperties... > paramPoints, const ordinal_type subcellDim, const ordinal_type subcellOrd, const shards::CellTopology parentCell) |
Computes parameterization maps of 1- and 2-subcells of reference cells. | |
template<typename refPointValueType , class ... refPointProperties, typename physPointValueType , class ... physPointProperties, typename worksetCellValueType , class ... worksetCellProperties> | |
static void | mapToReferenceFrame (Kokkos::DynRankView< refPointValueType, refPointProperties... > refPoints, const Kokkos::DynRankView< physPointValueType, physPointProperties... > physPoints, const Kokkos::DynRankView< worksetCellValueType, worksetCellProperties... > worksetCell, const shards::CellTopology cellTopo) |
Computes ![]() | |
template<typename refPointValueType , class ... refPointProperties, typename initGuessValueType , class ... initGuessProperties, typename physPointValueType , class ... physPointProperties, typename worksetCellValueType , class ... worksetCellProperties, typename HGradBasisPtrType > | |
static void | mapToReferenceFrameInitGuess (Kokkos::DynRankView< refPointValueType, refPointProperties... > refPoints, const Kokkos::DynRankView< initGuessValueType, initGuessProperties... > initGuess, const Kokkos::DynRankView< physPointValueType, physPointProperties... > physPoints, const Kokkos::DynRankView< worksetCellValueType, worksetCellProperties... > worksetCell, const HGradBasisPtrType basis) |
Computation of ![]() | |
template<typename refPointValueType , class ... refPointProperties, typename initGuessValueType , class ... initGuessProperties, typename physPointValueType , class ... physPointProperties, typename worksetCellValueType , class ... worksetCellProperties> | |
static void | mapToReferenceFrameInitGuess (Kokkos::DynRankView< refPointValueType, refPointProperties... > refPoints, const Kokkos::DynRankView< initGuessValueType, initGuessProperties... > initGuess, const Kokkos::DynRankView< physPointValueType, physPointProperties... > physPoints, const Kokkos::DynRankView< worksetCellValueType, worksetCellProperties... > worksetCell, const shards::CellTopology cellTopo) |
Computation of ![]() | |
template<typename subcvCoordValueType , class ... subcvCoordProperties, typename cellCoordValueType , class ... cellCoordProperties> | |
static void | getSubcvCoords (Kokkos::DynRankView< subcvCoordValueType, subcvCoordProperties... > subcvCoords, const Kokkos::DynRankView< cellCoordValueType, cellCoordProperties... > cellCoords, const shards::CellTopology primaryCell) |
Computes coordinates of sub-control volumes in each primary cell. | |
template<typename pointValueType , class ... pointProperties> | |
static bool | checkPointInclusion (const Kokkos::DynRankView< pointValueType, pointProperties... > point, const shards::CellTopology cellTopo, const double thres=threshold()) |
Checks if a point belongs to a reference cell. | |
template<typename inCellValueType , class ... inCellProperties, typename pointValueType , class ... pointProperties> | |
static void | checkPointwiseInclusion (Kokkos::DynRankView< inCellValueType, inCellProperties... > inCell, const Kokkos::DynRankView< pointValueType, pointProperties... > points, const shards::CellTopology cellTopo, const double thres=threshold()) |
Checks every point in a set for inclusion in a reference cell. | |
template<typename inCellValueType , class ... inCellProperties, typename pointValueType , class ... pointProperties, typename cellWorksetValueType , class ... cellWorksetProperties> | |
static void | checkPointwiseInclusion (Kokkos::DynRankView< inCellValueType, inCellProperties... > inCell, const Kokkos::DynRankView< pointValueType, pointProperties... > points, const Kokkos::DynRankView< cellWorksetValueType, cellWorksetProperties... > cellWorkset, const shards::CellTopology cellTopo, const double thres=threshold()) |
Checks every point in a set or multiple sets for inclusion in physical cells from a cell workset. | |
Private Types | |
using | ExecSpaceType = typename DeviceType::execution_space |
using | MemSpaceType = typename DeviceType::memory_space |
Static Private Member Functions | |
template<typename outputValueType , typename pointValueType > | |
static Teuchos::RCP< Basis< DeviceType, outputValueType, pointValueType > > | createHGradBasis (const shards::CellTopology cellTopo) |
Generates default HGrad basis based on cell topology. | |
A stateless class for operations on cell data. Provides methods for:
Definition at line 107 of file Intrepid2_CellTools.hpp.
|
private |
Definition at line 108 of file Intrepid2_CellTools.hpp.
|
private |
Definition at line 109 of file Intrepid2_CellTools.hpp.
|
static |
Allocates and returns a Data container suitable for storing determinants corresponding to the Jacobians in the Data container provided.
jacobian | [in] - data with shape (C,P,D,D), as returned by CellGeometry::allocateJacobianData() |
Definition at line 124 of file Intrepid2_CellToolsDefJacobian.hpp.
References Intrepid2::CONSTANT, Intrepid2::Data< DataScalar, DeviceType >::getExtents(), Intrepid2::getMatchingViewWithLabel(), Intrepid2::Data< DataScalar, DeviceType >::getUnderlyingView1(), Intrepid2::Data< DataScalar, DeviceType >::getUnderlyingView3(), Intrepid2::Data< DataScalar, DeviceType >::getUnderlyingView4(), and Intrepid2::Data< DataScalar, DeviceType >::getVariationTypes().
|
static |
Allocates and returns a Data container suitable for storing inverses corresponding to the Jacobians in the Data container provided.
jacobian | [in] - data with shape (C,P,D,D), as returned by CellGeometry::allocateJacobianData() |
Definition at line 158 of file Intrepid2_CellToolsDefJacobian.hpp.
References Intrepid2::Data< DataScalar, DeviceType >::getExtents(), Intrepid2::getMatchingViewWithLabel(), Intrepid2::Data< DataScalar, DeviceType >::getUnderlyingView1(), Intrepid2::Data< DataScalar, DeviceType >::getUnderlyingView2(), Intrepid2::Data< DataScalar, DeviceType >::getUnderlyingView3(), Intrepid2::Data< DataScalar, DeviceType >::getUnderlyingView4(), Intrepid2::Data< DataScalar, DeviceType >::getUnderlyingViewRank(), Intrepid2::Data< DataScalar, DeviceType >::getVariationTypes(), and INTREPID2_TEST_FOR_EXCEPTION_DEVICE_SAFE.
|
static |
Checks if a point belongs to a reference cell.
Requires cell topology with a reference cell.
point | [in] - reference coordinates of the point tested for inclusion |
cellTopo | [in] - cell topology |
threshold | [in] - "tightness" of the inclusion test |
Definition at line 69 of file Intrepid2_CellToolsDefInclusion.hpp.
|
static |
Checks every point in a set or multiple sets for inclusion in physical cells from a cell workset.
Checks every point from \b multiple point sets indexed by a cell ordinal, and stored in a rank-3 (C,P,D) array, for inclusion in the physical cell having the same cell ordinal, for \b all cells in a cell workset. For multiple point sets in a rank-3 array (C,P,D) returns a rank-2 (C,P) array such that
inCell | [out] - rank-1 array with results from the pointwise inclusion test |
points | [in] - rank-2 array with dimensions (P,D) with the physical points |
cellWorkset | [in] - rank-3 array with dimensions (C,N,D) with the nodes of the cell workset |
cellTopo | [in] - cell topology of the cells stored in cellWorkset |
threshold | [in] - tolerance for inclusion tests on the input points |
Definition at line 275 of file Intrepid2_CellToolsDefInclusion.hpp.
|
static |
Checks every point in a set for inclusion in a reference cell.
Requires cell topology with a reference cell. Admissible ranks and dimensions of the input point array and the corresponding rank and dimension of the output array are as follows: \verbatim |-------------------|-------------|-------------|-------------| | rank: (in)/(out) | 1/1 | 2/1 | 3/2 | |-------------------|-------------|-------------|-------------| | points (in) | (D) | (I, D) | (I, J, D) | |-------------------|-------------|-------------|-------------| | inRefCell (out) | (1) | (I) | (I, J) | |------------------ |-------------|-------------|-------------| \endverbatim Example: if \c points is rank-3 array with dimensions (I, J, D), then
inRefCell | [out] - rank-1 or 2 array with results from the pointwise inclusion test |
refPoints | [in] - rank-1,2 or 3 array (point, vector of points, matrix of points) |
cellTopo | [in] - cell topology of the cells stored in cellWorkset |
threshold | [in] - "tightness" of the inclusion test |
Definition at line 229 of file Intrepid2_CellToolsDefInclusion.hpp.
|
inlinestaticprivate |
Generates default HGrad basis based on cell topology.
cellTopo | [in] - cell topology |
Definition at line 130 of file Intrepid2_CellTools.hpp.
|
static |
Computes non-normalized tangent vectors to physical edges in an edge workset
It is similar to the CellTools::getPhysicalEdgeTangents function above, with the difference that the edge ordinal can change from point to point, and it is provided by the rank-2 input array worksetEdgeOrds, indexed by (C,P).
edgeTangents | [out] - rank-3 array (C,P,D1) with tangents on workset edges |
worksetJacobians | [in] - rank-4 array (C,P,D1,D1) with Jacobians evaluated at ref. edge points |
worksetEdgeOrds | [in] - rank-2 array (C,P) with edge ordinals, relative to ref. cell, of the edge workset |
parentCell | [in] - cell topology of the parent reference cell |
Definition at line 485 of file Intrepid2_CellToolsDefNodeInfo.hpp.
References Intrepid2::RefSubcellParametrization< DeviceType >::get(), and Intrepid2::RealSpaceTools< DeviceType >::matvec().
|
static |
Computes non-normalized tangent vectors to physical edges in an edge workset
For every edge in the workset the tangents are computed at the points
In this formula:
worksetJacobians
must contain the values of edgeTangents | [out] - rank-3 array (C,P,D1) with tangents on workset edges |
worksetJacobians | [in] - rank-4 array (C,P,D1,D1) with Jacobians evaluated at ref. edge points |
worksetEdgeOrd | [in] - edge ordinal, relative to ref. cell, of the edge workset |
parentCell | [in] - cell topology of the parent reference cell |
Definition at line 403 of file Intrepid2_CellToolsDefNodeInfo.hpp.
References Intrepid2::RealSpaceTools< DeviceType >::matvec().
Referenced by Intrepid2::FunctionSpaceTools< DeviceType >::computeEdgeMeasure().
|
static |
Computes non-normalized normal vectors to physical faces in a face workset
faceNormals | [out] - rank-3 array (C,P,D), normals at workset faces |
worksetJacobians | [in] - rank-4 array (C,P,D,D) with Jacobians at ref. face points |
worksetFaceOrds | [in] - rank-2 array (C,P) with face ordinals, relative to ref. cell, of the face workset |
parentCell | [in] - cell topology of the parent reference cell |
Definition at line 906 of file Intrepid2_CellToolsDefNodeInfo.hpp.
References Intrepid2::RealSpaceTools< DeviceType >::vecprod().
|
static |
Computes non-normalized normal vectors to physical faces in a face workset
For every face in the workset the normals are computed at the points
In this formula:
worksetJacobians
must contain the values of faceNormals | [out] - rank-3 array (C,P,D), normals at workset faces |
worksetJacobians | [in] - rank-4 array (C,P,D,D) with Jacobians at ref. face points |
worksetFaceOrd | [in] - face ordinal, relative to ref. cell, of the face workset |
parentCell | [in] - cell topology of the parent reference cell |
Definition at line 844 of file Intrepid2_CellToolsDefNodeInfo.hpp.
References Intrepid2::RealSpaceTools< DeviceType >::vecprod().
|
static |
Computes non-normalized tangent vector pairs to physical faces in a face workset
It is similar to the CellTools::getPhysicalFaceTangents function above, with the difference that the face ordinal can change from point to point, and it is provided by the rank-2 input array worksetFaceOrds, indexed by (C,P).
faceTanU | [out] - rank-3 array (C,P,D), image of ref. face u-tangent at workset faces |
faceTanV | [out] - rank-3 array (C,P,D), image of ref. face u-tangent at workset faces |
worksetJacobians | [in] - rank-4 array (C,P,D,D) with Jacobians at ref. face points |
worksetFaceOrds | [in] - rank-2 array (C,P) with face ordinals, relative to ref. cell, of the face workset |
parentCell | [in] - cell topology of the parent reference cell |
Definition at line 645 of file Intrepid2_CellToolsDefNodeInfo.hpp.
References Intrepid2::RefSubcellParametrization< DeviceType >::get(), and Intrepid2::RealSpaceTools< DeviceType >::matvec().
|
static |
Computes non-normalized tangent vector pairs to physical faces in a face workset
For every face in the workset the tangents are computed at the points
In this formula:
worksetJacobians
must contain the values of faceTanU | [out] - rank-3 array (C,P,D), image of ref. face u-tangent at workset faces |
faceTanV | [out] - rank-3 array (C,P,D), image of ref. face u-tangent at workset faces |
worksetJacobians | [in] - rank-4 array (C,P,D,D) with Jacobians at ref. face points |
worksetFaceOrd | [in] - face ordinal, relative to ref. cell, of the face workset |
parentCell | [in] - cell topology of the parent reference cell |
Definition at line 549 of file Intrepid2_CellToolsDefNodeInfo.hpp.
References Intrepid2::RealSpaceTools< DeviceType >::matvec().
|
static |
Computes non-normalized normal vectors to physical sides in a side workset
sideNormals | [out] - rank-3 array (C,P,D), normals at workset sides |
worksetJacobians | [in] - rank-4 array (C,P,D,D) with Jacobians at ref. side points |
worksetSideOrds | [in] - rank-2 array (C,P) with side ordinals, relative to ref. cell, of the side workset |
parentCell | [in] - cell topology of the parent reference cell |
Definition at line 797 of file Intrepid2_CellToolsDefNodeInfo.hpp.
|
static |
Computes non-normalized normal vectors to physical sides in a side workset
For every side in the workset the normals are computed at the points
Returns rank-3 array with dimensions (C,P,D), D = 2 or 3, such that
In this formula:
worksetJacobians
must contain the values of sideNormals | [out] - rank-3 array (C,P,D), normals at workset sides |
worksetJacobians | [in] - rank-4 array (C,P,D,D) with Jacobians at ref. side points |
worksetSideOrd | [in] - side ordinal, relative to ref. cell, of the side workset |
parentCell | [in] - cell topology of the parent reference cell |
Definition at line 746 of file Intrepid2_CellToolsDefNodeInfo.hpp.
Referenced by Intrepid2::CubatureControlVolumeSide< DeviceType, pointValueType, weightValueType >::getCubature().
|
static |
Computes the Cartesian coordinates of reference cell barycenter.
Requires cell topology with a reference cell.
cellCenter | [out] - coordinates of the specified reference cell center |
cell | [in] - cell topology |
Definition at line 68 of file Intrepid2_CellToolsDefNodeInfo.hpp.
References Intrepid2::RefCellCenter< DeviceType >::get().
Referenced by Intrepid2::Basis_HVOL_C0_FEM< DeviceType, outputValueType, pointValueType >::Basis_HVOL_C0_FEM().
|
static |
Computes constant tangent vectors to edges of 2D or 3D reference cells.
Returns rank-1 array with dimension (D), D=2 or D=3; such that
where
The length of computed edge tangents is one-half the length of their associated edges:
Because the edges of all reference cells are always affine images of [-1,1], the edge tangent is constant vector field.
refEdgeTangent | [out] - rank-1 array (D) with the edge tangent; D = cell dimension |
edgeOrd | [in] - ordinal of the edge whose tangent is computed |
parentCell | [in] - cell topology of the parent reference cell |
Definition at line 243 of file Intrepid2_CellToolsDefNodeInfo.hpp.
References Intrepid2::RefSubcellParametrization< DeviceType >::get().
Referenced by Intrepid2::Basis_HCURL_TET_In_FEM< DeviceType, outputValueType, pointValueType >::Basis_HCURL_TET_In_FEM(), Intrepid2::Basis_HCURL_TRI_In_FEM< DeviceType, outputValueType, pointValueType >::Basis_HCURL_TRI_In_FEM(), Intrepid2::Experimental::ProjectionTools< DeviceType >::getHCurlBasisCoeffs(), Intrepid2::Experimental::ProjectionTools< DeviceType >::getHGradBasisCoeffs(), and Intrepid2::Experimental::ProjectionTools< DeviceType >::getL2BasisCoeffs().
|
static |
Computes constant normal vectors to faces of 3D reference cell.
Returns rank-1 array with dimension (D), D=3 such that
where
and
The length of computed face normals is proportional to face area:
Because the faces of all reference cells are always affine images of R , the coordinate functions
refFaceNormal | [out] - rank-1 array (D) with (constant) face normal |
faceOrd | [in] - ordinal of the face whose normal is computed |
parentCell | [in] - cell topology of the parent reference cell |
Definition at line 366 of file Intrepid2_CellToolsDefNodeInfo.hpp.
References Intrepid2::RealSpaceTools< DeviceType >::vecprod().
|
static |
Computes pairs of constant tangent vectors to faces of a 3D reference cells.
Returns 2 rank-1 arrays with dimension (D), D=3, such that
where
and
Because the faces of all reference cells are always affine images of R , the coordinate functions
refFaceTanU | [out] - rank-1 array (D) with (constant) tangent in u-direction |
refFaceTanV | [out] - rank-1 array (D) with (constant) tangent in v-direction |
faceOrd | [in] - ordinal of the face whose tangents are computed |
parentCell | [in] - cell topology of the parent 3D reference cell |
Definition at line 281 of file Intrepid2_CellToolsDefNodeInfo.hpp.
References Intrepid2::RefSubcellParametrization< DeviceType >::get().
Referenced by Intrepid2::Basis_HCURL_TET_In_FEM< DeviceType, outputValueType, pointValueType >::Basis_HCURL_TET_In_FEM().
|
static |
Retrieves the Cartesian coordinates of a reference cell node.
Returns Cartesian coordinates of a reference cell node. Requires cell topology with a reference cell. Node coordinates are always returned as an (x,y,z)-triple regardlesss of the actual topological cell dimension. The unused coordinates are set to zero, e.g., node 0 of Line<2> is returned as {-1,0,0}.
cellNode | [out] - coordinates of the specified reference vertex |
cell | [in] - cell topology of the cell |
vertexOrd | [in] - node ordinal |
Definition at line 171 of file Intrepid2_CellToolsDefNodeInfo.hpp.
References Intrepid2::RefCellNodes< DeviceType >::get().
|
static |
Computes constant normal vectors to sides of 2D or 3D reference cells.
A side is defined as a subcell of dimension one less than that of its parent cell. Therefore, sides of 2D cells are 1-subcells (edges) and sides of 3D cells are 2-subcells (faces).
Returns rank-1 array with dimension (D), D = 2 or 3 such that
where
For sides of 2D cells R=[-1,1] and for sides of 3D cells
For 3D cells the length of computed side normals is proportional to side area:
For 2D cells the length of computed side normals is proportional to side length:
Because the sides of all reference cells are always affine images of R , the coordinate functions
refSideNormal | [out] - rank-1 array (D) with (constant) side normal |
sideOrd | [in] - ordinal of the side whose normal is computed |
parentCell | [in] - cell topology of the parent reference cell |
Definition at line 326 of file Intrepid2_CellToolsDefNodeInfo.hpp.
Referenced by Intrepid2::Basis_HDIV_TET_In_FEM< DeviceType, outputValueType, pointValueType >::Basis_HDIV_TET_In_FEM(), Intrepid2::Basis_HDIV_TRI_In_FEM< DeviceType, outputValueType, pointValueType >::Basis_HDIV_TRI_In_FEM(), Intrepid2::Experimental::ProjectionTools< DeviceType >::getHDivBasisCoeffs(), and Intrepid2::Experimental::ProjectionTools< DeviceType >::getL2BasisCoeffs().
|
static |
Retrieves the Cartesian coordinates of all nodes of a reference subcell.
Returns rank-2 array with the Cartesian coordinates of the nodes of the specified reference cell subcell. Requires cell topology with a reference cell.
subcellNodes | [out] - rank-2 (N,D) array with the Cartesian coordinates of the reference subcell nodes |
subcellDim | [in] - dimension of the subcell; 0 <= subcellDim <= parentCell dimension |
subcellOrd | [in] - ordinal of the subcell |
parentCell | [in] - topology of the cell that owns the subcell |
subcellDim
= dimension of the parentCell
this method returns the Cartesian coordinates of the nodes of the reference cell itself. Note that this requires subcellOrd=0
. Definition at line 201 of file Intrepid2_CellToolsDefNodeInfo.hpp.
|
static |
Retrieves the Cartesian coordinates of all vertices of a reference subcell.
Returns rank-2 array with the Cartesian coordinates of the vertices of the specified reference cell subcell. Requires cell topology with a reference cell.
subcellVertices | [out] - rank-2 (V,D) array with the Cartesian coordinates of the reference subcell vertices |
subcellDim | [in] - dimension of the subcell; 0 <= subcellDim <= parentCell dimension |
subcellOrd | [in] - ordinal of the subcell |
parentCell | [in] - topology of the cell that owns the subcell |
subcellDim
= dimension of the parentCell
this method returns the Cartesian coordinates of the vertices of the reference cell itself. Note that this requires subcellOrd=0. Definition at line 135 of file Intrepid2_CellToolsDefNodeInfo.hpp.
|
static |
Retrieves the Cartesian coordinates of a reference cell vertex.
Requires cell topology with a reference cell.
cellVertex | [out] - coordinates of the specified reference cell vertex |
cell | [in] - cell topology of the cell |
vertexOrd | [in] - vertex ordinal |
Definition at line 100 of file Intrepid2_CellToolsDefNodeInfo.hpp.
References Intrepid2::RefCellNodes< DeviceType >::get().
Referenced by Intrepid2::Experimental::ProjectionStruct< DeviceType, ValueType >::createHGradProjectionStruct(), and Intrepid2::Experimental::ProjectionStruct< DeviceType, ValueType >::createL2ProjectionStruct().
|
static |
Computes coordinates of sub-control volumes in each primary cell.
To build the system of equations for the control volume finite element method we need to compute geometric data for integration over control volumes. A control volume is polygon or polyhedron that surrounds a primary cell node and has vertices that include the surrounding primary cells' barycenter, edge midpoints, and face midpoints if in 3-d.
When using element-based assembly of the discrete equations over the primary mesh, a single element will contain a piece of each control volume surrounding each of the primary cell nodes. This piece of control volume (sub-control volume) is always a quadrilateral in 2-d and a hexahedron in 3-d.
In 2-d the sub-control volumes are defined in the following way:
Quadrilateral primary element: O________M________O | | | | 3 | 2 | B = cell barycenter | | | O = primary cell nodes M________B________M M = cell edge midpoints | | | | 0 | 1 | sub-control volumes 0, 1, 2, 3 | | | O________M________O Triangle primary element: O / \ / \ B = cell barycenter / \ O = primary cell nodes M 2 M M = cell edge midpoints / \ / \ / \ B / \ sub-control volumes 0, 1, 2 / | \ / 0 | 1 \ O________M________O
In 3-d the sub-control volumes are defined by the primary cell face centers and edge midpoints. The eight sub-control volumes for a hexahedron are shown below:
O__________E__________O /| /| /| E_|________F_|________E | /| | /| | /| | O_|_|______E_|_|______O | | O = primary cell nodes | | E------|-|-F------|-|-E B = cell barycenter | |/| | |/| | |/| F = cell face centers | F-|------|-B-|------|-F | E = cell edge midpoints |/| | |/| | |/| | E_|_|______F_|_|______E | | | | O------|-|-E------|-|-O | |/ | |/ | |/ | E--------|-F--------|-E |/ |/ |/ O__________E__________O
subCVCoords | [out] - array containing sub-control volume coordinates |
cellCoords | [in] - array containing coordinates of primary cells |
primaryCell | [in] - primary cell topology |
Definition at line 372 of file Intrepid2_CellToolsDefControlVolume.hpp.
Referenced by Intrepid2::CubatureControlVolume< DeviceType, pointValueType, weightValueType >::getCubature(), Intrepid2::CubatureControlVolumeBoundary< DeviceType, pointValueType, weightValueType >::getCubature(), and Intrepid2::CubatureControlVolumeSide< DeviceType, pointValueType, weightValueType >::getCubature().
|
inlinestatic |
Checks if a cell topology has reference cell.
cell | [in] - cell topology |
Definition at line 118 of file Intrepid2_CellTools.hpp.
References Intrepid2::RefSubcellParametrization< DeviceType >::isSupported().
|
inlinestatic |
Computes F, the reference-to-physical frame map.
There are 2 use cases:
For a single point set in a rank-2 array (P,D) returns a rank-3 (C,P,D) array such that
For multiple point sets in a rank-3 (C,P,D) array returns a rank-3 (C,P,D) array such that
This corresponds to mapping multiple sets of reference points to a matching number of physical cells.
Requires cell topology with a reference cell. See Section Reference-to-physical cell mapping for definition of the mapping function. Presently supported cell topologies are
Line<2>
Triangle<3>
, Triangle<6>
, Quadrilateral<4>
, Quadrilateral<9>
Tetrahedron<4>
, Tetrahedron<10>
, Hexahedron<8>
, Hexahedron<27>
refPoints
represents an arbitrary set of points in the reference frame that are not required to be in the reference cell corresponding to the specified cell topology. As a result, the images of these points under a given reference-to-physical map are not necessarily contained in the physical cell that is the image of the reference cell under that map. CellTools provides several inclusion tests methods to check whether or not the points are inside a reference cell.physPoints | [out] - rank-3 array with dimensions (C,P,D) with the images of the ref. points |
refPoints | [in] - rank-3/2 array with dimensions (C,P,D)/(P,D) with points in reference frame |
cellWorkset | [in] - rank-3 array with dimensions (C,N,D) with the nodes of the cell workset |
cellTopo | [in] - cell topology of the cells stored in cellWorkset |
Definition at line 1070 of file Intrepid2_CellTools.hpp.
References Intrepid2::CellTools< DeviceType >::mapToPhysicalFrame().
|
static |
Computes F, the reference-to-physical frame map.
There are 2 use cases:
For a single point set in a rank-2 array (P,D) returns a rank-3 (C,P,D) array such that
For multiple point sets in a rank-3 (C,P,D) array returns a rank-3 (C,P,D) array such that
This corresponds to mapping multiple sets of reference points to a matching number of physical cells.
Requires pointer to HGrad basis that defines reference to physical cell mapping.
See Section Reference-to-physical cell mapping for definition of the mapping function.
refPoints
represents an arbitrary set of points in the reference frame that are not required to be in the reference cell corresponding to the specified cell topology. As a result, the images of these points under a given reference-to-physical map are not necessarily contained in the physical cell that is the image of the reference cell under that map. CellTools provides several inclusion tests methods to check whether or not the points are inside a reference cell.physPoints | [out] - rank-3 array with dimensions (C,P,D) with the images of the ref. points |
refPoints | [in] - rank-3/2 array with dimensions (C,P,D)/(P,D) with points in reference frame |
cellWorkset | [in] - rank-3 container with logical dimensions (C,N,D) with the nodes of the cell workset |
basis | [in] - pointer to HGrad basis used in reference-to-physical cell mapping |
Definition at line 193 of file Intrepid2_CellToolsDefRefToPhys.hpp.
References Intrepid2::CellTools_mapToPhysicalFrameArgs().
Referenced by Intrepid2::CellTools< DeviceType >::mapToPhysicalFrame(), and Intrepid2::ProjectedGeometry< spaceDim, PointScalar, DeviceType >::projectOntoHGRADBasis().
|
static |
Computes
Applies
Requires cell topology with a reference cell. See Section Reference-to-physical cell mapping for definition of the mapping function. Presently supported cell topologies are
Line<2>
Triangle<3>
, Triangle<6>
, Quadrilateral<4>
, Quadrilateral<9>
Tetrahedron<4>
, Tetrahedron<10>
, Hexahedron<8>
, Hexahedron<27>
Line
topologies: line center (0) Triangle
topologies: the point (1/3, 1/3) Quadrilateral
topologies: the point (0, 0) Tetrahedron
topologies: the point (1/6, 1/6, 1/6) Hexahedron
topologies: the point (0, 0, 0) Wedge
topologies: the point (1/2, 1/2, 0) For some cells with extended topologies, these initial guesses may not be good enough for Newton's method to converge in the allotted number of iterations. A version of this method with user-supplied initial guesses is also available.physPoints
represents an arbitrary set (or sets) of points in the physical frame that are not required to belong in the physical cell (cells) that define(s) the reference to physical mapping. As a result, the images of these points in the reference frame are not necessarily contained in the reference cell corresponding to the specified cell topology.refPoints | [out] - rank-3 array with dimensions (C,P,D) with the images of the physical points |
physPoints | [in] - rank-3 array with dimensions (C,P,D) with points in physical frame |
worksetCell | [in] - rank-3 array with dimensions (C,N,D) with the nodes of the cell workset |
cellTopo | [in] - cell topology of the cells stored in cellWorkset |
Definition at line 71 of file Intrepid2_CellToolsDefPhysToRef.hpp.
References Intrepid2::CellTools_mapToReferenceFrameArgs().
Referenced by Intrepid2::PointTools::getWarpBlendLatticeTetrahedron(), and Intrepid2::PointTools::getWarpBlendLatticeTriangle().
|
static |
Computation of
Applies
Requires pointer to HGrad basis that defines reference to physical cell mapping.
See Section Reference-to-physical cell mapping for definition of the mapping function.
physPoints
represents an arbitrary set (or sets) of points in the physical frame that are not required to belong in the physical cell (cells) that define(s) the reference to physical mapping. As a result, the images of these points in the reference frame are not necessarily contained in the reference cell corresponding to the specified cell topology.refPoints | [out] - rank-3/2 array with dimensions (C,P,D)/(P,D) with the images of the physical points |
initGuess | [in] - rank-3/2 array with dimensions (C,P,D)/(P,D) with the initial guesses for each point |
physPoints | [in] - rank-3/2 array with dimensions (C,P,D)/(P,D) with points in physical frame |
worksetCell | [in] - rank-3 array with dimensions (C,N,D) with the nodes of the cell workset |
basis | [in] - pointer to HGrad basis used for reference to physical cell mapping |
Definition at line 122 of file Intrepid2_CellToolsDefPhysToRef.hpp.
References Intrepid2::Parameters::MaxNewton.
Referenced by Intrepid2::CellTools< DeviceType >::mapToReferenceFrameInitGuess().
|
inlinestatic |
Computation of
Applies
Requires cell topology with a reference cell. See Section Reference-to-physical cell mapping for definition of the mapping function. Presently supported cell topologies are
Line<2>
Triangle<3>
, Triangle<6>
, Quadrilateral<4>
, Quadrilateral<9>
Tetrahedron<4>
, Tetrahedron<10>
, Hexahedron<8>
, Hexahedron<27>
physPoints
represents an arbitrary set (or sets) of points in the physical frame that are not required to belong in the physical cell (cells) that define(s) the reference to physical mapping. As a result, the images of these points in the reference frame are not necessarily contained in the reference cell corresponding to the specified cell topology.refPoints | [out] - rank-3/2 array with dimensions (C,P,D)/(P,D) with the images of the physical points |
initGuess | [in] - rank-3/2 array with dimensions (C,P,D)/(P,D) with the initial guesses for each point |
physPoints | [in] - rank-3/2 array with dimensions (C,P,D)/(P,D) with points in physical frame |
worksetCell | [in] - rank-3 array with dimensions (C,N,D) with the nodes of the cell workset |
cellTopo | [in] - cell topology of the cells stored in cellWorkset |
Definition at line 1275 of file Intrepid2_CellTools.hpp.
References Intrepid2::CellTools< DeviceType >::mapToReferenceFrameInitGuess().
|
static |
Computes parameterization maps of 1- and 2-subcells of reference cells.
Applies
for 2-subcells:
and
paramPoints
. Here c is ordinal of a parent cell, relative to subcell workset, and i is subcell ordinal, relative to a reference cell, of the subcell workset. See Section Subcell worksets for definition of subcell workset and Section Parametrization of physical 1- and 2-subcells for definition of parametrization maps.refSubcellPoints | [out] - rank-2 (P,D1) array with images of parameter space points |
paramPoints | [in] - rank-2 (P,D2) array with points in 1D or 2D parameter domain |
subcellDim | [in] - dimension of the subcell where points are mapped to |
subcellOrd | [in] - subcell ordinal |
parentCell | [in] - cell topology of the parent cell. |
Definition at line 255 of file Intrepid2_CellToolsDefRefToPhys.hpp.
References Intrepid2::RefSubcellParametrization< DeviceType >::get().
Referenced by Intrepid2::Basis_HCURL_TET_In_FEM< DeviceType, outputValueType, pointValueType >::Basis_HCURL_TET_In_FEM(), Intrepid2::Basis_HCURL_TRI_In_FEM< DeviceType, outputValueType, pointValueType >::Basis_HCURL_TRI_In_FEM(), Intrepid2::Basis_HDIV_TET_In_FEM< DeviceType, outputValueType, pointValueType >::Basis_HDIV_TET_In_FEM(), Intrepid2::Basis_HDIV_TRI_In_FEM< DeviceType, outputValueType, pointValueType >::Basis_HDIV_TRI_In_FEM(), Intrepid2::Basis_HGRAD_TET_Cn_FEM< DeviceType, outputValueType, pointValueType >::Basis_HGRAD_TET_Cn_FEM(), Intrepid2::CubatureControlVolumeBoundary< DeviceType, pointValueType, weightValueType >::CubatureControlVolumeBoundary(), and Intrepid2::CubatureControlVolumeSide< DeviceType, pointValueType, weightValueType >::CubatureControlVolumeSide().
|
inlinestatic |
Computes the Jacobian matrix DF of the reference-to-physical frame map F.
There are two use cases:
For a single point set in a rank-2 array (P,D) returns a rank-4 (C,P,D,D) array such that
For multiple sets of reference points in a rank-3 (C,P,D) array returns rank-4 (C,P,D,D) array such that
Requires cell topology with a reference cell. See Section \ref sec_cell_topology_ref_map_DF for definition of the Jacobian. \warning The points are not required to be in the reference cell associated with the specified cell topology. CellTools provides several inclusion tests methods to check whether or not the points are inside a reference cell.
jacobian | [out] - rank-4 array with dimensions (C,P,D,D) with the Jacobians |
points | [in] - rank-2/3 array with dimensions (P,D)/(C,P,D) with the evaluation points |
cellWorkset | [in] - rank-3 array with dimensions (C,N,D) with the nodes of the cell workset |
cellTopo | [in] - cell topology of the cells stored in cellWorkset |
Definition at line 314 of file Intrepid2_CellTools.hpp.
References Intrepid2::CellTools< DeviceType >::setJacobian().
|
static |
Computes the Jacobian matrix DF of the reference-to-physical frame map F.
There are two use cases:
For a single point set in a rank-2 array (P,D) returns a rank-4 (C,P,D,D) array such that
For multiple sets of reference points in a rank-3 (C,P,D) array returns rank-4 (C,P,D,D) array such that
Requires pointer to HGrad basis that defines reference to physical cell mapping. See Section \ref sec_cell_topology_ref_map_DF for definition of the Jacobian. \warning The points are not required to be in the reference cell associated with the specified cell topology. CellTools provides several inclusion tests methods to check whether or not the points are inside a reference cell.
jacobian | [out] - rank-4 array with dimensions (C,P,D,D) with the Jacobians |
points | [in] - rank-2/3 array with dimensions (P,D)/(C,P,D) with the evaluation points |
cellWorkset | [in] - rank-3 container with logical dimensions (C,N,D) with the nodes of the cell workset |
basis | [in] - HGrad basis for reference to physical cell mapping |
startCell | [in] - first cell index in cellWorkset for which we should compute the Jacobian; corresponds to the 0 index in Jacobian and/or points container. Default: 0. |
endCell | [in] - first cell index in cellWorkset that we do not process; endCell - startCell must equal the extent of the Jacobian container in dimension 0. Default: -1, a special value that indicates the extent of the cellWorkset should be used. |
Definition at line 831 of file Intrepid2_CellToolsDefJacobian.hpp.
Referenced by Intrepid2::CubatureControlVolume< DeviceType, pointValueType, weightValueType >::getCubature(), Intrepid2::CubatureControlVolumeBoundary< DeviceType, pointValueType, weightValueType >::getCubature(), Intrepid2::CubatureControlVolumeSide< DeviceType, pointValueType, weightValueType >::getCubature(), Intrepid2::CellTools< DeviceType >::setJacobian(), and Intrepid2::CellGeometry< PointScalar, spaceDim, DeviceType >::setJacobianDataPrivate().
|
static |
Computes the Jacobian matrix DF of the reference-to-physical frame map F.
There are two use cases:
For a single point set in a rank-2 array (P,D) returns a rank-4 (C,P,D,D) array such that
For multiple sets of reference points in a rank-3 (C,P,D) array returns rank-4 (C,P,D,D) array such that
Requires pointer to HGrad basis that defines reference to physical cell mapping. See Section \ref sec_cell_topology_ref_map_DF for definition of the Jacobian. \warning The points are not required to be in the reference cell associated with the specified cell topology. CellTools provides several inclusion tests methods to check whether or not the points are inside a reference cell.
jacobian | [out] - rank-4 array with dimensions (C,P,D,D) with the Jacobians |
cellWorkset | [in] - rank-3 container with logical dimensions (C,N,D) with the nodes of the cell workset |
gradients | [in] - rank-3/4 array with dimensions (N,P,D)/(C,N,P,D) with the gradients of the physical-to-cell mapping |
startCell | [in] - first cell index in cellWorkset for which we should compute the Jacobian; corresponds to the 0 index in Jacobian and/or points container. Default: 0. |
endCell | [in] - first cell index in cellWorkset that we do not process; endCell - startCell must equal the extent of the Jacobian container in dimension 0. Default: -1, a special value that indicates the extent of the cellWorkset should be used. |
Definition at line 802 of file Intrepid2_CellToolsDefJacobian.hpp.
|
static |
Computes determinants corresponding to the Jacobians in the Data container provided.
jacobianDet | [out] - data with shape (C,P), as returned by CellTools::allocateJacobianDet() |
jacobian | [in] - data with shape (C,P,D,D), as returned by CellGeometry::allocateJacobianData() |
Definition at line 197 of file Intrepid2_CellToolsDefJacobian.hpp.
References Intrepid2::BLOCK_PLUS_DIAGONAL, Intrepid2::Data< DataScalar, DeviceType >::blockPlusDiagonalLastNonDiagonal(), Intrepid2::CONSTANT, Intrepid2::RealSpaceTools< DeviceType >::det(), Intrepid2::Data< DataScalar, DeviceType >::extent_int(), Intrepid2::Data< DataScalar, DeviceType >::getUnderlyingView1(), Intrepid2::Data< DataScalar, DeviceType >::getUnderlyingView2(), Intrepid2::Data< DataScalar, DeviceType >::getUnderlyingView3(), Intrepid2::Data< DataScalar, DeviceType >::getUnderlyingView4(), Intrepid2::Data< DataScalar, DeviceType >::getUnderlyingViewRank(), Intrepid2::Data< DataScalar, DeviceType >::getVariationTypes(), and INTREPID2_TEST_FOR_EXCEPTION_DEVICE_SAFE.
|
static |
Computes the determinant of the Jacobian matrix DF of the reference-to-physical frame map F.
Returns rank-2 array with dimensions (C,P) such that
jacobianDet | [out] - rank-2 array with dimensions (C,P) with Jacobian determinants |
jacobian | [in] - rank-4 array with dimensions (C,P,D,D) with the Jacobians |
Definition at line 906 of file Intrepid2_CellToolsDefJacobian.hpp.
References Intrepid2::CellTools_setJacobianDetArgs(), and Intrepid2::RealSpaceTools< DeviceType >::det().
Referenced by Intrepid2::CubatureControlVolume< DeviceType, pointValueType, weightValueType >::getCubature(), and Intrepid2::CubatureControlVolumeBoundary< DeviceType, pointValueType, weightValueType >::getCubature().
|
static |
Computes reciprocals of determinants corresponding to the Jacobians in the Data container provided.
jacobianDet | [out] - data with shape (C,P), as returned by CellTools::allocateJacobianDet() |
jacobian | [in] - data with shape (C,P,D,D), as returned by CellGeometry::allocateJacobianData() |
Definition at line 464 of file Intrepid2_CellToolsDefJacobian.hpp.
References Intrepid2::Data< DataScalar, DeviceType >::allocateConstantData(), and Intrepid2::Data< DataScalar, DeviceType >::storeInPlaceQuotient().
|
static |
Computes determinants corresponding to the Jacobians in the Data container provided.
jacobianInv | [out] - data container with shape (C,P,D,D), as returned by CellTools::allocateJacobianInv() |
jacobian | [in] - data with shape (C,P,D,D), as returned by CellGeometry::allocateJacobianData() |
Definition at line 474 of file Intrepid2_CellToolsDefJacobian.hpp.
References Intrepid2::BLOCK_PLUS_DIAGONAL, Intrepid2::Data< DataScalar, DeviceType >::blockPlusDiagonalLastNonDiagonal(), Intrepid2::CONSTANT, Intrepid2::Data< DataScalar, DeviceType >::getUnderlyingView1(), Intrepid2::Data< DataScalar, DeviceType >::getUnderlyingView2(), Intrepid2::Data< DataScalar, DeviceType >::getUnderlyingView3(), Intrepid2::Data< DataScalar, DeviceType >::getUnderlyingView4(), Intrepid2::Data< DataScalar, DeviceType >::getUnderlyingViewRank(), Intrepid2::Data< DataScalar, DeviceType >::getVariationTypes(), INTREPID2_TEST_FOR_EXCEPTION_DEVICE_SAFE, and Intrepid2::RealSpaceTools< DeviceType >::inverse().
|
static |
Computes the inverse of the Jacobian matrix DF of the reference-to-physical frame map F.
Returns rank-4 array with dimensions (C,P,D,D) such that
jacobianInv | [out] - rank-4 array with dimensions (C,P,D,D) with the inverse Jacobians |
jacobian | [in] - rank-4 array with dimensions (C,P,D,D) with the Jacobians |
Definition at line 893 of file Intrepid2_CellToolsDefJacobian.hpp.
References Intrepid2::CellTools_setJacobianInvArgs(), and Intrepid2::RealSpaceTools< DeviceType >::inverse().