#include <users_modules/basic_finite_elements/src/SurfaceSlidingConstrains.hpp>

Inheritance diagram for EdgeSlidingConstrains:

Collaboration diagram for EdgeSlidingConstrains:

Classes
struct	CalculateEdgeBase

struct	MyEdgeFE

struct	OpJacobian

Public Member Functions
MyEdgeFE &	getLoopFeRhs ()

MyEdgeFE &	getLoopFeLhs ()

MoFEMErrorCode	getOptions ()

	EdgeSlidingConstrains (MoFEM::Interface &m_field)

MoFEMErrorCode	setOperators (int tag, Range edges, Range faces, const std::string lagrange_multipliers_field_name, const std::string material_field_name)

MoFEMErrorCode	setOperators (int tag, const std::string lagrange_multipliers_field_name, const std::string material_field_name, const double *alpha=nullptr)

MoFEMErrorCode	setOperatorsConstrainOnly (int tag, Range edges, Range faces, const std::string lagrange_multipliers_field_name, const std::string material_field_name)

MoFEMErrorCode	setOperatorsConstrainOnly (int tag, const std::string lagrange_multipliers_field_name, const std::string material_field_name)

Public Member Functions inherited from GenericSliding
	GenericSliding ()=default

virtual	~GenericSliding ()=default

Public Attributes
MoFEM::Interface &	mField

boost::shared_ptr< MyEdgeFE >	feRhsPtr

boost::shared_ptr< MyEdgeFE >	feLhsPtr

MyEdgeFE &	feRhs

MyEdgeFE &	feLhs

double	aLpha

Detailed Description

Examples: mesh_smoothing.cpp.

Definition at line 639 of file SurfaceSlidingConstrains.hpp.

Constructor & Destructor Documentation

◆ EdgeSlidingConstrains()

EdgeSlidingConstrains::EdgeSlidingConstrains ( MoFEM::Interface & m_field )

inline

Definition at line 925 of file SurfaceSlidingConstrains.hpp.

      : mField(m_field), feRhsPtr(new MyEdgeFE(m_field)),
        feLhsPtr(new MyEdgeFE(m_field)), feRhs(*feRhsPtr), feLhs(*feLhsPtr),
        aLpha(1) {
    ierr = getOptions();
    CHKERRABORT(PETSC_COMM_WORLD, ierr);
  }

Member Function Documentation

◆ getLoopFeLhs()

MyEdgeFE & EdgeSlidingConstrains::getLoopFeLhs ( )

inline

Definition at line 908 of file SurfaceSlidingConstrains.hpp.

908{ return feLhs; }

◆ getLoopFeRhs()

MyEdgeFE & EdgeSlidingConstrains::getLoopFeRhs ( )

inline

Definition at line 906 of file SurfaceSlidingConstrains.hpp.

906{ return feRhs; }

◆ getOptions()

MoFEMErrorCode EdgeSlidingConstrains::getOptions ( )

inline

Definition at line 912 of file SurfaceSlidingConstrains.hpp.

                              {
    MoFEMFunctionBegin;
    ierr = PetscOptionsBegin(PETSC_COMM_WORLD, "",
                             "Get edge sliding constrains element scaling",
                             "none");
    CHKERRQ(ierr);
    CHKERR PetscOptionsScalar("-edge_sliding_alpha", "scaling parameter", "",
                              aLpha, &aLpha, PETSC_NULL);
    ierr = PetscOptionsEnd();
    CHKERRQ(ierr);
    MoFEMFunctionReturn(0);
  }

◆ setOperators() [1/2]

MoFEMErrorCode EdgeSlidingConstrains::setOperators	(	int	tag,
		const std::string	lagrange_multipliers_field_name,
		const std::string	material_field_name,
		const double *	alpha = `nullptr`
	)

inline

