LinearFormsIntegrators.hpp

Go to the documentation of this file.

/** \file LinearFormsIntegrators.hpp
  * \brief Linear forms integrators
  * \ingroup mofem_form
  *
  * This file provides template aliases for linear form integrators used in finite
  * element assembly. Linear forms represent the right-hand side vectors in finite
  * element formulations \f$(v, f)_\Omega\f$ where \f$v\f$ is a test function and
  * \f$f\f$ is a source term or field. The integrators handle various mathematical
  * operations including scalar/vector/tensor field integration, mixed formulations,
  * boundary conditions, and convective terms. All aliases reference implementations
  * in LinearFormsIntegratorsImpl.hpp for actual computational details.
  *
*/
 
#ifndef __LINEAR_FORMS_INTEGRATORS_HPP__
#define __LINEAR_FORMS_INTEGRATORS_HPP__
 
 
 
namespace MoFEM {
 
/**
 * @brief Linear integrator form
 * @ingroup mofem_forms
 *
 * @tparam EleOp
 * @tparam A
 * @tparam I
 */
template <typename EleOp>
template <AssemblyType A>
template <IntegrationType I>
struct FormsIntegrators<EleOp>::Assembly<A>::LinearForm {
 
  /**
   * @brief Integrate \f$(v,f(\mathbf{x}))_\Omega\f$ where f is a scalar function
   * @ingroup mofem_forms
   *
   * This operator integrates the product of test functions with a scalar source
   * function defined at integration points. Commonly used for:
   * - Body forces in mechanics (gravitational, thermal expansion)
   * - Source terms in heat transfer and diffusion problems
   * - Prescribed loads and boundary conditions
   *
   * @note \f$f(\mathbf{x})\f$ is a scalar function of coordinates
   * @note Implementation details are in LinearFormsIntegratorsImpl.hpp
   *
   * @tparam BASE_DIM Dimension of the basis functions (1D, 2D, 3D)
   * @tparam FIELD_DIM Dimension of the field being integrated
   * @tparam S Source function specialization type (default: SourceFunctionSpecialization)
   */
  template <int BASE_DIM, int FIELD_DIM,
            typename S = SourceFunctionSpecialization>
  using OpSource =
      OpSourceImpl<BASE_DIM, FIELD_DIM, I, typename S::template S<OpBase>>;
 
  /**
   * @brief Scalar field integrator \f$(v_i,f)_\Omega\f$ where f is a scalar
   * @ingroup mofem_forms
   *
   * This operator integrates the product of vector test functions with a scalar
   * field value. Each component of the test function is multiplied by the same
   * scalar value. Useful for:
   * - Uniform pressure loads in structural mechanics
   * - Constant temperature fields in thermal problems
   * - Scalar material properties affecting vector fields
   *
   * @note Implementation details are in LinearFormsIntegratorsImpl.hpp
   *
   * @tparam BASE_DIM Dimension of the basis functions (1D, 2D, 3D)
   * @tparam S Stride or scaling factor (default: 1)
   */
  template <int BASE_DIM, int S = 1>
  using OpBaseTimesScalar = OpBaseTimesScalarImpl<BASE_DIM, S, I, OpBase>;
 
  /**
   * @brief Deprecated alias for OpBaseTimesScalar
   * @deprecated Use OpBaseTimesScalar instead for consistency
   * 
   * @tparam BASE_DIM Dimension of the basis functions
   * @tparam S Stride or scaling factor (default: 1)
   */
  template <int BASE_DIM, int S = 1>
  using OpBaseTimesScalarField = OpBaseTimesScalar<BASE_DIM, S>;
 
  /**
   * @brief Vector field integrator \f$(v,f_i)_\Omega\f$ where f is a vector
   * @ingroup mofem_forms
   *
   * This operator integrates the product of test functions with vector field
   * values. Each test function component is multiplied by the corresponding
   * component of the vector field. Applications include:
   * - Vector body forces (wind loads, electromagnetic forces)
   * - Distributed loads with directional components
   * - Multi-component source terms in coupled problems
   *
   * @note Implementation details are in LinearFormsIntegratorsImpl.hpp
   *
   * @tparam BASE_DIM Dimension of the basis functions (1D, 2D, 3D)
   * @tparam FIELD_DIM Dimension of the vector field
   * @tparam S Stride or scaling factor
   */
  template <int BASE_DIM, int FIELD_DIM, int S>
  using OpBaseTimesVector =
      OpBaseTimesVectorImpl<BASE_DIM, FIELD_DIM, S, I, OpBase>;
  //! [Source operator]
 
  //! [Grad times tensor]
 
