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

Sources/FiniteElement/Operators/GlobalVariationalOperator/GlobalVariationalOperator.hpp

@@ -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

Sources/FiniteElement/Operators/GlobalVariationalOperator/Private/Impl/Recursivity.hxx

@@ -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();
                 

Sources/FiniteElement/Operators/GlobalVariationalOperatorInstances/BilinearForm/GradOnGradientBasedElasticityTensor.hpp

@@ -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;
 
             
         };

Sources/FiniteElement/Operators/GlobalVariationalOperatorInstances/BilinearForm/GradPhiGradPhi.hpp

@@ -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;
             
             
         };

Sources/FiniteElement/Operators/GlobalVariationalOperatorInstances/BilinearForm/Mass.hpp

@@ -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;
             
             
             

Sources/FiniteElement/Operators/GlobalVariationalOperatorInstances/BilinearForm/ScalarDivVectorial.hpp

@@ -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;
             
             
             

Sources/FiniteElement/Operators/GlobalVariationalOperatorInstances/LinearForm/Force.hpp

@@ -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,

Sources/FiniteElement/Operators/GlobalVariationalOperatorInstances/LinearForm/TransientSource.hpp

@@ -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,

Sources/FiniteElement/Operators/GlobalVariationalOperatorInstances/NonlinearForm/GradOnGradientBasedHyperelasticityTensor.hpp

@@ -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: