 |
ASPECT
|
|
ASPECT
|
Classes | |
| struct | DofToEvalPointData |
Protected Member Functions | |
| void | set_evaluation_points (const std::vector< Point< dim >> &evaluation_points) |
| std::vector< std::vector< double > > | evaluate_aspect_solution_at_points () const |
| LinearAlgebra::Vector | interpolate_external_velocities_to_surface_support_points (const std::vector< Tensor< 1, dim >> &velocities) const |
Protected Attributes | |
| std::vector< Point< dim > > | evaluation_points |
| std::unique_ptr< Utilities::MPI::RemotePointEvaluation< dim, dim > > | remote_point_evaluator |
| std::vector< DofToEvalPointData > | map_dof_to_eval_point |
Additional Inherited Members | |
 Static Public Member Functions inherited from aspect::Plugins::InterfaceBase | |
| static void | declare_parameters (ParameterHandler &prm) |
| Static Public Member Functions inherited from aspect::SimulatorAccess< dim > | |
| static void | get_composition_values_at_q_point (const std::vector< std::vector< double >> &composition_values, const unsigned int q, std::vector< double > &composition_values_at_q_point) |
This class provides support for writing classes derived from MeshDeformation::Interface when implementing surface deformation models that are based on external tools such as Fastscape, Landlab, OpenLEM, etc. The primary complication of interacting with these external tools is that they generally use their own discretization of surface processes, using a mesh that, in most cases, will be different from the one used by ASPECT. (Of course, ASPECT's use is a volume mesh, whereas surface processes use surface meshes. ASPECT's own surface diffusion, for example, works on the surface faces of ASPECT's mesh, but in general, external tools use a mesh that is entirely unrelated to the surface cells of ASPECT's volume mesh.) In these cases, one needs to implement transfer operations to take ASPECT's solution and interpolate it to the external tool's mesh, run some surface evolution steps, and then interpolate back to the surface nodes of ASPECT's mesh. These interpolation operations are difficult to implement and are especially cumbersome in parallel. This is because the points at which the external tool wants to know the solution on any given MPI process will, in general, not be located on the part of ASPECT's mesh that is owned by that MPI process. As a consequence, implementing the interpolation requires finding the MPI process that owns the cell on which that point is is located, and then communicating back and forth.
This class implements the interpolation functionality for derived classes to use. It works through a two-stage approach:
All three of these functions are protected member functions of this class, ready to be called by derived classes.
All classes derived from MeshDeformation::Interface need to implement the MeshDeformation::Interface::compute_velocity_constraints_on_boundary() function. Because the basic outline of this function looks essentially the same for all external tools, this class also provides a high-level implementation of this function as part of this class. In essence
Definition at line 91 of file parallel_unstructured_interface.h.
|
overridevirtual |
Main routine handling the mesh deformation
Reimplemented from aspect::MeshDeformation::Interface< dim >.
|
pure virtual |
Given all solution variables at each surface point, compute velocities at these points. This needs to be implemented by the derived class and implement the "surface evolution".
|
protected |
Declare at which points the external tool driven by a class derived from the current one needs to evaluate the ASPECT solution. Each process will call this function with the points it needs. Different processes will, in general, provide distinct sets of points.
The points provided here are given in the undeformed configuration that corresponds to the initial mesh. For example, if the mesh describes a box geometry, then the points should lie in the \(x\)- \(y\)-plane that forms the top reference surface of the model, and not on the currently deformed top surface that describes the current elevation map.
|
protected |
Return the value of the ASPECT solution at the set of points previously set via set_evaluation_points().
For each point, the return object contains a vector with as many components as there are ASPECT solution components.
|
protected |
Interpolate from velocities given in the evaluation points to ASPECT velocities on the surface in form of a finite element field.
The velocities, which are typically vertical, were previously computed by the external tool and belong to the current process. The output is a (global) finite element field vector that in the velocity components of surface nodes corresponds to an interpolation of the velocities provided.
The output of this function can then be used as input for a function that implements the compute_velocity_constraints_on_boundary() function of the base class.
|
protected |
The list of evaluation points owned by the current process. These are the points where the external tool will receive the ASPECT solution values and return the updated velocities.
Definition at line 178 of file parallel_unstructured_interface.h.
|
protected |
deal.II RemotePointEvaluation object used to do point evaluation in the evaluation points.
Definition at line 183 of file parallel_unstructured_interface.h.
|
protected |
A vector to store a map between Dof indices and evaluation points.
The map will contain an entry for each DoF on the surface of the ASPECT mesh and contains the index of the evaluation point that is closest to the DoF. As each support point has several components (x,y,z velocity), the map contains one entry for each component.
In a parallel computation, this map only contains entries for evaluation points owned by the current process. Note that the DoF indices are not necessarily locally owned.
This map is used in interpolate_external_velocities_to_surface_support_points() to copy external velocities to each surface DoF from the closest evaluation point.
Definition at line 221 of file parallel_unstructured_interface.h.
1.8.12