  /**
   * @brief Integrate \f$(v_{,i},f_{ij})_\Omega\f$ where f is a tensor
   * @ingroup mofem_forms
   *
   * This operator integrates the product of test function gradients with tensor
   * field values. The gradient of test functions contracts with the tensor field.
   * Common applications include:
   * - Stress-based formulations in mechanics
   * - Flux calculations in transport problems
   * - Gradient-dependent source terms
   *
   * @note \f$f_{ij}\f$ is a tensor field at integration points
   * @note Implementation details are in LinearFormsIntegratorsImpl.hpp
   *
   * @tparam BASE_DIM Dimension of the basis functions (1D, 2D, 3D)
   * @tparam FIELD_DIM Dimension of the field
   * @tparam SPACE_DIM Spatial dimension of the problem
   * @tparam S Stride or scaling factor (default: 1)
   */
  template <int BASE_DIM, int FIELD_DIM, int SPACE_DIM, int S = 1>
  using OpGradTimesTensor =
      OpGradTimesTensorImpl<BASE_DIM, FIELD_DIM, SPACE_DIM, S, I, OpBase>;
 
  /**
   * @brief Integrate \f$(v_{,i},f_{ij})_\Omega\f$ where f is a symmetric tensor
   * @ingroup mofem_forms
   *
   * This operator is specialized for symmetric tensors, providing computational
   * efficiency when the tensor field has symmetry properties. Applications include:
   * - Symmetric stress tensors in solid mechanics
   * - Symmetric diffusion tensors in transport problems
   * - Symmetric material property tensors
   *
   * @note \f$f_{ij}\f$ is a symmetric tensor field at integration points
   * @note Implementation details are in LinearFormsIntegratorsImpl.hpp
   *
   * @tparam BASE_DIM Dimension of the basis functions (1D, 2D, 3D)
   * @tparam FIELD_DIM Dimension of the field
   * @tparam SPACE_DIM Spatial dimension of the problem
   * @tparam S Stride or scaling factor (default: 1)
   */
  template <int BASE_DIM, int FIELD_DIM, int SPACE_DIM, int S = 1>
  using OpGradTimesSymTensor =
      OpGradTimesSymTensorImpl<BASE_DIM, FIELD_DIM, SPACE_DIM, S, I, OpBase>;
 
  /**
   * @brief Mixed formulation integrator: \f$(\lambda_{ij,j},u_{i})_\Omega\f$
   * @ingroup mofem_forms
   *
   * This operator integrates the divergence of a tensor field \f$\lambda_{ij}\f$
   * with vector test functions \f$u_i\f$. Essential for mixed formulations where
   * stress equilibrium or vector field divergence is enforced. Applications include:
   * - Stress-displacement coupling in solid mechanics
   * - Mixed formulations with tensor constraints
   * - Multi-physics problems with vector-tensor coupling
   *
   * @note \f$\lambda_{ij,j}\f$ is the divergence of tensor field at integration points
   * @note \f$u_i\f$ is the vector test function
   * @note Implementation details are in LinearFormsIntegratorsImpl.hpp
   *
   * @tparam BASE_DIM Dimension of the basis functions (1D, 2D, 3D)
   * @tparam FIELD_DIM Dimension of the field
   * @tparam SPACE_DIM Spatial dimension of the problem
   * @tparam CoordSys Coordinate system type (default: CARTESIAN)
   */
  template <int BASE_DIM, int FIELD_DIM, int SPACE_DIM,
            CoordinateTypes CoordSys = CARTESIAN>
  using OpMixDivTimesU =
      OpMixDivTimesUImpl<BASE_DIM, FIELD_DIM, SPACE_DIM, I, OpBase, CoordSys>;
 
  /**
   * @brief Mixed formulation integrator: \f$(\lambda_{ij},u_{i,j})_\Omega\f$
   * @ingroup mofem_forms
   *
   * This operator integrates tensor field values with the gradient of vector
   * test functions. The tensor field contracts with the gradient of test functions.
   * Applications include:
   * - Stress-strain coupling in mechanics
   * - Mixed formulations with gradient constraints
   * - Tensor-gradient field interactions
   *
   * @note \f$\lambda_{ij}\f$ is a tensor field at integration points
   * @note \f$u_{i,j}\f$ is the gradient of vector test function
   * @note Implementation details are in LinearFormsIntegratorsImpl.hpp
   *
   * @tparam SPACE_DIM Spatial dimension of the problem
   */
  template <int SPACE_DIM>
  using OpMixTensorTimesGradU = OpMixTensorTimesGradUImpl<SPACE_DIM, I, OpBase>;
 
