PoissonExample::CreateFiniteElements Struct Reference

Create finite elements instances. More...

#include <users_modules/tutorials/cor-2to5/src/PoissonOperators.hpp>

Collaboration diagram for PoissonExample::CreateFiniteElements:

Public Member Functions
	CreateFiniteElements (MoFEM::Interface &m_field)
MoFEMErrorCode	createFEToAssembleMatrixAndVector (boost::function< double(const double, const double, const double)> f_u, boost::function< double(const double, const double, const double)> f_source, boost::shared_ptr< ForcesAndSourcesCore > &domain_lhs_fe, boost::shared_ptr< ForcesAndSourcesCore > &boundary_lhs_fe, boost::shared_ptr< ForcesAndSourcesCore > &domain_rhs_fe, boost::shared_ptr< ForcesAndSourcesCore > &boundary_rhs_fe, bool trans=true) const
	Create finite element to calculate matrix and vectors. More...
MoFEMErrorCode	createFEToEvaluateError (boost::function< double(const double, const double, const double)> f_u, boost::function< FTensor::Tensor1< double, 3 >(const double, const double, const double)> g_u, Vec global_error, boost::shared_ptr< ForcesAndSourcesCore > &domain_error) const
	Create finite element to calculate error. More...
MoFEMErrorCode	creatFEToPostProcessResults (boost::shared_ptr< PostProcFE > &post_proc_volume) const
	Create finite element to post-process results. More...
MoFEMErrorCode	createFEToAssembleMatrixAndVectorForNonlinearProblem (boost::function< double(const double, const double, const double)> f_u, boost::function< double(const double, const double, const double)> f_source, boost::function< double(const double)> a, boost::function< double(const double)> diff_a, boost::shared_ptr< ForcesAndSourcesCore > &domain_lhs_fe, boost::shared_ptr< ForcesAndSourcesCore > &boundary_lhs_fe, boost::shared_ptr< ForcesAndSourcesCore > &domain_rhs_fe, boost::shared_ptr< ForcesAndSourcesCore > &boundary_rhs_fe, ForcesAndSourcesCore::RuleHookFun vol_rule, ForcesAndSourcesCore::RuleHookFun face_rule=FaceRule(), bool trans=true) const
	Create finite element to calculate matrix and vectors. More...

Private Attributes
MoFEM::Interface &	mField

Detailed Description

Create finite elements instances.

Create finite element instances and add operators to finite elements.

Examples

analytical_nonlinear_poisson.cpp, analytical_poisson.cpp, and analytical_poisson_field_split.cpp.

Definition at line 858 of file PoissonOperators.hpp.

Constructor & Destructor Documentation

CreateFiniteElements()

PoissonExample::CreateFiniteElements::CreateFiniteElements ( MoFEM::Interface &  m_field )

inline

Definition at line 860 of file PoissonOperators.hpp.

: mField(m_field) {}

Member Function Documentation

createFEToAssembleMatrixAndVector()

MoFEMErrorCode PoissonExample::CreateFiniteElements::createFEToAssembleMatrixAndVector ( boost::function< double(const double, const double, const double)>  f_u, boost::function< double(const double, const double, const double)>  f_source, boost::shared_ptr< ForcesAndSourcesCore > &  domain_lhs_fe, boost::shared_ptr< ForcesAndSourcesCore > &  boundary_lhs_fe, boost::shared_ptr< ForcesAndSourcesCore > &  domain_rhs_fe, boost::shared_ptr< ForcesAndSourcesCore > &  boundary_rhs_fe, bool  trans = true  ) const

inline

Create finite element to calculate matrix and vectors.

Examples

PoissonOperators.hpp, analytical_poisson.cpp, and analytical_poisson_field_split.cpp.

Definition at line 865 of file PoissonOperators.hpp.

                               {
    MoFEMFunctionBegin;
 
    // Create elements element instances
    domain_lhs_fe = boost::shared_ptr<ForcesAndSourcesCore>(
        new VolumeElementForcesAndSourcesCore(mField));
    boundary_lhs_fe = boost::shared_ptr<ForcesAndSourcesCore>(
        new FaceElementForcesAndSourcesCore(mField));
    domain_rhs_fe = boost::shared_ptr<ForcesAndSourcesCore>(
        new VolumeElementForcesAndSourcesCore(mField));
    boundary_rhs_fe = boost::shared_ptr<ForcesAndSourcesCore>(
        new FaceElementForcesAndSourcesCore(mField));
 
    // Set integration rule to elements instances
    domain_lhs_fe->getRuleHook = VolRule();
    domain_rhs_fe->getRuleHook = VolRule();
    boundary_lhs_fe->getRuleHook = FaceRule();
    boundary_rhs_fe->getRuleHook = FaceRule();
 
    // Add operators to element instances
    // Add operator grad-grad for calculate matrix
    domain_lhs_fe->getOpPtrVector().push_back(new OpK());
    // Add operator to calculate source terms
    domain_rhs_fe->getOpPtrVector().push_back(new OpF(f_source));
    // Add operator calculating constrains matrix
    boundary_lhs_fe->getOpPtrVector().push_back(new OpC(trans));
    // Add operator calculating constrains vector
    boundary_rhs_fe->getOpPtrVector().push_back(new Op_g(f_u));
 
    MoFEMFunctionReturn(0);
  }

