* Volume = {7},
* Year = {2018}}
* @endcode
- *
*/
class GeneralDataStorage : public Subscriptor
{
*
* Given a list of names to search for (provided by add()), objects of this
* class provide an index list of the selected data.
- *
*/
class NamedSelection
{
*
* For the call to (*#inverse_derivative), the vector <tt>"Newton
* residual"</tt> is inserted before <tt>"Newton iterate"</tt>.
- *
*/
template <typename VectorType>
class Newton : public OperatorBase
* or OutputOperator, depending on whether they return a value or not. See the
* documentation of those classes for more detailed information on how to use
* them.
- *
*/
namespace Algorithms
{
* the solution when the function returns. The object <tt>in</tt> is
* providing additional information and forwarded to the inner Operator
* objects of the nested iteration.
- *
*/
class OperatorBase : public Subscriptor
{
/**
* An unary operator base class, intended to output the vectors in AnyData
* in each step of an iteration.
- *
*/
template <typename VectorType>
class OutputOperator : public Subscriptor
*
* This is according to the convention set by the function
* <code>coordinate_to_one_dim_higher</code>.
- *
*/
template <int spacedim, typename Number = double>
class BoundingBox
/**
* This class generates graphical output for BoundingBox objects, starting from
* any object that can be converted by boost to a BoundingBox.
- *
*/
template <int dim>
class BoundingBoxDataOut : public DataOutInterface<dim, dim>
* <tt>2<sup>dim</sup></tt>.
*
* @ingroup output
- *
*/
template <int dim, int spacedim = dim>
struct Patch
* member variable that make no sense for zero-dimensional patches because
* points have no natural neighbors across their non-existent faces, nor
* can they reasonably be subdivided.
- *
*/
template <int spacedim>
struct Patch<0, spacedim>
* references other files. For example, it could be the name for a
* <code>.pvtu</code> file that references multiple parts of a parallel
* computation.
- *
*/
void
write_pvd_record(
*
* @note Use an empty string "" for the first argument if output is to be
* written in the current working directory.
- *
*/
std::string
write_vtu_with_pvtu_record(
* operator dumps the intermediate graphics format represented by the patch
* data structure. It may later be converted into regular formats for a
* number of graphics programs.
- *
*/
template <int dim, int spacedim>
std::ostream &
* operator reads the intermediate graphics format represented by the patch
* data structure, using the format in which it was written using the
* operator<<.
- *
*/
template <int dim, int spacedim>
std::istream &
* In deal.II we represent these derivatives using objects of type
* DerivativeForm@<1,dim,spacedim,Number@>,
* DerivativeForm@<2,dim,spacedim,Number@> and so on.
- *
*/
template <int order, int dim, int spacedim, typename Number = double>
class DerivativeForm
* // } end snapshot stage
* }
* @endcode
- *
*/
class DiscreteTime
{
* custom_function({&first_component, &second_component},
* {&zero_gradient, &zero_gradient});
* @endcode
- *
*/
template <int dim, typename RangeNumberType = double>
class FunctionFromFunctionObjects : public Function<dim, RangeNumberType>
* Since the ability to identify such objects with the integral dimension of
* the object represented, this class provides conversion operators to and
* from unsigned integers.
- *
*/
class GeometryPrimitive
{
* std::vector for efficiency). Each element of the outermost set
* corresponds to the iterators pointing to objects that are in the same
* partition (i.e., the same zone).
- *
*/
template <typename Iterator>
std::vector<std::vector<Iterator>>
* corresponds to the iterators pointing to objects that are in the same
* partition (have the same color) and consequently do not conflict. The
* elements of different sets may conflict.
- *
*/
template <typename Iterator>
std::vector<std::vector<Iterator>>
* thread-safe HDF5 version serializes the API but does not provide any level of
* concurrency. To achieve high parallel performance with HDF5, we advice to use
* HDF5 with MPI.
- *
*/
// clang-format on
namespace HDF5
{
/**
* Base class for the HDF5 objects.
- *
*/
class HDF5Object
{
/**
* This class implements an HDF5 DataSet.
- *
*/
class DataSet : public HDF5Object
{
/**
* This class implements an HDF5 Group
- *
*/
class Group : public HDF5Object
{
/**
* This class implements an HDF5 File
- *
*/
class File : public Group
{
* The data structures used in this class along with a rationale can be found
* in the
* @ref distributed_paper "Distributed Computing paper".
- *
*/
class IndexSet
{
* Split the set indices represented by this object into blocks given by the
* @p n_indices_per_block structure. The sum of its entries must match the
* global size of the current object.
- *
*/
std::vector<IndexSet>
split_by_block(
/**
* Create an object of type IteratorRange given the beginning and
* end iterator.
- *
*/
template <typename BaseIterator>
IteratorRange<BaseIterator>
* <code>size_type</code> type.
*
* @note TransposeTable uses this template to implement its iterators.
- *
*/
template <class DerivedIterator, class AccessorType>
class LinearIndexIterator
/**
* The standard log object of deal.II:
- *
*/
extern LogStream deallog;
DEAL_II_NAMESPACE_OPEN
/**
- *
*/
namespace MemorySpace
{
*
* @return A map from the rank (unsigned int) of the process
* which sent the data and object received.
- *
*/
template <typename T>
std::map<unsigned int, T>
* processes in the MPI communicator. Each entry contains the object
* received from the processor with the corresponding rank within the
* communicator.
- *
*/
template <typename T>
std::vector<T>
* processes in the MPI communicator. Each entry contains the object
* received from the processor with the corresponding rank within the
* communicator. All other processes receive an empty vector.
- *
*/
template <typename T>
std::vector<T>
* @return List containing the MPI process rank for each entry in the index
* set @p indices_to_look_up. The order coincides with the order
* within the ElementIterator.
- *
*/
std::vector<unsigned int>
compute_index_owner(const IndexSet &owned_indices,
* 1) deliver only references to empty vectors (of size 0) the data to be
* sent can be inserted to or read from, and 2) communicate these vectors
* blindly.
- *
*/
template <typename T1, typename T2>
class Process
*
* @tparam T1 The type of the elements of the vector to be sent.
* @tparam T2 The type of the elements of the vector to be received.
- *
*/
template <typename T1, typename T2>
class Interface
*
* @tparam T1 The type of the elements of the vector to be sent.
* @tparam T2 The type of the elements of the vector to be received.
- *
*/
template <typename T1, typename T2>
class NBX : public Interface<T1, T2>
*
* @tparam T1 The type of the elements of the vector to be sent.
* @tparam T2 The type of the elements of the vector to be received.
- *
*/
template <typename T1, typename T2>
class PEX : public Interface<T1, T2>
*
* @tparam T1 The type of the elements of the vector to be sent.
* @tparam T2 The type of the elements of the vector to be received.
- *
*/
template <typename T1, typename T2>
class Selector : public Interface<T1, T2>
/**
* A flexible Partitioner class, which does not impose restrictions
* regarding the order of the underlying index sets.
- *
*/
class NoncontiguousPartitioner
: public dealii::LinearAlgebra::CommunicationPatternBase
* exp.parse_arguments("3.0 : 4");
* exp(); // calls example_function(p, 3.0, 4);
* @endcode
- *
*/
template <typename ReturnType, class... FunctionArgs>
class MutableBind
* bound.parse_arguments("3: 4.0");
* bound(); // will execute my_function(3, 4.0);
* @endcode
- *
*/
template <typename ReturnType, class... FunctionArgs>
MutableBind<ReturnType, FunctionArgs...>
*
* @tparam Number The underlying data type for which one wants to find out
* the maximal length of hardware supported vectors.
- *
*/
template <typename Number>
struct VectorizedArrayWidthSpecifier
* for the data type `double` for the given processor architecture and
* optimization level. For a detailed description of supported maximal vector
* lengths, see the documentation of VectorizedArray.
- *
*/
template <>
struct VectorizedArrayWidthSpecifier<double>
* for the data type `float` for the given processor architecture and
* optimization level. For a detailed description of supported maximal vector
* lengths, see the documentation of VectorizedArray.
- *
*/
template <>
struct VectorizedArrayWidthSpecifier<float>
* types and complex number types. This template is mostly used to implement
* linear algebra classes such as vectors and matrices that work for both
* real and complex numbers.
- *
*/
template <typename number>
struct NumberTraits
/**
* Specialization of the general NumberTraits class that provides the
* relevant information if the underlying data type is std::complex<T>.
- *
*/
template <typename number>
struct NumberTraits<std::complex<number>>
* itself.
*
* See the tutorial program step-60 for an example on how to use this class.
- *
*/
class ParameterAcceptor : public Subscriptor
{
* files.
*
* See the tutorial program step-60 for an example on how to use this class.
- *
*/
template <class SourceClass>
class ParameterAcceptorProxy : public SourceClass, public ParameterAcceptor
* Volume = {7},
* Year = {2018}}
* @endcode
- *
*/
class ParsedConvergenceTable
{
* set Variable names = x,y,t
*
* @endcode
- *
*/
static void
declare_parameters(ParameterHandler & prm,
* export_to_ghosted_array_start() and import_from_ghosted_array_start()
* detect this case and only send the selected indices, taken from the
* full array of ghost entries.
- *
*/
class Partitioner : public ::dealii::LinearAlgebra::CommunicationPatternBase
{
*
* The default separator is a colon, owing to the fact that a pair is in fact
* a tuple with two elements.
- *
*/
class Tuple : public PatternBase
{
* The second template parameter is used internally to allow for advanced
* SFINAE (substitution failure is not an error) tricks used to specialise
* this class for arbitrary STL containers and maps.
- *
*/
template <class T, class Enable = void>
struct Convert
* See the documentation of the class Patterns::Tools::Convert, and of the
* helper class Patterns::Tools::RankInfo for details on the way separators
* are selected when outputting STL container types.
- *
*/
template <typename T>
std::string
* Notice that the current content of variable @p t is ignored. Its type is
* used to infer how to interpret the string. If the string is successfully
* parsed, then @p t will be set to the parsed content of @p s.
- *
*/
template <typename T>
void
* elementary types, like Point(), or std::complex<double>, are compatible
* with the List type. Adding more compatible types is a matter of adding
* a specialization of this struct for the given type.
- *
*/
template <class T, class Enable = void>
struct RankInfo
* form, the constructor with the roots in form of a Lagrange polynomial
* must be used. In case a manipulation is done that changes the roots, the
* representation is switched to the coefficient form.
- *
*/
template <typename number>
class Polynomial : public Subscriptor
/**
* Class generates Polynomial objects representing a monomial of degree n,
* that is, the function $x^n$.
- *
*/
template <typename number>
class Monomial : public Polynomial<number>
* entire space of polynomials of degree less than or equal <tt>degree</tt>.
*
* The Lagrange polynomials are implemented up to degree 10.
- *
*/
class LagrangeEquidistant : public Polynomial<double>
{
* interval $[-1,1]$. (ii) The polynomials have been scaled in such a way
* that they are orthonormal, not just orthogonal; consequently, the
* polynomials do not necessarily have boundary values equal to one.
- *
*/
class Legendre : public Polynomial<double>
{
*
* These polynomials are used for the construction of the shape functions of
* Nédélec elements of arbitrary order.
- *
*/
class Lobatto : public Polynomial<double>
{
* concept of a polynomial degree, if the given argument is zero, it does
* <b>not</b> return the linear polynomial described above, but rather a
* constant polynomial.
- *
*/
class Hierarchical : public Polynomial<double>
{
* \ldots & \ldots \\
* p_k(x) &= x^2(x-1)^2 L_{k-4}(x)
* @f}
- *
*/
class HermiteInterpolation : public Polynomial<double>
{
* but gives better condition numbers of interpolation, which improves the
* performance of some iterative schemes like conjugate gradients with
* point-Jacobi. This polynomial is used in FE_DGQHermite.
- *
*/
class HermiteLikeInterpolation : public Polynomial<double>
{
* polynomials:
*
* $L_{n} = \frac{l_{n} - l_{n-2}}{2n-1)}$
- *
*/
class IntegratedLegendreSZ : public Polynomials::Polynomial<double>
{
* dimensions: ${1,x,y,xy,x^2,y^2,x^2y,xy^2,x^3,y^3,...}$. The ordering of the
* monomials in $P_k1$ matches the ordering of the monomials in $P_k2$ for
* $k2>k1$.
- *
*/
template <int dim>
class PolynomialsP : public PolynomialSpace<dim>
* allow constructing FE_Q_iso_Q1 elements that put additional degrees of
* freedom into an equivalent of a refined mesh instead of higher order
* polynomials, which is useful when using mixed finite elements.
- *
*/
template <typename number>
class PiecewisePolynomial : public Subscriptor
*
* Currently the only place where one would use a ProcessGrid object is
* in connection with a ScaLAPACKMatrix object.
- *
*/
class ProcessGrid
{
* @ref GlossFaceOrientation "the glossary entry on face orientation"
* for more information on this.) The DataSetDescriptor member class is used
* to identify where each dataset starts.
- *
*/
template <int dim>
class QProjector
* member functions that generate objects of this type, given face or
* subface indices, and you can then use the generated object in place of an
* integer that denotes the offset of a given dataset.
- *
*/
class DataSetDescriptor
{
* @note Instantiations for this template are provided for dimensions 0, 1, 2,
* and 3 (see the section on
* @ref Instantiations).
- *
*/
template <int dim>
class Quadrature : public Subscriptor
*
* @note Each constructor can only be used in the dimension matching the
* number of arguments.
- *
*/
template <int dim>
class QAnisotropic : public Quadrature<dim>
* The aim of this class is to provide a low order formula, where the error
* constant can be tuned by increasing the number of quadrature points. This
* is useful in integrating non-differentiable functions on cells.
- *
*/
template <int dim>
class QIterated : public Quadrature<dim>
* described in <a
* href="http://en.wikipedia.org/wiki/Numerical_Recipes">Numerical
* Recipes</a>.
- *
*/
template <int dim>
class QGauss : public Quadrature<dim>
* @sa http://en.wikipedia.org/wiki/Handbook_of_Mathematical_Functions @sa
* Karniadakis, G.E. and Sherwin, S.J.: Spectral/hp element methods for
* computational fluid dynamics. Oxford: Oxford University Press, 2005
- *
*/
template <int dim>
class QGaussLobatto : public Quadrature<dim>
* misnomer results from the fact that its original authors' poor English
* language skills led them to translate the name incorrectly from the German
* "Trapezregel".
- *
*/
template <int dim>
class QTrapez : public Quadrature<dim>
*
* The weights and functions for Gauss Legendre formula have been tabulated up
* to order 12.
- *
*/
template <int dim>
class QTelles : public Quadrature<dim>
* the integral $\int_0^1 f(x) w(x) dx$ with the weight: $w(x) =
* 1/\sqrt{x(1-x)}$. For details see: M. Abramowitz & I.A. Stegun: Handbook of
* Mathematical Functions, par. 25.4.38
- *
*/
template <int dim>
class QGaussChebyshev : public Quadrature<dim>
* with the left endpoint as quadrature node, but the quadrature node can be
* imposed at the right endpoint through the variable ep that can assume the
* values left or right.
- *
*/
template <int dim>
class QGaussRadauChebyshev : public Quadrature<dim>
* $\int_0^1 f(x) w(x) dx$ with the weight: $w(x) = 1/\sqrt{x(1-x)}$. For
* details see: M. Abramowitz & I.A. Stegun: Handbook of Mathematical
* Functions, par. 25.4.40
- *
*/
template <int dim>
class QGaussLobattoChebyshev : public Quadrature<dim>
* singularities at certain points, or functions that present jumps along a
* co-dimension one surface inside the reference element, like in the extended
* finite element method (XFEM).
- *
*/
template <int dim>
class QSimplex : public Quadrature<dim>
* \end{pmatrix}
* \qquad \theta \dealcoloneq \frac\pi 2 \hat y
* \f]
- *
*/
class QTrianglePolar : public QSimplex<2>
{
*
* When $\beta = 1$, this transformation is also known as the Lachat-Watson
* transformation.
- *
*/
class QDuffy : public QSimplex<2>
{
/**
* A quadrature to use when the cell should be split into subregions to
* integrate using one or more base quadratures.
- *
*/
template <int dim>
class QSplit : public Quadrature<dim>
* However, within the cell this class stores a vector of objects of a single
* data type. For this reason, this class may not be sufficiently flexible when,
* for example, adopting a level-set approach to describe material behavior.
- *
*/
template <typename CellIteratorType, typename DataType>
class CellDataStorage : public Subscriptor
*
* To store and access instances of classes derived from this class, see the
* CellDataStorage class.
- *
*/
class TransferableQuadraturePointData
{
* yield over and undershoots that, once evaluated at a different set of
* quadrature points (on child or parent cells) results in values that will
* not make much sense.
- *
*/
template <int dim, typename DataType>
class ContinuousQuadratureDataTransfer
* This counter may be read from and written to concurrently in
* multithreaded code: hence we use the <code>std::atomic</code> class
* template.
- *
*/
mutable std::atomic<unsigned int> counter;
* between two tensors or ranks rank1 and rank2. In general, this is a
* tensor of rank <tt>rank1+rank2-4</tt>, but if this is zero it is a
* single scalar Number. For this case, we have a specialization.
- *
*/
template <int rank1,
int rank2,
* between two tensors or ranks rank1 and rank2. In general, this is a
* tensor of rank <tt>rank1+rank2-4</tt>, but if this is zero it is a
* single scalar Number. For this case, we have a specialization.
- *
*/
template <int dim, typename Number, typename OtherNumber>
struct double_contraction_result<2, 2, dim, Number, OtherNumber>
*
* This class is an adaptation of a similar class used for the Table
* class.
- *
*/
template <int rank, int dim, bool constness, int P, typename Number>
class Accessor
* elements of the table, rather than recursively returning access objects
* for further subsets. The same holds for this specialization as for the
* general template; see there for more information.
- *
*/
template <int rank, int dim, bool constness, typename Number>
class Accessor<rank, dim, constness, 1, Number>
* @param[out] Q The orthogonal matrix effecting the transformation
* @param[out] d The diagonal elements of the tridiagonal matrix
* @param[out] e The off-diagonal elements of the tridiagonal matrix
- *
*/
template <int dim, typename Number>
void
*
* @return An array containing the eigenvectors and the associated eigenvalues.
* The array is not sorted in any particular order.
- *
*/
template <int dim, typename Number>
std::array<std::pair<Number, Tensor<1, dim, Number>>, dim>
*
* @return An array containing the eigenvectors and the associated eigenvalues.
* The array is not sorted in any particular order.
- *
*/
template <int dim, typename Number>
std::array<std::pair<Number, Tensor<1, dim, Number>>, dim>
*
* @return An array containing the eigenvectors and the associated eigenvalues.
* The array is not sorted in any particular order.
- *
*/
template <typename Number>
std::array<std::pair<Number, Tensor<1, 2, Number>>, 2>
*
* @return An array containing the eigenvectors and the associated eigenvalues.
* The array is not sorted in any particular order.
- *
*/
template <typename Number>
std::array<std::pair<Number, Tensor<1, 3, Number>>, 3>
*
* This type, and the helper functions associated with it, are used as the
* Value concept for the blocked_range type of the Threading Building Blocks.
- *
*/
template <typename Iterators>
struct SynchronousIterators
* should use explicitly in your programs (except, of course, through access
* to the elements of tables with <tt>operator[]</tt>, which generates
* temporary objects of the types of this namespace).
- *
*/
namespace TableBaseAccessors
{
* objects of this class, as they are only thought as temporaries for
* access to elements of the table class, not for passing them around as
* arguments of functions, etc.
- *
*/
template <int N, typename T, bool C, unsigned int P>
class Accessor
* rather than recursively returning access objects for further subsets.
* The same holds for this specialization as for the general template; see
* there for more information.
- *
*/
template <int N, typename T, bool C>
class Accessor<N, T, C, 1>
* Global function @p swap which overloads the default implementation of the
* C++ standard library which uses a temporary object. The function simply
* exchanges the data of the two tables.
- *
*/
template <int N, typename T>
inline void
* the second type in the template.
*
* @deprecated Use std::enable_if instead.
- *
*/
template <typename T>
struct DEAL_II_DEPRECATED constraint_and_return_value<true, T>
* forward_call(&h, 1);
* }
* @endcode
- *
*/
template <typename T>
struct identity
* This class implements a comparison function that always returns @p false if
* the types of its two arguments are different, and returns <tt>p1 == p2</tt>
* otherwise.
- *
*/
struct PointerComparison
{
* that specialization of this class is only made for unqualified (fully
* stripped) types and that the ProductType class be used to determine the
* result of operating with (potentially) qualified types.
- *
*/
template <typename T, typename U>
struct ProductTypeImpl
* In all of these cases, this type is used to identify which type needs to be
* used for the result of computing the product of unknowns and the values,
* gradients, or other properties of shape functions.
- *
*/
template <typename T, typename U>
struct ProductType
* It also allows the declaration of overloads of a function such as @p
* multiply for different types of arguments, without resulting in ambiguous
* call errors by the compiler.
- *
*/
template <typename T>
struct EnableIfScalar;
* of such objects.
*
* @ingroup geomprimitives
- *
*/
namespace TensorAccessors
{
* alias <code>value_type</code> and an index operator
* <code>operator[]()</code> that returns a (const or non-const) reference
* of <code>value_type</code>.
- *
*/
template <int index, int rank, typename T>
constexpr DEAL_II_ALWAYS_INLINE internal::ReorderedIndexView<index, rank, T>
* @tparam ArrayType An array like object, such as std::array, or
* dealii::TableIndices that stores at least @p rank indices that can be
* accessed via operator[]().
- *
*/
template <int rank, typename T, typename ArrayType>
constexpr DEAL_II_ALWAYS_INLINE typename ReturnType<rank, T>::value_type &
* @note The Types @p T1, @p T2, and @p T3 must have rank rank_1 + rank_2 -
* 2 * no_contr, rank_1, or rank_2, respectively. Obviously, no_contr must
* be less or equal than rank_1 and rank_2.
- *
*/
template <int no_contr,
int rank_1,
*
* @note The Types @p T2, @p T3, and @p T4 must have rank rank_1, rank_1 +
* rank_2, and rank_3, respectively. @p T1 must be a scalar type.
- *
*/
template <int rank_1,
int rank_2,
* $P^x_2(x)P^y_1(y)$, $P^x_3(x)P^y_1(y)$, ...,
* $P^x_1(x)P^y_2(y)$, $P^x_2(x)P^y_2(y)$,
* $P^x_3(x)P^y_2(y)$, etc.
- *
*/
template <int dim>
class AnisotropicPolynomials : public ScalarPolynomialsBase<dim>
* $(2*x_j-1)^{degree-1}\prod_{i=0}^{dim-1}(x_i(1-x_i))$. This class inherits
* most of its functionality from TensorProductPolynomials. The bubble
* enrichments are added for the last indices. index.
- *
*/
template <int dim>
class TensorProductPolynomialsBubbles : public ScalarPolynomialsBase<dim>
* class inherits most of its functionality from TensorProductPolynomials. It
* works similarly to that class but adds a constant function for the last
* index.
- *
*/
template <int dim>
class TensorProductPolynomialsConst : public ScalarPolynomialsBase<dim>
* A namespace in which helper functions and the like for the threading
* subsystem are implemented. The members of this namespace are not meant
* for public use.
- *
*/
namespace internal
{
/**
* Namespace containing the time stepping methods.
- *
*/
namespace TimeStepping
/**
* Base class for the Runge-Kutta method
- *
*/
template <typename VectorType>
class RungeKutta : public TimeStepping<VectorType>
* @param[in] input The string to compress
*
* @return A compressed version of the input string
- *
*/
std::string
compress(const std::string &input);
* function compress()
*
* @return The original uncompressed string.
- *
*/
std::string
decompress(const std::string &compressed_input);
* @param binary_input A vector of characters, representing your input as
* binary data.
* @return A string containing the binary input as a base64 string.
- *
*/
std::string
encode_base64(const std::vector<unsigned char> &binary_input);
*
* @param base64_input A string that contains the input in base64 format.
* @return A vector of characters that represents your input as binary data.
- *
*/
std::vector<unsigned char>
decode_base64(const std::string &base64_input);
/**
* Determine how many digits are needed to represent numbers at most as
* large as the given number.
- *
*/
unsigned int
needed_digits(const unsigned int max_number);
* operation, this function reduces the absolute value of a floating point
* number and always rounds towards zero, since decimal places are simply
* cut off.
- *
*/
template <typename Number>
Number
* In general, C++ uses mangled names to identify types. This function
* uses boost::core::demangle to return a human readable string describing
* the type of the variable passed as argument.
- *
*/
template <class T>
std::string
* If many consecutive calls with the same buffer are considered, it is
* recommended for reasons of performance to ensure that its capacity is
* sufficient.
- *
*/
template <typename T>
size_t
* If the library has been compiled with ZLIB enabled, then the output buffer
* can be compressed. This can be triggered with the parameter
* @p allow_compression, and is only of effect if ZLIB is enabled.
- *
*/
template <typename T>
std::vector<char>
* This is because C++ does not allow functions to return arrays.
* Consequently, there is a separate unpack() function for arrays, see
* below.
- *
*/
template <typename T>
T
* The @p allow_compression parameter denotes if the buffer to
* read from could have been previously compressed with ZLIB, and
* is only of effect if ZLIB is enabled.
- *
*/
template <typename T>
T
* Note that unlike the other unpack() function, it is not necessary
* to explicitly specify the template arguments since they can be
* deduced from the second argument.
- *
*/
template <typename T, int N>
void
* The @p allow_compression parameter denotes if the buffer to
* read from could have been previously compressed with ZLIB, and
* is only of effect if ZLIB is enabled.
- *
*/
template <typename T, int N>
void
/**
* An iterator for VectorizedArray.
- *
*/
template <typename T>
class VectorizedArrayIterator
* Couriously Recurring Template Pattern (see
* https://en.wikipedia.org/wiki/Curiously_recurring_template_pattern) in this
* class to avoid having to resort to `virtual` member functions.
- *
*/
template <typename T, std::size_t width>
class VectorizedArrayBase
* @tparam Number underlying data type
* @tparam width vector length (optional; if not set, the maximal width of the
* architecture is used)
- *
*/
template <typename Number, std::size_t width>
class VectorizedArray
/**
* An alias for boost::geometry::model::segment that uses the deal.II
* Point class.
- *
*/
template <int dim>
using Segment = boost::geometry::model::segment<Point<dim>>;
* from, operations performed with auto-differentiable numbers.
* @tparam T An arbitrary type resulting from the application of
* the SFINAE idiom to selectively specialize this class.
- *
*/
template <typename ADNumberType, typename ScalarType, typename T = void>
struct TapedDrivers
* from, operations performed with auto-differentiable numbers.
* @tparam T An arbitrary type resulting from the application of
* the SFINAE idiom to selectively specialize this class.
- *
*/
template <typename ADNumberType, typename ScalarType, typename T = void>
struct TapelessDrivers
*
* @todo Make this class thread safe for Sacado number and ADOL-C tapeless
* numbers (if supported).
- *
*/
template <enum AD::NumberTypes ADNumberTypeCode,
typename ScalarType = double>
* deal.II, so this class should @b not be embedded within a multithreaded
* function when using ADOL-C number types. It is, however, suitable for use
* in both serial and MPI routines.
- *
*/
template <enum AD::NumberTypes ADNumberTypeCode,
typename ScalarType = double>
* deal.II, so this class should @b not be embedded within a multithreaded
* function when using ADOL-C number types. It is, however, suitable for use
* in both serial and MPI routines.
- *
*/
template <enum AD::NumberTypes ADNumberTypeCode,
typename ScalarType = double>
* deal.II, so this class should @b not be embedded within a multithreaded
* function when using ADOL-C number types. It is, however, suitable for use
* in both serial and MPI routines.
- *
*/
template <enum AD::NumberTypes ADNumberTypeCode,
typename ScalarType = double>
* deal.II, so this class should @b not be embedded within a multithreaded
* function when using ADOL-C number types. It is, however, suitable for use
* in both serial and MPI routines.
- *
*/
template <int dim,
enum AD::NumberTypes ADNumberTypeCode,
* deal.II, so this class should @b not be embedded within a multithreaded
* function when using ADOL-C number types. It is, however, suitable for use
* in both serial and MPI routines.
- *
*/
template <int dim,
enum AD::NumberTypes ADNumberTypeCode,
* deal.II, so this class should @b not be embedded within a multithreaded
* function when using ADOL-C number types. It is, however, suitable for use
* in both serial and MPI routines.
- *
*/
template <int dim,
enum AD::NumberTypes ADNumberTypeCode,
* to the given @p ScalarType.
* @tparam T An arbitrary type resulting from the application of
* the SFINAE idiom to selectively specialize this class.
- *
*/
template <typename ScalarType,
enum NumberTypes ADNumberTypeCode,
* auto-differentiable number.
* @tparam T An arbitrary type resulting from the application of
* the SFINAE idiom to selectively specialize this class.
- *
*/
template <typename ADNumberType, typename T = void>
struct ADNumberTraits;
* static const unsigned int n_supported_derivative_levels;
*
* @endcode
- *
*/
template <typename ScalarType,
enum NumberTypes ADNumberTypeCode,
* auto-differentiable number.
* @tparam T An arbitrary type resulting from the application of
* the SFINAE idiom to selectively specialize this class.
- *
*/
template <typename ADNumberType, typename T = void>
struct Marking;
* auto-differentiable number.
* @tparam T An arbitrary type resulting from the application of
* the SFINAE idiom to selectively specialize this class.
- *
*/
template <typename ADNumberType, typename T = void>
struct ExtractData;
* supported auto-differentiable number.
* @tparam T An arbitrary type resulting from the application of
* the SFINAE idiom to selectively specialize this class.
- *
*/
template <typename ADNumberTrait, typename T = void>
struct HasRequiredADInfo;
* an @p ADNumberType must be extracted through some function that is
* specific to each type of AD number. This requires some specialist
* intervention to get at this data.
- *
*/
template <typename T>
struct NumberType;
/**
* A small struct to remove the @p std::complex wrapper
* around a number.
- *
*/
template <typename Number>
struct RemoveComplexWrapper;
* auto-differentiable number or not. By default, numbers are not
* considered to have the necessary characteristics to fulfill this
* condition.
- *
*/
template <typename NumberType>
struct is_ad_number;
* auto-differentiable number or not. By default, numbers are not
* considered to have the necessary characteristics to fulfill this
* condition.
- *
*/
template <typename NumberType, typename = void>
struct is_taped_ad_number;
* auto-differentiable number or not. By default, numbers are not
* considered to have the necessary characteristics to fulfill this
* condition.
- *
*/
template <typename NumberType, typename = void>
struct is_tapeless_ad_number;
* auto-differentiable number or not. By default, numbers are not
* considered to have the necessary characteristics to fulfill this
* condition.
- *
*/
template <typename NumberType, typename = void>
struct is_real_valued_ad_number;
* auto-differentiable number or not. By default, numbers are not
* considered to have the necessary characteristics to fulfill this
* condition.
- *
*/
template <typename NumberType, typename = void>
struct is_complex_valued_ad_number;
* An enumeration to indicate which type of auto-differentiable number
* is to be used for computations. If a type that is selected for use
* is not available in the library, a run-time error will be thrown.
- *
*/
enum class NumberTypes
{
* A struct to indicate whether a given @p NumberType is an
* ADOL-C number or not. By default, numbers are not considered to
* have the necessary characteristics to fulfill this condition.
- *
*/
template <typename NumberType, typename = void>
struct is_adolc_number : std::false_type
* A struct to indicate whether a given @p NumberType is a taped
* ADOL-C number or not. By default, numbers are not considered to
* have the necessary characteristics to fulfill this condition.
- *
*/
template <typename NumberType, typename = void>
struct is_adolc_taped_number : std::false_type
* A struct to indicate whether a given @p NumberType is a tapeless
* ADOL-C number or not. By default, numbers are not considered to
* have the necessary characteristics to fulfill this condition.
- *
*/
template <typename NumberType, typename = void>
struct is_adolc_tapeless_number : std::false_type
/**
* A struct to help extract certain information associated with
* taped ADOL-C auto-differentiable numbers.
- *
*/
template <>
struct ExtractData<adouble>
/**
* A struct to help extract certain information associated with
* tapeless ADOL-C auto-differentiable numbers.
- *
*/
template <>
struct ExtractData<adtl::adouble>
* taped ADOL-C (real) double.
*
* @note In this case the number traits are the same as those for a taped double.
- *
*/
template <typename ADNumberType>
struct ADNumberTraits<
*
* @note In this case the number traits are the same as those for a taped complex
* double.
- *
*/
template <typename ADNumberType>
struct ADNumberTraits<
* tapeless ADOL-C (real) double.
*
* @note In this case the number traits are the same as those for a tapeless double.
- *
*/
template <typename ADNumberType>
struct ADNumberTraits<
*
* @note In this case the number traits are the same as those for a tapeless
* complex double.
- *
*/
template <typename ADNumberType>
struct ADNumberTraits<
* A struct to indicate whether a given @p NumberType is a
* Sacado number or not. By default, numbers are not considered to
* have the necessary characteristics to fulfill this condition.
- *
*/
template <typename NumberType, typename = void>
struct is_sacado_number : std::false_type
* A struct to indicate whether a given @p NumberType is a supported Sacado::Fad
* number or not. By default, numbers are not considered to have the
* necessary characteristics to fulfill this condition.
- *
*/
template <typename NumberType, typename = void>
struct is_sacado_dfad_number : std::false_type
* A struct to indicate whether a given @p NumberType is a supported Sacado::Rad
* number or not. By default, numbers are not considered to have the
* necessary characteristics to fulfill this condition.
- *
*/
template <typename NumberType, typename = void>
struct is_sacado_rad_number : std::false_type
* implementation details of a @p SacadoNumber. It defines
* various number types, and records how many levels of
* differentiation the number is able to support.
- *
*/
template <typename SacadoNumber, typename = void>
struct SacadoNumberInfo;
* A struct to help extract certain information associated with
* Sacado dynamic reverse auto-differentiable numbers. The @p NumberType
* can be either a floating point number or another Sacado type.
- *
*/
template <typename NumberType>
struct ExtractData<Sacado::Fad::DFad<NumberType>>
* A struct to help extract certain information associated with
* Sacado dynamic reverse auto-differentiable numbers. The @p NumberType
* can be either a floating point number or another Sacado type.
- *
*/
template <typename NumberType>
struct ExtractData<Sacado::Rad::ADvar<NumberType>>
* symbolically differentiable number or not. By default, numbers are not
* considered to have the necessary characteristics to fulfill this
* condition.
- *
*/
template <typename NumberType>
struct is_sd_number : std::false_type
* SymEngine number or not. By default, numbers are not
* considered to have the necessary characteristics to fulfill this
* condition.
- *
*/
template <typename NumberType>
struct is_symengine_number : std::false_type
* A struct to indicate whether a given @p NumberType is a supported
* symbolically differentiable number or not.
* This is a specialization for the SymEngine Expression class.
- *
*/
template <>
struct is_symengine_number<SymEngine::Expression> : std::true_type
* A struct to indicate whether a given @p NumberType is a supported
* symbolically differentiable number or not.
* This is a specialization for the SymEngine Expression class.
- *
*/
template <>
struct is_sd_number<SymEngine::Expression> : std::true_type
* // We can expect the above to evaluate to "2*10" which is,
* // of course, the numeric value 20.
* @endcode
- *
*/
class Expression
{
* A struct to indicate whether a given @p NumberType is a supported
* symbolically differentiable number or not.
* This is a specialization for the deal.II Expression class.
- *
*/
template <>
struct is_symengine_number<Expression> : std::true_type
* A struct to indicate whether a given @p NumberType is a supported
* SymEngine number or not.
* This is a specialization for the deal.II Expression class.
- *
*/
template <>
struct is_sd_number<Expression> : std::true_type
*
* It is intended that this class only be used in conjunction
* with the DictionarySubstitutionVisitor.
- *
*/
template <typename ReturnType, typename ExpressionType>
class CSEDictionaryVisitor
* between different optimizers and, more importantly, for integrating
* CSE into a dictionary substitution scheme. It is therefore only
* intended to be created and used by a BatchOptimizer.
- *
*/
template <typename ReturnType, typename ExpressionType>
class DictionarySubstitutionVisitor
* @warning The LLVM optimizer does not yet support complex numbers. If this
* incompatible combination of @p ReturnType and optimization method are
* selected, then an error will be thrown at run time.
- *
*/
template <typename ReturnType>
class BatchOptimizer
* would otherwise occur if trying to directly implement
* these as specializations of the ProductTypeImpl class
* itself.
- *
*/
template <typename T, typename U, typename V = void>
struct GeneralProductTypeImpl;
* @note Currently only simple periodicity conditions (i.e. without offsets
* and rotation matrices - see also the documentation of
* GridTools::collect_periodic_faces()) are supported.
- *
*/
template <int dim, int spacedim = dim>
class Triangulation
* appropriate for the partitioned mesh.
*
* @ingroup distributed
- *
*/
template <int dim, int spacedim = dim>
class Triangulation
* Consequently, the derived DoFCellAccessor class has an overloaded version
* of this function that calls the present function with
* <code>cell-@>active_fe_index</code> as last argument.
- *
*/
void
get_dof_indices(
* cell in spacedim space dimensions. Since vertices function differently than
* general faces, this class does a few things differently than the general
* template, but the interface should look the same.
- *
*/
template <template <int, int> class DoFHandlerType,
int spacedim,
* setter functions. Knowledge of the actual data format is therefore
* encapsulated to the present hierarchy of classes as well as the
* dealii::DoFHandler class.
- *
*/
template <int dim>
class DoFFaces
/**
* Store the indices of degrees of freedom on faces in 1D. As these would
* be vertices, which are treated separately, don't do anything.
- *
*/
template <>
class DoFFaces<1>
/**
* Store the indices of degrees of freedom on faces in 2D, which are
* lines.
- *
*/
template <>
class DoFFaces<2>
/**
* Store the indices of degrees of freedom on faces in 3D, which are
* quads, additionally also on lines.
- *
*/
template <>
class DoFFaces<3>
* @pre level must be less than this->n_levels().
*
* @ingroup CPP11
- *
*/
IteratorRange<level_cell_iterator>
mg_cell_iterators_on_level(const unsigned int level) const;
* setter functions. Knowledge of the actual data format is therefore
* encapsulated to the present hierarchy of classes as well as the
* dealii::DoFHandler class.
- *
*/
template <int dim>
class DoFLevel
*
* Detailed information can be found in the see
* @ref GlossPeriodicConstraints "Glossary entry on periodic boundary conditions".
- *
*/
template <typename FaceIterator, typename number>
void
* @see
* @ref GlossPeriodicConstraints "Glossary entry on periodic boundary conditions"
* and step-45 for further information.
- *
*/
template <typename DoFHandlerType, typename number>
void
* @see
* @ref GlossPeriodicConstraints "Glossary entry on periodic boundary conditions"
* for further information.
- *
*/
template <typename DoFHandlerType, typename number>
void
* IndexSet with all DoF indices. If the mask contains all components (which
* also corresponds to the default value), then the union of the returned
* index sets equlas what DoFHandler::locally_owned_dofs() returns.
- *
*/
template <typename DoFHandlerType>
std::vector<IndexSet>
* not have information about all cells of the triangulation available
* locally, and consequently can not say anything definitive about the
* degrees of freedom active on other processors' locally owned cells.
- *
*/
template <typename DoFHandlerType>
std::vector<IndexSet>
* not have information about all cells of the triangulation available
* locally, and consequently can not say anything definitive about the
* degrees of freedom active on other processors' locally owned cells.
- *
*/
template <typename DoFHandlerType>
std::vector<IndexSet>
* real cells of the complete, parallel triangulation. We can also query the
* degrees of freedom on these. In other words, this function can only work
* if all cells in the patch are either locally owned or ghost cells.
- *
*/
template <typename DoFHandlerType>
std::vector<types::global_dof_index>
* real cells of the complete, parallel triangulation. We can also query the
* degrees of freedom on these. In other words, this function can only work
* if all cells in the patch are either locally owned or ghost cells.
- *
*/
template <typename DoFHandlerType>
unsigned int
* derived class that wants to store information computed once at the
* beginning, needs to derive its own InternalData class from this class,
* and return an object of the derived type through its get_data() function.
- *
*/
class InternalDataBase
{
* Some numerical experiments have shown that this element may converge with
* first-order accuracy when using the BR1-Q0 pair for the mixed Laplace
* equation in step-20.
- *
*/
template <int dim>
class FE_BernardiRaugel : public FE_PolyTensor<dim>
* support points are at the vertices, then on the line, on the quads, and
* finally (for 3d) on the hexes. See the documentation of FE_Q for more
* details.
- *
- *
*/
template <int dim, int spacedim = dim>
* shape function 14 </td>
*
* <td align="center"></td> </tr> </table>
- *
*/
template <int dim, int spacedim = dim>
class FE_DGP : public FE_Poly<dim, spacedim>
* shape function 14 </td>
*
* <td align="center"></td> </tr> </table>
- *
*/
template <int dim>
class FE_DGPMonomial : public FE_Poly<dim>
* can thus simply use the members already provided by
* FiniteElement::InternalDataBase without adding anything in a derived class
* in this class.
- *
*/
template <int dim, int spacedim = dim>
class FE_DGPNonparametric : public FiniteElement<dim, spacedim>
* The Gauss-Lobatto points in 1D include the end points 0 and +1 of the unit
* interval. The interior points are shifted towards the end points, which
* gives a denser point distribution close to the element boundary.
- *
*/
template <int dim, int spacedim = dim>
class FE_DGQ : public FE_Poly<dim, spacedim>
* Gauss-Lobatto quadrature (provided through the base class).
*
* See the base class documentation in FE_DGQ for details.
- *
*/
template <int dim, int spacedim = dim>
class FE_DGQArbitraryNodes : public FE_DGQ<dim, spacedim>
* elements are not interpolatory and no support points are defined.
*
* See the base class documentation in FE_DGQ for details.
- *
*/
template <int dim, int spacedim = dim>
class FE_DGQLegendre : public FE_DGQ<dim, spacedim>
* usual Lagrange basis is constructed by this class.
*
* See the base class documentation in FE_DGQ for details.
- *
*/
template <int dim, int spacedim = dim>
class FE_DGQHermite : public FE_DGQ<dim, spacedim>
* and the @p restriction matrices are taken from the FESystem class.
*
* @ingroup fe
- *
*/
template <int dim, int spacedim = dim>
class FE_Enriched : public FiniteElement<dim, spacedim>
* const hp::FECollection<dim>&
* fe_collection(FE_helper.build_fe_collection(dof_handler));
* @endcode
- *
*/
template <int dim, int spacedim = dim>
struct Helper
* The class is made to be used inside MeshWorker::mesh_loop(). It is intended
* to be a low level replacement for MeshWorker and LocalIntegrators and a
* higher level abstraction compared to assembling face terms manually.
- *
*/
template <int dim, int spacedim = dim>
class FEInterfaceValues
* The points needed are those of QGauss<sub>k+1</sub> on each edge and
* QGauss<sub>k+2</sub> on each face and in the interior of the cell (or none
* for N<sub>1</sub>).
- *
*/
template <int dim>
class FE_Nedelec : public FE_PolyTensor<dim>
* problem for hp-hexahedral Nédélec elements with application to
* eddy current problems</b>, Computers & Structures 181, 41-54, 2017 (see
* https://doi.org/10.1016/j.compstruc.2016.05.021).
- *
*/
template <int dim, int spacedim = dim>
class FE_NedelecSZ : public FiniteElement<dim, dim>
*
* These values change with the orientation of the edges of a physical cell
* and so must take the "sign" into account when used for computation.
- *
*/
std::vector<std::vector<double>> edge_sigma_grads;
* @endcode
* The distinction lies in the mixed nature of the child faces, a case we have
* not implemented as of yet.
- *
*/
template <int dim, int spacedim = dim>
class FE_Nothing : public FiniteElement<dim, spacedim>
* The original paper for the P1 nonconforming element by Park and Sheen
* is accessible at https://doi.org/10.1137/S0036142902404923 ,
* see @cite park2003p .
- *
*/
class FE_P1NC : public FiniteElement<2, 2>
{
*
* @todo Since nearly all functions for spacedim != dim are specialized, this
* class needs cleaning up.
- *
*/
template <int dim, int spacedim = dim>
* are several pure virtual functions declared in the FiniteElement class
* which cannot be implemented by this class but are left for implementation
* in derived classes.
- *
*/
template <class PolynomialType,
int dim = PolynomialType::dimension + 1,
* whose support points are at the vertices, then on the line, on the quads,
* and finally (for 3d) on the hexes. Finally, there are support points for
* the bubble enrichments in the middle of the cell.
- *
*/
template <int dim, int spacedim = dim>
class FE_Q_Bubbles
/**
* Constructor for tensor product polynomials of degree @p p plus bubble
* enrichments
- *
*/
FE_Q_Bubbles(const unsigned int p);
* @endverbatim
* Index 21 has the same coordinates as index 20
* </ul>
- *
*/
template <int dim, int spacedim = dim>
class FE_Q_DG0
* shape function 24 </td>
*
* <td align="center"> </td> </tr> </table>
- *
- *
- *
*/
template <int dim>
class FE_Q_Hierarchical : public FE_Poly<dim>
* element compared to FE_Q. This is because DoFTools::make_sparsity_pattern
* assumes coupling between all degrees of freedom within the element, whereas
* FE_Q_iso_Q1 with more than one subdivision does have less coupling.
- *
*/
template <int dim, int spacedim = dim>
class FE_Q_iso_Q1
* The points needed are those of QGauss<sub>k+1</sub> on each face as well as
* QGauss<sub>k+1</sub> in the interior of the cell (or none for
* RT<sub>0</sub>).
- *
- *
*/
template <int dim>
class FE_RaviartThomas : public FE_PolyTensor<dim>
* @note The degree stored in the member variable
* FiniteElementData<dim>::degree is higher by one than the constructor
* argument!
- *
*/
template <int dim>
class FE_RaviartThomasNodal : public FE_PolyTensor<dim>
* right - $3D,\,k=2$.</td></tr> </table>
*
* @todo Implement restriction matrices
- *
*/
template <int dim>
class FE_RT_Bubbles : public FE_PolyTensor<dim>
* solution on the reference element. Coefficients of expansion are often used
* to estimate local smoothness of the underlying FiniteElement field to decide
* on h- or p-adaptive refinement strategy.
- *
*/
namespace FESeries
{
* Consequently $ c_{\bf k} \equiv c_{-\bf k}^\ast $ and
* we only need to compute $ c_{\bf k} $ for positive indices
* $ \bf k $ .
- *
*/
template <int dim, int spacedim = dim>
class Fourier : public Subscriptor
* This class calculates coefficients $ c_{\bf k} $ using
* $ dim $-dimensional Legendre polynomials constructed from
* $ \widetilde P_m(x) $ using tensor product rule.
- *
*/
template <int dim, int spacedim = dim>
class Legendre : public Subscriptor
*
* This class is used in the FETools::get_fe_by_name() and
* FETools::add_fe_name() functions.
- *
*/
template <int dim, int spacedim = dim>
class FEFactoryBase : public Subscriptor
* given as template argument, and with the degree (however the finite
* element class wishes to interpret this number) given as argument to
* get().
- *
*/
template <class FE>
class FEFactory : public FEFactoryBase<FE::dimension, FE::space_dimension>
* FESubfaceValues object.
*
* @ingroup feaccess vector_valued
- *
*/
template <int dim, int spacedim>
class SymmetricTensor<2, dim, spacedim>
* to an FEValues, FEFaceValues or FESubfaceValues object.
*
* @ingroup feaccess vector_valued
- *
*/
template <int dim, int spacedim>
class Tensor<2, dim, spacedim>
/**
* A class whose specialization is used to define what FEValuesViews
* object corresponds to the given FEValuesExtractors object.
- *
*/
template <int dim, int spacedim, typename Extractor>
struct ViewType
/**
* A templated alias that associates to a given Extractor class
* the corresponding view in FEValuesViews.
- *
*/
template <int dim, int spacedim, typename Extractor>
using View = typename dealii::internal::FEValuesViews::
* @note This class is an example of the
* <a href="https://www.artima.com/cppsource/type_erasure.html">type
* erasure</a> design pattern.
- *
*/
class CellIteratorBase;
* module.
*
* @ingroup feaccess vector_valued
- *
*/
template <int rank>
struct SymmetricTensor
* module.
*
* @ingroup feaccess vector_valued
- *
*/
template <int rank>
struct Tensor
* for the computation of the cell center from
* transform_unit_to_real_cell() applied to the center of the reference cell
* to computing the vertex averages.
- *
*/
virtual Point<spacedim>
get_center(const typename Triangulation<dim, spacedim>::cell_iterator &cell,
* may be smaller than the true bounding box.
*
* @param[in] cell The cell for which you want to compute the bounding box
- *
*/
virtual BoundingBox<spacedim>
get_bounding_box(
* MappingQ chooses them such that they interpolate the boundary, while this
* class chooses them such that the discretized boundary is globally
* continuously differentiable.
- *
*/
template <int dim, int spacedim = dim>
class MappingC1 : public MappingQ<dim, spacedim>
* The class is intended for efficiency, and it does not do a whole lot of
* error checking. If you apply this mapping to a cell that does not conform
* to the requirements above, you will get strange results.
- *
*/
template <int dim, int spacedim = dim>
class MappingCartesian : public Mapping<dim, spacedim>
* VectorTools::get_position_vector(dhq, eulerq, mask);
* MappingFEField<dim,spacedim> map(dhq, eulerq, mask);
* @endcode
- *
*/
template <int dim,
int spacedim = dim,
* @warning It is not possible, for mathematical reasons, for one to use this
* class with a geometry described by a SphericalManifold: see the note in
* that class for more information.
- *
*/
template <int dim, int spacedim = dim>
class MappingManifold : public Mapping<dim, spacedim>
*
* For more information about the <tt>spacedim</tt> template parameter check
* the documentation of FiniteElement or the one of Triangulation.
- *
*/
template <int dim, typename VectorType = Vector<double>, int spacedim = dim>
class MappingQ1Eulerian : public MappingQGeneric<dim, spacedim>
* mapping is pre-computed by the MappingQCache::initialize() function.
*
* The use of this class is discussed extensively in step-65.
- *
*/
template <int dim, int spacedim = dim>
class MappingQCache : public MappingQGeneric<dim, spacedim>
* To enable the use of the MappingQEulerian class also in the context of
* parallel codes using the PETSc or Trilinos wrapper classes, the type
* of the vector can be specified as template parameter <tt>VectorType</tt>.
- *
*/
template <int dim, typename VectorType = Vector<double>, int spacedim = dim>
class MappingQEulerian : public MappingQ<dim, spacedim>
* qualities if the transition between curved boundaries and flat interior
* domains is spread over a larger range as the mesh is refined. This is
* provided by the special manifold TransfiniteInterpolationManifold.
- *
*/
template <int dim, int spacedim = dim>
class MappingQGeneric : public Mapping<dim, spacedim>
/**
* A collection of %Gmsh related utilities and classes.
- *
*/
namespace Gmsh
{
/**
* A parameter class used to pass options to the %Gmsh executable.
- *
*/
class AdditionalParameters
{
* %Gmsh.
*
* The input curve @p boundary should be closed.
- *
*/
template <int spacedim>
void
*
* @note Implemented for <tt>Triangulation@<2,2@></tt>,
* <tt>Triangulation@<3,3@></tt>.
- *
*/
template <int dim>
void
*
* @param colorize Assign different boundary ids if set to true. The same
* comments apply as for the hyper_rectangle() function.
- *
*/
template <int dim, int spacedim>
void
*
* @p tria is the triangulation to be created. It needs to be empty upon
* calling this function.
- *
- */
+*/
template <int dim>
void
plate_with_a_hole(Triangulation<dim> & tria,
* @param tria The triangulation that will be created
* @param vertices The 2^dim vertices of the cell
* @param colorize If true, set different boundary ids.
- *
*/
template <int dim, int spacedim>
void
*
* @pre The triangulation passed as argument needs to be empty when calling
* this function.
- *
*/
template <int dim>
void
*
* @image html hyper_cross_2d.png
* @image html hyper_cross_3d.png
- *
*/
template <int dim, int spacedim>
void
*
* @note This function is declared to exist for triangulations of all space
* dimensions, but throws an error if called in 1D.
- *
*/
template <int dim, int spacedim>
void
* In this picture, a cylinder shell of length 2, inner radius 0.5, outer
* radius 1 is shown. The default argument for n_radial_cells and
* n_axial_cells are used and a single global refinement is carried out.
- *
*/
template <int dim>
void
* generates the following output:
*
* @image html concentric_hyper_shells_2d.svg
- *
*/
template <int dim>
void
* @param grid_generator_function_name The name of the function to call
* @param grid_generator_function_arguments The arguments of the function, in
* the format of a tuple-convertible string
- *
*/
template <int dim, int spacedim>
void
* @note Since @p input and @p output have different spatial dimensions no
* manifold objects are copied (nor are any manifold ids set) by this
* function.
- *
*/
void
extrude_triangulation(
* @note Since @p input and @p output have different spatial dimensions no
* manifold objects are copied by this function: you must attach new
* manifold objects to @p out_tria.
- *
*/
template <int dim, int spacedim1, int spacedim2>
void
*
* The companion GridOut::write_vtk function can be used to write VTK files
* compatible with this method.
- *
*/
void
read_vtk(std::istream &in);
* When this flag is set to true, the generated vtu file contains the
* triangulation in a xml section which is ignored by vtu general vtu readers.
* If this section is absent, an exception is thrown.
- *
*/
void
read_vtu(std::istream &in);
*
* The companion GridIn::read_vtk function can be used to read VTK files
* generated with this method.
- *
*/
template <int dim, int spacedim>
void
* n_active_cells but the aspect ratio is only computed for the cells that
* are locally owned and placed at index CellAccessor::active_cell_index(),
* respectively. All other values are set to 0.
- *
*/
template <int dim>
Vector<double>
* @note When running in parallel with a Triangulation that supports MPI,
* this is a collective call and the return value is the maximum over all
* processors.
- *
*/
template <int dim>
double
* the given @p object) but may only provide a few correct digits if the
* object has high curvature. If your manifold supports it then the
* specialized function Manifold::project_to_manifold() may perform better.
- *
*/
template <typename Iterator>
Point<Iterator::AccessorType::space_dimension>
*
* @note In the case of parallel codes, this function should be combined
* with GridGenerator::flatten_triangulation.
- *
*/
template <int dim, int spacedim>
void
* @note In the case of parallel codes, this function should be combined
* with GridGenerator::flatten_triangulation and
* GridTools::remove_hanging_nodes.
- *
*/
template <int dim, int spacedim>
void
*
* @param[in] limit_angle_fraction Maximum ratio of angle or solid
* angle that is allowed for a corner element in the mesh.
- *
*/
template <int dim, int spacedim>
void
* GridTools::Cache::get_cell_bounding_boxes_rtree(), which either returns
* a cached rtree or builds and stores one. Building an rtree might hinder
* the performance if the function is called only once on few points.
- *
*/
template <int dim, int spacedim>
# ifndef DOXYGEN
* @endcode
* The type is abbreviated in the online documentation to improve readability
* of this page.
- *
*/
template <int dim, int spacedim>
# ifndef DOXYGEN
* @ref ConceptMeshType "MeshType concept".
* @param container The container to extract vertices from.
* @param mapping The mapping to use to compute the points locations.
- *
*/
template <int dim, int spacedim>
std::map<unsigned int, Point<spacedim>>
* GridTools::extract_used_vertices().
* @param p The target point.
* @return The index of the vertex that is closest to the target point `p`.
- *
*/
template <int spacedim>
unsigned int
* Triangulation::n_vertices() for the triangulation underlying the given mesh
* (as opposed to the value returned by Triangulation::n_used_vertices()).
* @return The index of the closest vertex found.
- *
- *
*/
template <int dim, template <int, int> class MeshType, int spacedim>
unsigned int
* Triangulation::n_vertices() for the triangulation underlying the given mesh
* (as opposed to the value returned by Triangulation::n_used_vertices()).
* @return The index of the closest vertex found.
- *
*/
template <int dim, template <int, int> class MeshType, int spacedim>
unsigned int
* `cell_hint`, and optionally an RTree constructed from the used
* vertices of the Triangulation. All of these structures can be queried
* from a GridTools::Cache object.
- *
*/
template <int dim, template <int, int> class MeshType, int spacedim>
# ifndef _MSC_VER
/**
* A version of the previous function that exploits an already existing
* GridTools::Cache<dim,spacedim> object.
- *
*/
template <int dim, int spacedim>
std::pair<typename Triangulation<dim, spacedim>::active_cell_iterator,
* the case the given point `p` coincides with a vertex or an edge, several
* cells might hold independent values of the solution that get combined in
* some way in a user code.
- *
*/
template <int dim, template <int, int> class MeshType, int spacedim>
# ifndef _MSC_VER
* is a function that takes in an active cell and returns a boolean.
* @return A list of active cells sharing at least one common vertex with
* the predicated subdomain.
- *
*/
template <class MeshType>
std::vector<typename MeshType::active_cell_iterator>
* @param[in] mesh A mesh (i.e. objects of type Triangulation, DoFHandler,
* or hp::DoFHandler).
* @return A list of ghost cells
- *
*/
template <class MeshType>
std::vector<typename MeshType::active_cell_iterator>
* returns @p true.
*
* See compute_active_cell_halo_layer().
- *
*/
template <class MeshType>
std::vector<typename MeshType::active_cell_iterator>
*
* Also see compute_ghost_cell_halo_layer() and
* compute_active_cell_layer_within_distance().
- *
*/
template <class MeshType>
std::vector<typename MeshType::active_cell_iterator>
* @endcode
* The type is abbreviated in the online documentation to improve readability
* of this page.
- *
*/
template <int spacedim>
# ifndef DOXYGEN
*
* result[v][c] is a unit Tensor for vertex index v, indicating the direction
* of the center of the c-th cell with respect to the vertex v.
- *
*/
template <int dim, int spacedim>
std::vector<std::vector<Tensor<1, spacedim>>>
* from the (optional) @p mapping argument, to guarantee that the correct
* answer is returned when the underlying mapping modifies the position of the
* vertices.
- *
*/
template <int dim, int spacedim>
unsigned int
* @return A std::pair<unsigned int, double> such that the @p first value
* is the dimension of the highest elongation and the @p second value is the
* ratio among the dimensions of the @p cell.
- *
*/
template <int dim, int spacedim>
std::pair<unsigned int, double>
* ghost cells. For both, we know that these are in fact the real cells of
* the complete, parallel triangulation. We can also query the degrees of
* freedom on these.
- *
*/
template <class MeshType>
std::vector<typename MeshType::active_cell_iterator>
* GridTools::get_patch_around_cell().
* @return A list of cells with the coarsest common level of refinement of
* the input cells.
- *
*/
template <class Container>
std::vector<typename Container::cell_iterator>
* @param[out] patch_to_global_tria_map A map between the local
* triangulation which is built as explained above, and the cell iterators
* in the input list.
- *
*/
template <class Container>
void
* degrees of freedom on locally relevant cells to vectors containing
* DoFHandlerType::active_cell_iterators of cells in the support of the basis
* function at that degree of freedom.
- *
- *
*/
template <class DoFHandlerType>
std::map<types::global_dof_index,
* in the
* @ref GlossFaceOrientation "glossary"
* article.
- *
*/
template <typename FaceIterator>
bool orthogonal_equality(
* boundary indicators set. In general, this means that one must first set
* all boundary indicators on the coarse grid before performing any global
* or local grid refinement.
- *
*/
template <typename MeshType>
void
* @note This version of collect_periodic_faces() will not work on
* meshes with cells not in
* @ref GlossFaceOrientation "standard orientation".
- *
*/
template <typename MeshType>
void
*
* @ingroup manifold
* @relatesalso boundary
- *
*/
template <int dim, int spacedim>
void
*
* @ingroup manifold
* @relatesalso boundary
- *
*/
template <int dim, int spacedim>
void
* Triangulation. By default, face manifold_ids are not computed.
*
* @ingroup manifold
- *
*/
template <int dim, int spacedim>
void
* or face will maintain its original manifold indicator.
* If it is @p false, then also the manifold indicator of these faces and edges
* is set according to the return value of the @p disambiguation_function.
- *
*/
template <int dim, int spacedim>
void
* contains the bounding box.
*
* @note This function is a collective operation.
- *
*/
template <int spacedim>
RTree<std::pair<BoundingBox<spacedim>, unsigned int>>
* @param[out] vertex_to_coinciding_vertex_group Map of a vertex to the label
* of a group of coinciding vertices. Vertices not contained in
* this vector are not coinciding with any other vertex.
- *
*/
template <int dim, int spacedim>
void
* some vertex locations, then some of the structures in this class become
* obsolete, and you will have to mark them as outdated, by calling the
* method mark_for_update() manually.
- *
*/
template <int dim, int spacedim = dim>
class Cache : public Subscriptor
*
* You can select more than one flag by concatenation using the bitwise or
* <code>operator|(CacheUpdateFlags,CacheUpdateFlags)</code>.
- *
*/
enum CacheUpdateFlags
{
* boxes are used to describe approximately which portion
* of the mesh contains locally owned cells by the
* process of rank the second element of the pair.
- *
*/
update_covering_rtree = 0x040,
* FlatManifold<dim,spacedim>::project_to_manifold() is the identity function.
*
* @ingroup manifold
- *
*/
template <int dim, int spacedim = dim>
class FlatManifold : public Manifold<dim, spacedim>
* chartdim is 2.
*
* @ingroup manifold
- *
*/
template <int dim, int spacedim = dim, int chartdim = dim>
class ChartManifold : public Manifold<dim, spacedim>
* make any sense.
*
* @ingroup manifold
- *
*/
template <int dim, int spacedim = dim>
class PolarManifold : public ChartManifold<dim, spacedim, spacedim>
* ball. (See also the extensive discussion in step-65.)
*
* @ingroup manifold
- *
*/
template <int dim, int spacedim = dim>
class SphericalManifold : public Manifold<dim, spacedim>
* run time exception whenever spacedim is not equal to three.
*
* @ingroup manifold
- *
*/
template <int dim, int spacedim = dim>
class CylindricalManifold : public ChartManifold<dim, spacedim, 3>
* @image html elliptical_hyper_shell.png
*
* @ingroup manifold
- *
*/
template <int dim, int spacedim = dim>
class EllipticalManifold : public ChartManifold<dim, spacedim, spacedim>
* manifold.
* @param eccentricity Eccentricity of the
* manifold $e\in\left]0,1\right[$.
- *
*/
EllipticalManifold(const Point<spacedim> & center,
const Tensor<1, spacedim> &major_axis_direction,
* actually one the inverse of the other.
*
* @ingroup manifold
- *
*/
template <int dim, int spacedim = dim, int chartdim = dim>
class FunctionManifold : public ChartManifold<dim, spacedim, chartdim>
* GridGenerator::torus.
*
* @ingroup manifold
- *
*/
template <int dim>
class TorusManifold : public ChartManifold<dim, 3, 3>
* axis-aligned bounding boxes.
*
* @ingroup manifold
- *
*/
template <int dim, int spacedim = dim>
class TransfiniteInterpolationManifold : public Manifold<dim, spacedim>
* @tparam dim_B Dimension of ChartManifold B.
* @tparam spacedim_B Spacial dimension of ChartManifold B.
* @tparam chartdim_B Chart dimension of ChartManifold B.
- *
*/
template <int dim,
int dim_A,
* until we hit the end iterator. This is time consuming and since access
* to the number of lines etc is a rather frequent operation, this was not
* an optimal solution.
- *
*/
template <int dim>
struct NumberCache
* until we hit the end iterator. This is time consuming and since access
* to the number of lines etc is a rather frequent operation, this was not
* an optimal solution.
- *
*/
template <>
struct NumberCache<1>
* until we hit the end iterator. This is time consuming and since access
* to the number of lines etc is a rather frequent operation, this was not
* an optimal solution.
- *
*/
template <>
struct NumberCache<2> : public NumberCache<1>
* until we hit the end . This is time consuming and since access to the
* number of lines etc is a rather frequent operation, this was not an
* optimal solution.
- *
*/
template <>
struct NumberCache<3> : public NumberCache<2>
/**
* Configuration flags for Triangulations.
* Settings can be combined using bitwise OR.
- *
*/
enum Settings
{
* about a cell. However, in contrast to dealii::CellData, it also stores
* a unique id, partitioning information, and information related to cell
* faces and edges.
- *
*/
template <int dim>
struct CellData
/**
* Data used in Triangulation::create_triangulation().
- *
*/
template <int dim, int spacedim>
struct Description
* @note Please note this is necessary since the communicator inside of
* parallel::TriangulationBase is const and cannot be changed after the
* constructor has been called.
- *
*/
MPI_Comm comm;
*
* @note If construct_multigrid_hierarchy is set in the settings, the source
* triangulation has to be setup with limit_level_difference_at_vertices.
- *
*/
template <int dim, int spacedim = dim>
Description<dim, spacedim>
* @note If construct_multigrid_hierarchy is set in the settings, the
* @p smoothing parameter is extended with the
* limit_level_difference_at_vertices flag.
- *
*/
template <int dim, int spacedim = dim>
Description<dim, spacedim>
* want to enable anisotropic refinement. Therefore the TriaFaces classes
* store the information belonging to the faces of a triangulation
* separately from the TriaLevel classes.
- *
*/
class TriaFaces
{
* Print the address to which this iterator points to @p out. The address is
* given by the pair <tt>(level,index)</tt>, where @p index is an index
* relative to the level in which the object is that is pointed to.
- *
*/
template <typename Accessor>
inline std::ostream &
* Print the address to which this iterator points to @p out. The address is
* given by the pair <tt>(level,index)</tt>, where @p index is an index
* relative to the level in which the object is that is pointed to.
- *
*/
template <typename Accessor>
inline std::ostream &
* Print the address to which this iterator points to @p out. The address is
* given by the pair <tt>(level,index)</tt>, where @p index is an index
* relative to the level in which the object is that is pointed to.
- *
*/
template <typename Accessor>
inline std::ostream &
* The same applies for the @p face_iterator types, since lines have no
* substructures apart from vertices, which are handled in a different
* way, however.
- *
*/
template <int spacedim>
struct Iterators<1, spacedim>
* using face_iterator = line_iterator;
* using active_face_iterator = active_line_iterator;
* @endcode
- *
*/
template <int spacedim>
struct Iterators<2, spacedim>
* using face_iterator = quad_iterator;
* using active_face_iterator = active_quad_iterator;
* @endcode
- *
*/
template <int spacedim>
struct Iterators<3, spacedim>
* Likewise, in 3d, we need boundary indicators for lines and quads (we
* need to know how to refine a line if the two adjacent faces have
* different boundary indicators), and material data for cells.
- *
*/
class TriaLevel
{
*
* Objects of these classes are included in the TriaLevel and TriaFaces
* classes.
- *
*/
class TriaObjects
{
*
* @ingroup dofs
* @ingroup hp
- *
*/
template <int dim, int spacedim = dim>
class DoFHandler : public Subscriptor
* one case (<tt>spacedim != dim </tt>).
*
* @ingroup hp hpcollection
- *
*/
template <int dim, int spacedim = dim>
class FECollection : public Subscriptor
* ::FEValues, ::FEFaceValues, or ::FESubfaceValues.
*
* @ingroup hp
- *
*/
template <int dim, int q_dim, class FEValuesType>
class FEValuesBase
* for the rules which mapping will be selected for a given cell.
*
* @ingroup hp hpcollection
- *
*/
template <int dim, int spacedim = dim>
class MappingCollection : public Subscriptor
* module described in the doxygen documentation.
*
* @ingroup hp hpcollection
- *
*/
template <int dim>
class QCollection : public Subscriptor
* in which case a constant velocity is assumed, or a vector with as many
* entries as quadrature points if the velocity is not constant.
* @param factor is an optional multiplication factor for the result.
- *
*/
template <int dim>
void
* \f[ \int_Z v\nabla \cdot \mathbf u \,dx \f] This is the strong
* divergence operator and the trial space should be at least
* <b>H</b><sup>div</sup>. The test functions may be discontinuous.
- *
*/
template <int dim>
void
*
* The function cell_matrix() is the Frechet derivative of this function
* with respect to the test functions.
- *
*/
template <int dim, typename number>
void
*
* @todo Verify: The function cell_matrix() is the Frechet derivative of
* this function with respect to the test functions.
- *
*/
template <int dim, typename number>
void
*
* This is the strong gradient and the trial space should be at least in
* <i>H</i><sup>1</sup>. The test functions can be discontinuous.
- *
*/
template <int dim>
void
*
* The function gradient_matrix() is the Frechet derivative of this
* function with respect to the test functions.
- *
*/
template <int dim, typename number>
void
*
* @todo Verify: The function gradient_matrix() is the Frechet derivative
* of this function with respect to the test functions.
- *
*/
template <int dim, typename number>
void
* The trace of the divergence operator, namely the product of the normal
* component of the vector valued trial space and the test space.
* @f[ \int_F (\mathbf u\cdot \mathbf n) v \,ds @f]
- *
*/
template <int dim>
void
* @f[
* \int_F (\mathbf u\cdot \mathbf n) v \,ds
* @f]
- *
*/
template <int dim, typename number>
void
* @f[
* \int_F u (\mathbf v\cdot \mathbf n) \,ds
* @f]
- *
*/
template <int dim, typename number>
void
* \int_F (\mathbf u_1\cdot \mathbf n_1 + \mathbf u_2 \cdot \mathbf n_2)
* \frac{v_1+v_2}{2} \,ds
* @f]
- *
*/
template <int dim>
void
* (\mathbf v_1\cdot \mathbf n_1 + \mathbf v_2 \cdot \mathbf n_2)
* \,ds
* @f]
- *
*/
template <int dim>
void
* The vector is expected to consist of dim vectors of length equal to the
* number of quadrature points. The number of components of the finite
* element has to be equal to the space dimension.
- *
*/
template <int dim>
double
* respectively. <i>g</i> is the inhomogeneous boundary value in the
* argument <tt>data</tt>. $n$ is the outer normal vector and $\gamma$ is
* the usual penalty parameter.
- *
*/
template <int dim, typename number>
void
* are given in the arguments <tt>input</tt> and <tt>Dinput</tt>,
* respectively. $n$ is the outer normal vector and $\gamma$ is the usual
* penalty parameter.
- *
*/
template <int dim, typename number>
void
}
/**
* Elasticity residual term for the symmetric interior penalty method.
- *
*/
template <int dim, typename number>
void
* @f[
* \int_Z \nabla\cdot u \nabla \cdot v \,dx
* @f]
- *
*/
template <int dim>
void
* @f[
* \int_Z \nabla\cdot u \nabla \cdot v \,dx
* @f]
- *
*/
template <int dim, typename number>
void
* are given in the arguments <tt>input</tt> and <tt>Dinput</tt>,
* respectively. <i>g</i> is the inhomogeneous boundary value in the
* argument <tt>data</tt>. $\gamma$ is the usual penalty parameter.
- *
*/
template <int dim>
void
/**
* The interior penalty flux for the grad-div operator. See
* ip_residual() for details.
- *
*/
template <int dim>
* @f]
*
* See for instance Hansbo and Larson, 2002
- *
*/
template <int dim>
void
* @param fe The FEValues object describing the local trial function
* space. #update_values and #update_JxW_values must be set.
* @param factor A constant that multiplies the mass matrix.
- *
*/
template <int dim>
void
* @param weights The weights, $\omega(x)$, evaluated at the quadrature
* points in the finite element (size must be equal to the number of
* quadrature points in the element).
- *
*/
template <int dim>
void
* points in the finite element (size must be equal to the number of
* quadrature points in the element).
* @param factor A constant that multiplies the result.
- *
*/
template <int dim, typename number>
void
* at the quadrature points in the finite element (size of each component
* must be equal to the number of quadrature points in the element).
* @param factor A constant that multiplies the result.
- *
*/
template <int dim, typename number>
void
* first cell.
* @param factor2 A constant that multiplies the shape functions for the
* second cell.
- *
*/
template <int dim>
void
*
* The FiniteElement in <tt>fe</tt> may be scalar or vector valued. In the
* latter case, the Laplacian is applied to each component separately.
- *
*/
template <int dim>
void
*
* Here, $\gamma$ is the <tt>penalty</tt> parameter suitably computed with
* compute_penalty().
- *
*/
template <int dim>
void
*
* Here, $\gamma$ is the <tt>penalty</tt> parameter suitably computed with
* compute_penalty().
- *
*/
template <int dim>
void
* are given in the arguments <tt>input</tt> and <tt>Dinput</tt>,
* respectively. <i>g</i> is the inhomogeneous boundary value in the
* argument <tt>data</tt>. $\gamma$ is the usual penalty parameter.
- *
*/
template <int dim>
void
* are given in the arguments <tt>input</tt> and <tt>Dinput</tt>,
* respectively. <i>g</i> is the inhomogeneous boundary value in the
* argument <tt>data</tt>. $\gamma$ is the usual penalty parameter.
- *
*/
template <int dim>
void
* If <tt>factor2</tt> is missing or negative, the factor is assumed the
* same on both sides. If factors differ, note that the penalty parameter
* has to be computed accordingly.
- *
*/
template <int dim>
void
* @f]
*
* @warning This function is still under development!
- *
*/
template <int dim>
void
* \int_F \Bigl( \gamma [u][v] - \{\nabla u\}[v\mathbf n] - [u\mathbf
* n]\{\nabla v\} \Bigr) \; ds.
* @f]
- *
*/
template <int dim>
void
* - \{\nabla \mathbf u\}[\mathbf v\otimes \mathbf n]
* - [\mathbf u\otimes \mathbf n]\{\nabla \mathbf v\} \Bigr) \; ds.
* @f]
- *
*/
template <int dim>
void
* <i>p<sub>i</sub></i> is the polynomial degree on cell
* <i>Z<sub>i</sub></i> and <i>h<sub>i</sub></i> is the length of
* <i>Z<sub>i</sub></i> orthogonal to the current face.
- *
*/
template <int dim, int spacedim, typename number>
double
*
* @note The third tensor argument is not used in two dimensions and can
* for instance duplicate one of the previous.
- *
*/
template <int dim>
Tensor<1, dim>
*
* @note The third tensor argument is not used in two dimensions and can
* for instance duplicate one of the previous.
- *
*/
template <int dim>
Tensor<1, dim>
* \nabla \times v \,dx
* @f]
* in weak form.
- *
*/
template <int dim>
void
* This is the standard curl operator in 3D and the scalar curl in 2D. The
* vector curl operator can be obtained by exchanging test and trial
* functions.
- *
*/
template <int dim>
void
* n)(\nu \nabla\times u)
* \biggr)
* @f]
- *
*/
template <int dim>
void
* \int_F (u\times n)(v\times n)
* \, ds.
* @f]
- *
*/
template <int dim>
void
* n\}\{\nu \nabla\times u\}
* \biggr)\;dx
* @f]
- *
*/
template <int dim>
inline void
{
/**
* @brief Integrators writing patches with values in quadrature points
- *
*/
namespace Patches
{
* of eigenvalue problems) values. See also
* @ref step_36 "step-36"
* for an example.
- *
*/
class ArpackSolver : public Subscriptor
{
/**
* Namespace in which iterators in block matrices are implemented.
- *
*/
namespace BlockMatrixIterators
{
*
* This class is an example of the "static" type of
* @ref Sparsity.
- *
*/
class BlockSparsityPattern : public BlockSparsityPatternBase<SparsityPattern>
{
* BlockSparsityPattern sparsity;
* sparsity.copy_from(dsp);
* @endcode
- *
*/
class BlockDynamicSparsityPattern
* pattern can be used).
*
* This class is used in step-32.
- *
*/
class BlockSparsityPattern
: public dealii::BlockSparsityPatternBase<SparsityPattern>
/**
* Declare dealii::BlockVector as serial vector.
- *
*/
template <typename Number>
struct is_serial_vector<BlockVector<Number>> : std::true_type
* is true. This is sometimes useful in template contexts where we may want to
* do things differently depending on whether a template type denotes a
* regular or a block vector type.
- *
*/
template <typename VectorType>
struct IsBlockVector
{
/**
* Namespace in which iterators in block vectors are implemented.
- *
*/
namespace BlockVectorIterators
{
* does rarely change dynamically within an application, this is a
* constant and we again have that the iterator satisfies the requirements
* of a random access iterator.
- *
*/
template <class BlockVectorType, bool Constness>
class Iterator
* section on
* @ref Instantiations
* in the manual).
- *
*/
template <typename number>
class ChunkSparseMatrix : public virtual Subscriptor
* Note that this class only allows read access to elements, providing their
* row and column number. It does not allow modifying the sparsity pattern
* itself.
- *
*/
class Accessor
{
* It uses the compressed row storage (CSR) format to store data.
*
* The use of this class is demonstrated in step-51.
- *
*/
class ChunkSparsityPattern : public Subscriptor
{
* from the data that needs to be communicated. The goal is to reuse the same
* communication pattern for different containers.
* This is similar to the way SparseMatrix and SparsityPattern works.
- *
*/
class CommunicationPatternBase
{
* locally_relevant_dofs,
* mpi_communicator);
* @endcode
- *
*/
template <typename VectorType = Vector<double>>
class DiagonalMatrix : public Subscriptor
* row and column number (or alternatively the index within the complete
* sparsity pattern). It does not allow modifying the sparsity pattern
* itself.
- *
*/
class Accessor
{
* SparsityPattern sp;
* sp.copy_from (dynamic_pattern);
* @endcode
- *
*/
class DynamicSparsityPattern : public Subscriptor
{
* compute the smallest eigenvalue, too.
*
* Convergence of this method is known to be slow.
- *
*/
template <typename VectorType = Vector<double>>
class EigenPower : private SolverBase<VectorType>
* converges to the eigenvalue closest to the initial guess. This can be aided
* by the parameter AdditionalData::start_adaption, which indicates the first
* iteration step in which the shift value should be adapted.
- *
*/
template <typename VectorType = Vector<double>>
class EigenInverse : private SolverBase<VectorType>
* programs, see
* @ref Instantiations
* for details.
- *
*/
template <typename number>
class FullMatrix : public Table<2, number>
* section on
* @ref Instantiations
* in the manual).
- *
*/
template <typename number>
class Householder
* cg.solve (system_matrix, solution, system_rhs,
* IdentityMatrix(solution.size()));
* @endcode
- *
- *
*/
class IdentityMatrix
{
* i.e., whenever a non-zero ghost element is found, it is compared to
* the value on the owning processor and an exception is thrown if these
* elements do not agree.
- *
*/
virtual void
compress(::dealii::VectorOperation::values operation) override;
/**
* Declare dealii::LinearAlgebra::distributed::BlockVector as distributed
* vector.
- *
*/
template <typename Number>
struct is_serial_vector<LinearAlgebra::distributed::BlockVector<Number>>
/**
* Declare dealii::LinearAlgebra::Vector as distributed vector.
- *
*/
template <typename Number, typename MemorySpace>
struct is_serial_vector<LinearAlgebra::distributed::Vector<Number, MemorySpace>>
* ::dealii::LinearAlgebra::VectorSpaceVector. As opposed to the array of
* the C++ standard library, this class implements an element of a vector
* space suitable for numerical computations.
- *
*/
template <typename Number>
class Vector : public ReadWriteVector<Number>,
/**
* Declare dealii::LinearAlgebra::Vector as serial vector.
- *
*/
template <typename Number>
struct is_serial_vector<LinearAlgebra::Vector<Number>> : std::true_type
* columns represent the eigenvectors of the original content of the matrix.
* The elements of this enumeration are therefore used to track what is
* currently being stored by this object.
- *
*/
enum State
{
*
* This iterator is abstracted from the actual matrix type and can be used for
* any matrix having the required ACCESSOR type.
- *
*/
template <class ACCESSOR>
class MatrixIterator
* <code>pdseupd</code>, <code>pdnaupd</code>, <code>pdsaupd</code> work and
* also how to set the parameters appropriately please take a look into the
* PARPACK manual.
- *
*/
template <typename VectorType>
class PArpackSolver : public Subscriptor
/**
* Declare dealii::PETScWrappers::MPI::BlockVector as distributed vector.
- *
*/
template <>
struct is_serial_vector<PETScWrappers::MPI::BlockVector> : std::false_type
* semantics in the PETSc wrappers, this function will not throw an
* exception if an error occurs, but instead just returns the error code
* given by MatDestroy.
- *
*/
inline PetscErrorCode
destroy_matrix(Mat &matrix)
/**
* Declare dealii::PETScWrappers::MPI::Vector as distributed vector.
- *
*/
template <>
struct is_serial_vector<PETScWrappers::MPI::Vector> : std::false_type
* PreconditionUseMatrix<>(
* matrix,&SparseMatrix<double>::template precondition_Jacobi<double>));
* @endcode
- *
*/
template <typename MatrixType = SparseMatrix<double>,
class VectorType = Vector<double>>
*
* solver.solve (A, x, b, precondition);
* @endcode
- *
*/
template <typename MatrixType = SparseMatrix<double>>
class PreconditionJacobi : public PreconditionRelaxation<MatrixType>
*
* solver.solve (A, x, b, precondition);
* @endcode
- *
*/
template <typename MatrixType = SparseMatrix<double>>
class PreconditionSOR : public PreconditionRelaxation<MatrixType>
*
* solver.solve (A, x, b, precondition);
* @endcode
- *
*/
template <typename MatrixType = SparseMatrix<double>>
class PreconditionSSOR : public PreconditionRelaxation<MatrixType>
* section on
* @ref Instantiations
* in the manual).
- *
*/
template <typename MatrixType,
typename inverse_type = typename MatrixType::value_type>
* section on
* @ref Instantiations
* in the manual).
- *
*/
template <typename MatrixType,
typename inverse_type = typename MatrixType::value_type>
* section on
* @ref Instantiations
* in the manual).
- *
*/
template <typename MatrixType,
typename inverse_type = typename MatrixType::value_type>
* Additionally, it allows the storage of the original diagonal blocks, not
* only the inverses. These are for instance used in the intermediate step of
* the SSOR preconditioner.
- *
*/
template <typename number>
class PreconditionBlockBase
* ranges are stored in ascending order of the first index of each range.
* The function IndexSet::largest_range_starting_index() can be used to
* get the first index of the largest range.
- *
*/
template <typename Number>
class ReadWriteVector : public Subscriptor
* The parameter @p block_size is used for the block-cyclic distribution of the matrix.
* An identical block size is used for the rows and columns of the matrix.
* In general, it is recommended to use powers of $2$, e.g. $16,32,64, \dots$.
- *
*/
ScaLAPACKMatrix(
const size_type size,
* solver. Usage: All spectrum, all problem types, complex.
*
* @ingroup SLEPcWrappers
- *
*/
class SolverKrylovSchur : public SolverBase
{
* Usage: All spectrum, all problem types, complex.
*
* @ingroup SLEPcWrappers
- *
*/
class SolverArnoldi : public SolverBase
{
* Usage: All spectrum, all problem types, complex.
*
* @ingroup SLEPcWrappers
- *
*/
class SolverLanczos : public SolverBase
{
* Usage: Largest values of spectrum only, all problem types, complex.
*
* @ingroup SLEPcWrappers
- *
*/
class SolverPower : public SolverBase
{
* solver. Usage: All problem types.
*
* @ingroup SLEPcWrappers
- *
*/
class SolverGeneralizedDavidson : public SolverBase
{
* solver. Usage: All problem types.
*
* @ingroup SLEPcWrappers
- *
*/
class SolverJacobiDavidson : public SolverBase
{
* solver.
*
* @ingroup SLEPcWrappers
- *
*/
class SolverLAPACK : public SolverBase
{
* The solve() function of this class uses the mechanism described in the
* Solver base class to determine convergence. This mechanism can also be used
* to observe the progress of the iteration.
- *
*/
template <typename VectorType = Vector<double>>
class SolverBicgstab : public SolverBase<VectorType>,
* The solve() function of this class uses the mechanism described in the
* Solver base class to determine convergence. This mechanism can also be used
* to observe the progress of the iteration.
- *
- *
*/
template <typename VectorType = Vector<double>>
class SolverCG : public SolverBase<VectorType>
* not be achieved or at least was not achieved within the given maximal
* number of iterations.
* </ul>
- *
*/
class SolverControl : public Subscriptor
{
* is 1% and the tolerance is 0.1%. The initial residual is 2.5. The process
* will break if 20 iteration are completed or the new residual is less then
* 2.5*1% or if it is less then 0.1%.
- *
*/
class ReductionControl : public SolverControl
{
* class and the solver terminates similarly when one of the given tolerance
* or the maximum iteration count were reached. The only difference to
* SolverControl is that the solver returns success in the latter case.
- *
*/
class IterationNumberControl : public SolverControl
{
* the tolerance is 0.2. The ConsecutiveControl will return
* SolverControl::State::success only at the last step in the sequence 0.5,
* 0.0005, 1.0, 0.05, 0.01.
- *
*/
class ConsecutiveControl : public SolverControl
{
* <a href="http://onlinelibrary.wiley.com/doi/10.1002/pamm.201110246/full">
* Energy-Minimization in Atomic-to-Continuum Scale-Bridging Methods </a> by
* Eidel et al. 2011.
- *
*/
template <typename VectorType = Vector<double>>
class SolverFIRE : public SolverBase<VectorType>
* can be obtained by connecting a function as a slot using @p
* connect_condition_number_slot and @p connect_eigenvalues_slot. These slots
* will then be called from the solver with the estimates as argument.
- *
- *
*/
template <class VectorType = Vector<double>>
class SolverGMRES : public SolverBase<VectorType>
* preconditioner less at each restart and at the end of solve().
*
* For more details see @cite Saad1991.
- *
*/
template <class VectorType = Vector<double>>
class SolverFGMRES : public SolverBase<VectorType>
* iteration. If the user enables the history data, the residual at each of
* these steps is stored and therefore there will be multiple values per
* iteration.
- *
*/
template <class VectorType = Vector<double>>
class SolverIDR : public SolverBase<VectorType>
* The solve() function of this class uses the mechanism described in the
* Solver base class to determine convergence. This mechanism can also be used
* to observe the progress of the iteration.
- *
- *
*/
template <class VectorType = Vector<double>>
class SolverMinRes : public SolverBase<VectorType>
* The solve() function of this class uses the mechanism described in the
* Solver base class to determine convergence. This mechanism can also be used
* to observe the progress of the iteration.
- *
- *
*/
template <typename VectorType = Vector<double>>
class SolverQMRS : public SolverBase<VectorType>
* The solve() function of this class uses the mechanism described in the
* Solver base class to determine convergence. This mechanism can also be used
* to observe the progress of the iteration.
- *
- *
*/
template <class VectorType = Vector<double>>
class SolverRichardson : public SolverBase<VectorType>
* the calling of this solver has to be added and each user with program lines
* quoted above only needs to 'set solver = xyz' in their parameter file to get
* access to that new solver.
- *
*/
template <typename VectorType = Vector<double>>
class SolverSelector : public Subscriptor
/**
* Solver procedure. Calls the @p solve function of the @p solver whose @p
* SolverName was specified in the constructor.
- *
*/
template <class Matrix, class Preconditioner>
void
* <i>M</i> being this matrix.
*
* Source and destination must not be the same vector.
- *
*/
template <class OutVector, class InVector>
void
* section on
* @ref Instantiations
* in the manual).
- *
*/
template <typename number>
class SparseILU : public SparseLUDecomposition<number>
*
* @note The name of the class makes sense by pronouncing it the American way,
* where "EZ" is pronounced the same way as the word "easy".
- *
*/
template <typename number>
class SparseMatrixEZ : public Subscriptor
* Call @p initialize before calling this function.
*
* @note This function has not yet been implemented
- *
*/
template <typename somenumber>
void
* iterations (at most by one in each step) and they also do not change when
* the degrees of freedom are sorted by component, while the first strategy
* significantly deteriorated.
- *
*/
template <typename number>
class SparseBlockVanka : public SparseVanka<number>
* row and column number (or alternatively the index within the complete
* sparsity pattern). It does not allow modifying the sparsity pattern
* itself.
- *
*/
class Accessor
{
* SparseMatrix objects can store nonzero entries, are stored row-by-row.
* The ordering of non-zero elements within each row (i.e. increasing
* column index order) depends on the derived classes.
- *
*/
class SparsityPatternBase : public Subscriptor
{
* first, see for example the step-2 tutorial program as well as the
* documentation module
* @ref Sparsity.
- *
*/
class SparsityPattern : public SparsityPatternBase
{
* dimension). By default at -1, which means that the number of rows
* is determined at run-time by means of the matrices passed to the
* reinit() function.
- *
*/
template <int dim, typename Number, int n_rows_1d = -1>
class TensorProductMatrixSymmetricSumBase
* dimension). By default at -1, which means that the number of rows
* is determined at run-time by means of the matrices passed to the
* reinit() function.
- *
*/
template <int dim, typename Number, int n_rows_1d = -1>
class TensorProductMatrixSymmetricSum
* being the arithmetic template. For a detailed description see
* the main documentation of the generic
* TensorProductMatrixSymmetricSum class.
- *
*/
template <int dim, typename Number, int n_rows_1d>
class TensorProductMatrixSymmetricSum<dim, VectorizedArray<Number>, n_rows_1d>
/**
* Declare dealii::TrilinosWrappers::MPI::BlockVector as distributed vector.
- *
*/
template <>
struct is_serial_vector<TrilinosWrappers::MPI::BlockVector> : std::false_type
/**
* @addtogroup Exceptions
- *
*/
//@{
/**
/**
* An implementation of the solver interface using the Trilinos GMRES
* solver.
- *
*/
class SolverGMRES : public SolverBase
{
* For a regular dealii::SparseMatrix, we would use an accessor for the
* sparsity pattern. For Trilinos matrices, this does not seem so simple,
* therefore, we write a little base class here.
- *
*/
class AccessorBase
{
//@}
/**
* @addtogroup Exceptions
- *
*/
//@{
/**
/**
* Declare dealii::TrilinosWrappers::MPI::Vector as distributed vector.
- *
*/
template <>
struct is_serial_vector<TrilinosWrappers::MPI::Vector> : std::false_type
* \f]
*
* @note The function is implemented for real valued numbers only.
- *
*/
template <typename NumberType>
std::array<NumberType, 3>
* throw an error otherwise.
*
* @note The function is implemented for real valued numbers only.
- *
*/
template <typename NumberType>
std::array<NumberType, 3>
* @note This function provides an alternate estimate to that obtained from
* several steps of SolverCG with
* SolverCG<VectorType>::connect_eigenvalues_slot().
- *
*/
template <typename OperatorType, typename VectorType>
double
* @note If @p tau is equal to
* <code>std::numeric_limits<double>::infinity()</code>, no normalization
* will be performed.
- *
*/
template <typename OperatorType, typename VectorType>
void
* others can be generated in application programs (see the section on
* @ref Instantiations
* in the manual).
- *
*/
template <typename Number>
class Vector : public Subscriptor
* control flow leaves it due to an exception), a memory leak cannot
* happen: the vector the VectroMemory::Pointer object points to is
* <i>always</i> returned.
- *
- *
*/
template <typename VectorType = dealii::Vector<double>>
class VectorMemory : public Subscriptor
* allocates memory from a memory pool upon construction, and (ii) that the
* memory is not destroyed using `operator delete` but returned to the
* VectorMemory pool.
- *
*/
class Pointer
: public std::unique_ptr<VectorType, std::function<void(VectorType *)>>
* GrowingVectorMemory object whenever needed without the performance penalty
* of creating a new memory pool every time. A drawback of this policy is that
* vectors once allocated are only released at the end of the program run.
- *
*/
template <typename VectorType = dealii::Vector<double>>
class GrowingVectorMemory : public VectorMemory<VectorType>
* This is where the actual storage for GrowingVectorMemory is provided.
* Only one of these pools is used for each vector type, thus allocating all
* vectors from the same storage.
- *
*/
struct Pool
{
* implement global operations. This class is complementary of
* ReadWriteVector which allows the access of individual elements but does
* not allow global operations.
- *
*/
template <typename Number>
class VectorSpaceVector
* @endcode
* for a vector type with support of distributed storage,
* must be done in a header file of a vector declaration.
- *
*/
template <typename T>
struct is_serial_vector;
* double.
*
* @ingroup CUDAWrappers
- *
*/
template <int dim,
int fe_degree,
* combination will be handled in the MatrixFree class.
*
* @ingroup matrixfree
- *
*/
struct DoFInfo
{
* identity) and FEEvaluationImplTransformToCollocation (which can be
* transformed to a collocation space and can then use the identity in these
* spaces), which both allow for shorter code.
- *
*/
template <MatrixFreeFunctions::ElementType type,
int dim,
*
* This class allows for dimension-independent application of the operation,
* implemented by template recursion. It has been tested up to 6D.
- *
*/
template <EvaluatorVariant variant,
int dim,
* In literature, this form of evaluation is often called spectral
* evaluation, spectral collocation or simply collocation, meaning the same
* location for shape functions and evaluation space (quadrature points).
- *
*/
template <int dim, int fe_degree, int n_components, typename Number>
struct FEEvaluationImplCollocation
* in the quadrature points (i.e., the collocation space) and then perform
* the evaluation of the first and second derivatives in this transformed
* space, using the identity operation for the shape values.
- *
*/
template <int dim,
int fe_degree,
* computation. In order to avoid gaps in the memory representation, the
* four 'char' variables are put next to each other which occupies the
* same size as the unsigned integers on most architectures.
- *
*/
template <int vectorization_width>
struct FaceToCellTopology
/**
* A struct that is used to represent a collection of faces of a process
* with one of its neighbor within the setup done in struct FaceInfo.
- *
*/
struct FaceIdentifier
{
* sides). This data structure is used for the setup of the connectivity
* between faces and cells and for identification of the dof indices to be
* used for face integrals.
- *
*/
template <int dim>
struct FaceSetup
*
*
* @ingroup matrixfree
- *
*/
template <int dim,
int n_components_,
* MatrixFree object and lead to a structure that does not effectively use
* vectorization in the evaluate routines based on these values (instead,
* VectorizedArray::size() same copies are worked on).
- *
*/
template <typename VectorType>
void
* scalar and vector-valued elements are defined separately.
*
* @ingroup matrixfree
- *
*/
template <int dim,
int n_components_,
* gradients.
*
* @ingroup matrixfree
- *
*/
template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
class FEEvaluationAccess<dim, 1, Number, is_face, VectorizedArrayType>
* symmetric gradient and divergence.
*
* @ingroup matrixfree
- *
*/
template <int dim, typename Number, bool is_face, typename VectorizedArrayType>
class FEEvaluationAccess<dim, dim, Number, is_face, VectorizedArrayType>
* double
*
* @ingroup matrixfree
- *
*/
template <int dim,
int fe_degree,
*
* @note Currently only VectorizedArray<Number, width> is supported as
* VectorizedArrayType.
- *
*/
template <int dim,
int fe_degree,
* the geometry, but it rather provides the evaluated geometry from a
* given deal.II mapping (as passed to the constructor of this class) in a
* form accessible to FEEvaluation.
- *
*/
template <int dim, typename Number, typename VectorizedArrayType>
class MappingDataOnTheFly
* with several data fields for the individual quadrature formulas.
*
* @ingroup matrixfree
- *
*/
template <int structdim,
int spacedim,
* interiors for use in the matrix-free class.
*
* @ingroup matrixfree
- *
*/
template <int dim, typename Number, typename VectorizedArrayType>
struct MappingInfo
/**
* A helper class to extract either cell or face data from mapping info
* for use in FEEvaluationBase.
- *
*/
template <int, typename, bool, typename>
struct MappingInfoCellsOrFaces;
* @ref matrixfree "matrix-free module".
*
* @ingroup matrixfree
- *
*/
template <int dim,
* system_rhs *= -1.;
* // proceed with other terms from right hand side...
* @endcode
- *
*/
template <int dim,
typename VectorType = LinearAlgebra::distributed::Vector<double>,
* Note that the vmult_interface_down is used during the restriction phase of
* the multigrid V-cycle, whereas vmult_interface_up is used during the
* prolongation phase.
- *
*/
template <typename OperatorType>
class MGInterfaceOperator : public Subscriptor
* to provide an array for the inverse of the local coefficient (this class
* provide a helper method 'fill_inverse_JxW_values' to get the inverse of a
* constant-coefficient operator).
- *
*/
template <int dim,
int fe_degree,
* Note that this class only supports the non-blocked vector variant of the
* Base operator because only a single FEEvaluation object is used in the
* apply function.
- *
*/
template <int dim,
int fe_degree,
* Note that this class only supports the non-blocked vector variant of the
* Base operator because only a single FEEvaluation object is used in the
* apply function.
- *
*/
template <int dim,
int fe_degree,
* coordinates. This data structure also includes the evaluation of
* quantities at the cell boundary and on the sub-interval $(0, 0.5)$ and
* $(0.5, 1)$ for face integrals.
- *
*/
template <typename Number>
struct UnivariateShapeData
* case such as the hierarchical -> lexicographic ordering of FE_Q.
*
* @ingroup matrixfree
- *
*/
template <typename Number>
struct ShapeInfo
/**
* An interface for the worker object that runs the various operations we
* want to perform during the matrix-free loop.
- *
*/
struct MFWorkerInterface
{
* A struct that collects all information related to parallelization with
* threads: The work is subdivided into tasks that can be done
* independently.
- *
*/
struct TaskInfo
{
*
* You can select more than one flag by concatenation using the bitwise or
* <code>operator|(AssembleFlags,AssembleFlags)</code>.
- *
*/
enum AssembleFlags
{
* - @tparam n_matrices: Size of the array of matrices
* - @tparam n_vectors: size of the array of vectors
* - @tparam n_dof_indices: size of the array of local dof indices
- *
*/
template <int n_matrices = 1,
int n_vectors = n_matrices,
* completely different.
*
* @note In the current implementation, only cell data can be written.
- *
*/
class GnuplotPatch
{
* Volume = {7},
* Year = {2018}}
* @endcode
- *
*/
template <int dim, int spacedim = dim>
class ScratchData
*
* Usually, the derived class mg::Matrix, which operates on an MGLevelObject
* of matrices, will be sufficient for applications.
- *
*/
template <typename VectorType>
class MGMatrixBase : public Subscriptor
* Base class for coarse grid solvers. This defines the virtual parenthesis
* operator, being the interface used by multigrid methods. Any implementation
* will be done by derived classes.
- *
*/
template <typename VectorType>
class MGCoarseGridBase : public Subscriptor
* on block structures, it is not clear whether this case is really useful.
* Therefore, a tested implementation of this case will be supplied when
* needed.
- *
*/
template <typename VectorType>
class MGTransferBase : public Subscriptor
*
* @arg dst has as many elements as there are degrees of freedom on the
* coarser level.
- *
*/
virtual void
restrict_and_add(const unsigned int from_level,
* vector needs to be overwritten for a new incoming residual. On the other
* hand, all subsequent operations need to smooth the content already present
* in the vector @p u given the right hand side, which is done by smooth().
- *
*/
template <typename VectorType>
class MGSmootherBase : public Subscriptor
* to the choice of a block smoother by being initialized with a matrix and a
* smoother object. Therefore, the smoother object for each level must be
* constructed by hand.
- *
*/
template <typename MatrixType, class RelaxationType, typename number>
class MGSmootherBlock : public MGSmoother<BlockVector<number>>
/**
* Coarse grid solver using smoother only. This is a little wrapper,
* transforming a smoother into a coarse grid solver.
- *
*/
template <class VectorType = Vector<double>>
class MGCoarseGridApplySmoother : public MGCoarseGridBase<VectorType>
* it.
*
* @deprecated Use MGCoarseGridIterativeSolver instead.
- *
*/
template <typename SolverType, class VectorType = Vector<double>>
class DEAL_II_DEPRECATED MGCoarseGridLACIteration
* Upon initialization, the QR decomposition of the matrix is computed. then,
* the operator() uses Householder::least_squares() to compute the action of
* the inverse.
- *
*/
template <typename number = double, class VectorType = Vector<number>>
class MGCoarseGridHouseholder : public MGCoarseGridBase<VectorType>
*
* Upon initialization, the singular value decomposition of the matrix is
* computed. then, the operator() uses
- *
*/
template <typename number = double, class VectorType = Vector<number>>
class MGCoarseGridSVD : public MGCoarseGridBase<VectorType>
* Multilevel matrix. This matrix stores an MGLevelObject of
* LinearOperator objects. It implements the interface defined in
* MGMatrixBase, so that it can be used as a matrix in Multigrid.
- *
*/
template <typename VectorType = Vector<double>>
class Matrix : public MGMatrixBase<VectorType>
* BlockSparseMatrixEZ. Then, this class stores a pointer to a MGLevelObject
* of this matrix class. In each @p vmult, the block selected on
* initialization will be multiplied with the vector provided.
- *
*/
template <typename MatrixType, typename number>
class MGMatrixSelect : public MGMatrixBase<Vector<number>>
* adding to the abstract interface in MGSmootherBase, this class stores
* information on the number and type of smoothing steps, which in turn can be
* used by a derived class.
- *
*/
template <typename VectorType>
class MGSmoother : public MGSmootherBase<VectorType>
* other than for testing some multigrid procedures. Also some applications
* might get convergence without smoothing and then this class brings you the
* cheapest possible multigrid.
- *
*/
template <typename VectorType>
class MGSmootherIdentity : public MGSmootherBase<VectorType>
* the possibility to extract a single block for smoothing. In this case,
* the multigrid method must be used only with the vector associated to that
* single block.
- *
*/
template <class RelaxationType, typename VectorType>
class SmootherRelaxation : public MGLevelObject<RelaxationType>,
* <tt>Vector<.></tt>, where the template arguments are all combinations of @p
* float and @p double. Additional instantiations may be created by including
* the file mg_smoother.templates.h.
- *
*/
template <typename MatrixType, class RelaxationType, typename VectorType>
class MGSmootherRelaxation : public MGSmoother<VectorType>
* <tt>Vector<.></tt>, where the template arguments are all combinations of @p
* float and @p double. Additional instantiations may be created by including
* the file mg_smoother.templates.h.
- *
*/
template <typename MatrixType, typename PreconditionerType, typename VectorType>
class MGSmootherPrecondition : public MGSmoother<VectorType>
* in purpose and function to the @p DoFTools namespace, but operates on
* levels of DoFHandler objects. See there and the documentation of the member
* functions for more information.
- *
*/
namespace MGTools
{
/**
* Implementation of transfer between the global vectors and the multigrid
* levels for use in the derived class MGTransferPrebuilt and other classes.
- *
*/
template <typename VectorType>
class MGLevelGlobalTransfer : public MGTransferBase<VectorType>
* LinearAlgebra::distributed::Vector that requires a few different calling
* routines as compared to the %parallel vectors in the PETScWrappers and
* TrilinosWrappers namespaces.
- *
*/
template <typename Number>
class MGLevelGlobalTransfer<LinearAlgebra::distributed::Vector<Number>>
*
* See MGTransferBase to find out which of the transfer classes is best for
* your needs.
- *
*/
template <typename VectorType>
class MGTransferPrebuilt : public MGLevelGlobalTransfer<VectorType>
* where multigrid is applied only to one or some blocks, where a
* @ref GlossBlock
* comprises all degrees of freedom generated by one base element.
- *
*/
class MGTransferBlockBase
{
*
* See MGTransferBase to find out which of the transfer classes is best for
* your needs.
- *
*/
template <typename number>
class MGTransferBlock : public MGTransferBase<BlockVector<number>>,
*
* See MGTransferBase to find out which of the transfer classes is best for
* your needs.
- *
*/
template <typename number>
class MGTransferBlockSelect : public MGTransferBase<Vector<number>>,
* @note MGTransferBlockBase is probably the more logical class. Still
* eventually, a class should be developed allowing to select multiple
* components.
- *
*/
class MGTransferComponentBase
{
*
* See MGTransferBase to find out which of the transfer classes is best for
* your needs.
- *
*/
template <typename number>
class MGTransferSelect : public MGTransferBase<Vector<number>>,
* FE_Q and FE_DGQ elements, including systems involving multiple components
* of one of these elements. Systems with different elements or other elements
* are currently not implemented.
- *
*/
template <int dim, typename Number>
class MGTransferMatrixFree
* MGTransferMatrixFree.
* Both the cases that the same DoFHandler is used for all the blocks
* and that each block uses its own DoFHandler are supported.
- *
*/
template <int dim, typename Number>
class MGTransferBlockMatrixFree
* will have to set up quite a few auxiliary objects before you can use it.
* Unfortunately, it seems that this can be avoided only be restricting the
* flexibility of this class in an unacceptable way.
- *
*/
template <typename VectorType>
class Multigrid : public Subscriptor
* If VectorType is in fact a block vector and the TRANSFER object supports
* use of a separate DoFHandler for each block, this class also allows
* to be initialized with a separate DoFHandler for each block.
- *
*/
template <int dim, typename VectorType, class TRANSFER>
class PreconditionMG : public Subscriptor
/**
* Handler and storage for all five SparseMatrix object involved in using
* multigrid with local refinement.
- *
*/
template <typename number>
class SparseMatrixCollection : public Subscriptor
*
* See the tutorial program step-60 for an example on how to use this
* function.
- *
*/
template <int dim0,
int dim1,
* creating one internally. In this version of the function, the parameter @p
* space_mapping cannot be specified, since it is taken from the @p cache
* parameter.
- *
*/
template <int dim0,
int dim1,
*
* See the tutorial program step-60 for an example on how to use this
* function.
- *
*/
template <int dim0, int dim1, int spacedim, typename Matrix>
void
* creating one internally. In this version of the function, the parameter @p
* space_mapping cannot specified, since it is taken from the @p cache
* parameter.
- *
*/
template <int dim0, int dim1, int spacedim, typename Matrix>
void
* as input (but a quadrature formula @p quad is required). In this case, more
* restrictive conditions are required on the two spaces. See the
* documentation of the other create_coupling_sparsity_pattern() function.
- *
*/
template <int dim0,
int dim1,
* that the kernel is the Dirac delta distribution, and the call is forwarded
* to the method in this namespace with the same name, that does not take an
* epsilon as input.
- *
*/
template <int dim0, int dim1, int spacedim, typename Matrix>
void
* @f]
*
* @image html immersed_surface_quadrature.svg
- *
*/
template <int dim>
class ImmersedSurfaceQuadrature : public Quadrature<dim>
* In this namespace, we offer a few strategies that cope with this
* problem. Such strategies can be passed to the CellDataTransfer and
* parallel::distributed::CellDataTransfer constructors.
- *
*/
namespace AdaptationStrategies
{
*
* See the step-22 tutorial program for an example on how this information
* can be used in practice.
- *
*/
enum DataComponentInterpretation
{
* @note This class is an example of the
* <a href="https://www.artima.com/cppsource/type_erasure.html">type
* erasure</a> design pattern.
- *
*/
template <typename DoFHandlerType>
class DataEntryBase
/**
* Class that stores a pointer to a vector of type equal to the template
* argument, and provides the functions to extract data from it.
- *
*/
template <typename DoFHandlerType, typename VectorType>
class DataEntry : public DataEntryBase<DoFHandlerType>
* }
* };
* @endcode
- *
*/
template <int spacedim>
struct CommonInputs
* makes available access to the locations of evaluations points,
* normal vectors (if appropriate), and which cell data is currently
* being evaluated on (also if appropriate).
- *
*/
template <int spacedim>
struct Scalar : public CommonInputs<spacedim>
* makes available access to the locations of evaluations points,
* normal vectors (if appropriate), and which cell data is currently
* being evaluated on (also if appropriate).
- *
*/
template <int spacedim>
struct Vector : public CommonInputs<spacedim>
* to compute the jump terms differently. However, this class offers exactly
* the same public functions as the general template, so that a user will not
* see any difference.
- *
*/
template <int spacedim>
class KellyErrorEstimator<1, spacedim>
* iterations
* $\{k-1,k-2,...,k-m\}$, then addition of the new element will make
* the object contain elements from iterations $\{k,k-1,k-2,...,k-m+1\}$.
- *
*/
template <typename T>
class FiniteSizeHistory
* and only create a tree of the indices within the container, using the
* IndexableGetterFromIndices class defined below, and the function
* pack_rtree_of_indices().
- *
*/
template <typename LeafType,
typename IndexType = boost::geometry::index::linear<16>,
* Notice that the order of the parameters is the opposite with respect to the
* RTree class, since we can automatically infer the @p LeafType from the
* arguments.
- *
*/
template <typename IndexType = boost::geometry::index::linear<16>,
typename LeafTypeIterator,
* RTree class, since we can automatically infer the @p LeafType from the
* arguments, and we only need to specify the @p IndexType if the default is not
* adequate.
- *
*/
template <typename IndexType = boost::geometry::index::linear<16>,
typename ContainerType,
* This class is used by the pack_rtree_of_indices() function to construct an
* RTree where the leaves are indices pointing to the entries of the container
* passed to this class.
- *
*/
template <typename Container>
class IndexableGetterFromIndices
* the container. A reference to the external container is stored internally,
* but keep in mind that if you change the container, you should rebuild the
* tree.
- *
*/
template <typename IndexType = boost::geometry::index::linear<16>,
typename ContainerType>
* Although possible, direct usage of this structure is cumbersome. The
* suggested usage of this class is through the helper function
* extract_rtree_level().
- *
*/
template <typename Value,
typename Options,
* @image html rtree-process-0.png
* @image html rtree-process-1.png
* @image html rtree-process-2.png
- *
*/
template <typename Rtree>
inline std::vector<BoundingBox<
* The rate of the decay $\sigma$ can be used to estimate the smoothness. For
* example, one strategy to implement hp-refinement criteria is to perform
* p-refinement if $\sigma>1$ (see @cite mavriplis1994hp).
- *
*/
namespace Legendre
{
* timesteps[step-look_back]->sleep(look_back);
* }
* @endcode
- *
- *
*/
class TimeDependent
{
* functions (namely @p sleep and @p wake_up), the interface to previous and
* following grids, and some functions to be called before a new loop over all
* time steps is started.
- *
*/
class TimeStepBase : public Subscriptor
{
* TimeStepBase_Tria() class. These used to be local data types of that class,
* but some compilers choked on some aspects, so we put them into a namespace
* of their own.
- *
*/
namespace TimeStepBase_Tria_Flags
{
* @f[
* E = \| \nabla e \|_{L^\infty}.
* @f]
- *
*/
W1infty_seminorm,
* these objects separately (the order depends on what you want to get
* between cells), then each subsequent call will rewrite the intercell @p
* dofs of the previous one.
- *
*/
template <int dim,
int spacedim,
*
* This function is only implemented for FiniteElements where the specified
* components are primitive.
- *
*/
template <int dim,
int spacedim,
* TopoDS_Edge when projecting on a face. In this case, the vertices of the
* face would be collapsed to the edge, and your surrounding points would
* not be lying on the given shape, raising an exception.
- *
*/
template <int dim, int spacedim>
class NormalProjectionManifold : public FlatManifold<dim, spacedim>
* the triangulation to be refined is close to the boundary of the given
* TopoDS_Shape, or when the direction you use at construction time does not
* intersect the shape. An exception is thrown when this happens.
- *
*/
template <int dim, int spacedim>
class DirectionalProjectionManifold : public FlatManifold<dim, spacedim>
* TopoDS_Shape, or when the normal direction estimated from the surrounding
* points does not intersect the shape. An exception is thrown when this
* happens.
- *
*/
template <int dim, int spacedim>
class NormalToMeshProjectionManifold : public FlatManifold<dim, spacedim>
* surrounding points actually live on the Manifold, i.e., calling
* OpenCASCADE::closest_point() on those points leaves them untouched. If
* this is not the case, an ExcPointNotOnManifold is thrown.
- *
*/
template <int dim, int spacedim>
class ArclengthProjectionLineManifold : public ChartManifold<dim, spacedim, 1>
* Manifold description for the face of a CAD imported using OpenCASCADE.
*
* @ingroup manifold
- *
*/
template <int dim, int spacedim>
class NURBSPatchManifold : public ChartManifold<dim, spacedim, 2>
* If you wish to use these tools when the dimension of the space is two, then
* make sure your CAD files are actually flat and that all z coordinates are
* equal to zero, as otherwise you will get many exceptions.
- *
*/
namespace OpenCASCADE
{
* @param[in] mapping Optional input mapping
* @return An std::vector of TopoDS_Edge objects representing the smooth
* interpolation of the boundary of the `triangulation`
- *
*/
template <int spacedim>
std::vector<TopoDS_Edge>
* the largest value of int type. Some of the vectors in deal.II (see
* @ref Vector)
* may not satisfy the above requirements.
- *
*/
template <typename VectorType>
class VectorAdaptor : public ROL::Vector<typename VectorType::value_type>
* @f}
* for a symmetric positive definite $H$. Limited memory variant is
* implemented via the two-loop recursion.
- *
*/
template <typename VectorType>
class SolverBFGS : public SolverBase<VectorType>
* to write the properties attached to the particles
*
* @ingroup Particle
- *
*/
template <int dim, int spacedim = dim>
class DataOut : public dealii::DataOutInterface<0, spacedim>
* @param [in] data_component_interpretations An optional vector that
* controls if the particle properties are interpreted as scalars, vectors,
* or tensors. Has to be of the same length as @p data_component_names.
- *
*/
void
build_patches(const Particles::ParticleHandler<dim, spacedim> &particles,
* difficult to write either.
*
* @ingroup Particle
- *
*/
template <int dim, int spacedim = dim>
class Particle
* of the points that were passed to this function on the calling mpi
* process, and that falls within the part of triangulation owned by this
* mpi process.
- *
*/
std::map<unsigned int, IndexSet>
insert_global_particles(
* @param[in] displace_particles Control if the @p input_vector should
* be interpreted as a displacement vector, or a vector of absolute
* positions.
- *
*/
template <class VectorType>
typename std::enable_if<
* current position of the particle, thus displacing them by the
* amount given by the function. When false, the position of the
* particle is replaced by the value in the vector.
- *
*/
void
set_particle_positions(const std::vector<Point<spacedim>> &new_positions,
* of the function to the current position of the particle, thus displacing
* them by the amount given by the function. When false, the position of the
* particle is replaced by the value of the function.
- *
*/
void
set_particle_positions(const Function<spacedim> &function,
*
* @param[in] add_to_output_vector Control if the function should set the
* entries of the @p output_vector or if should add to them.
- *
*/
template <class VectorType>
void
* the particles is added to the positions vector. When false,
* the value of the points in the positions vector are replaced by the
* position of the particles.
- *
- *
*/
void
get_particle_positions(std::vector<Point<spacedim>> &positions,
*
* @return An IndexSet of size get_next_free_particle_index(), containing
* n_locally_owned_particle() indices.
- *
*/
IndexSet
locally_relevant_ids() const;
* supplied with the @p constraints argument. The method
* AffineConstraints::add_entries_local_to_global() is used to fill the
* final sparsity pattern.
- *
*/
template <int dim,
int spacedim,
* supplied with the @p constraints argument. The method
* AffineConstraints::distribute_local_to_global() is used to distribute
* the entries of the matrix to respect the given constraints.
- *
*/
template <int dim, int spacedim, typename MatrixType>
void
*
* @param[in] field_comps An optional component mask that decides which
* subset of the vector fields are interpolated
- *
*/
template <int dim,
int spacedim,
* @note These hold specifically for the codimension
* 0 case, where the metric tensor is the identity tensor.
- *
- */
+*/
namespace Kinematics
{
/**
* wikipedia page</a> and <a
* href="https://github.com/dealii/dealii/tree/master/tests/physics/notation-kelvin_02.cc">the
* unit tests</a>.
- *
*/
namespace Kelvin
{
/**
* Transformation functions and tensors that are defined in terms of
* rotation angles and axes of rotation.
- *
*/
namespace Rotations
{
* reference and spatial configurations, and their surfaces $\partial
* V_{0}$ and $\partial V_{t}$ have the outwards facing normals
* $\mathbf{N}$ and $\mathbf{n}$.
- *
*/
namespace Contravariant
{
* the curves $\partial A_{0}$ and $\partial A_{t}$ that are,
* respectively, associated with the line directors $\mathbf{L}$ and
* $\mathbf{l}$.
- *
*/
namespace Covariant
{
* Transformation of tensors that are defined in terms of a set of
* contravariant basis vectors and scale with the inverse of the volume
* change associated with the mapping.
- *
*/
namespace Piola
{
*
* ode.solve_ode(y);
* @endcode
- *
*/
template <typename VectorType = Vector<double>>
class ARKode
* y_dot[0] = kappa;
* time_stepper.solve_dae(y,y_dot);
* @endcode
- *
*/
template <typename VectorType = Vector<double>>
class IDA
* convergence checks:
* - get_solution_scaling;
* - get_function_scaling;
- *
*/
template <typename VectorType = Vector<double>>
class KINSOL
/**
* Implementation of derived classes of the CellIteratorBase
* interface. See there for a description of the use of these classes.
- *
*/
template <int dim, int spacedim>
template <typename CI>
* reminding the user that if they want to use these features, then the FEValues
* object has to be reinitialized with a cell iterator that allows to extract
* degree of freedom information.
- *
*/
template <int dim, int spacedim>
class FEValuesBase<dim, spacedim>::TriaCellIterator
* re-sort and group components
* as in
* DoFRenumbering::component_wise.
- *
- *
*/
template <int dim, typename number, int spacedim>
void
* finite difference approximation to the gradient on a cell. See the
* general documentation of this class for more information on
* implementation details.
- *
*/
template <int dim>
class Gradient
* finite difference approximation to the second derivatives on a cell. See
* the general documentation of this class for more information on
* implementational details.
- *
*/
template <int dim>
class SecondDerivative
* We test that the computed vectors are eigenvectors and mass-normal, i.e.
* a) (A*x_i-\lambda*B*x_i).L2() == 0
* b) x_i*B*x_i = 1
- *
*/
#include <deal.II/base/function.h>
* We test that the computed vectors are eigenvectors and mass-normal, i.e.
* a) (A*x_i-\lambda*B*x_i).L2() == 0
* b) x_i*B*x_i = 1
- *
*/
#include <deal.II/base/index_set.h>
* We test that the computed vectors are eigenvectors and mass-normal, i.e.
* a) (A*x_i-\lambda*B*x_i).L2() == 0
* b) x_i*B*x_i = 1
- *
*/
#include <deal.II/base/index_set.h>
* We test that the computed vectors are eigenvectors and mass-orthonormal, i.e.
* a) (A*x_i-\lambda*B*x_i).L2() == 0
* b) x_j*B*x_i = \delta_{i,j}
- *
*/
#include <deal.II/base/function.h>
* We test that the computed vectors are eigenvectors and mass-orthonormal, i.e.
* a) (A*x_i-\lambda*B*x_i).L2() == 0
* b) x_j*B*x_i = \delta_{i,j}
- *
*/
#include <deal.II/base/function.h>
* We test that the computed vectors are eigenvectors and mass-orthonormal, i.e.
* a) (A*x_i-\lambda*B*x_i).L2() == 0
* b) x_j*B*x_i = \delta_{i,j}
- *
*/
#include <deal.II/base/index_set.h>
* We test that the computed vectors are eigenvectors and mass-orthonormal, i.e.
* a) (A*x_i-\lambda*B*x_i).L2() == 0
* b) x_j*B*x_i = \delta_{i,j}
- *
*/
#include <deal.II/base/index_set.h>
* We test that the computed vectors are eigenvectors and mass-orthonormal, i.e.
* a) (A*x_i-\lambda*B*x_i).L2() == 0
* b) x_j*B*x_i = \delta_{i,j}
- *
*/
#include <deal.II/base/index_set.h>
* one Vector be enough?
*
* @param
- *
*/
template <int dim, class InVector, class OutVector>
void
* set_cellwise_color_set_and_fe_index. Now using material id,
* each cell is associated with a map which assigns a color to a
* particular enrichment function id.
- *
*/
auto cell = dof_handler.begin_active();
auto endc = dof_handler.end();
* set up basic grid which is a hyper cube or hyper ball based on
* parameter file. Refine as per the global refinement value in the
* parameter file.
- *
*/
if (prm.shape == 1)
GridGenerator::hyper_cube(triangulation, -prm.size / 2.0, prm.size / 2.0);
* Generate a grid consisting of two disjoint cells, colorize the two
* outermost faces. They will be matched via collect_periodic_faces.
* Only default orientation is available for this function.
- *
*/
/* The 2D case */
* DEAL::1018.29
* DEAL::1020.72
* DEAL::1020.72
- *
*/
#include <deal.II/base/index_set.h>
*
* ---------------------------------------------------------------------
- *
*
*/
*
* ---------------------------------------------------------------------
- *
*
*/
* The Jacobian to assemble is the following:
*
* J = alpha I + A
- *
*/
class HarmonicOscillator
{
* The Jacobian to assemble is the following:
*
* J = alpha I + A
- *
*/
class HarmonicOscillator
{
*
* y[0](t) = sin(k t)
* y[1](t) = k cos(k t)
- *
*/
int
main(int argc, char **argv)
*
* y[0](t) = sin(k t)
* y[1](t) = k cos(k t)
- *
*/
int
main(int argc, char **argv)
* Solve the non linear problem
*
* F(u) = 0 , where f_i(u) = u_i^2 - i^2, 0 <= i < N
- *
*/
int
main(int argc, char **argv)
* usual cells meet in one vertex and local refinement exceeds one
* level</td></tr>
* </table>
- *
*/
namespace TestGrids
{
* Additional Information: 2534: Attempted to write into off-processor matrix
* row that has not be specified as being writable upon initialization 2534:
* --------------------------------------------------------
- *
*/
#include <deal.II/base/geometry_info.h>
projects / dealii.git / commitdiff