/**
* Create a view to a part of a std::vector object. This is equivalent to
- * initializing the ArrayView object with a pointer to the @p starting_index-
- * th element and the @p size_of_view as the length of the view.
+ * initializing the ArrayView object with a pointer to the
+ * @p starting_index-th element and the @p size_of_view as the length of the view.
*
* This function is used for non-@p const references to objects of vector
* type. Such objects contain elements that can be written to. Consequently,
/**
* Create a view to a part of a std::vector object. This is equivalent to
- * initializing the ArrayView object with a pointer to the @p starting_index-
- * th element and the @p size_of_view as the length of the view.
+ * initializing the ArrayView object with a pointer to the @p starting_index-th
+ * element and the @p size_of_view as the length of the view.
*
* This function is used for @p const references to objects of vector type
* because they contain immutable elements. Consequently, the return type of
* parallel programs, this means that each of the MPI processes write to the
* screen, which yields many repetitions of the same text. To avoid it, one
* would have to have a designated process, say the one with MPI process
- * number zero, do the output, and guard each write statement with an if-
- * condition. This becomes cumbersome and clutters up the code. Rather than
+ * number zero, do the output, and guard each write statement with an
+ * if-condition. This becomes cumbersome and clutters up the code. Rather than
* doing so, the present class can be used: objects of its type act just like
* a standard output stream, but they only print something based on a
* condition that can be set to, for example, <tt>mpi_process==0</tt>, so that
* @code
* system_matrix.print_formatted(pout);
* @endcode
- * is <em>not</em> possible. Instead use the is_active() function for a work-
- * around:
+ * is <em>not</em> possible. Instead use the is_active() function for a
+ * work-around:
*
* @code
* if (pout.is_active())
/**
* Flag whether to fill the regions between the lines bounding the cells
* or not. If not, no hidden line removal is performed, which in this
- * crude implementation is done through writing the cells in a back-to-
- * front order, thereby hiding the cells in the background by cells in the
- * foreground.
+ * crude implementation is done through writing the cells in a
+ * back-to-front order, thereby hiding the cells in the background by
+ * cells in the foreground.
*
* If this flag is <tt>false</tt> and #draw_mesh is <tt>false</tt> as
* well, nothing will be printed.
const char *zone_name;
/**
- * Solution time for each zone in a strand. This value must be non-
- * negative, otherwise it will not be written to file. Do not assign any
+ * Solution time for each zone in a strand. This value must be
+ * non-negative, otherwise it will not be written to file. Do not assign any
* value for this in case of a static zone.
*/
double solution_time;
std::ostream &out);
/**
- * This is the same function as above except for domains that are not two-
- * dimensional. This function is not implemented (and will throw an error if
- * called) but is declared to allow for dimension-independent programs.
+ * This is the same function as above except for domains that are not
+ * two-dimensional. This function is not implemented (and will throw an error
+ * if called) but is declared to allow for dimension-independent programs.
*/
template <int dim, int spacedim>
void
* or several points (i.e. vector_value(), vector_value_list()), will
* <em>not</em> call the function returning one component at one point
* repeatedly, once for each point and component. The reason is efficiency:
- * this would amount to too many virtual function calls. If you have vector-
- * valued functions, you should therefore also provide overloads of the
+ * this would amount to too many virtual function calls. If you have
+ * vector-valued functions, you should therefore also provide overloads of the
* virtual functions for all components at a time.
*
* Also note, that unless only called a very small number of times, you should
* Virtual destructor; absolutely necessary in this case.
*
* This destructor is declared pure virtual, such that objects of this class
- * cannot be created. Since all the other virtual functions have a pseudo-
- * implementation to avoid overhead in derived classes, they can not be
+ * cannot be created. Since all the other virtual functions have a
+ * pseudo-implementation to avoid overhead in derived classes, they can not be
* abstract. As a consequence, we could generate an object of this class
* because none of this class's functions are abstract.
*
/**
* A scalar function that computes its values by (bi-, tri-)linear
* interpolation from a set of point data that are arranged on a possibly
- * non-uniform tensor product mesh. In other words, considering the three-
- * dimensional case, let there be points $x_0,\ldots, x_{K-1}$,
+ * non-uniform tensor product mesh. In other words, considering the
+ * three-dimensional case, let there be points $x_0,\ldots, x_{K-1}$,
* $y_0,\ldots,y_{L-1}$, $z_1,\ldots,z_{M-1}$, and data $d_{klm}$ defined at
* point $(x_k,y_l,z_m)^T$, then evaluating the function at a point $\mathbf
* x=(x,y,z)$ will find the box so that $x_k\le x\le x_{k+1}, y_l\le y\le
* @param coordinate_values An array of dim arrays. Each of the inner
* arrays contains the coordinate values $x_0,\ldots, x_{K-1}$ and
* similarly for the other coordinate directions. These arrays need not
- * have the same size. Obviously, we need dim such arrays for a dim-
- * dimensional function object. The coordinate values within this array
+ * have the same size. Obviously, we need dim such arrays for a
+ * dim-dimensional function object. The coordinate values within this array
* are assumed to be strictly ascending to allow for efficient lookup.
*
* @param data_values A dim-dimensional table of data at each of the mesh
/**
* A scalar function that computes its values by (bi-, tri-)linear
* interpolation from a set of point data that are arranged on a uniformly
- * spaced tensor product mesh. In other words, considering the three-
- * dimensional case, let there be points $x_0,\ldots, x_{K-1}$ that result
- * from a uniform subdivision of the interval $[x_0,x_{K-1}]$ into $K-1$
- * sub-intervals of size $\Delta x = (x_{K-1}-x_0)/(K-1)$, and similarly
+ * spaced tensor product mesh. In other words, considering the
+ * three-dimensional case, let there be points $x_0,\ldots, x_{K-1}$ that
+ * result from a uniform subdivision of the interval $[x_0,x_{K-1}]$ into
+ * $K-1$ sub-intervals of size $\Delta x = (x_{K-1}-x_0)/(K-1)$, and similarly
* $y_0,\ldots,y_{L-1}$, $z_1,\ldots,z_{M-1}$. Also consider data $d_{klm}$
* defined at point $(x_k,y_l,z_m)^T$, then evaluating the function at a
* point $\mathbf x=(x,y,z)$ will find the box so that $x_k\le x\le x_{k+1},
* v_1\wedge \mathbf v_2 \wedge \mathbf v_3 = (\mathbf v_1\times \mathbf
* v_2)\cdot \mathbf v_3$, where $\mathbf v_1, \mathbf v_2, \mathbf v_3$ are
* the images of the unit vectors at a vertex of the unit dim-dimensional
- * cell under transformation to the dim-dimensional cell in spacedim-
- * dimensional space. In both cases, i.e. for dim==2 or 3, the result
+ * cell under transformation to the dim-dimensional cell in
+ * spacedim-dimensional space. In both cases, i.e. for dim==2 or 3, the result
* happens to equal the determinant of the Jacobian of the mapping from
* reference cell to cell in real space. Note that it is the actual
* determinant, not its absolute value as often used in transforming
* shells around the very first cell. Note that elements in each zone may
* conflict with other elements in the same zone.
*
- * The question whether two iterators conflict is determined by a user-
- * provided function. The meaning of this function is discussed in the
+ * The question whether two iterators conflict is determined by a
+ * user-provided function. The meaning of this function is discussed in the
* documentation of the GraphColoring::make_graph_coloring() function.
*
* @param[in] begin The first element of a range of iterators for which a
* <h3>Class design: Motivation</h3>
*
* Informally, the way the C++11 standard describes <a
- * href="http://en.wikipedia.org/wiki/C%2B%2B11#Range-based_for_loop">range-
- * based for loops</a> works as follows: A <i>range-based for loop</i> of the
+ * href="http://en.wikipedia.org/wiki/C%2B%2B11#Range-based_for_loop">range-based
+ * for loops</a> works as follows: A <i>range-based for loop</i> of the
* form
* @code
* Container c;
* a call such as Triangulation::active_cell_iterators() returns an object
* that represents a <i>collection of iterators</i> of the kind <code>{begin,
* begin+1, ..., end-1}</code>. This is conveniently expressed as the half
- * open interval <code>[begin,end)</code>. The loop variable in the range-
- * based for loop would then take on each of these iterators in turn.
+ * open interval <code>[begin,end)</code>. The loop variable in the
+ * range-based for loop would then take on each of these iterators in turn.
*
*
* <h3>Class design: Implementation</h3>
private:
/**
* Internal wrapper around thread-local prefixes. This private function will
- * return the correct internal prefix stack. More important, a new thread-
- * local stack will be copied from the current stack of the "blessed" thread
- * that created this LogStream instance (usually, in the case of deallog,
- * the "main" thread).
+ * return the correct internal prefix stack. More important, a new
+ * thread-local stack will be copied from the current stack of the "blessed"
+ * thread that created this LogStream instance (usually, in the case of
+ * deallog, the "main" thread).
*/
std::stack<std::string> &
get_prefixes() const;
/**
* For this data type, alias the corresponding real type. Since the
* general template is selected for all data types that are not
- * specializations of std::complex<T>, the underlying type must be real-
- * values, so the real_type is equal to the underlying type.
+ * specializations of std::complex<T>, the underlying type must be
+ * real-values, so the real_type is equal to the underlying type.
*/
using real_type = number;
/**
* Print parameters to a logstream. This function allows to print all
- * parameters into a log-file. Sections will be indented in the usual log-
- * file style.
+ * parameters into a log-file. Sections will be indented in the usual
+ * log-file style.
*
* All current parameters and subsections are sorted
* alphabetically by default.
compute_coefficients(const unsigned int p);
/**
- * Get coefficients for constructor. This way, it can use the non-
- * standard constructor of Polynomial.
+ * Get coefficients for constructor. This way, it can use the
+ * non-standard constructor of Polynomial.
*/
static const std::vector<double> &
get_coefficients(const unsigned int p);
/**
* This class implements the <i>H<sup>div</sup></i>-conforming, vector-valued
- * Arnold-Boffi-Falk polynomials as described in the article by Arnold-Boffi-
- * Falk: Quadrilateral H(div) finite elements, SIAM J. Numer. Anal. Vol.42,
- * No.6, pp.2429-2451
+ * Arnold-Boffi-Falk polynomials as described in the article by Arnold, Boffi,
+ * and Falk: Quadrilateral H(div) finite elements, SIAM J. Numer. Anal., Vol.
+ * 42, No. 6, pp.2429-2451
*
*
* The ABF polynomials are constructed such that the divergence is in the
PolynomialsABF(const unsigned int k);
/**
- * Compute the value and the first and second derivatives of each Raviart-
- * Thomas polynomial at @p unit_point.
+ * Compute the value and the first and second derivatives of each
+ * Raviart-Thomas polynomial at @p unit_point.
*
* The size of the vectors must either be zero or equal <tt>n()</tt>. In
* the first case, the function will not compute these values.
* course is only allowed if <tt>dim>=2</tt>, and the face orientation,
* flip and rotation are ignored if the space dimension equals 2.
*
- * The last argument denotes the number of quadrature points the lower-
- * dimensional face quadrature formula (the one that has been projected
- * onto the faces) has.
+ * The last argument denotes the number of quadrature points the
+ * lower-dimensional face quadrature formula (the one that has been
+ * projected onto the faces) has.
*/
static DataSetDescriptor
face(const ReferenceCell &reference_cell,
/**
* @internal Have a class which declares some nested alias, depending
- * on its template parameters. Specialization for accessors to non-
- * constant objects.
+ * on its template parameters. Specialization for accessors to
+ * non-constant objects.
*/
template <int N, typename T>
struct Types<N, T, false>
using TableBase<3, T>::reinit;
/**
- * Access operator. Generate an object that accesses the requested two-
- * dimensional subobject of this three-dimensional table. Range checks are
+ * Access operator. Generate an object that accesses the requested
+ * two-dimensional subobject of this three-dimensional table. Range checks are
* performed.
*
* This version of the function only allows read access.
operator[](const size_type i) const;
/**
- * Access operator. Generate an object that accesses the requested two-
- * dimensional subobject of this three-dimensional table. Range checks are
- * performed.
+ * Access operator. Generate an object that accesses the requested
+ * two-dimensional subobject of this three-dimensional table. Range
+ * checks are performed.
*
* This version of the function allows read-write access.
*/
const size_type size4);
/**
- * Access operator. Generate an object that accesses the requested three-
- * dimensional subobject of this four-dimensional table. Range checks are
- * performed.
+ * Access operator. Generate an object that accesses the requested
+ * three-dimensional subobject of this four-dimensional table. Range checks
+ * are performed.
*
* This version of the function only allows read access.
*/
operator[](const size_type i) const;
/**
- * Access operator. Generate an object that accesses the requested three-
- * dimensional subobject of this four-dimensional table. Range checks are
- * performed.
+ * Access operator. Generate an object that accesses the requested
+ * three-dimensional subobject of this four-dimensional table. Range checks
+ * are performed.
*
* This version of the function allows read-write access.
*/
const size_type size5);
/**
- * Access operator. Generate an object that accesses the requested four-
- * dimensional subobject of this five-dimensional table. Range checks are
+ * Access operator. Generate an object that accesses the requested
+ * four-dimensional subobject of this five-dimensional table. Range checks are
* performed.
*
* This version of the function only allows read access.
operator[](const size_type i) const;
/**
- * Access operator. Generate an object that accesses the requested four-
- * dimensional subobject of this five-dimensional table. Range checks are
+ * Access operator. Generate an object that accesses the requested
+ * four-dimensional subobject of this five-dimensional table. Range checks are
* performed.
*
* This version of the function allows read-write access.
const size_type size6);
/**
- * Access operator. Generate an object that accesses the requested five-
- * dimensional subobject of this six-dimensional table. Range checks are
+ * Access operator. Generate an object that accesses the requested
+ * five-dimensional subobject of this six-dimensional table. Range checks are
* performed.
*
* This version of the function only allows read access.
operator[](const size_type i) const;
/**
- * Access operator. Generate an object that accesses the requested five-
- * dimensional subobject of this six-dimensional table. Range checks are
+ * Access operator. Generate an object that accesses the requested
+ * five-dimensional subobject of this six-dimensional table. Range checks are
* performed.
*
* This version of the function allows read-write access.
const size_type size7);
/**
- * Access operator. Generate an object that accesses the requested six-
- * dimensional subobject of this seven-dimensional table. Range checks are
+ * Access operator. Generate an object that accesses the requested
+ * six-dimensional subobject of this seven-dimensional table. Range checks are
* performed.
*
* This version of the function only allows read access.
operator[](const size_type i) const;
/**
- * Access operator. Generate an object that accesses the requested six-
- * dimensional subobject of this seven-dimensional table. Range checks are
+ * Access operator. Generate an object that accesses the requested
+ * six-dimensional subobject of this seven-dimensional table. Range checks are
* performed.
*
* This version of the function allows read-write access.
* @endcode
* - <code>table_with_separate_column_description</code>: This is a better
* format when there are many columns and the table as a whole can not be
- * displayed on the screen. Here, the column keys are first listed one-by-
- * one on lines of their own, and are numbered for better readability. In
- * addition, each of these description lines are prefixed by '#' to mark
+ * displayed on the screen. Here, the column keys are first listed
+ * one-by-one on lines of their own, and are numbered for better readability.
+ * In addition, each of these description lines are prefixed by '#' to mark
* these lines as comments for programs that want to read the following
* table as data and should ignore these descriptive lines. GNUPLOT is one
* such program that will automatically ignore lines so prefixed. Output
/**
* Each tensor product polynomial <i>i</i> is a product of one-dimensional
- * polynomials in each space direction. Compute the indices of these one-
- * dimensional polynomials for each space direction, given the index
+ * polynomials in each space direction. Compute the indices of these
+ * one-dimensional polynomials for each space direction, given the index
* <i>i</i>.
*/
void
/**
* Each tensor product polynomial $p_i$ is a product of one-dimensional
- * polynomials in each space direction. Compute the indices of these one-
- * dimensional polynomials for each space direction, given the index
+ * polynomials in each space direction. Compute the indices of these
+ * one-dimensional polynomials for each space direction, given the index
* <tt>i</tt>.
*/
void
* same time, the purpose of this function is to release memory other
* threads may have allocated for their own thread local objects after
* which every use of this object will require some kind of
- * initialization. This is necessary both in the multithreaded or non-
- * multithreaded case.
+ * initialization. This is necessary both in the multithreaded or
+ * non-multithreaded case.
*/
void
clear();
/**
* This method stores the vectorized arrays in transposed form into the given
* output array @p out with the given offsets @p offsets. This operation
- * corresponds to a transformation of a struct-of-array (input) into an array-
- * of-struct (output). This method operates on plain array, so no checks for
- * valid data access are made. It is the user's responsibility to ensure that
- * the given arrays are valid according to the access layout below.
+ * corresponds to a transformation of a struct-of-array (input) into an
+ * array-of-struct (output). This method operates on plain array, so no checks
+ * for valid data access are made. It is the user's responsibility to ensure
+ * that the given arrays are valid according to the access layout below.
*
* This method assumes that the specified offsets do not overlap. Otherwise,
* the behavior is undefined in the vectorized case. It is the user's
* that this function is in fact a member function of the class that
* generates the mesh, for example because it needs to access run-time
* parameters. This can be achieved as follows: assuming the
- * <code>set_boundary_ids()</code> function has been declared as a (non-
- * static, but possibly private) member function of the
+ * <code>set_boundary_ids()</code> function has been declared as a
+ * (non-static, but possibly private) member function of the
* <code>MyClass</code> class, then the following will work:
* @code
* #include <functional>
n_active_fe_indices() const;
/**
- * Return the @p n-th active FE index on this object. For cells and all non-
- * hp-objects, there is only a single active FE index, so the argument must
- * be equal to zero. For lower-dimensional hp-objects, there are
+ * Return the @p n-th active FE index on this object. For cells and all
+ * non-hp-objects, there is only a single active FE index, so the argument
+ * must be equal to zero. For lower-dimensional hp-objects, there are
* n_active_fe_indices() active finite elements, and this function can be
* queried for their indices.
*/
/**
* Return true if the finite element with given index is active on the
- * present object. When the current DoFHandler does not have hp-
- * capabilities, this is of course the case only if @p fe_index equals
+ * present object. When the current DoFHandler does not have
+ * hp-capabilities, this is of course the case only if @p fe_index equals
* zero. For cells, it is the case if @p fe_index equals active_fe_index()
* of this cell. For faces and other lower- dimensional objects, there may
* be more than one @p fe_index that are active on any given object (see
DoFAccessor();
/**
- * Constructor to be used if the object here refers to a vertex of a one-
- * dimensional triangulation, i.e. a face of the triangulation.
+ * Constructor to be used if the object here refers to a vertex of a
+ * one-dimensional triangulation, i.e. a face of the triangulation.
*
* Since there is no mapping from vertices to cells, an accessor object for
* a point has no way to figure out whether it is at the boundary of the
* If the cell is part of a DoFHandler with hp-capabilities, cells only have
* an associated finite element space if they are active. However, this
* function is supposed to also work on inactive cells with children.
- * Consequently, it carries a third argument that can be used in the hp-
- * context that denotes the finite element space we are supposed to
+ * Consequently, it carries a third argument that can be used in the
+ * hp-context that denotes the finite element space we are supposed to
* interpret the input vector of this function in. If the cell is active,
* this function then interpolates the input vector interpreted as an
* element of the space described by the <code>fe_index</code>th element of
/**
* Set the index of the FiniteElement used for this cell. This determines
* which element in an hp::FECollection to use. This function is only useful
- * if the DoF handler object associated with the current cell has hp-
- * capabilities enabled.
+ * if the DoF handler object associated with the current cell has
+ * hp-capabilities enabled.
*
* @note Since degrees of freedom only exist on active cells for DoFHandler
* objects with hp-capabilities (i.e., there is currently no implementation
* will be returned.
*
* For DoFHandlers without hp-capabilities enabled, this is of course always
- * the same element, independent of the cell we are presently on, but for hp-
- * DoFHandler objects this may change from cell to cell.
+ * the same element, independent of the cell we are presently on, but for
+ * hp-DoFHandler objects this may change from cell to cell.
*
* @note Since degrees of freedom only exist on active cells for DoFHandler
* objects with hp-capabilities (i.e., there is currently no implementation
BlockInfo block_info_object;
/**
- * Boolean indicating whether or not the current DoFHandler has hp-
- * capabilities.
+ * Boolean indicating whether or not the current DoFHandler has
+ * hp-capabilities.
*/
bool hp_capability_enabled;
* all the pressures so that the resulting matrix naturally decomposes into a
* $2\times 2$ system.
*
- * This kind of numbering may be obtained by calling the component_wise()
- * function of this class. Since it does not touch the order of indices within
- * each component, it may be worthwhile to first renumber using the Cuthill-
- * McKee or a similar algorithm and afterwards renumbering component-wise.
- * This will bring out the matrix structure and additionally have a good
- * numbering within each block.
+ * This kind of numbering may be obtained by calling the
+ * component_wise() function of this class. Since it does not touch
+ * the order of indices within each component, it may be worthwhile to
+ * first renumber using the Cuthill-McKee or a similar algorithm and
+ * afterwards renumbering component-wise. This will bring out the
+ * matrix structure and additionally have a good numbering within each
+ * block.
*
* The component_wise() function allows not only to honor enumeration based on
* vector components, but also allows to group together vector components into
* details of the generated patches. The default settings are those for
* Arnold-Falk-Winther type smoothers for divergence and curl conforming
* finite elements with essential boundary conditions. Other applications
- * are possible, in particular changing <tt>boundary_patches</tt> for non-
- * essential boundary conditions.
+ * are possible, in particular changing <tt>boundary_patches</tt> for
+ * non-essential boundary conditions.
*
* This function returns the <tt>vertex_mapping</tt>,
* that contains the mapping from the vertex indices to the block indices
* details of the generated patches. The default settings are those for
* Arnold-Falk-Winther type smoothers for divergence and curl conforming
* finite elements with essential boundary conditions. Other applications
- * are possible, in particular changing <tt>boundary_dofs</tt> for non-
- * essential boundary conditions.
+ * are possible, in particular changing <tt>boundary_dofs</tt> for
+ * non-essential boundary conditions.
*
* @arg <tt>block_list</tt>: the SparsityPattern into which the patches will
* be stored.
* components of a nonprimitive vector valued element is collected only in
* the first component. All other components will have a count of zero.
*
- * The additional optional argument @p target_component allows for a re-
- * sorting and grouping of components. To this end, it contains for each
+ * The additional optional argument @p target_component allows for a
+ * re-sorting and grouping of components. To this end, it contains for each
* component the component number it shall be counted as. Having the same
* number entered several times sums up several components as the same. One
* of the applications of this argument is when you want to form block
* module for handling the case where there are conflicting constraints on
* individual degrees of freedom.
* @param component_mask An optional component mask that restricts the
- * functionality of this function to a subset of an FESystem. For non-
- * @ref GlossPrimitive "primitive"
+ * functionality of this function to a subset of an FESystem. For
+ * non-@ref GlossPrimitive "primitive"
* shape functions, any degree of freedom is affected that belongs to a
* shape function where at least one of its nonzero components is affected
* by the component mask (see
shape_3rd_derivative(const unsigned int i, const Point<dim> &p) const;
/**
- * Just like for shape_3rd_derivative(), but this function will be called
- * when the shape function has more than one non-zero vector component. In
- * that case, this function should return the gradient of the @p component-
- * th vector component of the @p ith shape function at point @p p.
+ * Just like for shape_3rd_derivative(), but this function will be
+ * called when the shape function has more than one non-zero vector
+ * component. In that case, this function should return the gradient
+ * of the @p component-th vector component of the @p ith shape
+ * function at point @p p.
*/
virtual Tensor<3, dim>
shape_3rd_derivative_component(const unsigned int i,
/**
* Just like for shape_4th_derivative(), but this function will be called
* when the shape function has more than one non-zero vector component. In
- * that case, this function should return the gradient of the @p component-
- * th vector component of the @p ith shape function at point @p p.
+ * that case, this function should return the gradient of the
+ * @p component-th vector component of the @p ith shape function at point
+ * @p p.
*/
virtual Tensor<4, dim>
shape_4th_derivative_component(const unsigned int i,
is_primitive() const;
/**
- * Return whether the @p ith shape function is primitive in the sense that
- * the shape function is non-zero in only one vector component. Non-
- * primitive shape functions would then, for example, be those of divergence
- * free ansatz spaces, in which the individual vector components are
- * coupled.
+ * Return whether the @p ith shape function is primitive in the
+ * sense that the shape function is non-zero in only one vector
+ * component. Non-primitive shape functions would then, for example,
+ * be those of divergence free ansatz spaces, in which the
+ * individual vector components are coupled.
*
* The result of the function is @p true if and only if the result of
* <tt>n_nonzero_components(i)</tt> is equal to one.
* For a given degree of freedom, return whether it is logically associated
* with a vertex, line, quad or hex.
*
- * For instance, for continuous finite elements this coincides with the
- * lowest dimensional object the support point of the degree of freedom lies
- * on. To give an example, for $Q_1$ elements in 3d, every degree of freedom
- * is defined by a shape function that we get by interpolating using support
- * points that lie on the vertices of the cell. The support of these points
- * of course extends to all edges connected to this vertex, as well as the
- * adjacent faces and the cell interior, but we say that logically the
- * degree of freedom is associated with the vertex as this is the lowest-
- * dimensional object it is associated with. Likewise, for $Q_2$ elements in
- * 3d, the degrees of freedom with support points at edge midpoints would
- * yield a value of GeometryPrimitive::line from this function, whereas
- * those on the centers of faces in 3d would return GeometryPrimitive::quad.
+ * For instance, for continuous finite elements this coincides with
+ * the lowest dimensional object the support point of the degree of
+ * freedom lies on. To give an example, for $Q_1$ elements in 3d,
+ * every degree of freedom is defined by a shape function that we
+ * get by interpolating using support points that lie on the
+ * vertices of the cell. The support of these points of course
+ * extends to all edges connected to this vertex, as well as the
+ * adjacent faces and the cell interior, but we say that logically
+ * the degree of freedom is associated with the vertex as this is
+ * the lowest-dimensional object it is associated with. Likewise,
+ * for $Q_2$ elements in 3d, the degrees of freedom with support
+ * points at edge midpoints would yield a value of
+ * GeometryPrimitive::line from this function, whereas those on the
+ * centers of faces in 3d would return GeometryPrimitive::quad.
*
* To make this more formal, the kind of object returned by this function
* represents the object so that the support of the shape function
const bool cached_primitivity;
/**
- * Return the size of interface constraint matrices. Since this is needed in
- * every derived finite element class when initializing their size, it is
- * placed into this function, to avoid having to recompute the dimension-
- * dependent size of these matrices each time.
+ * Return the size of interface constraint matrices. Since this is
+ * needed in every derived finite element class when initializing
+ * their size, it is placed into this function, to avoid having to
+ * recompute the dimension-dependent size of these matrices each
+ * time.
*
* Note that some elements do not implement the interface constraints for
* certain polynomial degrees. In this case, this function still returns the
* last argument. This output argument is guaranteed to always be the same one
* when used with the InternalDataBase object returned by this function. In
* other words, the subdivision of scratch data and final data in the returned
- * object and the @p output_data object is as follows: If data can be pre-
- * computed on the reference cell in the exact form in which it will later
+ * object and the @p output_data object is as follows: If data can be
+ * pre-computed on the reference cell in the exact form in which it will later
* be needed on a concrete cell, then this function should already emplace
* it in the @p output_data object. An example are the values of shape
* functions at quadrature points for the usual Lagrange elements which on a
* compute. This set of flags may also include information that the finite
* element can not compute, e.g., flags that pertain to data produced by the
* mapping. An implementation of this function needs to set up all data
- * fields in the returned object that are necessary to produce the finite-
- * element related data specified by these flags, and may already pre-
- * compute part of this information as discussed above. Elements may want to
+ * fields in the returned object that are necessary to produce the
+ * finite-element related data specified by these flags, and may already
+ * pre-compute part of this information as discussed above. Elements may
+ * want to
* store these update flags (or a subset of these flags) in
* InternalDataBase::update_each so they know at the time when
* FiniteElement::fill_fe_values() is called what they are supposed to
* above. FEValues guarantees that this output object and the object
* returned by the current function will always be used together.
* @return A pointer to an object of a type derived from InternalDataBase
- * and that derived classes can use to store scratch data that can be pre-
- * computed, or for scratch arrays that then only need to be allocated once.
- * The calling site assumes ownership of this object and will delete it when
- * it is no longer necessary.
+ * and that derived classes can use to store scratch data that can be
+ * pre-computed, or for scratch arrays that then only need to be allocated
+ * once. The calling site assumes ownership of this object and will delete it
+ * when it is no longer necessary.
*/
virtual std::unique_ptr<InternalDataBase>
get_data(const UpdateFlags update_flags,
* compute. This set of flags may also include information that the finite
* element can not compute, e.g., flags that pertain to data produced by the
* mapping. An implementation of this function needs to set up all data
- * fields in the returned object that are necessary to produce the finite-
- * element related data specified by these flags, and may already pre-
- * compute part of this information as discussed above. Elements may want to
+ * fields in the returned object that are necessary to produce the
+ * finite-element related data specified by these flags, and may already
+ * pre-compute part of this information as discussed above. Elements may
+ * want to
* store these update flags (or a subset of these flags) in
* InternalDataBase::update_each so they know at the time when
* FiniteElement::fill_fe_face_values() is called what they are supposed to
* discussed above. FEValues guarantees that this output object and the
* object returned by the current function will always be used together.
* @return A pointer to an object of a type derived from InternalDataBase
- * and that derived classes can use to store scratch data that can be pre-
- * computed, or for scratch arrays that then only need to be allocated once.
- * The calling site assumes ownership of this object and will delete it when
- * it is no longer necessary.
+ * and that derived classes can use to store scratch data that can be
+ * pre-computed, or for scratch arrays that then only need to be allocated
+ * once. The calling site assumes ownership of this object and will
+ * delete it when it is no longer necessary.
*/
virtual std::unique_ptr<InternalDataBase>
get_face_data(const UpdateFlags update_flags,
* compute. This set of flags may also include information that the finite
* element can not compute, e.g., flags that pertain to data produced by the
* mapping. An implementation of this function needs to set up all data
- * fields in the returned object that are necessary to produce the finite-
- * element related data specified by these flags, and may already pre-
- * compute part of this information as discussed above. Elements may want to
+ * fields in the returned object that are necessary to produce the
+ * finite-element related data specified by these flags, and may already
+ * pre-compute part of this information as discussed above. Elements may
+ * want to
* store these update flags (or a subset of these flags) in
* InternalDataBase::update_each so they know at the time when
* FiniteElement::fill_fe_subface_values() is called what they are supposed
* discussed above. FEValues guarantees that this output object and the
* object returned by the current function will always be used together.
* @return A pointer to an object of a type derived from InternalDataBase
- * and that derived classes can use to store scratch data that can be pre-
- * computed, or for scratch arrays that then only need to be allocated once.
+ * and that derived classes can use to store scratch data that can be
+ * pre-computed, or for scratch arrays that then only need to be allocated
+ * once.
* The calling site assumes ownership of this object and will delete it when
* it is no longer necessary.
*/
*
* Note that there are situations where neither side dominates. The
* @ref hp_paper "hp-paper"
- * lists two case, with the simpler one being that a $Q_2\times Q_1$ vector-
- * valued element (i.e. a <code>FESystem(FE_Q(2),1,FE_Q(1),1)</code>) meets
- * a $Q_1\times Q_2$ element: here, for each of the two vector-components,
- * we can define a domination relationship, but it is different for the two
- * components.
+ * lists two case, with the simpler one being that a $Q_2\times Q_1$
+ * vector-valued element (i.e. a <code>FESystem(FE_Q(2),1,FE_Q(1),1)</code>)
+ * meets a $Q_1\times Q_2$ element: here, for each of the two
+ * vector-components, we can define a domination relationship, but it is
+ * different for the two components.
*
* It is clear that the concept of domination doesn't matter for
* discontinuous elements. However, discontinuous elements may be part of
/**
* Discontinuous finite elements based on Legendre polynomials.
*
- * This finite element implements complete polynomial spaces, that is, dim-
- * dimensional polynomials of degree p. For example, in 2d the element
+ * This finite element implements complete polynomial spaces, that is,
+ * dim-dimensional polynomials of degree p. For example, in 2d the element
* FE_DGP(1) would represent the span of the functions $\{1,\hat x,\hat y\}$,
* which is in contrast to the element FE_DGQ(1) that is formed by the span of
* $\{1,\hat x,\hat y,\hat x\hat y\}$. Since the DGP space has only three
/**
* Discontinuous finite elements based on monomials.
*
- * This finite element implements complete polynomial spaces, that is, dim-
- * dimensional polynomials of degree p. For example, in 2d the element
+ * This finite element implements complete polynomial spaces, that is,
+ * dim-dimensional polynomials of degree p. For example, in 2d the element
* FE_DGP(1) would represent the span of the functions $\{1,\hat x,\hat y\}$,
* which is in contrast to the element FE_DGQ(1) that is formed by the span of
* $\{1,\hat x,\hat y,\hat x\hat y\}$. Since the DGP space has only three
const unsigned int component) const override;
/**
- * Return the tensor of second derivatives of the @p ith shape function at
- * point @p p on the unit cell. The derivatives are derivatives on the unit
- * cell with respect to unit cell coordinates. Since this finite element is
- * always vector-valued, we return the value of the only non-zero component
- * of the vector value of this shape function. If the shape function has
- * more than one non-zero component (which we refer to with the term non-
- * primitive), then throw an exception of type @p
- * ExcShapeFunctionNotPrimitive.
+ * Return the tensor of second derivatives of the @p ith shape
+ * function at point @p p on the unit cell. The derivatives are
+ * derivatives on the unit cell with respect to unit cell
+ * coordinates. Since this finite element is always vector-valued,
+ * we return the value of the only non-zero component of the vector
+ * value of this shape function. If the shape function has more than
+ * one non-zero component (which we refer to with the term
+ * non-primitive), then throw an exception of type
+ * @p ExcShapeFunctionNotPrimitive.
*
* An @p ExcUnitShapeValuesDoNotExist is thrown if the shape values of the
* @p FiniteElement (corresponding to the @p ith shape function) depend on
* cell with respect to unit cell coordinates. Since this finite element is
* always vector-valued, we return the value of the only non-zero component
* of the vector value of this shape function. If the shape function has
- * more than one non-zero component (which we refer to with the term non-
- * primitive), then throw an exception of type @p
+ * more than one non-zero component (which we refer to with the term
+ * non-primitive), then throw an exception of type @p
* ExcShapeFunctionNotPrimitive.
*
* An @p ExcUnitShapeValuesDoNotExist is thrown if the shape values of the
* cell with respect to unit cell coordinates. Since this finite element is
* always vector-valued, we return the value of the only non-zero component
* of the vector value of this shape function. If the shape function has
- * more than one non-zero component (which we refer to with the term non-
- * primitive), then throw an exception of type @p
- * ExcShapeFunctionNotPrimitive.
+ * more than one non-zero component (which we refer to with the term
+ * non-primitive), then throw an exception of type
+ * @p ExcShapeFunctionNotPrimitive.
*
* An @p ExcUnitShapeValuesDoNotExist is thrown if the shape values of the
* @p FiniteElement (corresponding to the @p ith shape function) depend on
* data <tt>u<sub>q</sub>, 0 <= q < Q:=quadrature.size()</tt> defined at the
* quadrature points of a cell, with the points defined by the given
* <tt>rhs_quadrature</tt> object. We may then want to ask for that finite
- * element function (on a single cell) <tt>v<sub>h</sub></tt> in the finite-
- * dimensional space defined by the given FE object that is the projection
- * of <tt>u</tt> in the following sense:
+ * element function (on a single cell) <tt>v<sub>h</sub></tt> in the
+ * finite-dimensional space defined by the given FE object that is the
+ * projection of <tt>u</tt> in the following sense:
*
* Usually, the projection <tt>v<sub>h</sub></tt> is that function that
* satisfies <tt>(v<sub>h</sub>,w)=(u,w)</tt> for all discrete test
* The first one is that it really only makes sense to project onto a finite
* element that has at most as many degrees of freedom per cell as there are
* quadrature points; the projection of N quadrature point data into a space
- * with M>N unknowns is well-defined, but often yields funny and non-
- * intuitive results. Secondly, one would think that if the quadrature point
- * data is defined in the support points of the finite element, i.e. the
+ * with M>N unknowns is well-defined, but often yields funny and
+ * non-intuitive results. Secondly, one would think that if the quadrature
+ * point data is defined in the support points of the finite element, i.e. the
* quadrature points of <tt>rhs_quadrature</tt> equal
* <tt>fe.get_unit_support_points()</tt>, then the projection should be the
* identity, i.e. each degree of freedom of the finite element equals the
* The format of the @p name parameter should include the name of a finite
* element. However, it is safe to use either the class name alone or to use
* the result of FiniteElement::get_name (which includes the space dimension
- * as well as the polynomial degree), since everything after the first non-
- * name character will be ignored.
+ * as well as the polynomial degree), since everything after the first
+ * non-name character will be ignored.
*
* The FEFactory object should be an object newly created with <tt>new</tt>.
* FETools will take ownership of this object and delete it once it is not
* set of functions as above, except that for vector valued finite elements
* they return only one vector component. This is useful for elements of which
* shape functions have more than one non-zero component, since then the above
- * functions cannot be used, and you have to walk over all (or only the non-
- * zero) components of the shape function using this set of functions.
+ * functions cannot be used, and you have to walk over all (or only the
+ * non-zero) components of the shape function using this set of functions.
*
* <li> get_function_values(), get_function_gradients(), etc.: Compute a
* finite element function or its derivative in quadrature points.
* subface selected the last time the <tt>reinit</tt> function of the
* derived class was called.
*
- * If the shape function is vector-valued, then this returns the only non-
- * zero component. If the shape function has more than one non-zero
+ * If the shape function is vector-valued, then this returns the only
+ * non-zero component. If the shape function has more than one non-zero
* component (i.e. it is not primitive), then throw an exception of type
* ExcShapeFunctionNotPrimitive. In that case, use the
* shape_value_component() function.
* reference to the gradient's value is returned, there should be no major
* performance drawback.
*
- * If the shape function is vector-valued, then this returns the only non-
- * zero component. If the shape function has more than one non-zero
+ * If the shape function is vector-valued, then this returns the only
+ * non-zero component. If the shape function has more than one non-zero
* component (i.e. it is not primitive), then it will throw an exception of
* type ExcShapeFunctionNotPrimitive. In that case, use the
* shape_grad_component() function.
* one component. Since only a reference to the hessian values is returned,
* there should be no major performance drawback.
*
- * If the shape function is vector-valued, then this returns the only non-
- * zero component. If the shape function has more than one non-zero
+ * If the shape function is vector-valued, then this returns the only
+ * non-zero component. If the shape function has more than one non-zero
* component (i.e. it is not primitive), then throw an exception of type
* ExcShapeFunctionNotPrimitive. In that case, use the
* shape_hessian_component() function.
* to extract one component. Since only a reference to the 3rd derivative
* values is returned, there should be no major performance drawback.
*
- * If the shape function is vector-valued, then this returns the only non-
- * zero component. If the shape function has more than one non-zero
+ * If the shape function is vector-valued, then this returns the only
+ * non-zero component. If the shape function has more than one non-zero
* component (i.e. it is not primitive), then throw an exception of type
* ExcShapeFunctionNotPrimitive. In that case, use the
* shape_3rdderivative_component() function.
/**
* This function does the same as the other
- * get_function_third_derivatives(), but applied to multi-component (vector-
- * valued) elements. The meaning of the arguments is as explained there.
+ * get_function_third_derivatives(), but applied to multi-component
+ * (vector-valued) elements. The meaning of the arguments is as explained
+ * there.
*
* @post <code>third_derivatives[q]</code> is a vector of third derivatives
* of the field described by fe_function at the $q$th quadrature point. The
/**
- * Extractor for a vector of <code>spacedim</code> components of a vector-
- * valued element. The value of <code>spacedim</code> is defined by the
+ * Extractor for a vector of <code>spacedim</code> components of a
+ * vector-valued element. The value of <code>spacedim</code> is defined by the
* FEValues object the extractor is applied to. The result of applying an
* object of this type to an FEValues, FEFaceValues or FESubfaceValues
* object is of type FEValuesViews::Vector.
/**
* Extractor for a symmetric tensor of a rank specified by the template
* argument. For a second order symmetric tensor, this represents a
- * collection of <code>(dim*dim + dim)/2</code> components of a vector-
- * valued element. The value of <code>dim</code> is defined by the FEValues
+ * collection of <code>(dim*dim + dim)/2</code> components of a vector-valued
+ * element. The value of <code>dim</code> is defined by the FEValues
* object the extractor is applied to. The result of applying an object of
* this type to an FEValues, FEFaceValues or FESubfaceValues object is of
* type FEValuesViews::SymmetricTensor.
* - To provide scratch space for computations that are done in
* Mapping::fill_fe_values() and similar functions. Some of the derived
* classes would like to use scratch arrays and it would be a waste of time
- * to allocate these arrays every time this function is called, just to de-
- * allocate it again at the end of the function. Rather, one could allocate
+ * to allocate these arrays every time this function is called, just to
+ * de-allocate it again at the end of the function. Rather, one could allocate
* this memory once as a member variable of the current class, and simply
* use it in Mapping::fill_fe_values().
* - After calling Mapping::fill_fe_values(), FEValues::reinit()
* interface of mappings with the FEValues class).
*
* Derived classes will return pointers to objects of a type derived from
- * Mapping::InternalDataBase (see there for more information) and may pre-
- * compute some information already (in accordance with what will be asked
+ * Mapping::InternalDataBase (see there for more information) and may
+ * pre-compute some information already (in accordance with what will be asked
* of the mapping in the future, as specified by the update flags) and for
* the given quadrature object. Subsequent calls to transform() or
* fill_fe_values() and friends will then receive back the object created
* all boundary vertices (although you then lose control over the exact
* shape of the mapped domain).
*
- * @param[in,out] tria The Triangulation object. This object is changed in-
- * place, i.e., the previous locations of vertices are overwritten.
+ * @param[in,out] tria The Triangulation object. This object is changed
+ * in-place, i.e., the previous locations of vertices are overwritten.
*
* @param[in] coefficient An optional coefficient for the Laplace problem.
* Larger values make cells less prone to deformation (effectively
/**
* This class handles the history of a triangulation and can rebuild it after
- * it was deleted some time before. Its main purpose is support for time-
- * dependent problems where one frequently deletes a triangulation due to
+ * it was deleted some time before. Its main purpose is support for
+ * time-dependent problems where one frequently deletes a triangulation due to
* memory pressure and later wants to rebuild it; this class has all the
* information to rebuild it exactly as it was before including the mapping of
* cell numbers to the geometrical cells.
* previous_cell = Triangulation<dim>::active_cell_iterator();
* }
* @endcode
- * Here, whenever the triangulation is refined, it triggers the post-
- * refinement signal which calls the function object attached to it. This
+ * Here, whenever the triangulation is refined, it triggers the
+ * post-refinement signal which calls the function object attached to it. This
* function object is the member function
* <code>FEValues<dim>::invalidate_previous_cell</code> where we have bound
* the single argument (the <code>this</code> pointer of a member function
enum MeshSmoothing
{
/**
- * No mesh smoothing at all, except that meshes have to remain one-
- * irregular.
+ * No mesh smoothing at all, except that meshes have to remain
+ * one-irregular.
*/
none = 0x0,
/**
/**
* Return an iterator range that contains all cells (active or not) that
- * make up this triangulation. Such a range is useful to initialize range-
- * based for loops as supported by C++11. See the example in the
+ * make up this triangulation. Such a range is useful to initialize
+ * range-based for loops as supported by C++11. See the example in the
* documentation of active_cell_iterators().
*
* @return The half open range <code>[this->begin(), this->end())</code>
public:
/**
* Dimension of the space the object represented by this accessor lives in.
- * For example, if this accessor represents a quad that is part of a two-
- * dimensional surface in four-dimensional space, then this value is four.
+ * For example, if this accessor represents a quad that is part of a
+ * two-dimensional surface in four-dimensional space, then this value is four.
*/
static constexpr unsigned int space_dimension = spacedim;
public:
/**
* Dimension of the space the object represented by this accessor lives in.
- * For example, if this accessor represents a quad that is part of a two-
- * dimensional surface in four-dimensional space, then this value is four.
+ * For example, if this accessor represents a quad that is part of a
+ * two-dimensional surface in four-dimensional space, then this value is four.
*/
static constexpr unsigned int space_dimension = spacedim;
set_manifold_id(const types::manifold_id);
/**
- * Set the boundary indicator of this object and all of its lower-
- * dimensional sub-objects. Since this object only represents a single
+ * Set the boundary indicator of this object and all of its
+ * lower-dimensional sub-objects. Since this object only represents a single
* vertex, there are no lower-dimensional object and this function is
* equivalent to calling set_boundary_id() with the same argument.
*
set_all_boundary_ids(const types::boundary_id) const;
/**
- * Set the manifold indicator of this object and all of its lower-
- * dimensional sub-objects. Since this object only represents a single
+ * Set the manifold indicator of this object and all of its
+ * lower-dimensional sub-objects. Since this object only represents a single
* vertex, there are no lower-dimensional object and this function is
* equivalent to calling set_manifold_id() with the same argument.
*
set_material_id(const types::material_id new_material_id) const;
/**
- * Set the material id of this cell and all its children (and grand-
- * children, and so on) to the given value.
+ * Set the material id of this cell and all its children (and
+ * grand-children, and so on) to the given value.
*
* See the
* @ref GlossMaterialId "glossary"
* This function essentially exists to allow adding several constraints of
* the form <i>x<sub>i</sub></i>=0 all at once, where the set of indices
* <i>i</i> for which these constraints should be added are given by the
- * argument of this function. On the other hand, just as if the single-
- * argument add_line() function were called repeatedly, the constraints can
- * later be modified to include linear dependencies using the add_entry()
+ * argument of this function. On the other hand, just as if the
+ * single-argument add_line() function were called repeatedly, the constraints
+ * can later be modified to include linear dependencies using the add_entry()
* function as well as inhomogeneities using set_inhomogeneity().
*/
void
* This function essentially exists to allow adding several constraints of
* the form <i>x<sub>i</sub></i>=0 all at once, where the set of indices
* <i>i</i> for which these constraints should be added are given by the
- * argument of this function. On the other hand, just as if the single-
- * argument add_line() function were called repeatedly, the constraints can
- * later be modified to include linear dependencies using the add_entry()
+ * argument of this function. On the other hand, just as if the
+ * single-argument add_line() function were called repeatedly, the constraints
+ * can later be modified to include linear dependencies using the add_entry()
* function as well as inhomogeneities using set_inhomogeneity().
*/
void
* This function essentially exists to allow adding several constraints of
* the form <i>x<sub>i</sub></i>=0 all at once, where the set of indices
* <i>i</i> for which these constraints should be added are given by the
- * argument of this function. On the other hand, just as if the single-
- * argument add_line() function were called repeatedly, the constraints can
- * later be modified to include linear dependencies using the add_entry()
+ * argument of this function. On the other hand, just as if the
+ * single-argument add_line() function were called repeatedly, the constraints
+ * can later be modified to include linear dependencies using the add_entry()
* function as well as inhomogeneities using set_inhomogeneity().
*/
void
max_constraint_indirections() const;
/**
- * Return <tt>true</tt> in case the dof is constrained and there is a non-
- * trivial inhomogeneous values set to the dof.
+ * Return <tt>true</tt> in case the dof is constrained and there is a
+ * non-trivial inhomogeneous values set to the dof.
*/
bool
is_inhomogeneously_constrained(const size_type index) const;
* matrix to indices into the subobjects. You *must* call this function each
* time after you have changed the size of the sub-objects.
*
- * Derived classes should call this function whenever the size of the sub-
- * objects has changed and the @p X_block_indices arrays need to be updated.
+ * Derived classes should call this function whenever the size of the
+ * sub-objects has changed and the @p X_block_indices arrays need to be updated.
*
* Note that this function is not public since not all derived classes need
* to export its interface. For example, for the usual deal.II SparseMatrix
* latter tells the matrix how many nonzero elements there need to be
* reserved.
*
- * Basically, this function only calls SparseMatrix::reinit() of the sub-
- * matrices with the block sparsity patterns of the parameter.
+ * Basically, this function only calls SparseMatrix::reinit() of the
+ * sub-matrices with the block sparsity patterns of the parameter.
*
* You have to make sure that the lifetime of the sparsity structure is at
* least as long as that of this matrix or as long as reinit(const
/**
* Return whether the object is empty. It is empty if no memory is
* allocated, which is the same as that both dimensions are zero. This
- * function is just the concatenation of the respective call to all sub-
- * matrices.
+ * function is just the concatenation of the respective call to all
+ * sub-matrices.
*/
bool
empty() const;
/**
* Return number of columns of this matrix, which equals the dimension of
- * the domain space. It is the sum of the number of columns over the sub-
- * matrix blocks of this matrix. Recall that the matrix is of size m() times
- * n().
+ * the domain space. It is the sum of the number of columns over the
+ * sub-matrix blocks of this matrix. Recall that the matrix is of size m()
+ * times n().
*/
size_type
n() const;
/**
* Return whether the object is empty. It is empty if no memory is
* allocated, which is the same as that both dimensions are zero. This
- * function is just the concatenation of the respective call to all sub-
- * matrices.
+ * function is just the concatenation of the respective call to all
+ * sub-matrices.
*/
bool
empty() const;
/**
* Return number of columns of this matrix, which equals the dimension of
- * the range space. It is the sum of columns of the (block-)columns of sub-
- * matrices.
+ * the range space. It is the sum of columns of the (block-)columns of
+ * sub-matrices.
*/
using SparsityPatternBase::n_cols;
/**
- * Return whether the structure is compressed or not, i.e. whether all sub-
- * matrices are compressed.
+ * Return whether the structure is compressed or not, i.e. whether all
+ * sub-matrices are compressed.
*/
bool
is_compressed() const;
update_ghost_values() const;
/**
- * Initiates communication for the @p compress() function with non-
- * blocking communication. This function does not wait for the transfer
- * to finish, in order to allow for other computations during the time
- * it takes until all data arrives.
+ * Initiates communication for the @p compress() function with
+ * non-blocking communication. This function does not wait for the
+ * transfer to finish, in order to allow for other computations during the
+ * time it takes until all data arrives.
*
* Before the data is actually exchanged, the function must be followed
* by a call to @p compress_finish().
* This function collects the sizes of the sub-objects and stores them
* in internal arrays, in order to be able to relay global indices into
* the matrix to indices into the subobjects. You *must* call this
- * function each time after you have changed the size of the sub-
- * objects.
+ * function each time after you have changed the size of the sub-objects.
*/
void
collect_sizes();
* This function collects the sizes of the sub-objects and stores them
* in internal arrays, in order to be able to relay global indices into
* the vector to indices into the subobjects. You *must* call this
- * function each time after you have changed the size of the sub-
- * objects.
+ * function each time after you have changed the size of the sub-objects.
*/
void
collect_sizes();
* PreconditionBlock, since the index sets may be arbitrary and overlapping,
* while there only contiguous, disjoint sets of equal size are allowed. As a
* drawback, this class cannot be used as a preconditioner, since its
- * implementation relies on a straight forward implementation of the Gauss-
- * Seidel process.
+ * implementation relies on a straight forward implementation of the
+ * Gauss-Seidel process.
*
* Parallel computations require you to specify an initialized
* ghost vector in AdditionalData::temp_ghost_vector.
* rendering its behavior constant.
*
* Further examples of this functionality can be found in the test-suite, such
- * as <code>tests/lac/schur_complement_01.cc</code> . The solution of a multi-
- * component problem (namely step-22) using the schur_complement can be found
- * in <code>tests/lac/schur_complement_03.cc</code> .
+ * as <code>tests/lac/schur_complement_01.cc</code>. The solution of a
+ * multi-component problem (namely step-22) using the schur_complement can be
+ * found in <code>tests/lac/schur_complement_03.cc</code>.
*
* @see
* @ref GlossBlockLA "Block (linear algebra)"
*
* Note that the minimizing property of GMRes only pertains to the Krylov
* space spanned by the Arnoldi basis. Therefore, restarted GMRes is
- * <b>not</b> minimizing anymore. The choice of the basis length is a trade-
- * off between memory consumption and convergence speed, since a longer basis
- * means minimization over a larger space.
+ * <b>not</b> minimizing anymore. The choice of the basis length is a
+ * trade-off between memory consumption and convergence speed, since a longer
+ * basis means minimization over a larger space.
*
* For the requirements on matrices and vectors in order to work with this
* class, see the documentation of the Solver base class.
* sparsity pattern of the decomposition is a superset of the sparsity pattern
* in the original matrix.
*
- * Such fill-in can be accomplished by various ways, one of which is the copy-
- * constructor of the SparsityPattern class that allows the addition of side-
- * diagonals to a given sparsity structure.
+ * Such fill-in can be accomplished by various ways, one of which is the
+ * copy-constructor of the SparsityPattern class that allows the addition of
+ * side-diagonals to a given sparsity structure.
*
*
* <h3>Unified use of preconditioners</h3>
/**
- * Apply the transpose of the incomplete decomposition, i.e. do one forward-
- * backward step $dst=(LU)^{-T}src$.
+ * Apply the transpose of the incomplete decomposition, i.e. do one
+ * forward-backward step $dst=(LU)^{-T}src$.
*
* The initialize() function needs to be called before.
*/
* Return the $l_1$-norm of the matrix, that is $|M|_1=\max_{\mathrm{all\
* columns\ }j}\sum_{\mathrm{all\ rows\ } i} |M_{ij}|$, (max. sum of
* columns). This is the natural matrix norm that is compatible to the
- * $l_1$-norm for vectors, i.e. $|Mv|_1\leq |M|_1 |v|_1$. (cf. Haemmerlin-
- * Hoffmann: Numerische Mathematik)
+ * $l_1$-norm for vectors, i.e. $|Mv|_1\leq |M|_1 |v|_1$. (cf.
+ * Haemmerlin-Hoffmann: Numerische Mathematik)
*/
real_type
l1_norm() const;
vmult(Vector<somenumber> &dst, const Vector<somenumber> &src) const;
/**
- * Apply the transpose of the incomplete decomposition, i.e. do one forward-
- * backward step $dst=(LU)^{-1}src$.
+ * Apply the transpose of the incomplete decomposition, i.e. do one
+ * forward-backward step $dst=(LU)^{-1}src$.
*
* Call @p initialize before calling this function.
*
* Splitting the matrix into blocks is always done in a way such that the
* blocks are not necessarily of equal size, but such that the number of
* selected degrees of freedom for which a local system is to be solved is
- * equal between blocks. The reason for this strategy to subdivision is load-
- * balancing for multithreading. There are several possibilities to actually
- * split the matrix into blocks, which are selected by the flag @p
+ * equal between blocks. The reason for this strategy to subdivision is
+ * load-balancing for multithreading. There are several possibilities to
+ * actually split the matrix into blocks, which are selected by the flag @p
* blocking_strategy that is passed to the constructor. By a block, we will in
* the sequel denote a list of indices of degrees of freedom; the algorithm
* will work on each block separately, i.e. the solutions of the local systems
*
* This constructs objects intended for the application of the ILU(n)-method
* or other incomplete decompositions. Therefore, additional to the
- * original entry structure, space for <tt>extra_off_diagonals</tt> side-
- * diagonals is provided on both sides of the main diagonal.
+ * original entry structure, space for <tt>extra_off_diagonals</tt>
+ * side-diagonals is provided on both sides of the main diagonal.
*
* <tt>max_per_row</tt> is the maximum number of nonzero elements per row
* which this structure is to hold. It is assumed that this number is
* will usually want to give the same number as you gave for
* <tt>original</tt> plus the number of side diagonals times two. You may
* however give a larger value if you wish to add further nonzero entries
- * for the decomposition based on other criteria than their being on side-
- * diagonals.
+ * for the decomposition based on other criteria than their being on
+ * side-diagonals.
*
* This function requires that <tt>original</tt> refers to a quadratic
* matrix structure. It must be compressed. The matrix structure is not
* then queried from the input vector. Note that you should not write to
* the resulting vector any more, since the some data can be stored
* several times on different processors, leading to unpredictable
- * results. In particular, such a vector cannot be used for matrix-
- * vector products as for example done during the solution of linear
- * systems.
+ * results. In particular, such a vector cannot be used for
+ * matrix-vector products as for example done during the solution of
+ * linear systems.
*/
void
import_nonlocal_data_for_fe(const TrilinosWrappers::BlockSparseMatrix &m,
/**
* This specifies the minimum value the diagonal elements should have.
* This might be necessary when the Jacobi preconditioner is used on
- * matrices with zero diagonal elements. In that case, a straight-
- * forward application would not be possible since we would divide by
- * zero.
+ * matrices with zero diagonal elements. In that case, a
+ * straight-forward application would not be possible since we would
+ * divide by zero.
*/
double min_diagonal;
* setting the parameter <tt>min_diagonal</tt> to a small nonzero value
* the SOR will work on a matrix that is not too far away from the one we
* want to treat. Finally, <tt>overlap</tt> governs the overlap of the
- * partitions when the preconditioner runs in parallel, forming a so-
- * called additive Schwarz preconditioner.
+ * partitions when the preconditioner runs in parallel, forming a
+ * so-called additive Schwarz preconditioner.
*/
struct AdditionalData
{
/**
* This specifies the minimum value the diagonal elements should have.
* This might be necessary when the SSOR preconditioner is used on
- * matrices with zero diagonal elements. In that case, a straight-
- * forward application would not be possible since we divide by the
- * diagonal element.
+ * matrices with zero diagonal elements. In that case, a
+ * straight-forward application would not be possible since we divide by
+ * the diagonal element.
*/
double min_diagonal;
* setting the parameter <tt>min_diagonal</tt> to a small nonzero value
* the SOR will work on a matrix that is not too far away from the one we
* want to treat. Finally, <tt>overlap</tt> governs the overlap of the
- * partitions when the preconditioner runs in parallel, forming a so-
- * called additive Schwarz preconditioner.
+ * partitions when the preconditioner runs in parallel, forming a
+ * so-called additive Schwarz preconditioner.
*/
struct AdditionalData
{
/**
* This specifies the minimum value the diagonal elements should have.
* This might be necessary when the SOR preconditioner is used on
- * matrices with zero diagonal elements. In that case, a straight-
- * forward application would not be possible since we divide by the
- * diagonal element.
+ * matrices with zero diagonal elements. In that case, a
+ * straight-forward application would not be possible since we divide by
+ * the diagonal element.
*/
double min_diagonal;
/**
* This specifies the minimum value the diagonal elements should have.
* This might be necessary when the block Jacobi preconditioner is used
- * on matrices with zero diagonal elements. In that case, a straight-
- * forward application would not be possible since we divide by the
- * diagonal element.
+ * on matrices with zero diagonal elements. In that case, a
+ * straight-forward application would not be possible since we divide by
+ * the diagonal element.
*/
double min_diagonal;
/**
* A wrapper class for a block SSOR preconditioner for Trilinos matrices. As
- * opposed to PreconditionSSOR where each row is treated separately (point-
- * wise), this scheme collects block of a given size and inverts a full
+ * opposed to PreconditionSSOR where each row is treated separately
+ * (point-wise), this scheme collects block of a given size and inverts a full
* matrix for all these rows simultaneously. Trilinos allows to select
* several strategies for selecting which rows form a block, including
* "linear" (i.e., divide the local range of the matrix in slices of the
/**
* This specifies the minimum value the diagonal elements should have.
* This might be necessary when the SSOR preconditioner is used on
- * matrices with zero diagonal elements. In that case, a straight-
- * forward application would not be possible since we divide by the
- * diagonal element.
+ * matrices with zero diagonal elements. In that case, a
+ * straight-forward application would not be possible since we divide by
+ * the diagonal element.
*/
double min_diagonal;
/**
* This specifies the minimum value the diagonal elements should have.
* This might be necessary when the SOR preconditioner is used on
- * matrices with zero diagonal elements. In that case, a straight-
- * forward application would not be possible since we divide by the
- * diagonal element.
+ * matrices with zero diagonal elements. In that case, a
+ * straight-forward application would not be possible since we divide by
+ * the diagonal element.
*/
double min_diagonal;
* lets the user specify which elements should be dropped (i.e., should not
* be part of the incomplete decomposition). Trilinos calculates first the
* complete factorization for one row, and then skips those elements that
- * are lower than the threshold. This is the main difference to the non-
- * thresholded ILU preconditioner, where the parameter <tt>ilut_fill</tt>
+ * are lower than the threshold. This is the main difference to the
+ * non-thresholded ILU preconditioner, where the parameter <tt>ilut_fill</tt>
* governs the incomplete factorization structure. This parameter is
* available here as well, but provides only some extra information here.
*
public:
/**
* Standardized data struct to pipe additional parameters to the
- * preconditioner. The Trilinos ILU-T decomposition allows for some fill-
- * in, so it actually is a threshold incomplete LU factorization. The
+ * preconditioner. The Trilinos ILU-T decomposition allows for some
+ * fill-in, so it actually is a threshold incomplete LU factorization. The
* amount of fill-in, and hence, the amount of memory used by this
* preconditioner, is controlled by the parameters <tt>ilut_drop</tt> and
* <tt>ilut_fill</tt>, which specifies a threshold about which values
* processors.
*
* For proper functionality of this class we recommend using Trilinos v9.0
- * and higher. Older versions may have problems with generating the coarse-
- * matrix structure when using matrices with many nonzero entries per row
- * (i.e., matrices stemming from higher order finite element
+ * and higher. Older versions may have problems with generating the
+ * coarse-matrix structure when using matrices with many nonzero entries per
+ * row (i.e., matrices stemming from higher order finite element
* discretizations).
*
* @ingroup TrilinosWrappers
/**
* Determines whether the AMG preconditioner should be optimized for
* elliptic problems (ML option smoothed aggregation SA, using a
- * Chebyshev smoother) or for non-elliptic problems (ML option non-
- * symmetric smoothed aggregation NSSA, smoother is SSOR with
+ * Chebyshev smoother) or for non-elliptic problems (ML option
+ * non-symmetric smoothed aggregation NSSA, smoother is SSOR with
* underrelaxation).
*/
bool elliptic;
/**
* Determines whether the AMG preconditioner should be optimized for
* elliptic problems (MueLu option smoothed aggregation SA, using a
- * Chebyshev smoother) or for non-elliptic problems (MueLu option non-
- * symmetric smoothed aggregation NSSA, smoother is SSOR with
+ * Chebyshev smoother) or for non-elliptic problems (MueLu option
+ * non-symmetric smoothed aggregation NSSA, smoother is SSOR with
* underrelaxation).
*/
bool elliptic;
* actual matrix structure has more nonzero entries than specified in the
* constructor. However it is still advantageous to provide good estimates
* here since this will considerably increase the performance of the
- * matrix setup. However, there is no effect in the performance of matrix-
- * vector products, since Trilinos reorganizes the matrix memory prior to
- * use (in the compress() step).
+ * matrix setup. However, there is no effect in the performance of
+ * matrix-vector products, since Trilinos reorganizes the matrix memory
+ * prior to use (in the compress() step).
*/
SparseMatrix(const IndexSet ¶llel_partitioning,
const MPI_Comm communicator = MPI_COMM_WORLD,
* </ul>
*
* In both cases, this function compresses the data structures and allows
- * the resulting matrix to be used in all other operations like matrix-
- * vector products. This is a collective operation, i.e., it needs to be
- * run on all processors when used in %parallel.
+ * the resulting matrix to be used in all other operations like
+ * matrix-vector products. This is a collective operation, i.e., it needs to
+ * be run on all processors when used in %parallel.
*
* See
* @ref GlossCompress "Compressing distributed objects"
* that all elements of one row are accessed before the elements of the
* next row. If your algorithm relies on visiting elements within one row,
* you will need to consult with the Trilinos documentation on the order
- * in which it stores data. It is, however, generally not a good and long-
- * term stable idea to rely on the order in which receive elements if you
- * iterate over them.
+ * in which it stores data. It is, however, generally not a good and
+ * long-term stable idea to rely on the order in which receive elements if
+ * you iterate over them.
*
* When you iterate over the elements of a parallel matrix, you will only
* be able to access the locally owned rows. (You can access the other
* that all elements of one row are accessed before the elements of the
* next row. If your algorithm relies on visiting elements within one row,
* you will need to consult with the Trilinos documentation on the order
- * in which it stores data. It is, however, generally not a good and long-
- * term stable idea to rely on the order in which receive elements if you
- * iterate over them.
+ * in which it stores data. It is, however, generally not a good and
+ * long-term stable idea to rely on the order in which receive elements if
+ * you iterate over them.
*
* @note When you access the elements of a parallel matrix, you can only
* access the elements of rows that are actually stored locally. (You can
std::unique_ptr<Epetra_FECrsMatrix> matrix;
/**
- * A sparse matrix object in Trilinos to be used for collecting the non-
- * local elements if the matrix was constructed from a Trilinos sparsity
+ * A sparse matrix object in Trilinos to be used for collecting the
+ * non-local elements if the matrix was constructed from a Trilinos sparsity
* pattern with the respective option.
*/
std::unique_ptr<Epetra_CrsMatrix> nonlocal_matrix;
const std::vector<size_type> &n_entries_per_row);
/**
- * This constructor constructs general sparsity patterns, possible non-
- * square ones. Constructing a sparsity pattern this way allows the user
+ * This constructor constructs general sparsity patterns, possible
+ * non-square ones. Constructing a sparsity pattern this way allows the user
* to explicitly specify the rows into which we are going to add elements.
* This set is required to be a superset of the first index set @p
* row_parallel_partitioning that includes also rows that are owned by
const size_type n_entries_per_row = 0);
/**
- * This reinit function is used to specify general matrices, possibly non-
- * square ones. In addition to the arguments of the other reinit method
+ * This reinit function is used to specify general matrices, possibly
+ * non-square ones. In addition to the arguments of the other reinit method
* above, it allows the user to explicitly specify the rows into which we
* are going to add elements. This set is a superset of the first index
* set @p row_parallel_partitioning that includes also rows that are owned
/**
* Return a const reference to the underlying Trilinos Epetra_Map that
* sets the partitioning of the range space of this sparsity pattern,
- * i.e., the partitioning of the vectors that are result from matrix-
- * vector products.
+ * i.e., the partitioning of the vectors that are result from
+ * matrix-vector products.
*/
const Epetra_Map &
range_partitioner() const;
* then queried from the input vector. Note that you should not write to
* the resulting vector any more, since the some data can be stored
* several times on different processors, leading to unpredictable
- * results. In particular, such a vector cannot be used for matrix-
- * vector products as for example done during the solution of linear
- * systems.
+ * results. In particular, such a vector cannot be used for
+ * matrix-vector products as for example done during the solution of
+ * linear systems.
*/
void
import_nonlocal_data_for_fe(
* then it is possible to add data from a vector that uses a different
* map, i.e., a vector whose elements are split across processors
* differently. This may include vectors with ghost elements, for example.
- * In general, however, adding vectors with a different element-to-
- * processor map requires communicating data among processors and,
- * consequently, is a slower operation than when using vectors using the
- * same map.
+ * In general, however, adding vectors with a different
+ * element-to-processor map requires communicating data among processors
+ * and, consequently, is a slower operation than when using vectors using
+ * the same map.
*/
void
add(const Vector &V, const bool allow_different_maps = false);
clear();
/**
- * Return the FE index for a given finite element degree. If not in hp-
- * mode, this function always returns index 0. If an index is not found
+ * Return the FE index for a given finite element degree. If not in
+ * hp-mode, this function always returns index 0. If an index is not found
* in hp-mode, it returns numbers::invalid_unsigned_int.
*/
unsigned int
std::vector<unsigned int> cell_active_fe_index;
/**
- * Stores the maximum degree of different finite elements for the hp-
- * case.
+ * Stores the maximum degree of different finite elements for the
+ * hp-case.
*/
unsigned int max_fe_index;
* Return a read-only pointer to the first field of function hessians on
* quadrature points. First comes the xx-component of the hessian for the
* first component on all quadrature points, then the yy-component,
- * zz-component in (3d), then the xy-component, and so on. Next comes the xx-
- * component of the second component, and so on. This is related to the
+ * zz-component in (3d), then the xy-component, and so on. Next comes the
+ * xx-component of the second component, and so on. This is related to the
* internal data structures used in this class. The raw data after a call to
* @p evaluate only contains unit cell operations, so possible
* transformations, quadrature weights etc. must be applied manually. In
AlignedVector<Number> shape_values_eo;
/**
- * Stores the shape gradients in a different format, namely the so-
- * called even-odd scheme where the symmetries in shape_gradients are
+ * Stores the shape gradients in a different format, namely the
+ * so-called even-odd scheme where the symmetries in shape_gradients are
* used for faster evaluation.
*/
AlignedVector<Number> shape_gradients_eo;
* Initializes the data fields. Takes a one-dimensional quadrature
* formula and a finite element as arguments and evaluates the shape
* functions, gradients and Hessians on the one-dimensional unit cell.
- * This function assumes that the finite element is derived from a one-
- * dimensional element by a tensor product and that the zeroth shape
+ * This function assumes that the finite element is derived from a
+ * one-dimensional element by a tensor product and that the zeroth shape
* function in zero evaluates to one.
*/
template <int dim, int spacedim, int dim_q>
*
* The strategy is based on a two-level approach. The outer level is
* subdivided into partitions similar to the type of neighbors in
- * Cuthill-McKee, and the inner level is again subdivided into Cuthill-
- * McKee-like partitions (partitions whose level differs by more than 2
- * can be worked on independently). One task is represented by a chunk
- * of cells. The cell chunks are formed after subdivision into the two
- * levels of partitions.
+ * Cuthill-McKee, and the inner level is again subdivided into
+ * Cuthill-McKee-like partitions (partitions whose level differs by more
+ * than 2 can be worked on independently). One task is represented by a
+ * chunk of cells. The cell chunks are formed after subdivision into the
+ * two levels of partitions.
*
* @param cell_active_fe_index The active FE index corresponding to the
* individual indices in the list of all cell indices, in order to be
* is performed. This is a typical scenario in
* FEFaceEvaluation::evaluate() calls. If false,
* data from n_rows^(dim-1) points is expanded
- * into the n_rows^dim points of the higher-
- * dimensional data array. Derivatives in the
- * case contract_onto_face==false are summed
- * together.
+ * into the n_rows^dim points of the
+ * higher-dimensional data array. Derivatives in
+ * the case contract_onto_face==false are summed together.
* @tparam add If true, the result is added to the output vector, else
* the computed values overwrite the content in the output.
* @tparam max_derivative Sets the number of derivatives that should be
hp::QCollection<dim - 1> face_quadrature_collection;
/**
- * Boolean indicating whether or not the current ScratchData has hp-
- * capabilities.
+ * Boolean indicating whether or not the current ScratchData has
+ * hp-capabilities.
*/
bool hp_capability_enabled;
{
public:
/**
- * Constructor. Arguments are the multigrid object, pre-smoother, post-
- * smoother and coarse grid solver.
+ * Constructor. Arguments are the multigrid object, pre-smoother,
+ * post-smoother and coarse grid solver.
*/
PreconditionMG(const DoFHandler<dim> &dof_handler,
Multigrid<VectorType> &mg,
* tri)quadratic elements, then what is written into the output file is just
* a (bi-, tri)linear interpolation onto the current mesh, i.e., only the
* values at the vertices. If this is not good enough, you can, for example,
- * specify @p n_subdivisions equal to 2 to plot the solution on a once-
- * refined mesh, or if set to 3, on a mesh where each cell is represented by
- * 3-by-3 patches. On each of these smaller patches, given the limitations
+ * specify @p n_subdivisions equal to 2 to plot the solution on a
+ * once-refined mesh, or if set to 3, on a mesh where each cell is represented
+ * by 3-by-3 patches. On each of these smaller patches, given the limitations
* of output formats, the data is still linearly interpolated, but a linear
* interpolation of quadratic data on a finer mesh is still a better
* representation of the actual quadratic surface than on the original mesh.
* The one coordinate in the triangulation used by the DoFHandler object
* passed to this class is taken as the radial variable, and the output will
* then be either a circle or a ring domain. It is in the user's
- * responsibility to assure that the radial coordinate only attains non-
- * negative values.
+ * responsibility to assure that the radial coordinate only attains
+ * non-negative values.
*
*
* <h3>Details for 2d computations</h3>
* We will explain the concept for a time dependent problem, but instead of
* the time any parameter can be substituted. In our example, a solution of an
* equation is computed for each discrete time level. This is then added to an
- * object of the present class and after all time levels are added, a space-
- * time plot will be written in any of the output formats supported by the
+ * object of the present class and after all time levels are added, a
+ * space-time plot will be written in any of the output formats supported by the
* base class. Upon output, the (spatial) solution on each time level is
* extended into the time direction by writing it twice, once for the time
* level itself and once for a time equal to the time level minus a given time
* contribution of the face $F\in\partial K$ looks like \f[ n_F\int_F
* \left|g-a\frac{\partial u_h}{\partial n}\right|^2 ds \f] where $g$ is the
* Neumann boundary function, $n_F=\frac {h_K}{24}$ and $n_F=\frac {h_F}{p}$ for
- * the Kelly and hp-estimator, respectively. If the finite element is vector-
- * valued, then obviously the function denoting the Neumann boundary
+ * the Kelly and hp-estimator, respectively. If the finite element is
+ * vector-valued, then obviously the function denoting the Neumann boundary
* conditions needs to be vector-valued as well.
*
* <li> No other boundary conditions are considered.
/**
* Resize the arrays so that they fit the number of quadrature points
- * associated with the given finite element index into the hp-
- * collections.
+ * associated with the given finite element index into the
+ * hp-collections.
*/
void
resize(const unsigned int active_fe_index);
* find difficulties: when we eliminate a degree of freedom, we delete the row
* and column of this unknown, and set the diagonal entry to some positive
* value. To make the problem more or less well-conditioned, we set this
- * diagonal entry to the absolute value of its prior value if that was non-
- * zero, or to the average magnitude of all other nonzero diagonal elements.
+ * diagonal entry to the absolute value of its prior value if that was
+ * non-zero, or to the average magnitude of all other nonzero diagonal elements.
* Then we set the right hand side value such that the resulting solution
* entry has the right value as given by the boundary values. Since we add
* these contributions up over all local contributions, the diagonal entry and
/**
* This function is an updated version of the
* project_boundary_values_curl_conforming function. The intention is to fix
- * a problem when using the previous function in conjunction with non-
- * rectangular geometries (i.e. elements with non-rectangular faces). The
+ * a problem when using the previous function in conjunction with
+ * non-rectangular geometries (i.e. elements with non-rectangular faces). The
* L2-projection method used has been taken from the paper "Electromagnetic
* scattering simulation using an H (curl) conforming hp-finite element
* method in three dimensions" by PD Ledger, K Morgan and O Hassan ( Int. J.
* <h4>Computing constraints</h4>
*
* To compute the constraints we use a projection method based upon the
- * paper mentioned above. In 2d this is done in a single stage for the edge-
- * based shape functions, regardless of the order of the finite element. In
- * 3d this is done in two stages, edges first and then faces.
+ * paper mentioned above. In 2d this is done in a single stage for the
+ * edge-based shape functions, regardless of the order of the finite element.
+ * In 3d this is done in two stages, edges first and then faces.
*
* For each cell, each edge, $e$, is projected by solving the linear system
* $Ax=b$ where $x$ is the vector of constraints on degrees of freedom on the
projects / dealii.git / commitdiff