double start_val;
/**
- *The end of the time interval.
+ * The end of the time interval.
*/
double final_val;
/**
- * This class defines a predicate used by ArborXWrappers::BVH to determine
- * for given spheres which of the bounding boxes used to build the
- * ArborXWrappers::BVH intersect with them.
- * @note The class is not supposed to be used in a polymorphic context.
+ * This class defines a predicate used by ArborXWrappers::BVH to determine
+ * for given spheres which of the bounding boxes used to build the
+ * ArborXWrappers::BVH intersect with them.
+ * @note The class is not supposed to be used in a polymorphic context.
*/
class SphereIntersectPredicate : private SpherePredicate
{
{
/**
* Default constructor. Sets up the dimension labels with the default values
- of <tt>"x"</tt>, <tt>"y"</tt>, and <tt>"z"</tt>.
+ * of <tt>"x"</tt>, <tt>"y"</tt>, and <tt>"z"</tt>.
*/
GnuplotFlags();
unsigned int node_dim;
/**
- * The number of cells stored in @ref filtered_cells.
+ * The number of cells stored in
+ * @ref filtered_cells.
*/
unsigned int num_cells;
double start_time;
/**
- *The end of the time interval.
+ * The end of the time interval.
*/
double end_time;
* component, and consequently is not shown in boldface. Then assume
* that we want this $u_h(x)$ to be used as a boundary condition for a 2d
* problem at the line $y=0$. Let's say that this line corresponds to
- * @ref GlossBoundaryIndicator "boundary indicator" 123.
+ * @ref GlossBoundaryIndicator "boundary indicator"
+ * 123.
* If we say that the 2d problem is associated with
* @code
* DoFHandler<2> dof_handler_2d;
namespace internal
{
- /** This function returns the HDF5 datatype corresponding to the C++ type.
+ /**
+ * This function returns the HDF5 datatype corresponding to the C++ type.
* In the case of std::complex types the HDF5 handlers are automatically
* freed using the destructor of `std::shared_ptr`. `std::shared_ptr` is
* used instead of `std::unique_ptr` because the destructor of
std::shared_ptr<hid_t>
get_hdf5_datatype();
- /** Return the dimensions of `data`. For a std::vector this function returns
+ /**
+ * Return the dimensions of `data`. For a std::vector this function returns
* `std::vector<hsize_t>{vector_size}`.
*
* Several HDF5 functions such as H5Screate_simple() require a
std::vector<hsize_t>
get_container_dimensions(const std::vector<number> &data);
- /** Return the dimensions of `data`. For a Vector this function returns
+ /**
+ * Return the dimensions of `data`. For a Vector this function returns
* `std::vector<hsize_t>{vector_size}`.
*/
template <typename number>
std::vector<hsize_t>
get_container_dimensions(const Vector<number> &data);
- /** Return the dimensions of `data`. For a FullMatrix the function returns
+ /**
+ * Return the dimensions of `data`. For a FullMatrix the function returns
* `std::vector<hsize_t>{rows, columns}`.
*/
template <typename number>
std::vector<hsize_t>
get_container_dimensions(const FullMatrix<number> &data);
- /** This function returns the total size of the container. For a std::vector
+ /**
+ * This function returns the total size of the container. For a std::vector
* the function returns `int(vector_size)`.
*/
template <typename number>
unsigned int
get_container_size(const std::vector<number> &data);
- /** This function returns the total size of the container. For a Vector the
+ /**
+ * This function returns the total size of the container. For a Vector the
* function returns `int(vector_size)`.
*/
template <typename number>
unsigned int
get_container_size(const Vector<number> &data);
- /** This function returns the total size of the container. For a FullMatrix
+ /**
+ * This function returns the total size of the container. For a FullMatrix
* the function returns `int(rows*columns)`.
*/
template <typename number>
unsigned int
get_container_size(const FullMatrix<number> &data);
- /** This function initializes and returns a container of type std::vector,
+ /**
+ * This function initializes and returns a container of type std::vector,
* Vector or FullMatrix. The function does not set the values of the
* elements of the container. The container can store data of a HDF5 dataset
* or a HDF5 selection. The dimensions parameter holds the dimensions of the
Container>::type
initialize_container(const std::vector<hsize_t> &dimensions);
- /** Same as above.
+ /**
+ * Same as above.
*/
template <typename Container>
typename std::enable_if<
Container>::type
initialize_container(const std::vector<hsize_t> &dimensions);
- /** Same as above.
+ /**
+ * Same as above.
*/
template <typename Container>
typename std::enable_if<
Container>::type
initialize_container(const std::vector<hsize_t> &dimensions);
- /** This helper function sets the property list of the read and write
+ /**
+ * This helper function sets the property list of the read and write
* operations of DataSet. A property list has to be created for the MPI
* driver. For the serial driver the default H5P_DEFAULT can be used. In
* addition H5Pset_dxpl_mpio is used to set the MPI mode to collective.
inline void
set_plist(hid_t &plist, const bool mpi);
- /** This helper function releases the property list handler of the read and
+ /**
+ * This helper function releases the property list handler of the read and
* write operations of DataSet. For the serial version there is no need to
* release the property list handler because H5P_DEFAULT has been used. If
* query_io_mode is True then H5Pget_mpio_actual_io_mode and
const bool mpi,
const bool query_io_mode);
- /** Convert a HDF5 no_collective_cause code to a human readable string.
+ /**
+ * Convert a HDF5 no_collective_cause code to a human readable string.
*/
inline std::string
no_collective_cause_to_string(const uint32_t no_collective_cause);
* Create a vectorized array of given type and broadcast the scalar value
* to all array elements.
*
- * @relatesalso VectorizedArray
+ * @relatesalso VectorizedArray
*/
template <typename VectorizedArrayType>
inline DEAL_II_ALWAYS_INLINE VectorizedArrayType
_mm512_storeu_pd(ptr, data);
}
- /** @copydoc VectorizedArray<Number>::streaming_store()
+ /**
+ * @copydoc VectorizedArray<Number>::streaming_store()
* @note Memory must be aligned by 64 bytes.
*/
DEAL_II_ALWAYS_INLINE
_mm512_storeu_ps(ptr, data);
}
- /** @copydoc VectorizedArray<Number>::streaming_store()
+ /**
+ * @copydoc VectorizedArray<Number>::streaming_store()
* @note Memory must be aligned by 64 bytes.
*/
DEAL_II_ALWAYS_INLINE
_mm256_storeu_pd(ptr, data);
}
- /** @copydoc VectorizedArray<Number>::streaming_store()
+ /**
+ * @copydoc VectorizedArray<Number>::streaming_store()
* @note Memory must be aligned by 32 bytes.
*/
DEAL_II_ALWAYS_INLINE
_mm256_storeu_ps(ptr, data);
}
- /** @copydoc VectorizedArray<Number>::streaming_store()
+ /**
+ * @copydoc VectorizedArray<Number>::streaming_store()
* @note Memory must be aligned by 32 bytes.
*/
DEAL_II_ALWAYS_INLINE
_mm_storeu_pd(ptr, data);
}
- /** @copydoc VectorizedArray<Number>::streaming_store()
+ /**
+ * @copydoc VectorizedArray<Number>::streaming_store()
* @note Memory must be aligned by 16 bytes.
*/
DEAL_II_ALWAYS_INLINE
_mm_storeu_ps(ptr, data);
}
- /** @copydoc VectorizedArray<Number>::streaming_store()
+ /**
+ * @copydoc VectorizedArray<Number>::streaming_store()
* @note Memory must be aligned by 16 bytes.
*/
DEAL_II_ALWAYS_INLINE
vec_vsx_st(data, 0, ptr);
}
- /** @copydoc VectorizedArray<Number>::streaming_store()
+ /**
+ * @copydoc VectorizedArray<Number>::streaming_store()
*/
DEAL_II_ALWAYS_INLINE
void
store(ptr);
}
- /** @copydoc VectorizedArray<Number>::gather()
+ /**
+ * @copydoc VectorizedArray<Number>::gather()
*/
DEAL_II_ALWAYS_INLINE
void
*(reinterpret_cast<double *>(&data) + i) = base_ptr[offsets[i]];
}
- /** @copydoc VectorizedArray<Number>::scatter
+ /**
+ * @copydoc VectorizedArray<Number>::scatter
*/
DEAL_II_ALWAYS_INLINE
void
vec_vsx_st(data, 0, ptr);
}
- /** @copydoc VectorizedArray<Number>::streaming_store()
+ /**
+ * @copydoc VectorizedArray<Number>::streaming_store()
*/
DEAL_II_ALWAYS_INLINE
void
store(ptr);
}
- /** @copydoc VectorizedArray<Number>::gather()
+ /**
+ * @copydoc VectorizedArray<Number>::gather()
*/
DEAL_II_ALWAYS_INLINE
void
*(reinterpret_cast<float *>(&data) + i) = base_ptr[offsets[i]];
}
- /** @copydoc VectorizedArray<Number>::scatter
+ /**
+ * @copydoc VectorizedArray<Number>::scatter
*/
DEAL_II_ALWAYS_INLINE
void
* @ref GlossMPICommunicator "MPI communicators"
* or that they have
* @ref GlossLocallyOwnedCell "locally owned",
- * @ref GlossGhostCell "ghost", and possibly
+ * @ref GlossGhostCell "ghost",
+ * and possibly
* @ref GlossArtificialCell "artificial cells".
* This class provides
* a number of member functions that allows querying some information
* Save additional cell-attached data into the given file. The first
* arguments are used to determine the offsets where to write buffers to.
*
- * Called by @ref save.
+ * Called by
+ * @ref save.
*/
void
save_attached_data(const unsigned int global_first_cell,
* The first arguments are used to determine the offsets where to read
* buffers from.
*
- * Called by @ref load.
+ * Called by
+ * @ref load.
*/
void
load_attached_data(const unsigned int global_first_cell,
* A class that gives access to the degrees of freedom stored in a DoFHandler
* object. Accessors are used to access the data that pertains to edges,
* faces, and cells of a triangulation. The concept is explained in more
- * detail in connection to @ref Iterators.
+ * detail in connection to
+ * @ref Iterators.
*
* This class follows mainly the route laid out by the accessor library
* declared in the triangulation library (TriaAccessor). It enables the user
public:
/**
* The constructor.
- **/
+ */
Base(const FEInterfaceValues<dim, spacedim> &fe_interface);
protected:
* field must be continuous across the line (or surface) even though
* the normal component may not be. As a consequence, the
* Nédélec element is constructed in such a way that (i) it is
- * @ref vector_valued "vector-valued", (ii) the shape functions are
+ * @ref vector_valued "vector-valued",
+ * (ii) the shape functions are
* discontinuous, but (iii) the tangential component(s) of the vector field
* represented by each shape function are continuous across the faces
* of cells.
*
* Other properties of the Nédélec element are that (i) it is
- * @ref GlossPrimitive "not a primitive element"; (ii) the shape functions
+ * @ref GlossPrimitive "not a primitive element"
+ * ; (ii) the shape functions
* are defined so that certain integrals over the faces are either zero
* or one, rather than the common case of certain point values being
* either zero or one.
* the 3D version of FE_Nedelec has 12 degrees of freedom for `order = 0`
* and 54 for `degree = 1`. It is important to have enough quadrature points
* in order to perform the quadrature with sufficient accuracy.
- * For example [QGauss<dim>(order + 2)](@ref QGauss) can be used for the
+ * For example
+ * [QGauss<dim>(order + 2)](@ref QGauss)
+ * can be used for the
* quadrature formula, where `order` is the order of FE_Nedelec.
*/
FE_Nedelec(const unsigned int order);
* the 3D version of FE_NedelecSZ has 12 degrees of freedom for `order = 0`
* and 54 for `degree = 1`. It is important to have enough quadrature points
* in order to perform the quadrature with sufficient accuracy.
- * For example [QGauss<dim>(order + 2)](@ref QGauss) can be used for the
+ * For example
+ * [QGauss<dim>(order + 2)](@ref QGauss)
+ * can be used for the
* quadrature formula, where `order` is the order of FE_NedelecSZ.
*/
FE_NedelecSZ(const unsigned int order);
* field must be continuous across the line (or surface) even though
* the tangential component may not be. As a consequence, the
* Raviart-Thomas element is constructed in such a way that (i) it is
- * @ref vector_valued "vector-valued", (ii) the shape functions are
+ * @ref vector_valued "vector-valued",
+ * (ii) the shape functions are
* discontinuous, but (iii) the normal component of the vector field
* represented by each shape function is continuous across the faces
* of cells.
*
* Other properties of the Raviart-Thomas element are that (i) it is
- * @ref GlossPrimitive "not a primitive element"; (ii) the shape functions
+ * @ref GlossPrimitive "not a primitive element"
+ * ; (ii) the shape functions
* are defined so that certain integrals over the faces are either zero
* or one, rather than the common case of certain point values being
* either zero or one. (There is, however, the FE_RaviartThomasNodal
* <code>adjust_quad_dof_index_for_face_orientation_table</code> declared in
* fe.cc. We need to fill it with the correct values in case of non-standard,
* flipped (rotated by +180 degrees) or rotated (rotated by +90 degrees)
- *faces. These are given in the form three flags (face_orientation, face_flip,
- * face_rotation), see the documentation in GeometryInfo<dim> and
+ * faces. These are given in the form three flags (face_orientation,
+ * face_flip, face_rotation), see the documentation in GeometryInfo<dim> and
* this @ref GlossFaceOrientation "glossary entry on face orientation".
*
* <h3>Example: Raviart-Thomas Elements of order 2 (tensor polynomial
* unstable approximation to the mass matrix. For example: the shape functions
* of FE_SimplexP<2>(2) with support points at vertices have mean values of
* zero so that element cannot be used with mass lumping.
-
+ *
* This element avoids this issue by replacing the shape functions of
* FE_SimplexP with an augmented space amenable to the construction of nodal
* quadrature rules. For example, on the triangle a single basis function is
* <li> Tensor product construction (<code>do_tensor_product=true</code>):
* The tensor product construction, in the simplest case, builds a
* vector-valued element from scalar elements (see
- * @ref vector_valued "this documentation module" and
- * @ref GlossComponent "this glossary entry" for more information).
+ * @ref vector_valued "this documentation module"
+ * and
+ * @ref GlossComponent "this glossary entry"
+ * for more information).
* To give an example, consider creating a vector-valued element with
* two vector components, where the first should have linear shape
* functions and the second quadratic shape functions. In 1d, the
private:
/**
- * A shortcut for the type of the OutVector.
+ * A shortcut for the type of the OutVector.
*/
using value_type = typename OutVector::value_type;
*
* In 3D, triangulation will be extruded in the z-direction by the total
* height of @p L using @p n_slices slices (minimum is 2).
-
+ *
* If the @p colorize flag is <code>true</code>, the boundary_ids of the
* boundary faces are assigned such that the lower one in the x-direction is
* 0, and the upper one is 1 (see
*
* @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,
* opening to match their index. All other boundary faces will be assigned
* boundary ID 3.
*
- * @ref GlossManifoldIndicator "Manifold IDs" will be set on the mantles of each truncated cone in
+ * @ref GlossManifoldIndicator "Manifold IDs"
+ * will be set on the mantles of each truncated cone in
* the same way. Each cone will have a special manifold object assigned, which
* is based on the CylindricalManifold class. Further, all cells adjacent to
* the mantle are given the manifold ID 3. If desired, you can assign an
* If the @p colorize flag is <code>true</code>, the @p boundary_ids of the
* surfaces are assigned such that the left boundary is 0 and the others are
* assigned counterclockwise in ascending order (see
- * @ref GlossColorization "the glossary entry on colorization"). The @p
- * colorize option only works in two dimensions.
+ * @ref GlossColorization "the glossary entry on colorization").
+ * The @p colorize option only works in two dimensions.
*
* This function will create the classical L-shape in 2d
* and it will look like the following in 3d:
* This function is most often used to compose meshes for more complicated
* geometries if the geometry can be composed of simpler parts for which
* functions exist to generate
- * @ref GlossCoarseMesh "coarse meshes". For example, the channel mesh
+ * @ref GlossCoarseMesh "coarse meshes".
+ * For example, the channel mesh
* used in step-35 could in principle be created using a mesh created by the
* GridGenerator::hyper_cube_with_cylindrical_hole function and several
* rectangles, and merging them using the current function. The rectangles
* the input meshes.
*
* @note The two input triangulations must be
- * @ref GlossCoarseMesh "coarse meshes", i.e., they can not have any
+ * @ref GlossCoarseMesh "coarse meshes",
+ * i.e., they can not have any
* refined cells.
*
* @note The function copies the material ids of the cells of the two input
* @note This function is intended to create an adaptively refined
* triangulation that contains the <i>most refined cells</i> from two input
* triangulations that were derived from the <i>same</i>
- * @ref GlossCoarseMesh "coarse mesh" by
+ * @ref GlossCoarseMesh "coarse mesh"
+ * by
* adaptive refinement. This is an operation sometimes needed when one
* solves for two variables of a coupled problem on separately refined
* meshes on the same domain (for example because these variables have
* triangulation later on.
*
* All information about cell
- * @ref GlossManifoldIndicator "manifold indicators" and
- * @ref GlossMaterialId "material indicators" are copied from
+ * @ref GlossManifoldIndicator "manifold indicators"
+ * and
+ * @ref GlossMaterialId "material indicators"
+ * are copied from
* one triangulation to the other. The same is true for the manifold
* indicators and, if an object is at the boundary, the boundary
* indicators of faces and edges of the triangulation.
struct Svg
{
/**
- * Height of the plot in SVG units, computed from width if zero. Defaults
- * to 1000.
+ * Height of the plot in SVG units, computed from width if zero. Defaults
+ * to 1000.
*/
unsigned int height;
/**
- * The width of the plot. Computed automatically from height if zero
- * (default).
+ * The width of the plot. Computed automatically from height if zero
+ * (default).
*/
unsigned int width;
/**
- * Thickness of the lines between cells.
+ * Thickness of the lines between cells.
*/
unsigned int line_thickness;
/**
unsigned int boundary_line_thickness;
/**
- * Margin around the plotted area.
+ * Margin around the plotted area.
*/
bool margin;
* vertices so that all lines are consistently oriented.
*
* The expectations on orientation and a discussion of this function are
- * available in the @ref reordering "reordering module".
+ * available in the
+ * @ref reordering "reordering module".
*
* @param cells The array of CellData objects that describe the mesh's topology.
*/
* objects, and comparing against those special objects.
*
* The purposes and intents of this class are described in the
- * @ref GlossReferenceCell "reference cell" glossary entry.
+ * @ref GlossReferenceCell "reference cell"
+ * glossary entry.
*
* @ingroup grid geomprimitives aniso
*/
/**
* This class implements a collection of objects.
*
- * It implements the concepts stated in the @ref hpcollection
+ * It implements the concepts stated in the
+ * @ref hpcollection
* module described in the doxygen documentation.
*
* @ingroup hp hpcollection
{
/**
* Constructor. cuSPARSE allows to compute and use level information.
- * to the documentation this might improve performance.
+ * to the documentation this might improve performance.
* It is suggested to try both options.
*/
AdditionalData(bool use_level_analysis = true);
//@}
/**
- *@name Access to underlying CUDA data
+ * @name Access to underlying CUDA data
*/
//@{
/**
* setting AdditionalData::eig_cg_n_iterations to zero, and provide the
* variable AdditionalData::max_eigenvalue instead. The minimal eigenvalue is
* implicitly specified via `max_eigenvalue/smoothing_range`.
-
+ *
* <h4>Using the PreconditionChebyshev as a solver</h4>
*
* If the range <tt>[max_eigenvalue/smoothing_range, max_eigenvalue]</tt>
EigenvalueAlgorithm::lanczos);
/**
- * Copy assignment operator.
+ * Copy assignment operator.
*/
AdditionalData &
operator=(const AdditionalData &other_data);
/**
- * psyevx computes selected eigenvalues and, optionally, eigenvectors
- * of a real symmetric matrix A. Eigenvalues/vectors can be selected by
- * specifying a range of values or a range of indices for the desired
- * eigenvalues.
+ * psyevx computes selected eigenvalues and, optionally, eigenvectors
+ * of a real symmetric matrix A. Eigenvalues/vectors can be selected by
+ * specifying a range of values or a range of indices for the desired
+ * eigenvalues.
*/
void
pdsyevx_(const char * jobz,
const int * DESCC);
/**
- * psyevr computes selected eigenvalues and, optionally, eigenvectors
- * of a real symmetric matrix A using a parallel implementation of the MRR
+ * psyevr computes selected eigenvalues and, optionally, eigenvectors
+ * of a real symmetric matrix A using a parallel implementation of the MRR
* algorithm. Eigenvalues/vectors can be selected by specifying a range of
* values or a range of indices for the desired eigenvalues.
*/
*
* @ingroup TrilinosWrappers
* @ingroup Vectors
- * 2008, 2009, 2017
*/
class Vector : public Subscriptor
{
bool use_coloring;
/**
- * Overlap MPI communications with computation. This requires CUDA-aware
- * MPI and use_coloring must be false.
+ * Overlap MPI communications with computation. This requires CUDA-aware
+ * MPI and use_coloring must be false.
*/
bool overlap_communication_computation;
};
/**
* Evaluate the values and the gradients of the finite element function at
- * the quadrature points.
+ * the quadrature points.
*/
__device__ void
value_and_gradient_at_quad_pts(Number *const u, Number *grad_u[dim]);
* avoids the memory allocation and other expensive start-up cost of
* FEValues. Currently, the functionality is specialized for mappings derived
* from MappingQ and MappingCartesian and for finite elements with tensor
- * product structure
- * that work with the @ref matrixfree module. In those cases, the cost implied
+ * product structure that work with the
+ * @ref matrixfree
+ * module. In those cases, the cost implied
* by this class is similar (or sometimes even somewhat lower) than using
* `FEValues::reinit(cell)` followed by `FEValues::get_function_gradients`.
*/
* can not be computed without knowing the surface normal in
* $\mathbb{R}^{\text{spacedim}}$. The conormal is the unit vector parallel to
* the projection of the face normal into the surface plane. This is
- * essentially the same thing as the normalized @ref GlossBoundaryForm
- * "boundary form".
+ * essentially the same thing as the normalized
+ * @ref GlossBoundaryForm "boundary form".
*/
template <int dim, int spacedim = dim>
class ImmersedSurfaceQuadrature : public Quadrature<dim>
* small to be seen individually) or because you only want to see a certain
* region of the domain (for example only in the fluid part of the domain in
* step-46), or for some other reason.
-
+ *
* For this, internally build_patches() does not generate the sequence of cells
* to be converted into patches itself, but relies on the two private
* std::function objects first_cell_function() and next_cell_function(). By
* Holzapfel (2007) and Wriggers (2008). The citation for these references,
* as well as other notation used here, can be found in the description for
* the Physics::Elasticity namespace.
-
+ *
* @note These hold specifically for the codimension 0 case,
* where the metric tensor is the identity tensor.
*/
projects / dealii.git / commitdiff