deal.II version GIT relicensing-2248-g6a8f632045 2024-12-12 07:30:00+00:00
|
#include <deal.II/numerics/fe_field_function.h>
Public Types | |
using | time_type = typename FunctionTime< typename numbers::NumberTraits< VectorType::value_type >::real_type >::time_type |
Public Member Functions | |
FEFieldFunction (const DoFHandler< dim, spacedim > &dh, const VectorType &data_vector, const Mapping< dim > &mapping=StaticMappingQ1< dim >::mapping) | |
void | set_active_cell (const typename DoFHandler< dim, spacedim >::active_cell_iterator &newcell) |
virtual void | vector_value (const Point< dim > &p, Vector< typename VectorType::value_type > &values) const override |
virtual VectorType::value_type | value (const Point< dim > &p, const unsigned int component=0) const override |
virtual void | value_list (const std::vector< Point< dim > > &points, std::vector< typename VectorType::value_type > &values, const unsigned int component=0) const override |
virtual void | vector_value_list (const std::vector< Point< dim > > &points, std::vector< Vector< typename VectorType::value_type > > &values) const override |
virtual void | vector_gradient (const Point< dim > &p, std::vector< Tensor< 1, dim, typename VectorType::value_type > > &gradients) const override |
virtual Tensor< 1, dim, typename VectorType::value_type > | gradient (const Point< dim > &p, const unsigned int component=0) const override |
virtual void | vector_gradient_list (const std::vector< Point< dim > > &p, std::vector< std::vector< Tensor< 1, dim, typename VectorType::value_type > > > &gradients) const override |
virtual void | gradient_list (const std::vector< Point< dim > > &p, std::vector< Tensor< 1, dim, typename VectorType::value_type > > &gradients, const unsigned int component=0) const override |
virtual VectorType::value_type | laplacian (const Point< dim > &p, const unsigned int component=0) const override |
virtual void | vector_laplacian (const Point< dim > &p, Vector< typename VectorType::value_type > &values) const override |
virtual void | laplacian_list (const std::vector< Point< dim > > &points, std::vector< typename VectorType::value_type > &values, const unsigned int component=0) const override |
virtual void | vector_laplacian_list (const std::vector< Point< dim > > &points, std::vector< Vector< typename VectorType::value_type > > &values) const override |
unsigned int | compute_point_locations (const std::vector< Point< dim > > &points, std::vector< typename DoFHandler< dim, spacedim >::active_cell_iterator > &cells, std::vector< std::vector< Point< dim > > > &qpoints, std::vector< std::vector< unsigned int > > &maps) const |
virtual void | vector_values (const std::vector< Point< dim > > &points, std::vector< std::vector< VectorType::value_type > > &values) const |
virtual void | vector_gradients (const std::vector< Point< dim > > &points, std::vector< std::vector< Tensor< 1, dim, VectorType::value_type > > > &gradients) const |
virtual SymmetricTensor< 2, dim, VectorType::value_type > | hessian (const Point< dim > &p, const unsigned int component=0) const |
virtual void | vector_hessian (const Point< dim > &p, std::vector< SymmetricTensor< 2, dim, VectorType::value_type > > &values) const |
virtual void | hessian_list (const std::vector< Point< dim > > &points, std::vector< SymmetricTensor< 2, dim, VectorType::value_type > > &values, const unsigned int component=0) const |
virtual void | vector_hessian_list (const std::vector< Point< dim > > &points, std::vector< std::vector< SymmetricTensor< 2, dim, VectorType::value_type > > > &values) const |
virtual std::size_t | memory_consumption () const |
Number | get_time () const |
virtual void | set_time (const Number new_time) |
virtual void | advance_time (const Number delta_t) |
template<class Archive > | |
void | serialize (Archive &ar, const unsigned int version) |
EnableObserverPointer functionality | |
Classes derived from EnableObserverPointer provide a facility to subscribe to this object. This is mostly used by the ObserverPointer class. | |
void | subscribe (std::atomic< bool > *const validity, const std::string &identifier="") const |
void | unsubscribe (std::atomic< bool > *const validity, const std::string &identifier="") const |
unsigned int | n_subscriptions () const |
template<typename StreamType > | |
void | list_subscribers (StreamType &stream) const |
void | list_subscribers () const |
Static Public Member Functions | |
static ::ExceptionBase & | ExcInUse (int arg1, std::string arg2, std::string arg3) |
static ::ExceptionBase & | ExcNoSubscriber (std::string arg1, std::string arg2) |
Public Attributes | |
const unsigned int | n_components |
Static Public Attributes | |
static constexpr unsigned int | dimension |
Private Types | |
using | cell_hint_t = Threads::ThreadLocalStorage< typename DoFHandler< dim, spacedim >::active_cell_iterator > |
using | map_value_type = decltype(counter_map)::value_type |
using | map_iterator = decltype(counter_map)::iterator |
Private Member Functions | |
std::optional< Point< dim > > | get_reference_coordinates (const typename DoFHandler< dim, spacedim >::active_cell_iterator &cell, const Point< dim > &point) const |
void | check_no_subscribers () const noexcept |
Private Attributes | |
ObserverPointer< const DoFHandler< dim, spacedim >, FEFieldFunction< dim, VectorType, spacedim > > | dh |
const VectorType & | data_vector |
const Mapping< dim > & | mapping |
GridTools::Cache< dim, spacedim > | cache |
cell_hint_t | cell_hint |
Number | time |
std::atomic< unsigned int > | counter |
std::map< std::string, unsigned int > | counter_map |
std::vector< std::atomic< bool > * > | validity_pointers |
const std::type_info * | object_info |
Static Private Attributes | |
static std::mutex | mutex |
This is an interpolation function for the given dof handler and the given solution vector. The points at which this function can be evaluated MUST be inside the domain of the dof handler, but except from this, no other requirement is given. This function is rather slow, as it needs to construct a quadrature object for the point (or set of points) where you want to evaluate your finite element function. In order to do so, it needs to find out where the points lie.
If you know in advance in which cell your points lie, you can accelerate things a bit, by calling set_active_cell() before asking for values or gradients of the function. If you don't do this, and your points don't lie in the cell that is currently stored, the function GridTools::find_active_cell_around_point is called to find out where the point is. You can specify an optional mapping to use when looking for points in the grid. If you don't do so, this function uses a Q1 mapping.
Once the FEFieldFunction knows where the points lie, it creates a quadrature formula for those points, and calls FEValues::get_function_values or FEValues::get_function_gradients with the given quadrature points.
If you only need the quadrature points but not the values of the finite element function (you might want this for the adjoint interpolation), you can also use the function compute_point_locations() alone.
An example of how to use this function is the following:
The snippet of code above will work assuming that the second triangulation is entirely included in the first one.
FEFieldFunction is designed to be an easy way to get the results of your computations across different, possibly non matching, grids. No knowledge of the location of the points is assumed in this class, which makes it rely entirely on the GridTools::find_active_cell_around_point utility for its job. However the class can be fed an "educated guess" of where the points that will be computed actually are by using the FEFieldFunction::set_active_cell method, so if you have a smart way to tell where your points are, you will save a lot of computational time by letting this class know.
When using this class with a parallel distributed triangulation object and evaluating the solution at a particular point, not every processor will own the cell at which the solution should be evaluated. Rather, it may be that the cell in which this point is found is in fact a ghost or artificial cell (see GlossArtificialCell and GlossGhostCell). The solution can be evaluated on ghost cells, but for artificial cells we have no access to the solution there and functions that evaluate the solution at such a point will trigger an exception of type VectorTools::ExcPointNotAvailableHere.
To deal with this situation, you will want to use code as follows when, for example, evaluating the solution at the origin (here using a parallel TrilinosWrappers vector to hold the solution):
The last part (the ...do something...
) part needs to be application specific. If you really do need the information on this process, you need to communicate with the process that actually owns the cell in which the point at which you want the solution is located. Since you don't know which process that may be, this will necessarily require a global communication step. The FERemoteEvaluation class may be useful in this context.
Finally, there is the case of the value_list(), gradient_list(), and similar functions of this class that take a list of points. For these functions, it may be that some of the points are on locally owned cells, and others are not – in which case, again, you will receive an exception. Because these functions do not return information about which of the points can and which cannot be evaluated, the correct approach is to call the *_list()
function within a try
block, and if it fails fall back to calling value(), gradient(), or similar in a loop over the points you wanted evaluated to find out for which point the call fails.
Definition at line 184 of file fe_field_function.h.
|
private |
Typedef holding the local cell_hint.
Definition at line 466 of file fe_field_function.h.
|
inherited |
The scalar-valued real type used for representing time.
Definition at line 168 of file function.h.
|
privateinherited |
The data type used in counter_map.
Definition at line 238 of file enable_observer_pointer.h.
|
privateinherited |
The iterator type used in counter_map.
Definition at line 243 of file enable_observer_pointer.h.
Functions::FEFieldFunction< dim, VectorType, spacedim >::FEFieldFunction | ( | const DoFHandler< dim, spacedim > & | dh, |
const VectorType & | data_vector, | ||
const Mapping< dim > & | mapping = StaticMappingQ1< dim >::mapping |
||
) |
Construct a vector function. A smart pointers is stored to the dof handler, so you have to make sure that it make sense for the entire lifetime of this object. The number of components of this functions is equal to the number of components of the finite element object. If a mapping is specified, that is what is used to find out where the points lay. Otherwise the standard Q1 mapping is used.
void Functions::FEFieldFunction< dim, VectorType, spacedim >::set_active_cell | ( | const typename DoFHandler< dim, spacedim >::active_cell_iterator & | newcell | ) |
Set the current cell. If you know in advance where your points lie, you can tell this object by calling this function. This will speed things up a little.
|
overridevirtual |
Get one vector value at the given point. It is inefficient to use single points. If you need more than one at a time, use the vector_value_list() function. For efficiency reasons, it is better if all the points lie on the same cell. This is not mandatory, however it does speed things up.
Reimplemented from Function< dim, VectorType::value_type >.
|
overridevirtual |
Return the value of the function at the given point. Unless there is only one component (i.e. the function is scalar), you should state the component you want to have evaluated; it defaults to zero, i.e. the first component. It is inefficient to use single points. If you need more than one at a time, use the vector_value_list() function. For efficiency reasons, it is better if all the points lie on the same cell. This is not mandatory, however it does speed things up.
Reimplemented from Function< dim, VectorType::value_type >.
|
overridevirtual |
Set values
to the point values of the specified component of the function at the points
. It is assumed that values
already has the right size, i.e. the same size as the points array. This is rather efficient if all the points lie on the same cell. If this is not the case, things may slow down a bit.
Reimplemented from Function< dim, VectorType::value_type >.
|
overridevirtual |
Set values
to the point values of the function at the points
. It is assumed that values
already has the right size, i.e. the same size as the points array. This is rather efficient if all the points lie on the same cell. If this is not the case, things may slow down a bit.
Reimplemented from Function< dim, VectorType::value_type >.
|
overridevirtual |
Return the gradient of all components of the function at the given point. It is inefficient to use single points. If you need more than one at a time, use the vector_value_list() function. For efficiency reasons, it is better if all the points lie on the same cell. This is not mandatory, however it does speed things up.
Reimplemented from Function< dim, VectorType::value_type >.
|
overridevirtual |
Return the gradient of the specified component of the function at the given point. It is inefficient to use single points. If you need more than one at a time, use the vector_value_list() function. For efficiency reasons, it is better if all the points lie on the same cell. This is not mandatory, however it does speed things up.
Reimplemented from Function< dim, VectorType::value_type >.
|
overridevirtual |
Return the gradient of all components of the function at all the given points. This is rather efficient if all the points lie on the same cell. If this is not the case, things may slow down a bit.
Reimplemented from Function< dim, VectorType::value_type >.
|
overridevirtual |
Return the gradient of the specified component of the function at all the given points. This is rather efficient if all the points lie on the same cell. If this is not the case, things may slow down a bit.
Reimplemented from Function< dim, VectorType::value_type >.
|
overridevirtual |
Compute the Laplacian of a given component at point p
.
Reimplemented from Function< dim, VectorType::value_type >.
|
overridevirtual |
Compute the Laplacian of all components at point p
and store them in values
.
Reimplemented from Function< dim, VectorType::value_type >.
|
overridevirtual |
Compute the Laplacian of one component at a set of points.
Reimplemented from Function< dim, VectorType::value_type >.
|
overridevirtual |
Compute the Laplacians of all components at a set of points.
Reimplemented from Function< dim, VectorType::value_type >.
unsigned int Functions::FEFieldFunction< dim, VectorType, spacedim >::compute_point_locations | ( | const std::vector< Point< dim > > & | points, |
std::vector< typename DoFHandler< dim, spacedim >::active_cell_iterator > & | cells, | ||
std::vector< std::vector< Point< dim > > > & | qpoints, | ||
std::vector< std::vector< unsigned int > > & | maps | ||
) | const |
Given a set of points located in the domain (or, in the case of a parallel Triangulation, in the locally owned part of the domain or on the ghost cells for the current processor), sort these points into buckets for each of the cells on which at least one of the points is located.
This function fills three output vectors: cells
, qpoints
and maps
. The first is a list of the cells that contain the points, the second is a list of quadrature points matching each cell of the first list, and the third contains the index of the given quadrature points, i.e., points
[maps[3][4]] ends up as the 5th quadrature point in the 4th cell.
points
. This also equals the lengths of the output arrays.This function simply calls GridTools::compute_point_locations : using the original function avoids computing a new Cache at every function call.
|
private |
Given a cell, return the reference coordinates of the given point within this cell if it indeed lies within the cell. Otherwise return an uninitialized std::optional object.
|
virtualinherited |
For each component of the function, fill a vector of values, one for each point.
The default implementation of this function in Function calls value_list() for each component. In order to improve performance, this can be reimplemented in derived classes to speed up performance.
|
virtualinherited |
For each component of the function, fill a vector of gradient values, one for each point.
The default implementation of this function in Function calls value_list() for each component. In order to improve performance, this can be reimplemented in derived classes to speed up performance.
|
virtualinherited |
Compute the Hessian of a given component at point p
, that is the gradient of the gradient of the function.
|
virtualinherited |
Compute the Hessian of all components at point p
and store them in values
.
|
virtualinherited |
Compute the Hessian of one component at a set of points.
|
virtualinherited |
Compute the Hessians of all components at a set of points.
|
virtualinherited |
Return an estimate for the memory consumption, in bytes, of this object.
This function is virtual and can be overloaded by derived classes.
|
inherited |
Return the value of the time variable.
|
virtualinherited |
Set the time to new_time
, overwriting the old value.
|
virtualinherited |
Advance the time by the given time step delta_t
.
|
inherited |
Subscribes a user of the object by storing the pointer validity
. The subscriber may be identified by text supplied as identifier
.
Definition at line 131 of file enable_observer_pointer.cc.
|
inherited |
Unsubscribes a user from the object.
identifier
and the validity
pointer must be the same as the one supplied to subscribe(). Definition at line 151 of file enable_observer_pointer.cc.
|
inlineinherited |
Return the present number of subscriptions to this object. This allows to use this class for reference counted lifetime determination where the last one to unsubscribe also deletes the object.
Definition at line 322 of file enable_observer_pointer.h.
|
inlineinherited |
List the subscribers to the input stream
.
Definition at line 339 of file enable_observer_pointer.h.
|
inherited |
List the subscribers to deallog
.
Definition at line 199 of file enable_observer_pointer.cc.
|
inlineinherited |
Read or write the data of this object to or from a stream for the purpose of serialization using the BOOST serialization library.
This function does not actually serialize any of the member variables of this class. The reason is that what this class stores is only who subscribes to this object, but who does so at the time of storing the contents of this object does not necessarily have anything to do with who subscribes to the object when it is restored. Consequently, we do not want to overwrite the subscribers at the time of restoring, and then there is no reason to write the subscribers out in the first place.
Definition at line 331 of file enable_observer_pointer.h.
|
privatenoexceptinherited |
Check that there are no objects subscribing to this object. If this check passes then it is safe to destroy the current object. It this check fails then this function will either abort or print an error message to deallog (by using the AssertNothrow mechanism), but will not throw an exception.
Definition at line 53 of file enable_observer_pointer.cc.
|
private |
Pointer to the dof handler.
Definition at line 474 of file fe_field_function.h.
|
private |
A reference to the actual data vector.
Definition at line 479 of file fe_field_function.h.
|
private |
A reference to the mapping being used.
Definition at line 484 of file fe_field_function.h.
|
private |
The Cache object
Definition at line 489 of file fe_field_function.h.
|
mutableprivate |
The latest cell hint.
Definition at line 494 of file fe_field_function.h.
Export the value of the template parameter as a static member constant. Sometimes useful for some expression template programming.
Definition at line 158 of file function.h.
Number of vector components.
Definition at line 163 of file function.h.
|
privateinherited |
Store the present time.
Definition at line 112 of file function_time.h.
|
mutableprivateinherited |
Store the number of objects which subscribed to this object. Initially, this number is zero, and upon destruction it shall be zero again (i.e. all objects which subscribed should have unsubscribed again).
The creator (and owner) of an object is counted in the map below if HE manages to supply identification.
We use the mutable
keyword in order to allow subscription to constant objects also.
This counter may be read from and written to concurrently in multithreaded code: hence we use the std::atomic
class template.
Definition at line 227 of file enable_observer_pointer.h.
|
mutableprivateinherited |
In this map, we count subscriptions for each different identification string supplied to subscribe().
Definition at line 233 of file enable_observer_pointer.h.
|
mutableprivateinherited |
In this vector, we store pointers to the validity bool in the ObserverPointer objects that subscribe to this class.
Definition at line 249 of file enable_observer_pointer.h.
|
mutableprivateinherited |
Pointer to the typeinfo object of this object, from which we can later deduce the class name. Since this information on the derived class is neither available in the destructor, nor in the constructor, we obtain it in between and store it here.
Definition at line 257 of file enable_observer_pointer.h.
|
staticprivateinherited |
A mutex used to ensure data consistency when accessing the mutable
members of this class. This lock is used in the subscribe() and unsubscribe() functions, as well as in list_subscribers()
.
Definition at line 280 of file enable_observer_pointer.h.