  /**
   * @brief Mixed formulation integrator: \f$(u_{i},\lambda_{ij,j})_\Omega\f$
   * @ingroup mofem_forms
   *
   * This operator integrates vector test functions with the divergence of a
   * tensor field. This is the adjoint form of OpMixDivTimesU, commonly used
   * in mixed formulations for equilibrium enforcement. Applications include:
   * - Adjoint stress equilibrium in mechanics
   * - Dual formulations with tensor divergence
   * - Vector-tensor coupling in mixed problems
   *
   * @note \f$u_i\f$ is a vector test function
   * @note \f$\lambda_{ij,j}\f$ is the divergence of tensor field at integration points
   * @note Implementation details are in LinearFormsIntegratorsImpl.hpp
   *
   * @tparam SPACE_DIM Spatial dimension of the problem
   */
  template <int SPACE_DIM>
  using OpMixVecTimesDivLambda =
      OpMixVecTimesDivLambdaImpl<SPACE_DIM, I, OpBase>;
 
  /**
   * @brief Boundary integrator: normal vector times scalar function
   * @ingroup mofem_forms
   *
   * This operator multiplies vector test functions by the normal vector on
   * a face and integrates with a scalar field. Essential for natural boundary
   * conditions in mixed formulations. Applications include:
   * - Natural boundary conditions in fluid mechanics
   * - Surface flux conditions in transport problems
   * - Mixed boundary value problems
   *
   * @note This operator is used on domain boundaries (faces)
   * @note Implementation details are in LinearFormsIntegratorsImpl.hpp
   *
   * @tparam SPACE_DIM Spatial dimension of the problem
   */
  template <int SPACE_DIM>
  using OpNormalMixVecTimesScalar =
      OpNormalMixVecTimesScalarImpl<SPACE_DIM, I, OpBase>;
 
  /**
   * @brief Boundary integrator: normal vector times vector field
   * @ingroup mofem_forms
   *
   * This operator multiplies vector test functions by the normal vector on
   * a face and integrates with a vector field. Used for natural boundary
   * conditions involving vector quantities. Applications include:
   * - Vector-valued boundary conditions in mechanics
   * - Surface traction conditions in solid mechanics
   * - Vector flux conditions in multi-physics problems
   *
   * @note This operator is used on domain boundaries (faces)
   * @note Implementation details are in LinearFormsIntegratorsImpl.hpp
   *
   * @tparam SPACE_DIM Spatial dimension of the problem
   */
  template <int SPACE_DIM>
  using OpNormalMixVecTimesVectorField =
      OpNormalMixVecTimesVectorFieldImpl<SPACE_DIM, I, OpBase>;
 
  /**
   * @brief Convective term integrator: \f$(v, u_i \mathbf{y}_{,i})\f$
   * @ingroup mofem_forms
   *
   * This operator integrates convective terms where a velocity field \f$u_i\f$
   * transports a scalar or vector field \f$\mathbf{y}\f$. The convective operator
   * \f$u_i \mathbf{y}_{,i}\f$ represents advection. Applications include:
   * - Advection in fluid mechanics
   * - Convective transport in heat transfer
   * - Material transport in multi-physics problems
   *
   * @note \f$u_i\f$ is the velocity field at integration points
   * @note \f$\mathbf{y}_{,i}\f$ is the gradient of the transported field
   * @note \f$\mathbf{y}\f$ can be scalar or vector field
   * @note Implementation details are in LinearFormsIntegratorsImpl.hpp
   *
   * @tparam BASE_DIM Dimension of the basis functions (1D, 2D, 3D)
   * @tparam FIELD_DIM Dimension of the field
   * @tparam SPACE_DIM Spatial dimension of the problem
   */
  template <int BASE_DIM, int FIELD_DIM, int SPACE_DIM>
  using OpConvectiveTermRhs =
      OpConvectiveTermRhsImpl<BASE_DIM, FIELD_DIM, SPACE_DIM, I, OpBase>;
 
  /**
   * @brief Hybridization constraint integrator for broken spaces
   * @ingroup mofem_forms
   *
   * This operator assembles the right-hand side for constraint matrix C
   * during hybridization of broken finite element spaces. Hybridization
   * introduces Lagrange multipliers to enforce continuity across element
   * boundaries in discontinuous Galerkin methods. Applications include:
   * - Discontinuous Galerkin methods
   * - Mixed finite element methods with broken spaces
   * - Hybridizable discontinuous Galerkin (HDG) methods
   *
   * @note Used specifically for broken space hybridization
   * @note Implementation details are in LinearFormsIntegratorsImpl.hpp
   *
   * @tparam FIELD_DIM Dimension of the field
   */
  template <int FIELD_DIM>
  using OpBrokenSpaceConstrainDHybrid =
      OpBrokenSpaceConstrainDHybridImpl<FIELD_DIM, I, OpBase>;
 
  /**
   * @brief Assemble Rhs for contraint matrix C^T whole hybridisation
   * 
   * @tparam FIELD_DIM 
   */
  template <int FIELD_DIM>
  using OpBrokenSpaceConstrainDFlux =
      OpBrokenSpaceConstrainDFluxImpl<FIELD_DIM, I, OpBrokenBase>;
};
 
} // namespace MoFEM
 
#endif // __LINEAR_FORMS_INTEGRATORS_HPP__