createFEToAssembleMatrixAndVectorForNonlinearProblem()

MoFEMErrorCode PoissonExample::CreateFiniteElements::createFEToAssembleMatrixAndVectorForNonlinearProblem ( boost::function< double(const double, const double, const double)>  f_u, boost::function< double(const double, const double, const double)>  f_source, boost::function< double(const double)>  a, boost::function< double(const double)>  diff_a, boost::shared_ptr< ForcesAndSourcesCore > &  domain_lhs_fe, boost::shared_ptr< ForcesAndSourcesCore > &  boundary_lhs_fe, boost::shared_ptr< ForcesAndSourcesCore > &  domain_rhs_fe, boost::shared_ptr< ForcesAndSourcesCore > &  boundary_rhs_fe, ForcesAndSourcesCore::RuleHookFun  vol_rule, ForcesAndSourcesCore::RuleHookFun  face_rule = FaceRule(), bool  trans = true  ) const

inline

Create finite element to calculate matrix and vectors.

Examples

analytical_nonlinear_poisson.cpp.

Definition at line 1010 of file PoissonOperators.hpp.

                               {
    MoFEMFunctionBegin;
 
    // Create elements element instances
    domain_lhs_fe = boost::shared_ptr<ForcesAndSourcesCore>(
        new VolumeElementForcesAndSourcesCore(mField));
    boundary_lhs_fe = boost::shared_ptr<ForcesAndSourcesCore>(
        new FaceElementForcesAndSourcesCore(mField));
    domain_rhs_fe = boost::shared_ptr<ForcesAndSourcesCore>(
        new VolumeElementForcesAndSourcesCore(mField));
    boundary_rhs_fe = boost::shared_ptr<ForcesAndSourcesCore>(
        new FaceElementForcesAndSourcesCore(mField));
 
    // Set integration rule to elements instances
    domain_lhs_fe->getRuleHook = vol_rule;
    domain_rhs_fe->getRuleHook = vol_rule;
    boundary_lhs_fe->getRuleHook = face_rule;
    boundary_rhs_fe->getRuleHook = face_rule;
 
    // Set integration rule
    // Crate shared vector storing values of field "u" on integration points on
    // element. element is local and is used to exchange data between operators.
    boost::shared_ptr<VectorDouble> values_at_integration_ptr =
        boost::make_shared<VectorDouble>();
    // Storing gradients of field
    boost::shared_ptr<MatrixDouble> grad_at_integration_ptr =
        boost::make_shared<MatrixDouble>();
    // multipliers values
    boost::shared_ptr<VectorDouble> multiplier_at_integration_ptr =
        boost::make_shared<VectorDouble>();
 
    // Add operators to element instances
    // Add default operator to calculate field values at integration points
    domain_lhs_fe->getOpPtrVector().push_back(
        new OpCalculateScalarFieldValues("U", values_at_integration_ptr));
    // Add default operator to calculate field gradient at integration points
    domain_lhs_fe->getOpPtrVector().push_back(
        new OpCalculateScalarFieldGradient<3>("U", grad_at_integration_ptr));
    // Add operator grad-(1+u^2)grad for calculate matrix
    domain_lhs_fe->getOpPtrVector().push_back(new OpKt(
        a, diff_a, values_at_integration_ptr, grad_at_integration_ptr));
 
    // Add default operator to calculate field values at integration points
    domain_rhs_fe->getOpPtrVector().push_back(
        new OpCalculateScalarFieldValues("U", values_at_integration_ptr));
    // Add default operator to calculate field gradient at integration points
    domain_rhs_fe->getOpPtrVector().push_back(
        new OpCalculateScalarFieldGradient<3>("U", grad_at_integration_ptr));
    // Add operator to calculate source terms
    domain_rhs_fe->getOpPtrVector().push_back(new OpResF_Domain(
        f_source, a, values_at_integration_ptr, grad_at_integration_ptr));
 
    // Add operator calculating constrains matrix
    boundary_lhs_fe->getOpPtrVector().push_back(new OpC(trans));
 
    // Add default operator to calculate field values at integration points
    boundary_rhs_fe->getOpPtrVector().push_back(
        new OpCalculateScalarFieldValues("U", values_at_integration_ptr));
    // Add default operator to calculate values of Lagrange multipliers
    boundary_rhs_fe->getOpPtrVector().push_back(
        new OpCalculateScalarFieldValues("L", multiplier_at_integration_ptr));
    // Add operator calculating constrains vector
    boundary_rhs_fe->getOpPtrVector().push_back(
        new OpRes_g(f_u, values_at_integration_ptr));
    boundary_rhs_fe->getOpPtrVector().push_back(
        new OpResF_Boundary(multiplier_at_integration_ptr));
 
    MoFEMFunctionReturn(0);
  }

createFEToEvaluateError()

