@ingroup grid
*/
-//@}
+/** @} */
/**
/**
* @name Data storage and access
+ * @{
*/
- //@{
/**
* Store internally a copy of the given object. The copied object is
void
remove_object_with_name(const std::string &name);
- //@}
+ /** @} */
/**
* An entry with this name does not exist in the internal boost::any map.
DeclException1(ExcRateColumnAlreadyExists,
std::string,
<< "Rate column <" << arg1 << "> does already exist.");
- //@}
+ /** @} */
};
<< "It is not possible to have a structural dimension of " << arg1
<< " to be larger than the space dimension of the surrounding"
<< " space " << arg2);
- //@}
+ /** @} */
};
<< "It is not possible to have a structural dimension of " << arg1
<< " to be larger than the space dimension of the surrounding"
<< " space " << arg2);
- //@}
+ /** @} */
};
<< "There was an error opening Tecplot file " << arg1
<< " for output.");
- //@}
+ /** @} */
} // namespace DataOutBase
{
/**
* @addtogroup Exceptions
+ * @{
*/
- //@{
/**
* Exception denoting a division by zero.
std::string,
<< "There was an error in a cuSPARSE function: " << arg1);
#endif
- //@}
+ /** @} */
/**
* This function requires support for the Exodus II library.
<< ") is not equal to the number of expressions (" << arg2
<< ").");
- //@}
+ /** @} */
};
<< "Parsing Error at Column " << arg1
<< ". The parser said: " << arg2);
- //@}
+ /** @} */
/**
* deal.II uses muParser as a purely internal dependency. To this end, we do
"file to include <"
<< arg3 << "> cannot be opened.");
- //@}
+ /** @} */
private:
/**
int,
<< "The values " << arg1 << " and " << arg2
<< " do not form a valid range.");
- //@}
+ /** @} */
private:
/**
* Copy of the pattern that each element of the list has to satisfy.
int,
<< "The values " << arg1 << " and " << arg2
<< " do not form a valid range.");
- //@}
+ /** @} */
private:
/**
* Copy of the patterns that each key and each value of the map has to
int,
<< "A comma was found at position " << arg1
<< " of your input string, but commas are not allowed here.");
- //@}
+ /** @} */
private:
/**
* List of valid strings as passed to the constructor. We don't make this
std::string,
<< "The string \"" << arg1
<< "\" does not match the pattern \"" << arg2 << "\"");
- //@}
+ /** @} */
} // namespace Tools
} // namespace Patterns
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup Quadrature */
-/*@{*/
-
+/**
+ * @addtogroup Quadrature
+ * @{
+ */
/**
* This class is a helper class to facilitate the usage of quadrature formulae
};
};
-/*@}*/
+/** @} */
// ------------------- inline and template functions ----------------
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup Quadrature */
-/*@{*/
+/**
+ * @addtogroup Quadrature
+ * @{
+ */
/**
* Base class for quadrature formulae in arbitrary dimensions. This class
-/*@}*/
+/** @} */
#ifndef DOXYGEN
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup Quadrature */
-/*@{*/
+/**
+ * @addtogroup Quadrature
+ * @{
+ */
/**
* The Gauss-Legendre family of quadrature rules for numerical integration.
explicit QGaussPyramid(const unsigned int n_points_1D);
};
-/*@}*/
+/** @} */
/* -------------- declaration of explicit specializations ------------- */
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup Quadrature */
-/*@{*/
+/**
+ * @addtogroup Quadrature
+ * @{
+ */
/**
* A class for storing at each cell represented by iterators of type @p CellIteratorType
#endif
-/*@}*/
+/** @} */
#ifndef DOXYGEN
DeclException1(ExcInvalidQuadrature,
std::string,
<< arg1 << " is not a valid name for a quadrature rule.");
- //@}
+ /** @} */
private:
/**
* This static function creates a quadrature object according to the name
*
* Classes derived from Subscriptor provide a facility to subscribe to this
* object. This is mostly used by the SmartPointer class.
+ * @{
*/
- // @{
/**
* Subscribes a user of the object by storing the pointer @p validity. The
void
list_subscribers() const;
- // @}
+ /** @} */
/**
* @addtogroup Exceptions
<< "No subscriber with identifier <" << arg2
<< "> subscribes to this object of class " << arg1
<< ". Consequently, it cannot be unsubscribed.");
- //@}
+ /** @} */
/**
* Read or write the data of this object to or from a stream for the purpose
<< '<' << arg1 << "> is not a tex column format. Use "
<< "'l', 'c', or 'r' to indicate left, centered, or "
<< "right aligned text.");
- //@}
+ /** @} */
protected:
/**
* Structure encapsulating all the data that is needed to describe one
/**
* @name Output functions for Tensor objects
+ * @{
*/
-//@{
/**
* Output operator for tensors. Print the elements consecutively, with a space
}
-//@}
+/** @} */
/**
* @name Vector space operations on Tensor objects:
+ * @{
*/
-//@{
-
/**
* Scalar multiplication of a tensor of rank 0 with an object from the left.
return tmp;
}
-//@}
+/** @} */
/**
* @name Contraction operations and the outer product for tensor objects
+ * @{
*/
-//@{
-
/**
* The dot product (single contraction) for tensors. This function return a
}
-//@}
+/** @} */
/**
* @name Special operations on tensors of rank 1
+ * @{
*/
-//@{
-
/**
* Return the cross product in 2d. This is just a rotation by 90 degrees
}
-//@}
+/** @} */
/**
* @name Special operations on tensors of rank 2
+ * @{
*/
-//@{
-
/**
* Compute the determinant of a tensor or rank 2.
return max;
}
-//@}
+/** @} */
#ifndef DOXYGEN
<< ") is not equal to the number of expressions (" << arg2
<< ").");
- //@}
+ /** @} */
private:
/**
* Number of components is equal dim<sup>rank</sup>.
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup threads */
-/*@{*/
+/**
+ * @addtogroup threads
+ * @{
+ */
# ifndef DOXYGEN
class LogStream;
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup threads */
-/*@{*/
-
+/**
+ * @addtogroup threads
+ * @{
+ */
/**
* A namespace for the implementation of thread management in deal.II. Most of
"The current object is not associated with a task that "
"can be joined. It may have been detached, or you "
"may have already joined it in the past.");
- //@}
+ /** @} */
private:
/**
* A data structure that holds a std::future into which the task deposits
/**
* @name Packing and unpacking of a VectorizedArray
+ * @{
*/
-//@{
-
/**
* Create a vectorized array that sets all entries in the array to the given
}
-//@}
+/** @} */
#ifndef DOXYGEN
/**
* @name Arithmetic operations with VectorizedArray
+ * @{
*/
-//@{
/**
* Relational operator == for VectorizedArray
return out;
}
-//@}
+/** @} */
/**
* @name Ternary operations on VectorizedArray
+ * @{
*/
-//@{
-
/**
* enum class encoding binary operations for a component-wise comparison of
return result;
}
-//@}
+/** @} */
#ifndef DOXYGEN
# if DEAL_II_VECTORIZATION_WIDTH_IN_BITS >= 512 && defined(__AVX512F__)
{
/**
* @addtogroup Exceptions
+ * @{
*/
- //@{
/**
* Exception denoting that a class requires some specialization
<< ", but to perform the intended operation the number must support at least "
<< arg2 << " levels.");
- //@}
+ /** @} */
/**
/**
* @name Taping
+ * @{
*/
- //@{
/**
* Return whether or not this class is tracking calculations performed
const typename Types<ADNumberType>::tape_index tape_index,
std::ostream & stream) const;
- //@}
+ /** @} */
/**
* @name Drivers for scalar functions (one dependent variable)
+ * @{
*/
- //@{
/**
* Compute the value of the scalar field.
const std::vector<ScalarType> &independent_variables,
FullMatrix<ScalarType> & hessian) const;
- //@}
+ /** @} */
/**
* @name Drivers for vector functions (multiple dependent variables)
+ * @{
*/
- //@{
/**
* Compute the values of the vector field.
const std::vector<ScalarType> &independent_variables,
FullMatrix<ScalarType> & jacobian) const;
- //@}
+ /** @} */
};
/**
* @name Configuration
+ * @{
*/
- //@{
/**
* In the event that the tapeless mode requires <i>a priori</i> knowledge
static void
initialize_global_environment(const unsigned int n_independent_variables);
- //@}
+ /** @} */
/**
* Operation status
+ * @{
*/
- //@{
/**
* Set a flag that states that we can safely mark dependent variables
bool
is_dependent_variable_marking_allowed() const;
- //@}
+ /** @} */
/**
* @name Drivers for scalar functions
+ * @{
*/
- //@{
/**
* Compute the value of the scalar field.
const std::vector<ADNumberType> &dependent_variables,
FullMatrix<ScalarType> & hessian) const;
- //@}
+ /** @} */
/**
* @name Drivers for vector functions
+ * @{
*/
- //@{
/**
* Compute the values of the vector field.
const std::vector<ADNumberType> &dependent_variables,
FullMatrix<ScalarType> & jacobian) const;
- //@}
+ /** @} */
};
} // namespace AD
/**
* @name Taping
+ * @{
*/
- //@{
bool
is_recording() const;
const typename Types<ADNumberType>::tape_index tape_index,
std::ostream & stream) const;
- //@}
+ /** @} */
/**
* @name Drivers for scalar functions (one dependent variable)
+ * @{
*/
- //@{
scalar_type
value(const typename Types<ADNumberType>::tape_index active_tape_index,
const std::vector<scalar_type> &independent_variables,
FullMatrix<scalar_type> & hessian) const;
- //@}
+ /** @} */
/**
* @name Drivers for vector functions (multiple dependent variables)
+ * @{
*/
- //@{
void
values(const typename Types<ADNumberType>::tape_index active_tape_index,
const std::vector<scalar_type> &independent_variables,
FullMatrix<scalar_type> & jacobian) const;
- //@}
+ /** @} */
protected:
/**
/**
* @name Taping
+ * @{
*/
- //@{
bool
is_recording() const;
print_tape_stats(const typename Types<ADNumberType>::tape_index,
std::ostream &) const;
- //@}
+ /** @} */
/**
* @name Drivers for scalar functions (one dependent variable)
+ * @{
*/
- //@{
scalar_type
value(const typename Types<ADNumberType>::tape_index,
const std::vector<scalar_type> &,
FullMatrix<scalar_type> &) const;
- //@}
+ /** @} */
/**
* @name Drivers for vector functions (multiple dependent variables)
+ * @{
*/
- //@{
void
values(const typename Types<ADNumberType>::tape_index,
const std::vector<scalar_type> &,
FullMatrix<scalar_type> &) const;
- //@}
+ /** @} */
};
# endif // DEAL_II_WITH_ADOLC
/**
* @name Taping
+ * @{
*/
- //@{
bool
is_recording() const;
const typename Types<ADNumberType>::tape_index tape_index,
std::ostream & stream) const;
- //@}
+ /** @} */
/**
* @name Drivers for scalar functions (one dependent variable)
+ * @{
*/
- //@{
scalar_type
value(const typename Types<ADNumberType>::tape_index active_tape_index,
const std::vector<scalar_type> &independent_variables,
FullMatrix<scalar_type> & hessian) const;
- //@}
+ /** @} */
/**
* @name Drivers for vector functions (multiple dependent variables)
+ * @{
*/
- //@{
void
values(const typename Types<ADNumberType>::tape_index active_tape_index,
const std::vector<scalar_type> &independent_variables,
FullMatrix<scalar_type> & jacobian) const;
- //@}
+ /** @} */
private:
/**
/**
* @name Configuration
+ * @{
*/
- //@{
static void
initialize_global_environment(const unsigned int n_independent_variables);
- //@}
+ /** @} */
/**
- * Operation status
+ * @name Operation status
+ * @{
*/
- //@{
void
allow_dependent_variable_marking();
bool
is_dependent_variable_marking_allowed() const;
- //@}
+ /** @} */
/**
* @name Drivers for scalar functions
+ * @{
*/
- //@{
ScalarType
value(const std::vector<ADNumberType> &dependent_variables) const;
const std::vector<ADNumberType> &dependent_variables,
FullMatrix<ScalarType> & hessian) const;
- //@}
+ /** @} */
/**
* @name Drivers for vector functions
+ * @{
*/
- //@{
void
values(const std::vector<ADNumberType> &dependent_variables,
const std::vector<ADNumberType> &dependent_variables,
FullMatrix<ScalarType> & jacobian) const;
- //@}
+ /** @} */
private:
/**
/**
* @name Configuration
+ * @{
*/
- //@{
static void
initialize_global_environment(const unsigned int n_independent_variables);
- //@}
+ /** @} */
/**
- * Operation status
+ * @name Operation status
+ * @{
*/
- //@{
void
allow_dependent_variable_marking();
bool
is_dependent_variable_marking_allowed() const;
- //@}
+ /** @} */
/**
* @name Drivers for scalar functions
+ * @{
*/
- //@{
ScalarType
value(const std::vector<ADNumberType> &dependent_variables) const;
const std::vector<ADNumberType> &dependent_variables,
FullMatrix<ScalarType> & hessian) const;
- //@}
+ /** @} */
/**
* @name Drivers for vector functions
+ * @{
*/
- //@{
void
values(const std::vector<ADNumberType> &dependent_variables,
const std::vector<ADNumberType> &dependent_variables,
FullMatrix<ScalarType> & jacobian) const;
- //@}
+ /** @} */
private:
/**
/**
* @name Constructor / destructor
+ * @{
*/
- //@{
/**
* The constructor for the class.
*/
virtual ~HelperBase() = default;
- //@}
+ /** @} */
/**
* @name Interrogation of internal information
+ * @{
*/
- //@{
/**
* Return the number of independent variables that this object expects to
print_tape_stats(const typename Types<ad_type>::tape_index tape_index,
std::ostream & stream) const;
- //@}
+ /** @} */
/**
* @name Operations specific to tapeless mode
+ * @{
*/
- //@{
/**
* Pre-specify the number of @p independent_variables to be used in
configure_tapeless_mode(const unsigned int n_independent_variables,
const bool ensure_persistent_setting = true);
- //@}
+ /** @} */
/**
* @name Operations specific to taped mode: Recording tapes
+ * @{
*/
- //@{
/**
* Reset the state of the helper class.
void
clear_active_tape();
- //@}
+ /** @} */
protected:
/**
* @name Drivers and taping
+ * @{
*/
- //@{
/**
* An object used to help manage stored tapes.
activate_tape(const typename Types<ad_type>::tape_index tape_index,
const bool read_mode);
- //@}
+ /** @} */
/**
* @name Independent variables
+ * @{
*/
- //@{
/**
* A set of independent variables $\mathbf{X}$ that differentiation will
unsigned int
n_registered_independent_variables() const;
- //@}
+ /** @} */
/**
* @name Dependent variables
+ * @{
*/
- //@{
/**
* The set of dependent variables $\mathbf{f}(\mathbf{X})$ of which the
register_dependent_variable(const unsigned int index,
const ad_type & func);
- //@}
+ /** @} */
}; // class HelperBase
/**
* @name Constructor / destructor
*/
- //@{
+ /** @{ */
/**
* The constructor for the class.
*/
virtual ~CellLevelBase() = default;
- //@}
+ /** @} */
/**
* @name Independent variables
*/
- //@{
+ /** @{ */
/**
* Register the complete set of independent variables $\mathbf{X}$ that
const std::vector<ad_type> &
get_sensitive_dof_values() const;
- //@}
+ /** @} */
/**
* @name Operations specific to taped mode: Reusing tapes
*/
- //@{
+ /** @{ */
/**
* Set the values for the independent variables $\mathbf{X}$, i.e., the
const VectorType & values,
const std::vector<dealii::types::global_dof_index> &local_dof_indices);
- //@}
+ /** @} */
/**
* @name Dependent variables
*/
- //@{
+ /** @{ */
/**
* Compute the value of the residual vector field
virtual void
compute_linearization(FullMatrix<scalar_type> &linearization) const = 0;
- //@}
+ /** @} */
}; // class CellLevelBase
/**
* @name Constructor / destructor
*/
- //@{
+ /** @{ */
/**
* The constructor for the class.
*/
virtual ~EnergyFunctional() = default;
- //@}
+ /** @} */
/**
* @name Dependent variables
*/
- //@{
+ /** @{ */
/**
* Register the definition of the total cell energy
compute_linearization(
FullMatrix<scalar_type> &linearization) const override;
- //@}
+ /** @} */
}; // class EnergyFunctional
/**
* @name Constructor / destructor
*/
- //@{
+ /** @{ */
/**
* The constructor for the class.
*/
virtual ~ResidualLinearization() = default;
- //@}
+ /** @} */
/**
* @name Dependent variables
*/
- //@{
+ /** @{ */
/**
* Register the definition of the cell residual vector
compute_linearization(
FullMatrix<scalar_type> &linearization) const override;
- //@}
+ /** @} */
}; // class ResidualLinearization
/**
* @name Constructor / destructor
*/
- //@{
+ /** @{ */
/**
* The constructor for the class.
*/
virtual ~PointLevelFunctionsBase() = default;
- //@}
+ /** @} */
/**
* @name Independent variables
*/
- //@{
+ /** @{ */
/**
* @copydoc HelperBase::reset()
ExtractorType>::template tensor_type<ad_type>
get_sensitive_variables(const ExtractorType &extractor) const;
- //@}
+ /** @} */
/**
* @name Operations specific to taped mode: Reusing tapes
*/
- //@{
+ /** @{ */
/**
* Set the values for the independent variables $\mathbf{X}$.
set_independent_variable(const ValueType & value,
const ExtractorType &extractor);
- //@}
+ /** @} */
protected:
/**
* @name Independent variables
*/
- //@{
+ /** @{ */
/**
* Set the actual value of the independent variable $X_{i}$.
unsigned int
n_symmetric_independent_variables() const;
- //@}
+ /** @} */
private:
/**
* @name Independent variables
*/
- //@{
+ /** @{ */
/**
* The independent variables for which we must take into account symmetry
*/
std::vector<bool> symmetric_independent_variables;
- //@}
+ /** @} */
}; // class PointLevelFunctionsBase
/**
* @name Constructor / destructor
*/
- //@{
+ /** @{ */
/**
* The constructor for the class.
*/
virtual ~ScalarFunction() = default;
- //@}
+ /** @} */
/**
* @name Dependent variables
*/
- //@{
+ /** @{ */
/**
* Register the definition of the scalar field $\Psi(\mathbf{X})$.
const FEValuesExtractors::SymmetricTensor<2> &extractor_row,
const FEValuesExtractors::SymmetricTensor<2> &extractor_col);
- //@}
+ /** @} */
}; // class ScalarFunction
/**
* @name Constructor / destructor
*/
- //@{
+ /** @{ */
/**
* The constructor for the class.
*/
virtual ~VectorFunction() = default;
- //@}
+ /** @} */
/**
* @name Dependent variables
*/
- //@{
+ /** @{ */
/**
* Register the definition of the vector field
const FEValuesExtractors::SymmetricTensor<2> &extractor_row,
const FEValuesExtractors::SymmetricTensor<2> &extractor_col);
- //@}
+ /** @} */
}; // class VectorFunction
/**
* @name Power functions
*/
- //@{
+ /** @{ */
/**
* Return a symbolic number that represents a @p base value raised to the power of
Expression
log10(const Expression &x);
- //@}
+ /** @} */
/**
* @name Trigonometric functions
*/
- //@{
+ /** @{ */
/**
* Return a symbolic number that represents the sine function with the
Expression
acot(const Expression &x);
- //@}
+ /** @} */
/**
* @name Hyperbolic trigonometric functions
*/
- //@{
+ /** @{ */
/**
* Return a symbolic number that represents the hyperbolic sine function
Expression
acoth(const Expression &x);
- //@}
+ /** @} */
/**
* @name Other functions
*/
- //@{
+ /** @{ */
/**
* Return a symbolic number that represents the absolute value of value @p x.
Expression
erfc(const Expression &x);
- //@}
+ /** @} */
} // namespace SD
} // namespace Differentiation
<< "previously declared all symbolic variables that are present "
<< "in the expression?");
- //@}
+ /** @} */
/**
* A class to wrap SymEngine expressions.
/**
* @name Constructors
*/
- //@{
+ /** @{ */
/**
* Default constructor.
*/
virtual ~Expression() = default;
- //@}
+ /** @} */
/**
* Utilities
*/
- //@{
+ /** @{ */
/**
* Parse an expression from a string representing a symbolic @p expression.
BOOST_SERIALIZATION_SPLIT_MEMBER()
# endif
- //@}
+ /** @} */
/**
* @name Values
*/
- //@{
+ /** @{ */
/**
* Return the value or expression that this class instance represents.
const SymEngine::RCP<const SymEngine::Basic> &
get_RCP() const;
- //@}
+ /** @} */
/**
* @name Math and relational operators with (potentially) symbolic types
*/
- //@{
+ /** @{ */
/**
* Assignment operator.
Expression &
operator/=(const Expression &rhs);
- //@}
+ /** @} */
/**
* @name Math and relational operators with numeric types
*/
- //@{
+ /** @{ */
/**
* Assignment operator.
Expression &
operator/=(const NumberType &rhs);
- //@}
+ /** @} */
/**
* @name Differentiation
*/
- //@{
+ /** @{ */
/**
* Return the derivative of this object's @p expression
Expression
differentiate(const SymEngine::RCP<const SymEngine::Basic> &symbol) const;
- //@}
+ /** @} */
/**
* @name Dictionary-based substitution
*/
- //@{
+ /** @{ */
/**
* Perform substitution of all symbols found in this object's @p expression
substitute_and_evaluate(
const SymEngine::map_basic_basic &substitution_values) const;
- //@}
+ /** @} */
/**
* @name Conversion operators
*/
- //@{
+ /** @{ */
/**
* Conversion operator for real integer or floating point values, and
*/
operator const SymEngine::RCP<const SymEngine::Basic> &() const;
- //@}
+ /** @} */
protected:
/**
/**
* @name Type traits
*/
- //@{
+ /** @{ */
/**
* A struct to indicate whether a given @p NumberType is a supported
struct is_sd_number<Expression> : std::true_type
{};
- //@}
+ /** @} */
/**
* @name Bitwise operators
*/
- //@{
+ /** @{ */
/**
* Bitwise left shift operator.
std::istream &
operator>>(std::istream &stream, Expression &expression);
- //@}
+ /** @} */
/**
* @name Comparison operators
*/
- //@{
+ /** @{ */
/**
* Equality operator.
Expression
operator>=(const Expression &lhs, const Expression &rhs);
- //@}
+ /** @} */
/**
* @name Logical operators
*/
- //@{
+ /** @{ */
/**
* Logical not operator.
Expression
operator||(const Expression &lhs, const Expression &rhs);
- //@}
+ /** @} */
/**
* @name Mathematical operators
*/
- //@{
+ /** @{ */
/**
* Addition operator.
return lhs / Expression(rhs);
}
- //@}
+ /** @} */
} // namespace SD
} // namespace Differentiation
"The SymEngine LLVM optimizer does not (yet) support the "
"selected return type.");
- //@}
+ /** @} */
// Forward declarations
/**
* @name Independent variables
*/
- //@{
+ /** @{ */
/**
* Register a collection of symbols that represents an independent
std::size_t
n_independent_variables() const;
- //@}
+ /** @} */
/**
* @name Dependent variables
*/
- //@{
+ /** @{ */
/**
* Register a scalar symbolic expression that represents a dependent
std::size_t
n_dependent_variables() const;
- //@}
+ /** @} */
/**
* @name Optimization
*/
- //@{
+ /** @{ */
/**
* Select the @p optimization_method for the batch optimizer to
bool
optimized() const;
- //@}
+ /** @} */
/**
* @name Symbol substitution
*/
- //@{
+ /** @{ */
/**
* Perform batch substitution of all of the registered symbols
bool
values_substituted() const;
- //@}
+ /** @} */
/**
* @name Evaluation / data extraction
*/
- //@{
+ /** @{ */
/**
* Returns the result of a value substitution into the optimized
extract(const SymmetricTensor<rank, dim, Expression> &funcs,
const std::vector<ReturnType> &cached_evaluation) const;
- //@}
+ /** @} */
private:
/**
/**
* @name Symbolic variable creation
*/
- //@{
+ /** @{ */
/**
* Return an Expression representing a scalar symbolic variable
make_symbolic_function(const std::string & symbol,
const types::substitution_map &arguments);
- //@}
+ /** @} */
/**
* @name Symbolic differentiation
*/
- //@{
+ /** @{ */
/**
* Return the symbolic result of computing the partial derivative of the
Expression
differentiate(const Expression &f, const Expression &x);
- //@}
+ /** @} */
/**
* @name Symbol map creation and manipulation
*/
- //@{
+ /** @{ */
namespace internal
{
set_value_in_symbol_map(types::substitution_map & substitution_map,
const types::substitution_map &symbol_values);
- //@}
+ /** @} */
/**
* @name Symbol substitution map creation
*/
- //@{
+ /** @{ */
/**
* Return a substitution map that has the entry key given by @p symbol
const std::pair<ExpressionType, ValueType> &symbol_value,
const Args &...other_symbol_values);
- //@}
+ /** @} */
/**
* @name Symbol substitution map enlargement
*/
- //@{
+ /** @{ */
namespace internal
{
merge_substitution_maps(const types::substitution_map &substitution_map_in,
const Args &...other_substitution_maps_in);
- //@}
+ /** @} */
/**
* @name Symbol substitution and evaluation
*/
- //@{
+ /** @{ */
/**
* Return a substitution map that has any explicit interdependencies between
substitute_and_evaluate(const Expression &expression,
const Args &...symbol_values);
- //@}
+ /** @} */
} // namespace SD
} // namespace Differentiation
/**
* @name Symbolic variable creation
*/
- //@{
+ /** @{ */
/**
* Return a vector of Expressions representing a vectorial symbolic
const std::string & symbol,
const types::substitution_map &arguments);
- //@}
+ /** @} */
/**
* @name Symbolic differentiation
*/
- //@{
+ /** @{ */
/**
* Return the symbolic result of computing the partial derivative of the
differentiate(const SymmetricTensor<rank_1, dim, Expression> &S,
const Tensor<rank_2, dim, Expression> & T);
- //@}
+ /** @} */
/**
* @name Symbol map creation and manipulation
*/
- //@{
+ /** @{ */
/**
* A convenience function for adding empty entries, with the key values
const SymmetricTensor<rank, dim, SymbolicType> &symbol_tensor,
const SymmetricTensor<rank, dim, ValueType> & value_tensor);
- //@}
+ /** @} */
/**
* @name Symbol substitution map creation
*/
- //@{
+ /** @{ */
/**
* Return a substitution map that has the entry keys given by the
const SymmetricTensor<rank, dim, ExpressionType> &symbol_tensor,
const SymmetricTensor<rank, dim, ValueType> & value_tensor);
- //@}
+ /** @} */
/**
* @name Symbol substitution map enlargement
*/
- //@{
+ /** @{ */
/**
* A convenience function for adding an entry to the @p substitution_map.
const SymmetricTensor<rank, dim, ExpressionType> &symbol_tensor,
const SymmetricTensor<rank, dim, ValueType> & value_tensor);
- //@}
+ /** @} */
/**
* @name Symbol substitution and evaluation
*/
- //@{
+ /** @{ */
/**
* Perform a single substitution sweep of a set of symbols into the given
const SymmetricTensor<rank, dim, Expression> &expression_tensor,
const types::substitution_map & substitution_map);
- //@}
+ /** @} */
} // namespace SD
} // namespace Differentiation
extract_constant_modes(const DoFHandler<dim, spacedim> &dof_handler,
const ComponentMask & component_mask,
std::vector<std::vector<bool>> & constant_modes);
- //@}
+ /** @} */
/**
* @name Parallelization and domain decomposition
* and related classes to implement Schwarz preconditioners and smoothers,
* where the subdomains consist of small numbers of cells only.
*/
- //@{
+ /** @{ */
/**
* Return the set of degrees of freedom that live on a set of cells (i.e., a
has_support_on_face(const unsigned int shape_index,
const unsigned int face_index) const;
- //@}
+ /** @} */
/**
* @name Transfer and constraint matrices
* @{
virtual void
get_interpolation_matrix(const FiniteElement<dim, spacedim> &source,
FullMatrix<double> & matrix) const;
- //@}
+ /** @} */
/**
* @name Functions to support hp-adaptivity
const unsigned int subface,
FullMatrix<double> & matrix,
const unsigned int face_no = 0) const;
- //@}
+ /** @} */
/**
compare_for_domination(const FiniteElement<dim, spacedim> &fe_other,
const unsigned int codim = 0) const;
- //@}
+ /** @} */
/**
* Comparison operator.
unsigned int
component_to_block_index(const unsigned int component) const;
- //@}
+ /** @} */
/**
* @name Component and block matrices
virtual std::pair<Table<2, bool>, std::vector<unsigned int>>
get_constant_modes() const;
- //@}
+ /** @} */
/**
* @name Support points and interpolation
const std::vector<Vector<double>> &support_point_values,
std::vector<double> & nodal_values) const;
- //@}
+ /** @} */
/**
* Determine an estimate for the memory consumption (in bytes) of this
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup fe */
-/*@{*/
+/**
+ * @addtogroup fe
+ * @{
+ */
/**
* Implementation of Arnold-Boffi-Falk (ABF) elements, conforming with the
-/*@}*/
+/** @} */
DEAL_II_NAMESPACE_CLOSE
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup fe */
-/*@{*/
+/**
+ * @addtogroup fe
+ * @{
+ */
/**
* Implementation of a scalar Bernstein finite element @p that we call
-/*@}*/
+/** @} */
DEAL_II_NAMESPACE_CLOSE
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup fe */
-/*@{*/
+/**
+ * @addtogroup fe
+ * @{
+ */
/**
* Discontinuous finite elements based on Legendre polynomials.
get_dpo_vector(const unsigned int degree);
};
-/* @} */
+/** @} */
DEAL_II_NAMESPACE_CLOSE
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup fe */
-/*@{*/
+/**
+ * @addtogroup fe
+ * @{
+ */
/**
* Discontinuous finite elements based on monomials.
initialize_restriction();
};
-/*@}*/
+/** @} */
DEAL_II_NAMESPACE_CLOSE
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup fe */
-/*@{*/
+/**
+ * @addtogroup fe
+ * @{
+ */
/**
* Discontinuous finite elements evaluated at the mapped quadrature points.
friend class FE_DGPNonparametric;
};
-/*@}*/
+/** @} */
DEAL_II_NAMESPACE_CLOSE
class Quadrature;
#endif
-/*!@addtogroup fe */
-/*@{*/
+/**
+ * @addtogroup fe
+ * @{
+ */
/**
* Implementation of scalar, discontinuous tensor product elements based on
};
-/*@}*/
+/** @} */
DEAL_II_NAMESPACE_CLOSE
const RefinementCase<dim> &refinement_case =
RefinementCase<dim>::isotropic_refinement) const override;
- //@}
+ /** @} */
/**
* @name Functions to support hp
compare_for_domination(const FiniteElement<dim, spacedim> &fe_other,
const unsigned int codim = 0) const override final;
- //@}
+ /** @} */
/**
/**
* @name Access to shape functions
*/
- //@{
+ /** @{ */
/**
* Return the value of the shape function
const unsigned int interface_dof_index,
const unsigned int q_point) const;
- //@}
+ /** @} */
/**
* @name Access to jumps in shape functions and their derivatives
*/
- //@{
+ /** @{ */
/**
* Return the jump $\jump{u}=u_1 - u_2$ on the interface for the shape
jump_3rd_derivative(const unsigned int interface_dof_index,
const unsigned int q_point) const;
- //@}
+ /** @} */
/**
* @name Access to the average of shape functions and their derivatives
*/
- //@{
+ /** @{ */
/**
* Return the average value $\average{u}=\frac{1}{2}(u_1 + u_2)$ on the
average_hessian(const unsigned int interface_dof_index,
const unsigned int q_point) const;
- //@}
+ /** @} */
/**
* @name Access to values of global finite element fields
*/
- //@{
+ /** @{ */
/**
* Return the values of the selected scalar component of the finite
std::vector<solution_value_type<typename InputVector::value_type>>
&values) const;
- //@}
+ /** @} */
/**
* @name Access to jumps in global finite element fields
*/
- //@{
+ /** @{ */
/**
* Return the jump in the values of the selected scalar component of the
solution_third_derivative_type<typename InputVector::value_type>>
&third_derivatives) const;
- //@}
+ /** @} */
/**
* @name Access to the average of global finite element fields
*/
- //@{
+ /** @{ */
/**
* Return the average of the values of the selected scalar component of the
std::vector<solution_hessian_type<typename InputVector::value_type>>
&hessians) const;
- //@}
+ /** @} */
private:
/**
/**
* @name Access to shape functions
*/
- //@{
+ /** @{ */
/**
* Return the value of the vector components selected by this view
const unsigned int interface_dof_index,
const unsigned int q_point) const;
- //@}
+ /** @} */
/**
* @name Access to jumps in shape functions and their derivatives
*/
- //@{
+ /** @{ */
/**
* Return the jump vector $[\mathbf{u}]=\mathbf{u_1} - \mathbf{u_2}$ on the
jump_3rd_derivative(const unsigned int interface_dof_index,
const unsigned int q_point) const;
- //@}
+ /** @} */
/**
* @name Access to the average of shape functions and their derivatives
*/
- //@{
+ /** @{ */
/**
* Return the average vector $\average{\mathbf{u}}=\frac{1}{2}(\mathbf{u_1}
average_hessian(const unsigned int interface_dof_index,
const unsigned int q_point) const;
- //@}
+ /** @} */
/**
* @name Access to values of global finite element fields
*/
- //@{
+ /** @{ */
/**
* Return the values of the selected vector component of the finite
std::vector<solution_value_type<typename InputVector::value_type>>
&values) const;
- //@}
+ /** @} */
/**
* @name Access to jumps in global finite element fields
*/
- //@{
+ /** @{ */
/**
* Return the jump in the values of the selected vector component of the
solution_third_derivative_type<typename InputVector::value_type>>
&third_derivatives) const;
- //@}
+ /** @} */
/**
* @name Access to the average of global finite element fields
*/
- //@{
+ /** @{ */
/**
* Return the average of the values of the selected vector component of the
std::vector<solution_hessian_type<typename InputVector::value_type>>
&hessians) const;
- //@}
+ /** @} */
private:
/**
std::vector<Tensor<3, spacedim, typename InputVector::value_type>>
&third_derivatives) const;
- //@}
+ /** @} */
/**
* @name Access to the average of the function values and derivatives
*/
- //@{
+ /** @{ */
/**
* Return the average of the values of the
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup fe */
-/*@{*/
+/**
+ * @addtogroup fe
+ * @{
+ */
/**
* @warning Several aspects of the implementation are experimental. For the
#endif // DOXYGEN
-/*@}*/
+/** @} */
DEAL_II_NAMESPACE_CLOSE
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup fe */
-/*@{*/
+/**
+ * @addtogroup fe
+ * @{
+ */
/**
* This class represents an implementation of the
-/*@}*/
+/** @} */
DEAL_II_NAMESPACE_CLOSE
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup fe */
-/*@{*/
+/**
+ * @addtogroup fe
+ * @{
+ */
/**
* Definition of a finite element space with zero degrees of freedom and that,
};
-/*@}*/
+/** @} */
DEAL_II_NAMESPACE_CLOSE
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup fe */
-/*@{*/
+/**
+ * @addtogroup fe
+ * @{
+ */
/**
* Implementation of the scalar version of the P1 nonconforming finite
-/*@}*/
+/** @} */
DEAL_II_NAMESPACE_CLOSE
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup febase */
-/*@{*/
+/**
+ * @addtogroup fe
+ * @{
+ */
/**
* This class gives a unified framework for the implementation of
const std::unique_ptr<ScalarPolynomialsBase<dim>> poly_space;
};
-/*@}*/
+/** @} */
DEAL_II_NAMESPACE_CLOSE
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup febase */
-/*@{*/
+/**
+ * @addtogroup fe
+ * @{
+ */
/**
* @warning This class is not sufficiently tested yet!
PolynomialType poly_space;
};
-/*@}*/
+/** @} */
DEAL_II_NAMESPACE_CLOSE
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup fe */
-/*@{*/
+/**
+ * @addtogroup fe
+ * @{
+ */
/**
* Implementation of a scalar Lagrange finite element @p Qp that yields the
-/*@}*/
+/** @} */
DEAL_II_NAMESPACE_CLOSE
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup fe */
-/*@{*/
+/**
+ * @addtogroup fe
+ * @{
+ */
/**
* This class collects the basic methods used in FE_Q, FE_Q_DG0 and
hp_quad_dof_identities(const FiniteElement<dim, spacedim> &fe_other,
const unsigned int face_no = 0) const override;
- //@}
+ /** @} */
/**
* Attempt to construct an FE_Q object of degree 0
};
-/*@}*/
+/** @} */
DEAL_II_NAMESPACE_CLOSE
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup fe */
-/*@{*/
+/**
+ * @addtogroup fe
+ * @{
+ */
/**
* Implementation of a scalar Lagrange finite element $Q_p^+$ that yields the
-/*@}*/
+/** @} */
DEAL_II_NAMESPACE_CLOSE
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup fe */
-/*@{*/
+/**
+ * @addtogroup fe
+ * @{
+ */
/**
* Implementation of a scalar Lagrange finite element @p Qp+DG0 that yields
-/*@}*/
+/** @} */
DEAL_II_NAMESPACE_CLOSE
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup fe */
-/*@{*/
+/**
+ * @addtogroup fe
+ * @{
+ */
/**
* Implementation of hierarchical @p Qp shape functions that yield the finite
compare_for_domination(const FiniteElement<dim> &fe_other,
const unsigned int codim = 0) const override final;
- /*@}*/
+ /** @} */
/**
* Return the matrix interpolating from a face of one element to the face of
friend class FE_Q_Hierarchical;
};
-/*@}*/
+/** @} */
/* -------------- declaration of explicit specializations ------------- */
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup fe */
-/*@{*/
+/**
+ * @addtogroup fe
+ * @{
+ */
/**
* Implementation of a scalar Lagrange finite element @p Qp-iso-Q1
compare_for_domination(const FiniteElement<dim, spacedim> &fe_other,
const unsigned int codim = 0) const override final;
- //@}
+ /** @} */
};
-/*@}*/
+/** @} */
DEAL_II_NAMESPACE_CLOSE
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup fe */
-/*@{*/
+/**
+ * @addtogroup fe
+ * @{
+ */
/**
* Implementation of Raviart-Thomas (RT) elements. The Raviart-Thomas space
mutable Threads::Mutex mutex;
};
-/*@}*/
+/** @} */
/* -------------- declaration of explicit specializations ------------- */
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup feall */
-/*@{*/
+/**
+ * @addtogroup fe
+ * @{
+ */
/**
} // namespace FESeries
-/*@}*/
+/** @} */
compare_for_domination(const FiniteElement<dim, spacedim> &fe_other,
const unsigned int codim = 0) const override final;
- //@}
+ /** @} */
/**
* Implementation of the
#endif
-/*!@addtogroup feall */
-/*@{*/
+/**
+ * @addtogroup feall
+ * @{
+ */
/**
- //@}
+ /** @} */
/**
* @name Functions which should be in DoFTools
*/
- //@{
+ /** @{ */
/**
* Compute the interpolation of a the @p dof1-function @p u1 to a @p
* dof2-function @p u2. @p dof1 and @p dof2 need to be DoFHandlers based on
const AffineConstraints<typename OutVector::value_type> &constraints,
OutVector & z2);
- //@}
+ /** @} */
/**
* The numbering of the degrees of freedom in continuous finite elements is
* hierarchic, i.e. in such a way that we first number the vertex dofs, in
#endif
-/*@}*/
+/** @} */
DEAL_II_NAMESPACE_CLOSE
class FiniteElement;
#endif
-/*!@addtogroup feaccess */
-/*@{*/
+/** @addtogroup feaccess */
+/** @{ */
/**
* The enum type given to the constructors of FEValues, FEFaceValues and
} // namespace internal
-/*@}*/
+/** @} */
/// @name Access to shape function values
///
/// These fields are filled by the finite element.
- //@{
+ /** @{ */
/**
* Value of a shape function at a quadrature point on the cell, face or
const unsigned int point_no,
const unsigned int component) const;
- //@}
+ /** @} */
/// @name Access to values of global finite element fields
- //@{
+ /** @{ */
/**
* Return the values of a finite element function restricted to the current
ArrayView<std::vector<typename InputVector::value_type>> values,
const bool quadrature_points_fastest) const;
- //@}
+ /** @} */
/// @name Access to derivatives of global finite element fields
- //@{
+ /** @{ */
/**
* Compute the gradients of a finite element at the quadrature points of a
gradients,
const bool quadrature_points_fastest = false) const;
- //@}
+ /** @} */
/// @name Access to second derivatives
///
/// Hessian matrices and Laplacians of global finite element fields
- //@{
+ /** @{ */
/**
* Compute the tensor of second derivatives of a finite element at the
std::vector<std::vector<typename InputVector::value_type>> &laplacians,
const bool quadrature_points_fastest = false) const;
- //@}
+ /** @} */
/// @name Access to third derivatives of global finite element fields
- //@{
+ /** @{ */
/**
* Compute the tensor of third derivatives of a finite element at the
std::vector<Tensor<3, spacedim, typename InputVector::value_type>>>
third_derivatives,
const bool quadrature_points_fastest = false) const;
- //@}
+ /** @} */
/// @name Cell degrees of freedom
- //@{
+ /** @{ */
/**
* Return an object that can be thought of as an array containing all
std_cxx20::ranges::iota_view<unsigned int, unsigned int>
dof_indices_ending_at(const unsigned int end_dof_index) const;
- //@}
+ /** @} */
/// @name Geometry of the cell
- //@{
+ /** @{ */
/**
* Return an object that can be thought of as an array containing all
const std::vector<Tensor<1, spacedim>> &
get_normal_vectors() const;
- //@}
+ /** @} */
/// @name Extractors Methods to extract individual components
- //@{
+ /** @{ */
/**
* Create a view of the current FEValues object that represents a particular
const FEValuesViews::Tensor<2, dim, spacedim> &
operator[](const FEValuesExtractors::Tensor<2> &tensor) const;
- //@}
+ /** @} */
/// @name Access to the raw data
- //@{
+ /** @{ */
/**
* Constant reference to the selected mapping object.
*/
std::size_t
memory_consumption() const;
- //@}
+ /** @} */
/**
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup mapping */
-/*@{*/
+/**
+ * @addtogroup mapping
+ * @{
+ */
/**
* Mapping class that uses C1 (continuously differentiable) cubic mappings of
std::vector<Point<dim>> & a) const override;
};
-/*@}*/
+/** @} */
/* -------------- declaration of explicit specializations ------------- */
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup mapping */
-/*@{*/
+/**
+ * @addtogroup mapping
+ * @{
+ */
/**
* A class providing a mapping from the reference cell to cells that are
&output_data) const;
};
-/*@}*/
+/** @} */
DEAL_II_NAMESPACE_CLOSE
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup mapping */
-/*@{*/
-
+/**
+ * @addtogroup mapping
+ * @{
+ */
/**
* This class consistently uses a user-provided finite element on all cells of a
-/*@}*/
+/** @} */
/*----------------------------------------------------------------------*/
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup mapping */
-/*@{*/
+/**
+ * @addtogroup mapping
+ * @{
+ */
/**
* The MappingFEField is a generalization of the MappingQEulerian class, for
friend class MappingFEField;
};
-/*@}*/
+/** @} */
/* -------------- declaration of explicit specializations ------------- */
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup mapping */
-/*@{*/
-
+/**
+ * @addtogroup mapping
+ * @{
+ */
/**
* This class implements the functionality for Manifold conforming
-/*@}*/
+/** @} */
/*----------------------------------------------------------------------*/
class MappingQCache;
#endif
-/*!@addtogroup mapping */
-/*@{*/
-
+/**
+ * @addtogroup mapping
+ * @{
+ */
/**
* This class implements the functionality for polynomial mappings $Q_p$ of
template <int dim, int spacedim = dim>
using MappingQGeneric = MappingQ<dim, spacedim>;
-/*@}*/
+/** @} */
/*----------------------------------------------------------------------*/
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup mapping */
-/*@{*/
-
+/**
+ * @addtogroup mapping
+ * @{
+ */
/**
* Implementation of a $d$-linear mapping from the reference cell to a general
};
-/*@}*/
+/** @} */
DEAL_II_NAMESPACE_CLOSE
class Vector;
-/*!@addtogroup mapping */
-/*@{*/
+/**
+ * @addtogroup mapping
+ * @{
+ */
/**
* This class provides a mapping that adds to the location of each cell
shiftmap_dof_handler;
};
-/*@}*/
+/** @} */
/*----------------------------------------------------------------------*/
#endif
-/*!@addtogroup mapping */
-/*@{*/
-
+/**
+ * @addtogroup mapping
+ * @{
+ */
/**
* This class implements a caching strategy for objects of the MappingQ family
bool uses_level_info;
};
-/*@}*/
+/** @} */
DEAL_II_NAMESPACE_CLOSE
class Vector;
-/*!@addtogroup mapping */
-/*@{*/
+/**
+ * @addtogroup mapping
+ * @{
+ */
/**
* This class is an extension of the MappingQ1Eulerian class to higher order
mutable Threads::Mutex fe_values_mutex;
};
-/*@}*/
+/** @} */
/*----------------------------------------------------------------------*/
/**
* @name Creating meshes for basic geometries
*/
- ///@{
+ //** @{ */
/**
* Initialize the given triangulation with a hypercube (line in 1D, square
Triangulation<3> & vol_tria,
const CGALWrappers::AdditionalData<3> &data =
CGALWrappers::AdditionalData<3>{});
- ///@}
+ //** @} */
/**
* @name Creating meshes from other meshes
*/
- ///@{
+ //** @{ */
/**
* Given the two triangulations specified as the first two arguments, create
const double p2 = 1.0,
const bool colorize = false);
- ///@}
+ //** @} */
/**
* @name Creating lower-dimensional meshes
*
* Created from parts of higher-dimensional meshes.
*/
- ///@{
+ //** @{ */
#ifdef _MSC_VER
// Microsoft's VC++ has a bug where it doesn't want to recognize that
const std::set<types::boundary_id> &boundary_ids =
std::set<types::boundary_id>());
- ///@}
+ //** @} */
/**
* @name Exceptions
*/
- ///@{
+ //** @{ */
/**
DeclExceptionMsg(ExcInvalidInputOrientation,
"The input to this function is oriented in a way that will"
" cause all cells to have negative measure.");
- ///@}
+ //** @} */
#ifndef DOXYGEN
// These functions are only implemented with specializations; declare them
/**
* @name Information about meshes and cells
*/
- /*@{*/
+ /** @{ */
/**
* Return the diameter of a triangulation. The diameter is computed using
tuple<std::vector<Point<spacedim>>, std::vector<CellData<dim>>, SubCellData>
get_coarse_mesh_description(const Triangulation<dim, spacedim> &tria);
- /*@}*/
+ /** @} */
/**
* @name Functions supporting the creation of meshes
*/
- /*@{*/
+ /** @{ */
/**
* Remove vertices that are not referenced by any of the cells. This
void
consistently_order_cells(std::vector<CellData<dim>> &cells);
- /*@}*/
+ /** @} */
/**
* @name Rotating, stretching and otherwise transforming meshes
*/
- /*@{*/
+ /** @{ */
/**
* Transform the vertices of the given triangulation by applying the
regularize_corner_cells(Triangulation<dim, spacedim> &tria,
const double limit_angle_fraction = .75);
- /*@}*/
+ /** @} */
/**
* @name Finding cells and vertices of a triangulation
*/
- /*@{*/
+ /** @{ */
/**
* Given a Triangulation's @p cache and a list of @p points, call
get_longest_direction(
typename Triangulation<dim, spacedim>::active_cell_iterator cell);
- /*@}*/
+ /** @} */
/**
* @name Partitions and subdomains of triangulations
*/
- /*@{*/
+ /** @{ */
/**
* Produce a sparsity pattern in which nonzero entries indicate that two
std::vector<bool>
get_locally_owned_vertices(const Triangulation<dim, spacedim> &triangulation);
- /*@}*/
+ /** @} */
/**
* @name Comparing different meshes
*/
- /*@{*/
+ /** @{ */
/**
* Given two meshes (i.e. objects of type Triangulation or DoFHandler) that
bool
have_same_coarse_mesh(const MeshType &mesh_1, const MeshType &mesh_2);
- /*@}*/
+ /** @} */
/**
* @name Dealing with distorted cells
*/
- /*@{*/
+ /** @{ */
/**
* Given a triangulation and a list of cells whose children have become
- /*@}*/
+ /** @} */
/**
* @name Extracting and creating patches of cells
*
* These functions extract and create patches of cells surrounding a single
* cell, and creating triangulation out of them.
*/
- /*@{*/
+ /** @{ */
/**
get_dof_to_support_patch_map(DoFHandler<dim, spacedim> &dof_handler);
- /*@}*/
+ /** @} */
/**
* @name Dealing with periodic domains
*/
- /*@{*/
+ /** @{ */
/**
* Data type that provides all information necessary to create periodicity
dealii::Tensor<1, MeshType::space_dimension>(),
const FullMatrix<double> &matrix = FullMatrix<double>());
- /*@}*/
+ /** @} */
/**
* @name Dealing with boundary and manifold ids
*/
- /*@{*/
+ /** @{ */
/**
* Copy boundary ids to manifold ids on faces and edges at the boundary. The
return numbers::flat_manifold_id;
},
bool overwrite_only_flat_manifold_ids = true);
- /*@}*/
+ /** @} */
/**
* Exchange arbitrary data of type @p DataType provided by the function
/**
* @name Exceptions
*/
- /*@{*/
+ /** @{ */
/**
* Exception
<< "The given vertex with index " << arg1
<< " is not used in the given triangulation.");
- /*@}*/
+ /** @} */
} /*namespace GridTools*/
/**
* @name Dereferencing
*/
- /*@{*/
+ /** @{ */
/**
* Dereferencing operator, returns a reference to an accessor. Usage is thus
* like <tt>(*i).index ();</tt>
const Accessor &
access_any() const;
- /*@}*/
+ /** @} */
/**
* Assignment operator.
/**
* @name Advancement of iterators
*/
- /*@{*/
+ /** @{ */
/**
* Prefix <tt>++</tt> operator: <tt>++iterator</tt>. This operator advances
* the iterator to the next element and returns a reference to
*/
TriaRawIterator
operator--(int);
- /*@}*/
+ /** @} */
/**
* Return the state of the iterator.
/**
* @name Exceptions
*/
- /*@{*/
+ /** @{ */
/**
* Exception for TriaObjects with level, i.e. cells.
*/
*/
DeclException0(ExcInvalidComparison);
- /*@}*/
+ /** @} */
protected:
/**
* Object holding the real data.
/**
* @name Advancement of iterators
*/
- /*@{*/
+ /** @{ */
/**
* Prefix <tt>++</tt> operator: <tt>++i</tt>. This operator advances the
* iterator to the next used element and returns a reference to
*/
TriaIterator<Accessor>
operator--(int);
- /*@}*/
+ /** @} */
/**
* Declare some aliases which are standard for iterators and are used
/**
* @name Advancement of iterators
*/
- /*@{*/
+ /** @{ */
/**
* Postfix <tt>++</tt> operator: <tt>i++</tt>. This operator advances the
* iterator to the next active element, but returns an iterator to the
*/
TriaActiveIterator<Accessor>
operator--(int);
- /*@}*/
+ /** @} */
/**
* Declare some alias which are standard for iterators and are used
/**
* @name Size information
*/
- //@{
+ /** @{ */
/**
* Number of blocks in index field.
std::string
to_string() const;
- //@}
+ /** @} */
/**
* @name Index conversion
* object. If applied to other objects, the numbers obtained from these
* functions are meaningless.
*/
- //@{
+ /** @{ */
/**
* Return the block and the index within that block for the global index @p
*/
size_type
block_start(const unsigned int i) const;
- //@}
+ /** @} */
/**
* Copy operator.
/**
* @name Creation of a BlockLinearOperator
*/
-//@{
+/** @{ */
/**
* @relatesalso BlockLinearOperator
-//@}
+/** @} */
/**
* @name Manipulation of a BlockLinearOperator
*/
-//@{
+/** @{ */
/**
* @relatesalso LinearOperator
return return_op;
}
-//@}
+/** @} */
DEAL_II_NAMESPACE_CLOSE
#endif
-/*! @addtogroup Matrix1
- *@{
+/**
+ * @addtogroup Matrix1
+ * @{
*/
/**
int,
<< "The blocks [" << arg1 << ',' << arg2 << "] and [" << arg3
<< ',' << arg4 << "] have differing column numbers.");
- //@}
+ /** @} */
protected:
/**
* Release all memory and return to a state just like after having called
};
-/*@}*/
+/** @} */
#ifndef DOXYGEN
/* ------------------------- Template functions ---------------------- */
DEAL_II_NAMESPACE_OPEN
-/*! @addtogroup Matrix1
- *@{
+/**
+ * @addtogroup Matrix1
+ * @{
*/
/**
* @name Constructors and initialization
*/
- //@{
+ /** @{ */
/**
* Constructor; initializes the matrix to be empty, without any structure,
* i.e. the matrix is not usable at all. This constructor is therefore only
*/
virtual void
reinit(const BlockSparsityPattern &sparsity);
- //@}
+ /** @} */
/**
* @name Information on the matrix
*/
- //@{
+ /** @{ */
/**
* Return whether the object is empty. It is empty if either both dimensions
* are zero or no BlockSparsityPattern is associated.
*/
std::size_t
memory_consumption() const;
- //@}
+ /** @} */
/**
* @name Multiplications
*/
- //@{
+ /** @{ */
/**
* Matrix-vector multiplication: let $dst = M*src$ with $M$ being this
* matrix.
void
Tvmult(Vector<nonblock_number> & dst,
const Vector<nonblock_number> &src) const;
- //@}
+ /** @} */
/**
* @name Preconditioning methods
*/
- //@{
+ /** @{ */
/**
* Apply the Jacobi preconditioner, which multiplies every element of the
* <tt>src</tt> vector by the inverse of the respective diagonal element and
precondition_Jacobi(Vector<number2> & dst,
const Vector<number2> &src,
const number omega = 1.) const;
- //@}
+ /** @} */
/**
* @name Input/Output
*/
- //@{
+ /** @{ */
/**
* Print the matrix in the usual format, i.e. as a matrix and not as a list
* of nonzero elements. For better readability, elements not in the matrix
const unsigned int width = 0,
const char * zero_string = " ",
const double denominator = 1.) const;
- //@}
+ /** @} */
/**
* @addtogroup Exceptions
* @{
* Exception
*/
DeclException0(ExcBlockDimensionMismatch);
- //@}
+ /** @} */
private:
/**
-/*@}*/
+/** @} */
/* ------------------------- Template functions ---------------------- */
class BlockVector;
#endif
-/*! @addtogroup Matrix1
- *@{
+/**
+ * @addtogroup Matrix1
+ * @{
*/
Table<2, SparseMatrixEZ<Number>> blocks;
};
-/*@}*/
+/** @} */
/*----------------------------------------------------------------------*/
class BlockDynamicSparsityPattern;
#endif
-/*! @addtogroup Sparsity
- *@{
+/**
+ * @addtogroup Sparsity
+ * @{
*/
int,
<< "The blocks [" << arg1 << ',' << arg2 << "] and [" << arg3
<< ',' << arg4 << "] have differing column numbers.");
- //@}
+ /** @} */
protected:
/**
using BlockSparsityPatternBase<DynamicSparsityPattern>::reinit;
};
-/*@}*/
+/** @} */
#ifdef DEAL_II_WITH_TRILINOS
namespace TrilinosWrappers
{
- /*! @addtogroup TrilinosWrappers
- *@{
+ /**
+ * @addtogroup TrilinosWrappers
+ * @{
*/
/**
using BlockSparsityPatternBase<SparsityPattern>::reinit;
};
- /*@}*/
+ /** @} */
} /* namespace TrilinosWrappers */
#endif
-/*! @addtogroup Vectors
- *@{
+/**
+ * @addtogroup Vectors
+ * @{
*/
* Exception
*/
DeclException0(ExcIteratorRangeDoesNotMatchVectorSize);
- //@}
+ /** @} */
};
-/*@}*/
+/** @} */
#ifndef DOXYGEN
/*----------------------- Inline functions ----------------------------------*/
DEAL_II_NAMESPACE_OPEN
-/*! @addtogroup Vectors
- *@{
+/**
+ * @addtogroup Vectors
+ * @{
*/
namespace internal
"different block vectors. There is no reasonable way "
"to do this.");
- //@}
+ /** @} */
private:
/**
* Pointer to the block vector object to which this iterator points.
};
-/*@}*/
+/** @} */
/*----------------------- Inline functions ----------------------------------*/
class FullMatrix;
# endif
-/*! @addtogroup Matrix1
- *@{
+/**
+ * @addtogroup Matrix1
+ * @{
*/
/**
/**
* @name Constructors and initialization.
*/
- //@{
+ /** @{ */
/**
* Constructor; initializes the matrix to be empty, without any structure,
* i.e. the matrix is not usable at all. This constructor is therefore only
*/
virtual void
clear();
- //@}
+ /** @} */
/**
* @name Information on the matrix
*/
- //@{
+ /** @{ */
/**
* Return whether the object is empty. It is empty if either both dimensions
* are zero or no ChunkSparsityPattern is associated.
std::size_t
memory_consumption() const;
- //@}
+ /** @} */
/**
* @name Modifying entries
*/
- //@{
+ /** @{ */
/**
* Set the element (<i>i,j</i>) to <tt>value</tt>. Throws an error if the
* entry does not exist or if <tt>value</tt> is not a finite number. Still,
void
add(const number factor, const ChunkSparseMatrix<somenumber> &matrix);
- //@}
+ /** @} */
/**
* @name Entry Access
*/
- //@{
+ /** @{ */
/**
* Return the value of the entry (<i>i,j</i>). This may be an expensive
size_type * column_indices,
number * values) const;
- //@}
+ /** @} */
/**
* @name Matrix vector multiplications
*/
- //@{
+ /** @{ */
/**
* Matrix-vector multiplication: let <i>dst = M*src</i> with <i>M</i> being
* this matrix.
const Vector<somenumber> &x,
const Vector<somenumber> &b) const;
- //@}
+ /** @} */
/**
* @name Matrix norms
*/
- //@{
+ /** @{ */
/**
* Return the l1-norm of the matrix, that is $|M|_1=max_{all columns
*/
real_type
frobenius_norm() const;
- //@}
+ /** @} */
/**
* @name Preconditioning methods
*/
- //@{
+ /** @{ */
/**
* Apply the Jacobi preconditioner, which multiplies every element of the
SSOR_step(Vector<somenumber> & v,
const Vector<somenumber> &b,
const number om = 1.) const;
- //@}
+ /** @} */
/**
* @name Iterators
*/
- //@{
+ /** @{ */
/**
* Iterator starting at first entry of the matrix. This is the version for
*/
iterator
end(const unsigned int r);
- //@}
+ /** @} */
/**
* @name Input/Output
*/
- //@{
+ /** @{ */
/**
* Print the matrix to the given stream, using the format <tt>(line,col)
*/
void
block_read(std::istream &in);
- //@}
+ /** @} */
/**
* @addtogroup Exceptions
* @{
"You are attempting an operation on two matrices that "
"are the same object, but the operation requires that the "
"two objects are in fact different.");
- //@}
+ /** @} */
private:
/**
* Pointer to the sparsity pattern used for this matrix. In order to
friend class ChunkSparseMatrixIterators::Accessor;
};
-/*@}*/
+/** @} */
# ifndef DOXYGEN
/*---------------------- Inline functions -----------------------------------*/
class ChunkSparseMatrix;
#endif
-/*! @addtogroup Sparsity
- *@{
+/**
+ * @addtogroup Sparsity
+ * @{
*/
size_type,
<< "The array has size " << arg1 << " but should have size "
<< arg2);
- //@}
+ /** @} */
private:
/**
* Number of rows that this sparsity structure shall represent.
};
-/*@}*/
+/** @} */
/*---------------------- Inline functions -----------------------------------*/
#ifndef DOXYGEN
/**
* @name Indirectly applying constraints to LinearOperator
*/
-//@{
+/** @{ */
/**
return return_comp;
}
-//@}
+/** @} */
DEAL_II_NAMESPACE_CLOSE
/**
* @name Constructors and initialization
*/
- //@{
+ /** @{ */
/**
* Constructor. Initialize the matrix to be empty, without any structure,
* i.e., the matrix is not usable at all. This constructor is therefore
void
reinit(Utilities::CUDA::Handle & handle,
const ::dealii::SparseMatrix<Number> &sparse_matrix_host);
- //@}
+ /** @} */
/**
* @name Information on the matrix
*/
- //@{
+ /** @{ */
/**
* Return the dimension of the codomain (or range) space. Note that the
* matrix is of dimension $m \times n$.
const unsigned int width = 0,
const char * zero_string = " ",
const double denominator = 1.) const;
- //@}
+ /** @} */
/**
* @name Modifying entries
*/
- //@{
+ /** @{ */
/**
* Multiply the entire matrix by a fixed factor.
*/
*/
SparseMatrix &
operator/=(const Number factor);
- //@}
+ /** @} */
/**
* @name Multiplications
*/
- //@{
+ /** @{ */
/**
* Matrix-vector multiplication: let $dst = M \cdot src$ with $M$
* being this matrix.
residual(LinearAlgebra::CUDAWrappers::Vector<Number> & dst,
const LinearAlgebra::CUDAWrappers::Vector<Number> &x,
const LinearAlgebra::CUDAWrappers::Vector<Number> &b) const;
- //@}
+ /** @} */
/**
* @name Matrix norms
*/
- //@{
+ /** @{ */
/**
* 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
*/
Number
frobenius_norm() const;
- //@}
+ /** @} */
/**
* @name Access to underlying CUDA data
*/
- //@{
+ /** @{ */
/**
* Return a tuple containing the pointer to the values of matrix, the
* pointer to the columns indices, the pointer to the rows pointer,
*/
std::tuple<Number *, int *, int *, cusparseMatDescr_t, cusparseSpMatDescr_t>
get_cusparse_matrix() const;
- //@}
+ /** @} */
private:
/**
class DynamicSparsityPattern;
#endif
-/*! @addtogroup Sparsity
- *@{
+/**
+ * @addtogroup Sparsity
+ * @{
*/
friend class DynamicSparsityPatternIterators::Accessor;
};
-/*@}*/
+/** @} */
/*---------------------- Inline functions -----------------------------------*/
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup Solvers */
-/*@{*/
+/**
+ * @addtogroup Solvers
+ * @{
+ */
/**
* Power method (von Mises) for eigenvalue computations.
AdditionalData additional_data;
};
-/*@}*/
+/** @} */
//---------------------------------------------------------------------------
/**
* @addtogroup Exceptions
*/
- //@{
+ /** @{ */
/**
* This function only works for quadratic matrices.
<< "An error with error number " << arg1
<< " occurred while calling a Trilinos function");
- //@}
+ /** @} */
} // namespace LACExceptions
class LAPACKFullMatrix;
#endif
-/*! @addtogroup Matrix1
- *@{
+/**
+ * @addtogroup Matrix1
+ * @{
*/
/**
* @name Constructors and initialization. See also the base class Table.
*/
- //@{
+ /** @{ */
/**
* Constructor. Initialize the matrix as a square matrix with dimension
std::size_t
memory_consumption() const;
- //@}
+ /** @} */
///@name Iterator functions
- //@{
+ /** @{ */
/**
* Mutable iterator starting at the first entry of row <tt>r</tt>.
const_iterator
end(const size_type r) const;
- //@}
+ /** @} */
///@name Modifying operators
- //@{
+ /** @{ */
/**
* Scale the entire matrix by a fixed factor.
void
right_invert(const FullMatrix<number2> &M);
- //@}
+ /** @} */
///@name Multiplications
- //@{
+ /** @{ */
/**
* Matrix-matrix-multiplication.
void
backward(Vector<number2> &dst, const Vector<number2> &src) const;
- //@}
+ /** @} */
/**
* @addtogroup Exceptions
* Exception
*/
DeclException0(ExcMatrixNotPositiveDefinite);
- //@}
+ /** @} */
};
/**@}*/
class Vector;
#endif
-/*! @addtogroup Matrix2
- *@{
+/**
+ * @addtogroup Matrix2
+ * @{
*/
FullMatrix<double> storage;
};
-/*@}*/
+/** @} */
#ifndef DOXYGEN
/*-------------------------Inline functions -------------------------------*/
DEAL_II_NAMESPACE_OPEN
-/*! @addtogroup Matrix1
- *@{
+/**
+ * @addtogroup Matrix1
+ * @{
*/
{
namespace distributed
{
- /*! @addtogroup Vectors
- *@{
+ /**
+ * @addtogroup Vectors
+ * @{
*/
/**
* @name 1: Basic operations
*/
- //@{
+ /** @{ */
/**
* Constructor. There are three ways to use this constructor. First,
*/
void
swap(BlockVector<Number> &v);
- //@}
+ /** @} */
/**
* @name 2: Implementation of VectorSpaceVector
*/
- //@{
+ /** @{ */
/**
* Change the dimension to that of the vector V. The elements of V are not
*/
virtual std::size_t
memory_consumption() const override;
- //@}
+ /** @} */
/**
* @addtogroup Exceptions
* Exception
*/
DeclException0(ExcIteratorRangeDoesNotMatchVectorSize);
- //@}
+ /** @} */
};
- /*@}*/
+ /** @} */
} // end of namespace distributed
{
namespace distributed
{
- /*! @addtogroup Vectors
- *@{
+ /**
+ * @addtogroup Vectors
+ * @{
*/
/**
/**
* @name 1: Basic Object-handling
*/
- //@{
+ /** @{ */
/**
* Empty constructor.
*/
Vector<Number, MemorySpace> &
operator=(const Vector<Number2, MemorySpace> &in_vector);
- //@}
+ /** @} */
/**
* @name 2: Parallel data exchange
*/
- //@{
+ /** @{ */
/**
* This function copies the data that has accumulated in the data buffer
* for ghost indices to the owning processor. For the meaning of the
import(const Vector<Number, MemorySpace2> &src,
VectorOperation::values operation);
- //@}
+ /** @} */
/**
* @name 3: Implementation of VectorSpaceVector
*/
- //@{
+ /** @{ */
/**
* Change the dimension to that of the vector V. The elements of V are not
*/
virtual std::size_t
memory_consumption() const override;
- //@}
+ /** @} */
/**
* @name 4: Other vector operations not included in VectorSpaceVector
*/
- //@{
+ /** @{ */
/**
* Sets all elements of the vector to the scalar @p s. If the scalar is
void
sadd(const Number s, const Vector<Number, MemorySpace> &V);
- //@}
+ /** @} */
/**
* @name 5: Entry access and local data representation
*/
- //@{
+ /** @{ */
/**
* Return the local size of the vector, i.e., the number of indices
*/
real_type
lp_norm(const real_type p) const;
- //@}
+ /** @} */
/**
* @name 6: Mixed stuff
*/
- //@{
+ /** @{ */
/**
* Return a reference to the MPI communicator object in use with this
const std::vector<ArrayView<const Number>> &
shared_vector_data() const;
- //@}
+ /** @} */
/**
* Attempt to perform an operation between two incompatible vector types.
template <typename Number2>
friend class BlockVector;
};
- /*@}*/
+ /** @} */
/*-------------------- Inline functions ---------------------------------*/
*/
namespace LinearAlgebra
{
- /*! @addtogroup Vectors
- *@{
+ /**
+ * @addtogroup Vectors
+ * @{
*/
/**
friend class Vector;
};
- /*@}*/
+ /** @} */
/*--------------------------- Inline functions ----------------------------*/
template <typename Number>
/**
* @name In-place vector space operations
*/
- //@{
+ /** @{ */
/**
* Addition with a LinearOperator @p second_op with the same @p Domain and
*/
bool is_null_operator;
- //@}
+ /** @} */
};
/**
* @name Vector space operations
*/
-//@{
+/** @{ */
/**
* @relatesalso LinearOperator
return number * op;
}
-//@}
+/** @} */
/**
* @name Composition and manipulation of a LinearOperator
*/
-//@{
+/** @{ */
/**
* @relatesalso LinearOperator
return inverse_operator(op, solver);
}
-//@}
+/** @} */
/**
* @name Creation of a LinearOperator
*/
-//@{
+/** @{ */
/**
* @relatesalso LinearOperator
}
-//@}
+/** @} */
#ifndef DOXYGEN
/**
* @name In-place vector space operations
*/
- //@{
+ /** @{ */
/**
* Addition with a PackagedOperation @p second_comp with the same @p Range.
*this = *this * number;
return *this;
}
- //@}
+ /** @} */
/**
* Store the result of the PackagedOperation in a vector v of the @p Range
/**
* @name Vector space operations
*/
-//@{
+/** @{ */
/**
* @relatesalso PackagedOperation
return PackagedOperation<Range>(offset) - comp;
}
-//@}
+/** @} */
/**
* @name Creation of a PackagedOperation object
*/
-//@{
+/** @{ */
namespace internal
{
return return_comp;
}
-//@}
+/** @} */
DEAL_II_NAMESPACE_CLOSE
{
namespace MPI
{
- /*! @addtogroup PETScWrappers
- *@{
+ /**
+ * @addtogroup PETScWrappers
+ * @{
*/
/**
- /*@}*/
+ /** @} */
// ------------- inline and template functions -----------------
namespace MPI
{
- /*! @addtogroup PETScWrappers
- *@{
+ /**
+ * @addtogroup PETScWrappers
+ * @{
*/
/**
DeclException0(ExcNonMatchingBlockVectors);
};
- /*@}*/
+ /** @} */
/*--------------------- Inline functions --------------------------------*/
namespace PETScWrappers
{
- /*! @addtogroup PETScWrappers
- *@{
+ /**
+ * @addtogroup PETScWrappers
+ * @{
*/
/**
do_reinit(const size_type m, const size_type n);
};
- /*@}*/
+ /** @} */
} // namespace PETScWrappers
<< "The number of local rows " << arg1
<< " must be larger than the total number of rows "
<< arg2);
- //@}
+ /** @} */
/**
* Return the square of the norm of the vector $v$ with respect to the
DEAL_II_NAMESPACE_OPEN
-/*! @addtogroup PETScWrappers
- *@{
+/**
+ * @addtogroup PETScWrappers
+ * @{
*/
namespace PETScWrappers
{
#endif
-/*! @addtogroup Preconditioners
- *@{
+/**
+ * @addtogroup Preconditioners
+ * @{
*/
-/*@}*/
+/** @} */
/* ---------------------------------- Inline functions ------------------- */
#ifndef DOXYGEN
DEAL_II_NAMESPACE_OPEN
-/*! @addtogroup Preconditioners
- *@{
+/**
+ * @addtogroup Preconditioners
+ * @{
*/
*/
DeclException0(ExcInverseMatricesAlreadyExist);
- //@}
+ /** @} */
protected:
/**
Tstep(Vector<number2> &dst, const Vector<number2> &rhs) const;
};
-/*@}*/
+/** @} */
//---------------------------------------------------------------------------
#ifndef DOXYGEN
#endif
-/*! @addtogroup Preconditioners
- *@{
+/**
+ * @addtogroup Preconditioners
+ * @{
*/
/**
*/
DeclException0(ExcNoMatrixGivenToUse);
- //@}
+ /** @} */
protected:
/**
* Stores the name of the preconditioning.
const typename VectorType::value_type omega;
};
-/*@}*/
+/** @} */
/* --------------------- Inline and template functions ------------------- */
namespace LinearAlgebra
{
- /*! @addtogroup Vectors
- *@{
+ /**
+ * @addtogroup Vectors
+ * @{
*/
/**
/**
* @name 1: Basic Object-handling
*/
- //@{
+ /** @{ */
/**
* Empty constructor.
*/
*/
const_iterator
end() const;
- //@}
+ /** @} */
/**
* @name 2: Data-Access
*/
- //@{
+ /** @{ */
/**
* Read access to the data in the position corresponding to @p
*/
Number &
local_element(const size_type local_index);
- //@}
+ /** @} */
/**
* @name 3: Modification of vectors
*/
- //@{
+ /** @{ */
/**
* This function adds a whole set of values stored in @p values to the
*/
std::size_t
memory_consumption() const;
- //@}
+ /** @} */
protected:
#ifdef DEAL_II_WITH_TRILINOS
};
};
- /*@}*/
+ /** @} */
/*---------------------------- Inline functions ---------------------------*/
/**
* @name Creation of a LinearOperator related to the Schur Complement
*/
-//@{
+/** @{ */
/**
* @relatesalso LinearOperator
return -1.0 * C * A_inv * B;
}
-//@}
+/** @} */
/**
* @name Creation of PackagedOperation objects related to the Schur Complement
*/
-//@{
+/** @{ */
/**
* @relatesalso PackagedOperation
return A_inv * (f - B * y);
}
-//@}
+/** @} */
DEAL_II_NAMESPACE_CLOSE
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup Solvers */
-/*@{*/
+/**
+ * @addtogroup Solvers
+ * @{
+ */
namespace internal
{
iterate(const MatrixType &A, const PreconditionerType &preconditioner);
};
-/*@}*/
+/** @} */
/*-------------------------Inline functions -------------------------------*/
#ifndef DOXYGEN
#endif
-/*!@addtogroup Solvers */
-/*@{*/
+/** @addtogroup Solvers */
+/** @{ */
/**
* This class implements the preconditioned Conjugate Gradients (CG)
};
-/*@}*/
+/** @} */
/*------------------------- Implementation ----------------------------*/
class ParameterHandler;
#endif
-/*!@addtogroup Solvers */
-/*@{*/
+/**
+ * @addtogroup Solvers
+ * @{
+ */
/**
* Control class to determine convergence of iterative solvers.
unsigned int n_converged_iterations;
};
-/*@}*/
+/** @} */
//---------------------------------------------------------------------------
#ifndef DOXYGEN
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup Solvers */
-/*@{*/
+/**
+ * @addtogroup Solvers
+ * @{
+ */
/**
* FIRE (Fast Inertial Relaxation Engine) for minimization of (potentially
const AdditionalData additional_data;
};
-/*@}*/
+/** @} */
/*------------------------- Implementation ----------------------------*/
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup Solvers */
-/*@{*/
+/**
+ * @addtogroup Solvers
+ * @{
+ */
namespace internal
{
FullMatrix<double> H1;
};
-/*@}*/
+/** @} */
/* --------------------- Inline and template functions ------------------- */
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup Solvers */
-/*@{*/
+/**
+ * @addtogroup Solvers
+ * @{
+ */
namespace internal
{
AdditionalData additional_data;
};
-/*@}*/
+/** @} */
/*------------------------- Implementation ----------------------------*/
#ifndef DOXYGEN
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup Solvers */
-/*@{*/
+/**
+ * @addtogroup Solvers
+ * @{
+ */
/**
* Minimal residual method for symmetric matrices.
* Exception
*/
DeclException0(ExcPreconditionerNotDefinite);
- //@}
+ /** @} */
protected:
/**
double res2;
};
-/*@}*/
+/** @} */
/*------------------------- Implementation ----------------------------*/
#ifndef DOXYGEN
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup Solvers */
-/*@{*/
+/**
+ * @addtogroup Solvers
+ * @{
+ */
/**
* <h3>Quasi-minimal method for symmetric matrices (SQMR)</h3>
unsigned int step;
};
-/*@}*/
+/** @} */
/*------------------------- Implementation ----------------------------*/
#ifndef DOXYGEN
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup Solvers */
-/*@{*/
+/**
+ * @addtogroup Solvers
+ * @{
+ */
/**
* Implementation of the preconditioned Richardson iteration method. The
AdditionalData additional_data;
};
-/*@}*/
+/** @} */
/*----------------- Implementation of the Richardson Method ------------------*/
#ifndef DOXYGEN
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup Solvers */
-/*@{*/
+/**
+ * @addtogroup Solvers
+ * @{
+ */
/**
* Selects a solver by changing a parameter.
typename SolverFGMRES<VectorType>::AdditionalData fgmres_data;
};
-/*@}*/
+/** @} */
/* --------------------- Inline and template functions ------------------- */
DEAL_II_NAMESPACE_OPEN
-/*! @addtogroup Preconditioners
- *@{
+/**
+ * @addtogroup Preconditioners
+ * @{
*/
/**
double,
<< "The strengthening parameter " << arg1
<< " is not greater or equal than zero!");
- //@}
+ /** @} */
protected:
/**
* Copies the passed SparseMatrix onto this object. This object's sparsity
SparsityPattern *own_sparsity;
};
-/*@}*/
+/** @} */
//---------------------------------------------------------------------------
#ifndef DOXYGEN
DEAL_II_NAMESPACE_OPEN
-/*! @addtogroup Preconditioners
- *@{
+/**
+ * @addtogroup Preconditioners
+ * @{
*/
/**
<< ". This must stop the ILU algorithm because it means "
"that the matrix for which you try to compute a "
"decomposition is singular.");
- //@}
+ /** @} */
};
-/*@}*/
+/** @} */
//---------------------------------------------------------------------------
/**
* @name Constructors and initialization
*/
- //@{
+ /** @{ */
/**
* Constructor; initializes the matrix to be empty, without any structure,
* i.e. the matrix is not usable at all. This constructor is therefore only
*/
virtual void
clear();
- //@}
+ /** @} */
/**
* @name Information on the matrix
*/
- //@{
+ /** @{ */
/**
* Return whether the object is empty. It is empty if either both dimensions
* are zero or no SparsityPattern is associated.
*/
void compress(::dealii::VectorOperation::values);
- //@}
+ /** @} */
/**
* @name Modifying entries
*/
- //@{
+ /** @{ */
/**
* Set the element (<i>i,j</i>) to <tt>value</tt>. Throws an error if the
* entry does not exist or if <tt>value</tt> is not a finite number. Still,
void
add(const number factor, const SparseMatrix<somenumber> &matrix);
- //@}
+ /** @} */
/**
* @name Accessing elements
*/
- //@{
+ /** @{ */
/**
* Return the value of the entry (<i>i,j</i>). This may be an expensive
number &
diag_element(const size_type i);
- //@}
+ /** @} */
/**
* @name Multiplying matrices and vectors
*/
- //@{
+ /** @{ */
/**
* Matrix-vector multiplication: let <i>dst = M*src</i> with <i>M</i> being
* this matrix.
const Vector<number> & V = Vector<number>(),
const bool rebuild_sparsity_pattern = true) const;
- //@}
+ /** @} */
/**
* @name Matrix norms
*/
- //@{
+ /** @{ */
/**
* Return the $l_1$-norm of the matrix, that is $|M|_1=\max_{\mathrm{all\
*/
real_type
frobenius_norm() const;
- //@}
+ /** @} */
/**
* @name Preconditioning methods
*/
- //@{
+ /** @{ */
/**
* Apply the Jacobi preconditioner, which multiplies every element of the
SSOR_step(Vector<somenumber> & v,
const Vector<somenumber> &b,
const number omega = 1.) const;
- //@}
+ /** @} */
/**
* @name Iterators
*/
- //@{
+ /** @{ */
/**
* Return an iterator pointing to the first element of the matrix.
*/
iterator
end(const size_type r);
- //@}
+ /** @} */
/**
* @name Input/Output
*/
- //@{
+ /** @{ */
/**
* Print the matrix to the given stream, using the format <tt>(row,column)
*/
void
block_read(std::istream &in);
- //@}
+ /** @} */
/**
* @addtogroup Exceptions
* @{
"You are attempting an operation on two matrices that "
"are the same object, but the operation requires that the "
"two objects are in fact different.");
- //@}
+ /** @} */
protected:
/**
/**
* @name Constructors and initialization
*/
- //@{
+ /** @{ */
/**
* Constructor. Initializes an empty matrix of dimension zero times zero.
*/
*/
void
clear();
- //@}
+ /** @} */
/**
* @name Information on the matrix
*/
- //@{
+ /** @{ */
/**
* Return whether the object is empty. It is empty if both dimensions are
* zero.
size_type & reserved,
std::vector<size_type> &used_by_line,
const bool compute_by_line) const;
- //@}
+ /** @} */
/**
* @name Modifying entries
*/
- //@{
+ /** @{ */
/**
* Set the element <tt>(i,j)</tt> to @p value.
*
template <typename MatrixType>
void
add(const number factor, const MatrixType &matrix);
- //@}
+ /** @} */
/**
* @name Entry Access
*/
- //@{
+ /** @{ */
/**
* Return the value of the entry (i,j). This may be an expensive operation
* and you should always take care where to call this function. In order to
*/
number
el(const size_type i, const size_type j) const;
- //@}
+ /** @} */
/**
* @name Multiplications
*/
- //@{
+ /** @{ */
/**
* Matrix-vector multiplication: let $dst = M*src$ with $M$ being this
* matrix.
template <typename somenumber>
void
Tvmult_add(Vector<somenumber> &dst, const Vector<somenumber> &src) const;
- //@}
+ /** @} */
/**
* @name Matrix norms
*/
- //@{
+ /** @{ */
/**
* Frobenius-norm of the matrix.
*/
number
l2_norm() const;
- //@}
+ /** @} */
/**
* @name Preconditioning methods
*/
- //@{
+ /** @{ */
/**
* Apply the Jacobi preconditioner, which multiplies every element of the @p
* src vector by the inverse of the respective diagonal element and
conjugate_add(const MatrixTypeA &A,
const MatrixTypeB &B,
const bool transpose = false);
- //@}
+ /** @} */
/**
* @name Iterators
*/
- //@{
+ /** @{ */
/**
* Iterator starting at the first existing entry.
*/
*/
const_iterator
end(const size_type r) const;
- //@}
+ /** @} */
/**
* @name Input/Output
*/
- //@{
+ /** @{ */
/**
* Print the matrix to the given stream, using the format <tt>(line,col)
* value</tt>, i.e. one nonzero entry of the matrix per line.
*/
void
block_read(std::istream &in);
- //@}
+ /** @} */
/**
* @addtogroup Exceptions
int,
<< "An entry with index (" << arg1 << ',' << arg2
<< ") cannot be allocated.");
- //@}
+ /** @} */
private:
/**
* Find an entry and return a const pointer. Return a zero-pointer if the
DEAL_II_NAMESPACE_OPEN
-/*! @addtogroup Preconditioners
- *@{
+/**
+ * @addtogroup Preconditioners
+ * @{
*/
/**
<< "The diagonal element (" << arg1 << ',' << arg1 << ") is "
<< arg2 << ", but must be positive");
- //@}
+ /** @} */
private:
/**
* Values of the computed diagonal.
get_rowsum(const size_type row) const;
};
-/*@}*/
+/** @} */
DEAL_II_NAMESPACE_CLOSE
class SparseBlockVanka;
#endif
-/*! @addtogroup Preconditioners
- *@{
+/**
+ * @addtogroup Preconditioners
+ * @{
*/
/**
const BlockingStrategy blocking_strategy);
};
-/*@}*/
+/** @} */
/* ---------------------------------- Inline functions ------------------- */
#ifndef DOXYGEN
}
#endif
-/*! @addtogroup Sparsity
- *@{
+/**
+ * @addtogroup Sparsity
+ * @{
*/
namespace internals
DEAL_II_NAMESPACE_OPEN
-/*! @addtogroup Sparsity
- *@{
+/**
+ * @addtogroup Sparsity
+ * @{
*/
/**
class Vector;
#endif
-/*! @addtogroup Matrix1
- *@{
+/**
+ * @addtogroup Matrix1
+ * @{
*/
{
public:
///@name Constructors
- //@{
+ /** @{ */
/**
* Declare type for container size.
*/
reinit(size_type n, bool symmetric = false);
- //@}
+ /** @} */
///@name Non-modifying operators
- //@{
+ /** @{ */
/**
* Number of rows of this matrix. Note that the matrix is an <i>m x
bool
all_zero() const;
- //@}
+ /** @} */
///@name Element access
- //@{
+ /** @{ */
/**
* Read-only access to a value. This is restricted to the case where
* <i>|i-j| <= 1</i>.
number &
operator()(size_type i, size_type j);
- //@}
+ /** @} */
///@name Multiplications with vectors
- //@{
+ /** @{ */
/**
* Matrix-vector-multiplication. Multiplies <tt>v</tt> from the right and
number
matrix_norm_square(const Vector<number> &v) const;
- //@}
+ /** @} */
///@name LAPACK operations
- //@{
+ /** @{ */
/**
* Compute the eigenvalues of the symmetric tridiagonal matrix.
*
*/
number
eigenvalue(const size_type i) const;
- //@}
+ /** @} */
///@name Miscellanea
- //@{
+ /** @{ */
/**
* Output of the matrix in user-defined format.
*/
print(OutputStream & s,
const unsigned int width = 5,
const unsigned int precision = 2) const;
- //@}
+ /** @} */
private:
/**
namespace TrilinosWrappers
{
- /*! @addtogroup TrilinosWrappers
- *@{
+ /**
+ * @addtogroup TrilinosWrappers
+ * @{
*/
/**
int,
<< "The blocks [" << arg1 << ',' << arg2 << "] and [" << arg3
<< ',' << arg4 << "] have differing column numbers.");
- ///@}
+ //** @} */
private:
/**
- /*@}*/
+ /** @} */
// ------------- inline and template functions -----------------
/**
* @name Creation of a LinearOperator
*/
- //@{
+ /** @{ */
/**
}
- //@}
+ /** @} */
/**
* @name Creation of a BlockLinearOperator
*/
- //@{
+ /** @{ */
/**
return dealii::block_diagonal_operator<m, Range, Domain, BlockPayload>(ops);
}
- //@}
+ /** @} */
} // namespace TrilinosWrappers
} // namespace TrilinosWrappers
# endif
-/*! @addtogroup TrilinosWrappers
- *@{
+/**
+ * @addtogroup TrilinosWrappers
+ * @{
*/
namespace TrilinosWrappers
} /* namespace TrilinosWrappers */
-/*@}*/
+/** @} */
namespace internal
class SparsityPattern;
# endif
-/*! @addtogroup TrilinosWrappers
- *@{
+/**
+ * @addtogroup TrilinosWrappers
+ * @{
*/
namespace TrilinosWrappers
/**
* @name Access to underlying Trilinos data
*/
- //@{
+ /** @{ */
/**
*
* Calling this function from an uninitialized object will cause an
*/
Epetra_Operator &
trilinos_operator() const;
- //@}
+ /** @} */
/**
* @name Partitioners
*/
- //@{
+ /** @{ */
/**
* Return the partitioning of the domain space of this matrix, i.e., the
IndexSet
locally_owned_range_indices() const;
- //@}
+ /** @} */
/**
* @addtogroup Exceptions
*/
- //@{
+ /** @{ */
/**
* Exception.
*/
<< "The sparse matrix the preconditioner is based on "
<< "uses a map that is not compatible to the one in vector "
<< arg1 << ". Check preconditioner and matrix setup.");
- //@}
+ /** @} */
friend class SolverBase;
} // namespace TrilinosWrappers
-/*@}*/
+/** @} */
DEAL_II_NAMESPACE_CLOSE
/**
* @name Constructors and initialization.
*/
- //@{
+ /** @{ */
/**
* Default constructor. Generates an empty (zero-size) matrix.
*/
*/
void
reinit(const Epetra_CrsMatrix &input_matrix, const bool copy_values = true);
- //@}
+ /** @} */
/**
* @name Constructors and initialization using an IndexSet description
*/
- //@{
+ /** @{ */
/**
* Constructor using an IndexSet and an MPI communicator to describe the
* %parallel partitioning. The parameter @p n_max_entries_per_row sets the
const double drop_tolerance = 1e-13,
const bool copy_values = true,
const ::dealii::SparsityPattern * use_this_sparsity = nullptr);
- //@}
+ /** @} */
/**
* @name Information on the matrix
*/
- //@{
+ /** @{ */
/**
* Return the number of rows in this matrix.
MPI_Comm
get_mpi_communicator() const;
- //@}
+ /** @} */
/**
* @name Modifying entries
*/
- //@{
+ /** @{ */
/**
* This operator assigns a scalar to a matrix. Since this does usually not
void
transpose();
- //@}
+ /** @} */
/**
* @name Entry Access
*/
- //@{
+ /** @{ */
/**
* Return the value of the entry (<i>i,j</i>). This may be an expensive
TrilinosScalar
diag_element(const size_type i) const;
- //@}
+ /** @} */
/**
* @name Multiplications
*/
- //@{
+ /** @{ */
/**
* Matrix-vector multiplication: let <i>dst = M*src</i> with <i>M</i>
const SparseMatrix &B,
const MPI::Vector & V = MPI::Vector()) const;
- //@}
+ /** @} */
/**
* @name Matrix norms
*/
- //@{
+ /** @{ */
/**
* Return the <i>l</i><sub>1</sub>-norm of the matrix, that is $|M|_1=
TrilinosScalar
frobenius_norm() const;
- //@}
+ /** @} */
/**
* @name Access to underlying Trilinos data
*/
- //@{
+ /** @{ */
/**
* Return a const reference to the underlying Trilinos Epetra_CrsMatrix
const Epetra_CrsGraph &
trilinos_sparsity_pattern() const;
- //@}
+ /** @} */
/**
* @name Partitioners
*/
- //@{
+ /** @{ */
/**
* Return the partitioning of the domain space of this matrix, i.e., the
IndexSet
locally_owned_range_indices() const;
- //@}
+ /** @} */
/**
* @name Iterators
*/
- //@{
+ /** @{ */
/**
* Return an iterator pointing to the first element of the matrix.
iterator
end(const size_type r);
- //@}
+ /** @} */
/**
* @name Input/Output
*/
- //@{
+ /** @{ */
/**
* Abstract Trilinos object that helps view in ASCII other Trilinos
print(std::ostream &out,
const bool write_extended_trilinos_info = false) const;
- //@}
+ /** @} */
/**
* @addtogroup Exceptions
*/
- //@{
+ /** @{ */
/**
* Exception
*/
<< "You tried to access element (" << arg1 << '/' << arg2
<< ')' << " of a sparse matrix, but it appears to not"
<< " exist in the Trilinos sparsity pattern.");
- //@}
+ /** @} */
/**
* @name Constructors / destructor
*/
- //@{
+ /** @{ */
/**
* Default constructor
TrilinosPayload>
inverse_payload(Solver &, const Preconditioner &) const;
- //@}
+ /** @} */
/**
* @name LinearOperator functionality
*/
- //@{
+ /** @{ */
/**
* Return an IndexSet that defines the partitioning of the domain space
*/
std::function<void(VectorType &, const VectorType &)> inv_Tvmult;
- //@}
+ /** @} */
/**
* @name Core Epetra_Operator functionality
*/
- //@{
+ /** @{ */
/**
* Return the status of the transpose flag for this operator
*/
virtual int
ApplyInverse(const VectorType &Y, VectorType &X) const override;
- //@}
+ /** @} */
/**
* @name Additional Epetra_Operator functionality
*/
- //@{
+ /** @{ */
/**
* Return a label to describe this class.
*/
virtual const Epetra_Map &
OperatorRangeMap() const override;
- //@}
+ /** @} */
private:
/**
/**
* @name Basic constructors and initialization
*/
- //@{
+ /** @{ */
/**
* Default constructor. Generates an empty (zero-size) sparsity pattern.
*/
*/
void
compress();
- //@}
+ /** @} */
/**
* @name Constructors and initialization using an IndexSet description
*/
- //@{
+ /** @{ */
/**
* Constructor for a square sparsity pattern using an IndexSet and an MPI
const SparsityPatternType &nontrilinos_sparsity_pattern,
const MPI_Comm & communicator = MPI_COMM_WORLD,
const bool exchange_data = false);
- //@}
+ /** @} */
/**
* @name Information on the sparsity pattern
*/
- //@{
+ /** @{ */
/**
* Return the state of the sparsity pattern, i.e., whether compress()
std::size_t
memory_consumption() const;
- //@}
+ /** @} */
/**
* @name Adding entries
*/
- //@{
+ /** @{ */
/**
* Add the element (<i>i,j</i>) to the sparsity pattern.
*/
ForwardIterator begin,
ForwardIterator end,
const bool indices_are_sorted = false);
- //@}
+ /** @} */
/**
* @name Access of underlying Trilinos data
*/
- //@{
+ /** @{ */
/**
* Return a const reference to the underlying Trilinos Epetra_CrsGraph
*/
MPI_Comm
get_mpi_communicator() const;
- //@}
+ /** @} */
/**
* @name Partitioners
*/
- //@{
+ /** @{ */
/**
* Return the partitioning of the domain space of this pattern, i.e., the
IndexSet
locally_owned_range_indices() const;
- //@}
+ /** @} */
/**
* @name Iterators
*/
- //@{
+ /** @{ */
/**
* Iterator starting at the first entry.
const_iterator
end(const size_type r) const;
- //@}
+ /** @} */
/**
* @name Input/Output
*/
- //@{
+ /** @{ */
/**
* Abstract Trilinos object that helps view in ASCII other Trilinos
void
print_gnuplot(std::ostream &out) const;
- //@}
+ /** @} */
/**
* @addtogroup Exceptions
* @{
<< "You tried to access element (" << arg1 << '/' << arg2
<< ')' << " of a sparse matrix, but it appears to not"
<< " exist in the Trilinos sparsity pattern.");
- //@}
+ /** @} */
private:
/**
* Pointer to the user-supplied Epetra Trilinos mapping of the matrix
/**
* @name 1: Basic Object-handling
*/
- //@{
+ /** @{ */
/**
* Default constructor that generates an empty (zero size) vector. The
* function <tt>reinit()</tt> will have to give the vector the correct
*/
bool
is_non_negative() const;
- //@}
+ /** @} */
/**
* @name 2: Data-Access
*/
- //@{
+ /** @{ */
/**
* Provide access to a given element, both read and write.
const_iterator
end() const;
- //@}
+ /** @} */
/**
* @name 3: Modification of vectors
*/
- //@{
+ /** @{ */
/**
* A collective set operation: instead of setting individual elements of a
*/
void
equ(const TrilinosScalar a, const Vector &V);
- //@}
+ /** @} */
/**
* @name 4: Mixed stuff
*/
- //@{
+ /** @{ */
/**
* Return a const reference to the underlying Trilinos Epetra_MultiVector
*/
const MPI_Comm &
get_mpi_communicator() const;
- //@}
+ /** @} */
/**
* Exception
} /* end of namespace TrilinosWrappers */
-/*@}*/
+/** @} */
namespace internal
#endif
-/*! @addtogroup Vectors
- *@{
+/**
+ * @addtogroup Vectors
+ * @{
*/
/**
/**
* @name Basic object handling
*/
- //@{
+ /** @{ */
/**
* Constructor. Create a vector of dimension zero.
*/
bool
operator!=(const Vector<Number2> &v) const;
- //@}
+ /** @} */
/**
* @name Scalar products, norms and related operations
*/
- //@{
+ /** @{ */
/**
* Return the scalar product of two vectors. The return type is the
Number
add_and_dot(const Number a, const Vector<Number> &V, const Vector<Number> &W);
- //@}
+ /** @} */
/**
* @name Data access
*/
- //@{
+ /** @{ */
/**
* Return a pointer to the underlying data buffer.
extract_subvector_to(ForwardIterator indices_begin,
const ForwardIterator indices_end,
OutputIterator values_begin) const;
- //@}
+ /** @} */
/**
* @name Modification of vectors
*/
- //@{
+ /** @{ */
/**
* Add the given vector to the present one.
*/
void
update_ghost_values() const;
- //@}
+ /** @} */
/**
* @name Input and output
*/
- //@{
+ /** @{ */
/**
* Print to a stream. @p precision denotes the desired precision with which
* values shall be printed, @p scientific whether scientific notation shall
/**
* @name Information about the object
*/
- //@{
+ /** @{ */
/**
* Return true if the given global index is in the local range of this
*/
void
zero_out_ghost_values() const;
- //@}
+ /** @} */
private:
/**
friend class Vector;
};
-/*@}*/
+/** @} */
/*----------------------- Inline functions ----------------------------------*/
#endif
-/*! @addtogroup Vectors
- *@{
+/**
+ * @addtogroup Vectors
+ * @{
*/
return out;
}
-/*@}*/
+/** @} */
/**
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup VMemory */
-/*@{*/
+/**
+ * @addtogroup VMemory
+ * @{
+ */
/**
* Memory management base class for vectors. This is an abstract base class
"You are trying to deallocate a vector from a memory pool, but this "
"vector has not actually been allocated by the same pool before.");
- //@}
+ /** @} */
/**
* A class that looks like a pointer for all practical purposes and that
}
} // namespace internal
-/*@}*/
+/** @} */
#ifndef DOXYGEN
/* --------------------- inline functions ---------------------- */
DEAL_II_NAMESPACE_OPEN
-/*! @addtogroup Vectors
- *@{
+/**
+ * @addtogroup Vectors
+ * @{
*/
/**
};
};
-/*@}*/
+/** @} */
DEAL_II_NAMESPACE_CLOSE
namespace LinearAlgebra
{
- /*! @addtogroup Vectors
- *@{
+ /**
+ * @addtogroup Vectors
+ * @{
*/
/**
*/
virtual ~VectorSpaceVector() = default;
};
- /*@}*/
+ /** @} */
} // namespace LinearAlgebra
// ---------------------------- Free functions --------------------------
/**
* @name 1: Reading from and writing to vectors
*/
- //@{
+ /** @{ */
/**
* For the vector @p src, read out the values on the degrees of freedom of
* the current cell, and store them internally. Similar functionality as the
const std::bitset<VectorizedArrayType::size()> &mask =
std::bitset<VectorizedArrayType::size()>().flip()) const;
- //@}
+ /** @} */
/**
* @name 2: Access to data at quadrature points or the gather vector data
*/
- //@{
+ /** @{ */
/**
* Return the value stored for the local degree of freedom with index @p
* dof. If the object is vector-valued, a vector-valued return argument is
value_type
integrate_value() const;
- //@}
+ /** @} */
/**
* Return the underlying MatrixFree object.
/**
* @name 1: Access to geometry data at quadrature points
*/
- //@{
+ /** @{ */
/**
* Return an ArrayView to internal memory for temporary use. Note that some
Tensor<1, dim, Number>
get_normal_vector(const unsigned int q_point) const;
- //@}
+ /** @} */
/**
* @name 2: Access to internal data arrays
*/
- //@{
+ /** @{ */
/**
* Return a read-only pointer to the first field of the dof values. This is
* the data field the read_dof_values() functions write into. First come the
Number *
begin_hessians();
- //@}
+ /** @} */
/**
* @name 3: Information about the current cell this class operates on
*/
- //@{
+ /** @{ */
/**
* Return the index offset within the geometry fields for the cell the @p
std_cxx20::ranges::iota_view<unsigned int, unsigned int>
quadrature_point_indices() const;
- //@}
+ /** @} */
/**
* @name 3: Functions to access cell- and face-data vectors.
*/
- //@{
+ /** @{ */
/**
* Provides a unified interface to access data in a vector of
set_face_data(AlignedVector<std::array<T, Number::size()>> &array,
const std::array<T, Number::size()> & value) const;
- //@}
+ /** @} */
/**
* This data structure is used for the initialization by the derived
/**
* @name 1: Construction and initialization
*/
- //@{
+ /** @{ */
/**
* Default empty constructor. Does nothing.
*/
void
clear();
- //@}
+ /** @} */
/**
* This class defines the type of data access for face integrals in loop ()
/**
* @name 2: Matrix-free loops
*/
- //@{
+ /** @{ */
/**
* This method runs the loop over all cells (in parallel) and performs the
* MPI data exchange on the source vector and destination vector.
get_face_active_fe_index(const std::pair<unsigned int, unsigned int> range,
const bool is_interior_face = true) const;
- //@}
+ /** @} */
/**
* @name 3: Initialization of vectors
*/
- //@{
+ /** @{ */
/**
* Initialize function for a vector with each entry associated with a cell
* batch (cell data). For reading and writing the vector use:
renumber_dofs(std::vector<types::global_dof_index> &renumbering,
const unsigned int dof_handler_index = 0);
- //@}
+ /** @} */
/**
* @name 4: General information
*/
- //@{
+ /** @{ */
/**
* Return whether a given FiniteElement @p fe is supported by this class.
*/
void
print(std::ostream &out) const;
- //@}
+ /** @} */
/**
* @name 5: Access of internal data structure
*
* Note: Expert mode, interface not stable between releases.
*/
- //@{
+ /** @{ */
/**
* Return information on task graph.
*/
release_scratch_data_non_threadsafe(
const AlignedVector<Number> *memory) const;
- //@}
+ /** @} */
private:
/**
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup MeshWorker */
-/*@{*/
+/**
+ * @addtogroup MeshWorker
+ * @{
+ */
namespace MeshWorker
{
}
} // namespace MeshWorker
-/*@}*/
+/** @} */
DEAL_II_NAMESPACE_CLOSE
* The quadrature rule used on interior faces.
*/
Quadrature<dim - 1> face_quadrature;
- /* @} */
+ /** @} */
/**
* @name Data vectors
std::shared_ptr<MeshWorker::VectorDataBase<dim, spacedim>> cell_data;
std::shared_ptr<MeshWorker::VectorDataBase<dim, spacedim>> boundary_data;
std::shared_ptr<MeshWorker::VectorDataBase<dim, spacedim>> face_data;
- /* @} */
+ /** @} */
/**
* @name Interface for MeshWorker::loop()
*/
CellInfo neighbor;
- /* @} */
+ /** @} */
};
/**
* @name Methods to work on current cell
+ * @{
*/
- /**@{*/ // CurrentCellMethods
/**
* Initialize the internal FEValues with the given @p cell, and return
/**
* @name Methods to work on neighbor cell
+ * @{
*/
- /** @{ */ // NeighborCellMethods
/**
* Initialize the internal neighbor FEValues to use the given @p cell, and
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup mg */
-/*@{*/
-
+/**
+ * @addtogroup mg
+ * @{
+ */
/**
* Multilevel matrix base. This class sets up the interface needed by
apply(const unsigned int level, VectorType &u, const VectorType &rhs) const;
};
-/*@}*/
+/** @} */
DEAL_II_NAMESPACE_CLOSE
* MGSmootherBase is defined in mg_base.h
*/
-/*!@addtogroup mg */
-/*@{*/
+/**
+ * @addtogroup mg
+ * @{
+ */
/**
* General smoother class for block vectors. This class gives complete freedom
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup mg */
-/*@{*/
+/**
+ * @addtogroup mg
+ * @{
+ */
/**
* Coarse grid solver using smoother only. This is a little wrapper,
LAPACKFullMatrix<number> matrix;
};
-/*@}*/
+/** @} */
#ifndef DOXYGEN
/* ------------------ Functions for MGCoarseGridApplySmoother -----------*/
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup mg */
-/*@{*/
+/**
+ * @addtogroup mg
+ * @{
+ */
namespace mg
{
unsigned int col;
};
-/*@}*/
+/** @} */
/*----------------------------------------------------------------------*/
* MGSmootherBase is defined in mg_base.h
*/
-/*!@addtogroup mg */
-/*@{*/
+/**
+ * @addtogroup mg
+ * @{
+ */
/**
* A base class for smoother handling information on smoothing. While not
MGLevelObject<LinearOperator<VectorType>> matrices;
};
-/*@}*/
+/** @} */
/* ------------------------------- Inline functions --------------------------
*/
} // namespace MGTools
-/* @} */
+/** @} */
DEAL_II_NAMESPACE_CLOSE
* MGTransferBase is defined in mg_base.h
*/
-/*!@addtogroup mg */
-/*@{*/
-
-
+/**
+ * @addtogroup mg
+ * @{
+ */
/**
* Implementation of transfer between the global vectors and the multigrid
};
-/*@}*/
+/** @} */
DEAL_II_NAMESPACE_CLOSE
* MGTransferBase is defined in mg_base.h
*/
-/*!@addtogroup mg */
-/*@{*/
+/**
+ * @addtogroup mg
+ * @{
+ */
/**
* Implementation of matrix generation for MGTransferBlock.
unsigned int selected_block;
};
-/*@}*/
+/** @} */
//------------------------- inline function definition ------------------------
template <typename number>
* MGTransferBase is defined in mg_base.h
*/
-/*!@addtogroup mg */
-/*@{*/
+/**
+ * @addtogroup mg
+ * @{
+ */
/**
* Implementation of matrix generation for component wise multigrid transfer.
SmartPointer<const AffineConstraints<double>> constraints;
};
-/*@}*/
+/** @} */
//---------------------------------------------------------------------------
template <typename number>
DEAL_II_NAMESPACE_OPEN
-/*!@addtogroup mg */
-/*@{*/
+/**
+ * @addtogroup mg
+ * @{
+ */
/**
* Implementation of the MGTransferBase interface for which the transfer
};
-/*@}*/
+/** @} */
//------------------------ templated functions -------------------------
*after* the deal.II headers or you can define the 'QT_NO_KEYWORDS' macro and use the 'Q_SIGNALS' macro."
#endif
-/*!@addtogroup mg */
-/*@{*/
+/**
+ * @addtogroup mg
+ * @{
+ */
namespace mg
{
mg::Signals signals;
};
-/*@}*/
+/** @} */
#ifndef DOXYGEN
/* --------------------------- inline functions --------------------- */
/**
* @name Interpolation and projection
*/
- //@{
+ /** @{ */
/**
* Compute constraints on the solution that corresponds to the imposition
/**
* @name Interpolation and projection
*/
- //@{
+ /** @{ */
/**
* This function computes the constraints that correspond to boundary
#endif
));
- //@}
+ /** @} */
} // namespace VectorTools
DEAL_II_NAMESPACE_CLOSE
/**
* @name Evaluation of functions and errors
*/
- //@{
+ /** @{ */
/**
* Compute the cellwise error of the finite element solution. Integrate the
const NormType & norm,
const double exponent = 2.);
- //@}
+ /** @} */
} // namespace VectorTools
DEAL_II_NAMESPACE_CLOSE
/**
* @name Interpolation and projection
*/
- //@{
+ /** @{ */
/**
* Compute the interpolation of @p function at the support points to the
const AffineConstraints<typename VectorType::value_type> &constraints,
VectorType & u2);
- //@}
+ /** @} */
/**
* Geometrical interpolation
*/
- //@{
+ /** @{ */
/**
* Given a DoFHandler containing at least a spacedim vector field, this
* function interpolates the Triangulation at the support points of a FE_Q()
VectorType & vector,
const ComponentMask & mask = ComponentMask());
- //@}
+ /** @} */
} // namespace VectorTools
DEAL_II_NAMESPACE_CLOSE
/**
* Mean value operations
*/
- //@{
+ /** @{ */
/**
* Subtract the (algebraic) mean value from a vector.
const Quadrature<dim> & quadrature,
const VectorType & v,
const unsigned int component);
- //@}
+ /** @} */
} // namespace VectorTools
DEAL_II_NAMESPACE_CLOSE
/**
* @name Evaluation of functions and errors
*/
- //@{
+ /** @{ */
/**
* Evaluate a possibly vector-valued finite element function defined by the
const VectorType & fe_function,
const Point<spacedim, double> & point);
- //@}
+ /** @} */
} // namespace VectorTools
DEAL_II_NAMESPACE_CLOSE
/**
* @name Assembling of right hand sides
*/
- //@{
+ /** @{ */
/**
* Create a right hand side vector for a point source at point @p p. In
/**
* @name Evaluation of functions and errors
*/
- //@{
+ /** @{ */
/**
* Point error evaluation. Find the first cell containing the given point
const DoFHandler<dim, spacedim> & dof,
const VectorType & fe_function,
const Point<spacedim, double> & point);
- //@}
+ /** @} */
} // namespace VectorTools
DEAL_II_NAMESPACE_CLOSE
/**
* @name Interpolation and projection
*/
- //@{
+ /** @{ */
/**
* Compute the projection of @p function to the finite element space. In other
/**
* @name Assembling of right hand sides
*/
- //@{
+ /** @{ */
/**
* Create a right hand side vector. Prior content of the given @p rhs_vector
} // namespace OpenCASCADE
-/*@}*/
+/** @} */
DEAL_II_NAMESPACE_CLOSE
/**
* @name Deformation tensors
*/
- //@{
+ /** @{ */
/**
* Return the deformation gradient tensor,
DEAL_II_ALWAYS_INLINE SymmetricTensor<2, dim, Number>
b(const Tensor<2, dim, Number> &F);
- //@}
+ /** @} */
/**
* @name Strain tensors
*/
- //@{
+ /** @{ */
/**
* Return the symmetric Green-Lagrange strain tensor,
DEAL_II_ALWAYS_INLINE SymmetricTensor<2, dim, Number>
e(const Tensor<2, dim, Number> &F);
- //@}
+ /** @} */
/**
* @name Strain rate tensors
*/
- //@{
+ /** @{ */
/**
* Return the spatial velocity gradient tensor,
Tensor<2, dim, Number>
w(const Tensor<2, dim, Number> &F, const Tensor<2, dim, Number> &dF_dt);
- //@}
+ /** @} */
} // namespace Kinematics
} // namespace Elasticity
} // namespace Physics
/**
* @name Metric tensors
*/
- //@{
+ /** @{ */
/**
* The second-order referential/spatial symmetric identity (metric) tensor
#endif
;
- //@}
+ /** @} */
/**
* @name Projection operators
*/
- //@{
+ /** @{ */
/**
* The fourth-order spatial deviatoric tensor. Also known as the
static DEAL_II_CONSTEXPR SymmetricTensor<4, dim, Number>
Dev_P_T(const Tensor<2, dim, Number> &F);
- //@}
+ /** @} */
/**
* @name Scalar derivatives
*/
- //@{
+ /** @{ */
/**
* Return the derivative of the volumetric Jacobian
* $J = \text{det} \mathbf{F}$ with respect to the right Cauchy-Green
static DEAL_II_CONSTEXPR SymmetricTensor<2, dim, Number>
ddet_F_dC(const Tensor<2, dim, Number> &F);
- //@}
+ /** @} */
/**
* @name Tensor derivatives
*/
- //@{
+ /** @{ */
/**
* Return the derivative of the inverse of the right Cauchy-Green
static DEAL_II_CONSTEXPR SymmetricTensor<4, dim, Number>
dC_inv_dC(const Tensor<2, dim, Number> &F);
- //@}
+ /** @} */
};
} // namespace Elasticity
/**
* @name Forward operation: Tensor notation to Kelvin notation
*/
- //@{
+ /** @{ */
/**
* Convert a scalar value to its compressed vector equivalent.
FullMatrix<Number>
to_matrix(const SymmetricTensor<4, dim, Number> &st);
- //@}
+ /** @} */
/**
* @name Reverse operation: Kelvin notation to tensor notation
*/
- //@{
+ /** @{ */
/**
* Convert a compressed vector to its equivalent scalar value.
template <typename TensorType, typename Number>
TensorType
to_tensor(const FullMatrix<Number> &vec);
- //@}
+ /** @} */
} // namespace Kelvin
/**
* @name Rotation matrices
*/
- //@{
+ /** @{ */
/**
* Return the rotation matrix for 2-d Euclidean space, namely
DEAL_II_DEPRECATED Tensor<2, 3, Number>
rotation_matrix_3d(const Point<3, Number> &axis, const Number &angle);
- //@}
+ /** @} */
} // namespace Rotations
/**
* @name Push forward operations
*/
- //@{
+ /** @{ */
/**
* Return the result of the push forward transformation on a
push_forward(const SymmetricTensor<4, dim, Number> &H,
const Tensor<2, dim, Number> & F);
- //@}
+ /** @} */
/**
* @name Pull back operations
*/
- //@{
+ /** @{ */
/**
* Return the result of the pull back transformation on a contravariant
pull_back(const SymmetricTensor<4, dim, Number> &h,
const Tensor<2, dim, Number> & F);
- //@}
+ /** @} */
} // namespace Contravariant
/**
/**
* @name Push forward operations
*/
- //@{
+ /** @{ */
/**
* Return the result of the push forward transformation on a covariant
push_forward(const SymmetricTensor<4, dim, Number> &H,
const Tensor<2, dim, Number> & F);
- //@}
+ /** @} */
/**
* @name Pull back operations
*/
- //@{
+ /** @{ */
/**
* Return the result of the pull back transformation on a covariant
pull_back(const SymmetricTensor<4, dim, Number> &h,
const Tensor<2, dim, Number> & F);
- //@}
+ /** @} */
} // namespace Covariant
/**
/**
* @name Push forward operations
*/
- //@{
+ /** @{ */
/**
* Return the result of the push forward transformation on a
push_forward(const SymmetricTensor<4, dim, Number> &H,
const Tensor<2, dim, Number> & F);
- //@}
+ /** @} */
/**
* @name Pull back operations
*/
- //@{
+ /** @{ */
/**
* Return the result of the pull back transformation on a contravariant
pull_back(const SymmetricTensor<4, dim, Number> &h,
const Tensor<2, dim, Number> & F);
- //@}
+ /** @} */
} // namespace Piola
/**
* @name Special operations
*/
- //@{
+ /** @{ */
/**
* Return the result of applying Nanson's formula for the transformation
nansons_formula(const Tensor<1, dim, Number> &N,
const Tensor<2, dim, Number> &F);
- //@}
+ /** @} */
/**
* @name Basis transformations
*/
- //@{
+ /** @{ */
/**
* Return a vector with a changed basis, i.e.
basis_transformation(const SymmetricTensor<4, dim, Number> &H,
const Tensor<2, dim, Number> & B);
- //@}
+ /** @} */
} // namespace Transformations
} // namespace Physics
projects / dealii.git / commitdiff