Commit dd123b19 authored by GILLES Sebastien's avatar GILLES Sebastien
Browse files

#531 Clean-up Doxygen comments for instantiations of operators.

parent 33952769
......@@ -196,7 +196,7 @@ namespace HappyHeart
* may include both types of objects; the ordering doesn't matter.
*
* \param[in] linear_algebra_tuple List of global matrices and/or vectors into which the operator is
* assembled.
* assembled. These objects are assumed to be already properly allocated.
* \param[in] domain Domain upon which the assembling takes place. Beware: if this domain is not a subset
* of the finite element space, assembling can only occur in a subset of the domain defined in the finite
* element space; if current \a domain is not a subset of finite element space one, assembling will occur
......
......@@ -83,10 +83,6 @@ namespace HappyHeart
{
auto& global_matrix = global_matrix_with_coefficient.first;
auto& elementary_data = local_variational_operator.GetNonCstElementaryData();
// auto& local_matrix = elementary_data.GetNonCstMatrixResult();
const auto& row_numbering_subset = global_matrix.GetRowNumberingSubset();
const auto& col_numbering_subset = global_matrix.GetColNumberingSubset();
......
......@@ -92,24 +92,20 @@ namespace HappyHeart
/*!
* \brief Assemble a matrix.
* \brief Assemble into one or several matrices.
*
* \param[in] coefficient Coefficient applied during the assembling. For instance if the
* same a * Mass + b * G is assembled inside a same GlobalMatrix, Assemble will be called twice:
* \code
* GradOnGradientBasedElasticityTensor G(a, my_matrix, domain);
* G.Assemble(b, my_matrix, domain);
* \endcode
* \param[in,out] global_matrix GlobalMatrix into which the assembling is done.
* \param[in] domain Geometric domain onto which the integration is performed.
* \tparam LinearAlgebraTupleT A tuple that may include \a GlobalMatrixAndCoefficient objects.
*
* \param[in] global_matrix_with_coeff_tuple List of global matrices into which the operator is
* assembled. These matrices are assumed to be already properly allocated.
* \param[in] domain Domain upon which the assembling takes place. Beware: if this domain is not a subset
* of the finite element space, assembling can only occur in a subset of the domain defined in the finite
* element space; if current \a domain is not a subset of finite element space one, assembling will occur
* upon the intersection of both.
*
* \internal This inline method does nothing more than calling the variadic method from the
* parent class, but it's much easier for an advanced user to see the true prototype expected
* for Assemble() method rather than figuring out what is a variadic method and which additional
* arguments are required (none for this specific operator).
*/
template<class LinearAlgebraTupleT>
void Assemble(LinearAlgebraTupleT&& global_matrix_with_coeff, const Domain& domain = Domain()) const;
void Assemble(LinearAlgebraTupleT&& global_matrix_with_coeff_tuple, const Domain& domain = Domain()) const;
};
......
......@@ -85,24 +85,20 @@ namespace HappyHeart
/*!
* \brief Assemble a matrix.
* \brief Assemble into one or several matrices.
*
* \param[in] coefficient Coefficient applied during the assembling. For instance if the
* same a * GradPhiGradPhi + b * G is assembled inside a same GlobalMatrix, Assemble will be called twice:
* \code
* GradPhiGradPhi(a, my_matrix, domain);
* G.Assemble(b, my_matrix, domain);
* \endcode
* \param[in,out] global_matrix GlobalMatrix into which the assembling is done.
* \param[in] domain Geometric domain onto which the integration is performed.
* \tparam LinearAlgebraTupleT A tuple that may include \a GlobalMatrixAndCoefficient objects.
*
* \param[in] global_matrix_with_coeff_tuple List of global matrices into which the operator is
* assembled. These matrices are assumed to be already properly allocated.
* \param[in] domain Domain upon which the assembling takes place. Beware: if this domain is not a subset
* of the finite element space, assembling can only occur in a subset of the domain defined in the finite
* element space; if current \a domain is not a subset of finite element space one, assembling will occur
* upon the intersection of both.
*
* \internal This inline method does nothing more than calling the variadic method from the
* parent class, but it's much easier for an advanced user to see the true prototype expected
* for Assemble() method rather than figuring out what is a variadic method and which additional
* arguments are required (none for this specific operator).
*/
template<class LinearAlgebraTupleT>
void Assemble(LinearAlgebraTupleT&& global_matrix_with_coeff, const Domain& domain = Domain()) const;
void Assemble(LinearAlgebraTupleT&& global_matrix_with_coeff_tuple, const Domain& domain = Domain()) const;
};
......
......@@ -84,24 +84,20 @@ namespace HappyHeart
/*!
* \brief Assemble a matrix.
* \brief Assemble into one or several matrices.
*
* \param[in] coefficient Coefficient applied during the assembling. For instance if the
* same a * Mass + b * G is assembled inside a same GlobalMatrix, Assemble will be called twice:
* \code
* Mass(a, my_matrix, domain);
* G.Assemble(b, my_matrix, domain);
* \endcode
* \param[in,out] global_matrix GlobalMatrix into which the assembling is done.
* \param[in] domain Geometric domain onto which the integration is performed.
* \tparam LinearAlgebraTupleT A tuple that may include \a GlobalMatrixAndCoefficient objects.
*
* \param[in] global_matrix_with_coeff_tuple List of global matrices into which the operator is
* assembled. These matrices are assumed to be already properly allocated.
* \param[in] domain Domain upon which the assembling takes place. Beware: if this domain is not a subset
* of the finite element space, assembling can only occur in a subset of the domain defined in the finite
* element space; if current \a domain is not a subset of finite element space one, assembling will occur
* upon the intersection of both.
*
* \internal This inline method does nothing more than calling the variadic method from the
* parent class, but it's much easier for an advanced user to see the true prototype expected
* for Assemble() method rather than figuring out what is a variadic method and which additional
* arguments are required (none for this specific operator).
*/
template<class LinearAlgebraTupleT>
void Assemble(LinearAlgebraTupleT&& global_matrix_with_coeff, const Domain& domain = Domain()) const;
void Assemble(LinearAlgebraTupleT&& global_matrix_with_coeff_tuple, const Domain& domain = Domain()) const;
......
......@@ -84,24 +84,20 @@ namespace HappyHeart
/*!
* \brief Assemble a matrix.
* \brief Assemble into one or several matrices.
*
* \param[in] coefficient Coefficient applied during the assembling. For instance if the
* same a * Mass + b * G is assembled inside a same GlobalMatrix, Assemble will be called twice:
* \code
* Mass(a, my_matrix, domain);
* G.Assemble(b, my_matrix, domain);
* \endcode
* \param[in,out] global_matrix GlobalMatrix into which the assembling is done.
* \param[in] domain Geometric domain onto which the integration is performed.
* \tparam LinearAlgebraTupleT A tuple that may include \a GlobalMatrixAndCoefficient objects.
*
* \param[in] global_matrix_with_coeff_list List of global matrices into which the operator is
* assembled. These matrices are assumed to be already properly allocated.
* \param[in] domain Domain upon which the assembling takes place. Beware: if this domain is not a subset
* of the finite element space, assembling can only occur in a subset of the domain defined in the finite
* element space; if current \a domain is not a subset of finite element space one, assembling will occur
* upon the intersection of both.
*
* \internal This inline method does nothing more than calling the variadic method from the
* parent class, but it's much easier for an advanced user to see the true prototype expected
* for Assemble() method rather than figuring out what is a variadic method and which additional
* arguments are required (none for this specific operator).
*/
template<class LinearAlgebraTupleT>
void Assemble(LinearAlgebraTupleT&& global_matrix_with_coeff, const Domain& domain = Domain()) const;
void Assemble(LinearAlgebraTupleT&& global_matrix_with_coeff_list, const Domain& domain = Domain()) const;
......
......@@ -92,21 +92,16 @@ namespace HappyHeart
///@}
/*!
* \brief Assemble a vector.
* \brief Assemble into one or several vectors.
*
* \param[in] coefficient Coefficient applied during the assembling. For instance if the
* same a * Force + b * G is assembled inside a same GlobalVector, Assemble will be called twice:
* \code
* Force.Assemble(a, my_vector, domain);
* G.Assemble(b, my_vector, domain);
* \endcode
* \param[in,out] global_vector GlobalVector into which the assembling is done.
* \param[in] domain Geometric domain onto which the integration is performed.
* \tparam LinearAlgebraTupleT A tuple that may include \a GlobalVectorAndCoefficient objects.
*
* \internal This inline method does nothing more than calling the variadic method from the
* parent class, but it's much easier for an advanced user to see the true prototype expected
* for Assemble() method rather than figuring out what is a variadic method and which additional
* arguments are required (none for this specific operator).
* \param[in] global_vector_with_coeff_tuple List of global vectors into which the operator is
* assembled. These vectors are assumed to be already properly allocated.
* \param[in] domain Domain upon which the assembling takes place. Beware: if this domain is not a subset
* of the finite element space, assembling can only occur in a subset of the domain defined in the finite
* element space; if current \a domain is not a subset of finite element space one, assembling will occur
* upon the intersection of both.
*/
template<class LinearAlgebraTupleT>
void Assemble(LinearAlgebraTupleT&& global_vector_with_coeff_tuple,
......
......@@ -93,23 +93,17 @@ namespace HappyHeart
/*!
* \brief Assemble a vector.
* \brief Assemble into one or several vectors.
*
* \param[in] coefficient Coefficient applied during the assembling. For instance if the
* same a * Force + b * G is assembled inside a same GlobalVector, Assemble will be called twice:
* \code
* Force.Assemble(a, my_vector, domain);
* G.Assemble(b, my_vector, domain);
* \endcode
* \param[in,out] global_vector GlobalVector into which the assembling is done.
* \param[in] domain Geometric domain onto which the integration is performed.
* \param[in] time Current time in seconds.
* \internal This parameter is computed by SupplArgumentsComputeEltArray() method.
* \tparam LinearAlgebraTupleT A tuple that may include \a GlobalVectorAndCoefficient objects.
*
* \internal This inline method does nothing more than calling the variadic method from the
* parent class, but it's much easier for an advanced user to see the true prototype expected
* for Assemble() method rather than figuring out what is a variadic method and which additional
* arguments are required (none for this specific operator).
* \param[in] global_vector_with_coeff_tuple List of global vectors into which the operator is
* assembled. These vectors are assumed to be already properly allocated.
* \param[in] domain Domain upon which the assembling takes place. Beware: if this domain is not a subset
* of the finite element space, assembling can only occur in a subset of the domain defined in the finite
* element space; if current \a domain is not a subset of finite element space one, assembling will occur
* upon the intersection of both.
* \param[in] time Time in seconds.
*/
template<class LinearAlgebraTupleT>
void Assemble(LinearAlgebraTupleT&& global_vector_with_coeff_tuple,
......
......@@ -111,49 +111,25 @@ namespace HappyHeart
/*!
* \brief Assemble a vector and a matrix in the same time.
* \brief Assemble into one or several matrices and/or vectors.
*
* \param[in] matrix_coefficient Coefficient applied during the assembling. For instance if the
* same a * GradOnGradientBasedHyperelasticityTensor::GradOnGradientBasedHyperelasticityTensor + b * G is assembled inside a same
* GlobalMatrix, Assemble will be called twice:
* \code
* GradOnGradientBasedHyperelasticityTensor::GradOnGradientBasedHyperelasticityTensor.Assemble(a, my_matrix, domain);
* G.Assemble(b, my_matrix, domain);
* \endcode
* \param[in] vector_coefficient Same as \a matrix_coefficient for the GlobalVector.
* \param[in,out] global_matrix GlobalMatrix into which the assembling is done.
* \param[in,out] global_vector GlobalVector into which the assembling is done.
* \param[in] domain Geometric domain onto which the integration is performed.
* \tparam LinearAlgebraTupleT A tuple that may include \a GlobalMatrixAndCoefficient and/or
* \a GlobalVectorAndCoefficient objects. Ordering doesn't matter.
*
* \param[in] linear_algebra_tuple List of global matrices and/or vectors into which the operator is
* assembled. These objects are assumed to be already properly allocated.
* \param[in] domain Domain upon which the assembling takes place. Beware: if this domain is not a subset
* of the finite element space, assembling can only occur in a subset of the domain defined in the finite
* element space; if current \a domain is not a subset of finite element space one, assembling will occur
* upon the intersection of both.
* \param[in] previous_iteration_data Vector that includes data from the previous iteration. (its nature
* varies depending on the time scheme used).
*
* \internal This inline method does nothing more than calling the variadic method from the
* parent class, but it's much easier for an advanced user to see the true prototype expected
* for Assemble() method rather than figuring out what is a variadic method and which additional
* arguments are required (none for this specific operator).
*/
// void Assemble(double matrix_coefficient, GlobalMatrix& global_matrix,
// double vector_coefficient, GlobalVector& global_vector,
// const GlobalVector& previous_iteration_data,
// const Domain& domain = Domain()) const;
//
// //! Same as overload above except only a matrix is assembled.
// void Assemble(double matrix_coefficient, GlobalMatrix& global_matrix,
// const GlobalVector& previous_iteration_data,
// const Domain& domain = Domain()) const;
//
// //! Same as overload above except only a vector is assembled.
// void Assemble(double vector_coefficient, GlobalVector& global_vector,
// const GlobalVector& previous_iteration_data,
// const Domain& domain = Domain()) const;
template<class LinearAlgebraTupleT>
void Assemble(LinearAlgebraTupleT&& linear_algebra_tuple,
const GlobalVector& previous_iteration_data,
const Domain& domain = Domain()) const;
private:
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment