* Removed the fixed low-order finite element classes for wedges.
* Replace more cases of 'int' variables with 'Geometry::Type',
mainly in class FiniteElement and its derived classes.
* Use constants from BasisType (instead of Quadrature1D) in the
parameters of the *WedgeElement finite element classes.
* Impose ordering on the construction of some global objects by
moving them into the same translation unit: specifically, moved
the objects 'TriangleFE', 'TetrahedronFE', 'WedgeFE', and
'Geometries' into fem/fe.cpp.
* In switchs on 'Geometry::Type', move the 'Geometry::PRISM' case
last - just to follow the order in the enumeration.
* Add a new method CoarseFineTransformations::GetPointMatrices
that simplifies some code that uses CoarseFineTransformations.
* Removed the 'INVALID' and 'MIXED' constants from the enum
Element::Type.
* Remove the static method Element::GeometryType.
* Tweak some doxygen comments in the classes Embedding and
CoarseFineTransformations.
* Generate an error if the method Wedge::GetNFaces is called:
its parameter 'nFaceVertices' does not make sense for wedges.
so that open-type quadrature (i.e. without the end points) can also
be used for refinement.
Enhanced class InverseElementTransformation with more options, set
by the methods SetInitGuessPointsType() and SetInitGuessRelOrder()
which control the type and order of the initial guess refinement
used by the Closest* initial guess types.
ElementsTransformation inversion algorithms, and serves as a base class
for other, e.g. custom, implementations. The new class contains all
previous implementations of ElementTransformation::TransformBack() and
adds a some new options.
The method IsoparametricTransformation::TransformBack() is now
implemented by simply constructing a InverseElementTransformation object
(with default options) and calling its Transform() method.
Updated the methods Mesh::FindPoints() and ParMesh::FindPoints() to
accept an optional argument of type InverseElementTransformation,
allowing more flexibility through customization of the transformation
inversion algorithm. In ParMesh::FindPoints(), when the i-th point was
found by one or more ranks, the output entry elem_ids[i] will be set to
-2 (except on the rank that is assigned that point) to indicate that the
i-th point was found but assigned to another rank - this value allows
all ranks to distinguish this case from the case when a point was not
found by any rank - indicated by elem_ids[j] set to -1.
Added two new methods to class ElementTransformation: GetGeometryType()
and GetDimension(). To aviod making these new methods virtual (and to
make the existing method GetSpaceDim() non-virtual), added data fields
'geom' and 'space_dim' to the base class ElementTransformation. In order
to facilitate the initialization of those fields for class
IsoparametricTransformation, added new method, FinalizeTransformation().
This method must be called after setting the point-matrix and the finite
element of the IsoparametricTransformation - all such places in MFEM
have been updated to perform that call.
Add new version of Geometry::ProjectPoint() that projects points outside
the reference element to the closest boundary point of the element.
Updated class GeometryRefiner to allow simultaneous use by different
places in a code - new calls to the Refine() and RefineInterior()
methods will not destroy previously allocated and returned objects by
the same calls.
There were some edge cases on an element's boundary where
the solver converged, but the original tolerance of 1e-15 was too low.
Changing the tolerances to 1e-14 fixes this while still
passing all tests for transforming points back and forth.
The refinement order is used to choose the initial IntegrationPoint
for the Newton-Raphson solve in IsoparametricTransformation's TransformBack
function. The default value is to use the elements order.
Also added a new public function to IsoparametricTransfomation to find
the closest IntegrationPoint within an element to a given point in space.
This function uses the elements RefinedIntules for the given order.
This is helpful in determining is an IntegrationPoint is almost inside
an element.
Also uses this overload in IsoparametricTransformation::TransformBack().
The TransformBack function had an optimization to project points
that moved outside the element onto the element boundary. This caused
the code to incorrectly determine some internal points as outside on curved elements.
This commit removes this optimization and instead checks whether the found
IntegrationPoint is inside or outside the element once the algorithm converges.
The function now chooses the RefinedIntRules integration point whose transform
is closest to the query point in physical space. Previously, TransformBack
was hard-coded to choose the IntegrationPoint at the element's center as the
initial guess for the Newton-Raphson solve.
Stowell, Mark L