MoFEMErrorCode PoissonExample::CreateFiniteElements::createFEToEvaluateError ( boost::function< double(const double, const double, const double)>  f_u, boost::function< FTensor::Tensor1< double, 3 >(const double, const double, const double)>  g_u, Vec  global_error, boost::shared_ptr< ForcesAndSourcesCore > &  domain_error  ) const

inline

Create finite element to calculate error.

Examples

PoissonOperators.hpp, analytical_nonlinear_poisson.cpp, analytical_poisson.cpp, and analytical_poisson_field_split.cpp.

Definition at line 908 of file PoissonOperators.hpp.

                                                                 {
    MoFEMFunctionBegin;
    // Create finite element instance to calculate error
    domain_error = boost::shared_ptr<ForcesAndSourcesCore>(
        new VolumeElementForcesAndSourcesCore(mField));
    domain_error->getRuleHook = VolRule();
    // Set integration rule
    // Crate shared vector storing values of field "u" on integration points on
    // element. element is local and is used to exchange data between operators.
    boost::shared_ptr<VectorDouble> values_at_integration_ptr =
        boost::make_shared<VectorDouble>();
    // Storing gradients of field
    boost::shared_ptr<MatrixDouble> grad_at_integration_ptr =
        boost::make_shared<MatrixDouble>();
    // Add default operator to calculate field values at integration points
    domain_error->getOpPtrVector().push_back(
        new OpCalculateScalarFieldValues("U", values_at_integration_ptr));
    // Add default operator to calculate field gradient at integration points
    domain_error->getOpPtrVector().push_back(
        new OpCalculateScalarFieldGradient<3>("U", grad_at_integration_ptr));
    // Add operator to integrate error element by element.
    domain_error->getOpPtrVector().push_back(
        new OpError(f_u, g_u, values_at_integration_ptr,
                    grad_at_integration_ptr, global_error));
    MoFEMFunctionReturn(0);
  }

creatFEToPostProcessResults()

MoFEMErrorCode PoissonExample::CreateFiniteElements::creatFEToPostProcessResults ( boost::shared_ptr< PostProcFE > &  post_proc_volume ) const

inline

Create finite element to post-process results.

Examples

PoissonOperators.hpp, analytical_nonlinear_poisson.cpp, analytical_poisson.cpp, and analytical_poisson_field_split.cpp.

Definition at line 944 of file PoissonOperators.hpp.

                                                           {
 
    MoFEMFunctionBegin;
 
    // Note that user can stack together arbitrary number of operators to
    // compose complex PDEs.
 
    // Post-process results. This is standard element, with functionality
    // enabling refining mesh for post-processing. In addition in
    // PostProcOnRefMesh.hpp are implanted set of  users operators to
    // post-processing fields. Here using simplified mechanism for
    // post-processing finite element, we add operators to save data from field
    // on mesh tags for ParaView visualization.
    post_proc_volume =
        boost::shared_ptr<PostProcFE>(new PostProcFE(mField));
    // Add operators to the elements, starting with some generic
 
    auto det_ptr = boost::make_shared<VectorDouble>();
    auto jac_ptr = boost::make_shared<MatrixDouble>();
    auto inv_jac_ptr = boost::make_shared<MatrixDouble>();
    post_proc_volume->getOpPtrVector().push_back(
        new OpCalculateHOJac<3>(jac_ptr));
    post_proc_volume->getOpPtrVector().push_back(
        new OpInvertMatrix<3>(jac_ptr, det_ptr, inv_jac_ptr));
    post_proc_volume->getOpPtrVector().push_back(
        new OpSetHOInvJacToScalarBases<3>(H1, inv_jac_ptr));
 
    auto u_ptr = boost::make_shared<VectorDouble>();
    auto grad_ptr = boost::make_shared<MatrixDouble>();
    auto e_ptr = boost::make_shared<VectorDouble>();
 
    post_proc_volume->getOpPtrVector().push_back(
        new OpCalculateScalarFieldValues("U", u_ptr));
    post_proc_volume->getOpPtrVector().push_back(
        new OpCalculateScalarFieldGradient<3>("U", grad_ptr));
    post_proc_volume->getOpPtrVector().push_back(
        new OpCalculateScalarFieldValues("ERROR", e_ptr));
 
    using OpPPMap = OpPostProcMapInMoab<3, 3>;
 
    post_proc_volume->getOpPtrVector().push_back(
 
        new OpPPMap(
 
            post_proc_volume->getPostProcMesh(),
            post_proc_volume->getMapGaussPts(),
 
            {{"U", u_ptr}, {"ERROR", e_ptr}},
 
            {{"GRAD", grad_ptr}},
 
            {},
 
            {}
 
            )
 
    );
 
    MoFEMFunctionReturn(0);
  }

Member Data Documentation

mField

MoFEM::Interface& PoissonExample::CreateFiniteElements::mField

private

Examples

PoissonOperators.hpp.

Definition at line 1093 of file PoissonOperators.hpp.

---

The documentation for this struct was generated from the following file:

• users_modules/tutorials/cor-2to5/src/PoissonOperators.hpp