Definition at line 1103 of file SurfaceSlidingConstrains.hpp.

                                                             {
    MoFEMFunctionBegin;
 
    if (alpha) {
      aLpha = *alpha;
    }
 
    boost::shared_ptr<VectorDouble> active_variables_ptr(
        new VectorDouble(4 + 6));
    boost::shared_ptr<VectorDouble> results_ptr(new VectorDouble(4 + 6));
    boost::shared_ptr<MatrixDouble> jacobian_ptr(
        new MatrixDouble(4 + 6, 4 + 6));
 
    feRhs.getOpPtrVector().clear();
    feRhs.getOpPtrVector().push_back(new OpGetActiveDofsLambda(
        lagrange_multipliers_field_name, active_variables_ptr));
    feRhs.getOpPtrVector().push_back(new OpGetActiveDofsPositions<4>(
        material_field_name, active_variables_ptr));
    feRhs.getOpPtrVector().push_back(new OpJacobian(
        tag, lagrange_multipliers_field_name, active_variables_ptr, results_ptr,
        jacobian_ptr, false, aLpha));
    feRhs.getOpPtrVector().push_back(
        new OpAssembleRhs<4, 6>(lagrange_multipliers_field_name, results_ptr));
    feRhs.getOpPtrVector().push_back(
        new OpAssembleRhs<4, 6>(material_field_name, results_ptr));
 
    // Adding operators to calculate the left hand side
    feLhs.getOpPtrVector().clear();
    feLhs.getOpPtrVector().push_back(new OpGetActiveDofsLambda(
        lagrange_multipliers_field_name, active_variables_ptr));
    feLhs.getOpPtrVector().push_back(new OpGetActiveDofsPositions<4>(
        material_field_name, active_variables_ptr));
    feLhs.getOpPtrVector().push_back(new OpJacobian(
        tag, lagrange_multipliers_field_name, active_variables_ptr, results_ptr,
        jacobian_ptr, true, aLpha));
    feLhs.getOpPtrVector().push_back(new OpAssembleLhs<4, 6>(
        lagrange_multipliers_field_name, material_field_name, jacobian_ptr));
    feLhs.getOpPtrVector().push_back(new OpAssembleLhs<4, 6>(
        material_field_name, lagrange_multipliers_field_name, jacobian_ptr));
    feLhs.getOpPtrVector().push_back(new OpAssembleLhs<4, 6>(
        material_field_name, material_field_name, jacobian_ptr));
 
    MoFEMFunctionReturn(0);
  }

◆ setOperators() [2/2]

MoFEMErrorCode EdgeSlidingConstrains::setOperators	(	int	tag,
		Range	edges,
		Range	faces,
		const std::string	lagrange_multipliers_field_name,
		const std::string	material_field_name
	)

inline

Definition at line 1092 of file SurfaceSlidingConstrains.hpp.

                                                                   {
    MoFEMFunctionBegin;
    CHKERR EdgeSlidingConstrains::CalculateEdgeBase::setTags(mField.get_moab(),
                                                             edges, faces);
    CHKERR setOperators(tag, lagrange_multipliers_field_name,
                        material_field_name);
    MoFEMFunctionReturn(0);
  }

◆ setOperatorsConstrainOnly() [1/2]

MoFEMErrorCode EdgeSlidingConstrains::setOperatorsConstrainOnly	(	int	tag,
		const std::string	lagrange_multipliers_field_name,
		const std::string	material_field_name
	)

inline

Definition at line 1165 of file SurfaceSlidingConstrains.hpp.

                                                                 {
    MoFEMFunctionBegin;
 
    boost::shared_ptr<VectorDouble> active_variables_ptr(
        new VectorDouble(4 + 6));
    boost::shared_ptr<VectorDouble> results_ptr(new VectorDouble(4 + 6));
    boost::shared_ptr<MatrixDouble> jacobian_ptr(
        new MatrixDouble(4 + 6, 4 + 6));
 
    // Adding operators to calculate the left hand side
    feLhs.getOpPtrVector().clear();
    feLhs.getOpPtrVector().push_back(new OpGetActiveDofsLambda(
        lagrange_multipliers_field_name, active_variables_ptr));
    feLhs.getOpPtrVector().push_back(new OpGetActiveDofsPositions<4>(
        material_field_name, active_variables_ptr));
    feLhs.getOpPtrVector().push_back(new OpJacobian(
        tag, lagrange_multipliers_field_name, active_variables_ptr, results_ptr,
        jacobian_ptr, true, aLpha));
    feLhs.getOpPtrVector().push_back(new OpAssembleLhs<4, 6>(
        lagrange_multipliers_field_name, material_field_name, jacobian_ptr));
 
    MoFEMFunctionReturn(0);
  }

◆ setOperatorsConstrainOnly() [2/2]

MoFEMErrorCode EdgeSlidingConstrains::setOperatorsConstrainOnly	(	int	tag,
		Range	edges,
		Range	faces,
		const std::string	lagrange_multipliers_field_name,
		const std::string	material_field_name
	)

inline

Definition at line 1152 of file SurfaceSlidingConstrains.hpp.

                                                                 {
    MoFEMFunctionBegin;
 
    CHKERR EdgeSlidingConstrains::CalculateEdgeBase::setTags(mField.get_moab(),
                                                             edges, faces);
    CHKERR setOperatorsConstrainOnly(tag, lagrange_multipliers_field_name,
                                     material_field_name);
    MoFEMFunctionReturn(0);
  }