Set of functions declaring elements and setting operators for basic boundary conditions interface. More...

#include "users_modules/basic_finite_elements/src/BasicBoundaryConditionsInterface.hpp"

Inheritance diagram for BasicBoundaryConditionsInterface:

Collaboration diagram for BasicBoundaryConditionsInterface:

Classes
struct	BasicBCVectorConst

struct	BasicBCVectorScale

struct	LoadScale

Public Types
using	DomainEle = VolumeElementForcesAndSourcesCore

using	DomainEleOp = DomainEle::UserDataOperator

using	BoundaryEle = FaceElementForcesAndSourcesCore

using	BoundaryEleOp = BoundaryEle::UserDataOperator

using	OpBodyForce = FormsIntegrators< DomainEleOp >::Assembly< PETSC >::LinearForm< GAUSS >::OpSource< 1, 3 >

using	DomainNaturalBC = NaturalBC< DomainEleOp >::Assembly< PETSC >::LinearForm< GAUSS >

using	OpBodyForceVector = DomainNaturalBC::OpFlux< NaturalMeshsetTypeVectorScaling< BLOCKSET >, 1, 3 >

using	OpMass = FormsIntegrators< DomainEleOp >::Assembly< PETSC >::BiLinearForm< GAUSS >::OpMass< 1, 3 >

using	OpInertiaForce = FormsIntegrators< DomainEleOp >::Assembly< PETSC >::LinearForm< GAUSS >::OpBaseTimesVector< 1, 3, 3 >

Public Types inherited from GenericElementInterface
enum	TSType { EX , IM , IM2 , IMEX , DEFAULT , EX , IM , IM2 , IMEX , DEFAULT }

enum	TSType { EX , IM , IM2 , IMEX , DEFAULT , EX , IM , IM2 , IMEX , DEFAULT }

using	BcMarkerPtr = boost::shared_ptr< std::vector< char unsigned > >

using	BcMarkerPtr = boost::shared_ptr< std::vector< char unsigned > >

Public Member Functions
	BasicBoundaryConditionsInterface (MoFEM::Interface &m_field, string postion_field, string mesh_pos_field_name="MESH_NODE_POSITIONS", string problem_name="ELASTIC", string domain_element_name="ELASTIC_FE", bool is_displacement_field=true, bool is_quasi_static=true, double *snes_load_factor=nullptr, bool is_partitioned=true)

	~BasicBoundaryConditionsInterface ()

MoFEMErrorCode	getCommandLineParameters () override

MoFEMErrorCode	addElementFields () override

MoFEMErrorCode	createElements () override

MoFEMErrorCode	setOperators () override

MoFEMErrorCode	addElementsToDM (SmartPetscObj< DM > dm) override

MoFEMErrorCode	updateElementVariables () override

MoFEMErrorCode	postProcessElement (int step) override

string	getHistoryParam (string prefix)

template<typename T >
MoFEMErrorCode	setupSolverFunction (const TSType type=IM)

template<typename T >
MoFEMErrorCode	setupSolverJacobian (const TSType type=IM)

template<typename T , bool RHS>
MoFEMErrorCode	setupSolverImpl (const TSType type=IM)

MoFEMErrorCode	setupSolverFunctionSNES () override

MoFEMErrorCode	setupSolverJacobianSNES () override

MoFEMErrorCode	setupSolverFunctionTS (const TSType type) override

MoFEMErrorCode	setupSolverJacobianTS (const TSType type) override

Public Member Functions inherited from GenericElementInterface
	GenericElementInterface ()

virtual	~GenericElementInterface ()

virtual MoFEMErrorCode	setGlobalBoundaryMarker (BcMarkerPtr mark)

virtual BcMarkerPtr	getGlobalBoundaryMarker ()

virtual MoFEMErrorCode	setMonitorPtr (boost::shared_ptr< MoFEM::FEMethod > monitor_ptr)

virtual BitRefLevel	getBitRefLevel ()

virtual BitRefLevel	getBitRefLevelMask ()

virtual MoFEMErrorCode	opFactoryDomainRhs (boost::ptr_deque< ForcesAndSourcesCore::UserDataOperator > &pip)

virtual MoFEMErrorCode	opFactoryDomainLhs (boost::ptr_deque< ForcesAndSourcesCore::UserDataOperator > &pip)

virtual MoFEMErrorCode	setUpdateElementVariablesOperators ()

virtual MoFEMErrorCode	updateElementVariables (SmartPetscObj< DM > dm, string fe_name)

virtual MoFEMErrorCode	postProcessElement (int step, SmartPetscObj< DM > dm, string fe_name)

	GenericElementInterface ()

virtual	~GenericElementInterface ()

virtual MoFEMErrorCode	setGlobalBoundaryMarker (BcMarkerPtr mark)

virtual BcMarkerPtr	getGlobalBoundaryMarker ()

virtual MoFEMErrorCode	setMonitorPtr (boost::shared_ptr< FEMethod > monitor_ptr)

virtual BitRefLevel	getBitRefLevel ()

virtual BitRefLevel	getBitRefLevelMask ()

virtual MoFEMErrorCode	opFactoryDomainRhs (boost::ptr_deque< ForcesAndSourcesCore::UserDataOperator > &pip)

virtual MoFEMErrorCode	opFactoryDomainLhs (boost::ptr_deque< ForcesAndSourcesCore::UserDataOperator > &pip)

virtual MoFEMErrorCode	setUpdateElementVariablesOperators ()

virtual MoFEMErrorCode	updateElementVariables (SmartPetscObj< DM > dm, string fe_name)

virtual MoFEMErrorCode	postProcessElement (int step, SmartPetscObj< DM > dm, string fe_name)

Public Attributes
MoFEM::Interface &	mField

SmartPetscObj< DM >	dM

double *	snesLambdaLoadFactorPtr

bool	isDisplacementField

bool	isQuasiStatic

bool	isPartitioned

bool	isLinear

BitRefLevel	bIt

string	positionField

string	meshNodeField

boost::ptr_map< std::string, NeumannForcesSurface >	neumann_forces

boost::ptr_map< std::string, NodalForce >	nodal_forces

boost::ptr_map< std::string, EdgeForce >	edge_forces

boost::shared_ptr< FluidPressure >	fluidPressureElementPtr

boost::shared_ptr< FaceElementForcesAndSourcesCore >	springRhsPtr

boost::shared_ptr< FaceElementForcesAndSourcesCore >	springLhsPtr

boost::shared_ptr< VolumeElementForcesAndSourcesCore >	bodyForceRhsPtr

boost::shared_ptr< VolumeElementForcesAndSourcesCore >	bodyForceLhsPtr

boost::shared_ptr< DirichletDisplacementBc >	dirichletBcPtr

boost::shared_ptr< KelvinVoigtDamper >	damperElementPtr

const string	domainProblemName

const string	domainElementName

Public Attributes inherited from GenericElementInterface
BcMarkerPtr	mBoundaryMarker

int	atomTest

int	restartRunStep

boost::shared_ptr< MoFEM::FEMethod >	monitorPtr

boost::shared_ptr< FEMethod >	monitorPtr

Detailed Description

Set of functions declaring elements and setting operators for basic boundary conditions interface.

Definition at line 20 of file BasicBoundaryConditionsInterface.hpp.

Member Typedef Documentation

◆ BoundaryEle

using BasicBoundaryConditionsInterface::BoundaryEle = FaceElementForcesAndSourcesCore

Definition at line 24 of file BasicBoundaryConditionsInterface.hpp.

◆ BoundaryEleOp

using BasicBoundaryConditionsInterface::BoundaryEleOp = BoundaryEle::UserDataOperator

Definition at line 25 of file BasicBoundaryConditionsInterface.hpp.

◆ DomainEle

using BasicBoundaryConditionsInterface::DomainEle = VolumeElementForcesAndSourcesCore

Definition at line 22 of file BasicBoundaryConditionsInterface.hpp.

◆ DomainEleOp

using BasicBoundaryConditionsInterface::DomainEleOp = DomainEle::UserDataOperator

Definition at line 23 of file BasicBoundaryConditionsInterface.hpp.

◆ DomainNaturalBC

using BasicBoundaryConditionsInterface::DomainNaturalBC = NaturalBC<DomainEleOp>::Assembly<PETSC>::LinearForm<GAUSS>

Definition at line 29 of file BasicBoundaryConditionsInterface.hpp.

◆ OpBodyForce

using BasicBoundaryConditionsInterface::OpBodyForce = FormsIntegrators<DomainEleOp>::Assembly< PETSC>::LinearForm<GAUSS>::OpSource<1, 3>

Definition at line 27 of file BasicBoundaryConditionsInterface.hpp.

◆ OpBodyForceVector

using BasicBoundaryConditionsInterface::OpBodyForceVector = DomainNaturalBC::OpFlux<NaturalMeshsetTypeVectorScaling<BLOCKSET>, 1, 3>

Definition at line 31 of file BasicBoundaryConditionsInterface.hpp.

◆ OpInertiaForce

using BasicBoundaryConditionsInterface::OpInertiaForce = FormsIntegrators<DomainEleOp>::Assembly< PETSC>::LinearForm<GAUSS>::OpBaseTimesVector<1, 3, 3>

Definition at line 36 of file BasicBoundaryConditionsInterface.hpp.

◆ OpMass

using BasicBoundaryConditionsInterface::OpMass = FormsIntegrators<DomainEleOp>::Assembly<PETSC>::BiLinearForm< GAUSS>::OpMass<1, 3>

Definition at line 34 of file BasicBoundaryConditionsInterface.hpp.

Constructor & Destructor Documentation

◆ BasicBoundaryConditionsInterface()

BasicBoundaryConditionsInterface::BasicBoundaryConditionsInterface	(	MoFEM::Interface &	m_field,
		string	postion_field,
		string	mesh_pos_field_name = `"MESH_NODE_POSITIONS"`,
		string	problem_name = `"ELASTIC"`,
		string	domain_element_name = `"ELASTIC_FE"`,
		bool	is_displacement_field = `true`,
		bool	is_quasi_static = `true`,
		double *	snes_load_factor = `nullptr`,
		bool	is_partitioned = `true`
	)

inline

Definition at line 113 of file BasicBoundaryConditionsInterface.hpp.

      : mField(m_field), positionField(postion_field),
        meshNodeField(mesh_pos_field_name), domainProblemName(problem_name),
        domainElementName(domain_element_name),
        isDisplacementField(is_displacement_field),
        isQuasiStatic(is_quasi_static),
        snesLambdaLoadFactorPtr(snes_load_factor),
        isPartitioned(is_partitioned), isLinear(PETSC_FALSE) {}

◆ ~BasicBoundaryConditionsInterface()

BasicBoundaryConditionsInterface::~BasicBoundaryConditionsInterface ( )

inline

Definition at line 128 of file BasicBoundaryConditionsInterface.hpp.

128{}

Member Function Documentation

◆ addElementFields()

MoFEMErrorCode BasicBoundaryConditionsInterface::addElementFields ( )

inlineoverridevirtual

Implements GenericElementInterface.

Definition at line 146 of file BasicBoundaryConditionsInterface.hpp.

146{ return 0;};

◆ addElementsToDM()

MoFEMErrorCode BasicBoundaryConditionsInterface::addElementsToDM ( SmartPetscObj< DM > dm )

inlineoverridevirtual

Implements GenericElementInterface.

Definition at line 403 of file BasicBoundaryConditionsInterface.hpp.

                                                                {
    MoFEMFunctionBeginHot;
    this->dM = dm;
    auto simple = mField.getInterface<Simple>();
    vector<const char *> element_list{"FORCE_FE", "PRESSURE_FE",
                                      "FLUID_PRESSURE_FE",
                                      "SPRING",
                                      "DAMPER_FE"};
    for (auto &el : element_list) {
      CHKERR DMMoFEMAddElement(dM, el);
      simple->getOtherFiniteElements().push_back(el);
    }
    // if (!fluidPressureElementPtr->setOfFluids.empty())
    // FIXME:
    // CHKERR mField.modify_problem_add_finite_element(domainProblemName,
    //                                                 "FLUID_PRESSURE_FE");
    // CHKERR dynamic_cast<DirichletDisplacementRemoveDofsBc &>(
    //     *dirichletBcPtr).iNitialize();
    MoFEMFunctionReturnHot(0);
  };

◆ createElements()

MoFEMErrorCode BasicBoundaryConditionsInterface::createElements ( )

inlineoverridevirtual

Implements GenericElementInterface.

Definition at line 148 of file BasicBoundaryConditionsInterface.hpp.

                                           {
    MoFEMFunctionBeginHot;
 
    CHKERR MetaSpringBC::addSpringElements(mField, positionField,
                                           meshNodeField);
    CHKERR MetaNeumannForces::addNeumannBCElements(mField, positionField);
    CHKERR MetaNodalForces::addElement(mField, positionField);
    CHKERR MetaEdgeForces::addElement(mField, positionField);
 
    if (!isDisplacementField)
      dirichletBcPtr = boost::make_shared<DirichletSpatialRemoveDofsBc>(
          mField, positionField, domainProblemName, meshNodeField,
          "DISPLACEMENT", isPartitioned);
    else
      dirichletBcPtr = boost::make_shared<DirichletDisplacementRemoveDofsBc>(
          mField, positionField, domainProblemName, "DISPLACEMENT",
          isPartitioned);
    // CHKERR dynamic_cast<DirichletDisplacementRemoveDofsBc &>(
    //     *dirichletBcPtr).iNitialize();
 
    CHKERR mField.add_finite_element("DAMPER_FE", MF_ZERO);
    CHKERR mField.modify_finite_element_add_field_row("DAMPER_FE",
                                                      positionField);
    CHKERR mField.modify_finite_element_add_field_col("DAMPER_FE",
                                                      positionField);
    CHKERR mField.modify_finite_element_add_field_data("DAMPER_FE",
                                                       positionField);
    CHKERR mField.modify_finite_element_add_field_data("DAMPER_FE",
                                                       meshNodeField);
 
    // CHKERR mField.add_finite_element(domainElementName, "FLUID_PRESSURE_FE");
 
    fluidPressureElementPtr = boost::make_shared<FluidPressure>(mField);
    fluidPressureElementPtr->addNeumannFluidPressureBCElements(positionField);
    CHKERR AddHOOps<2, 3, 3>::add(
        fluidPressureElementPtr->getLoopFe().getOpPtrVector(), {},
        meshNodeField);
 
    damperElementPtr = boost::make_shared<KelvinVoigtDamper>(mField);
    damperElementPtr->commonData.meshNodePositionName = meshNodeField;
 
    auto &common_data = damperElementPtr->commonData;
 
    common_data.spatialPositionName = positionField;
    common_data.spatialPositionNameDot = "DOT_" + positionField;
    damperElementPtr->setBlockDataMap(); FIXME:
 
    for (auto &[id, data] : damperElementPtr->blockMaterialDataMap) {
      data.lInear = isLinear;
      int cid = id;
      damperElementPtr->constitutiveEquationMap.insert(
          cid, new KelvinVoigtDamper::ConstitutiveEquation<adouble>(data, isDisplacementField));
      CHKERR mField.add_ents_to_finite_element_by_type(data.tEts, MBTET,
                                                       "DAMPER_FE");
    }
 
    MoFEMFunctionReturnHot(0);
  };

◆ getCommandLineParameters()

MoFEMErrorCode BasicBoundaryConditionsInterface::getCommandLineParameters ( )

inlineoverridevirtual

Reimplemented from GenericElementInterface.

Definition at line 130 of file BasicBoundaryConditionsInterface.hpp.

                                                     {
    MoFEMFunctionBegin;
 
    PetscBool quasi_static = PETSC_FALSE;
    PetscBool is_linear = PETSC_FALSE;
    CHKERR PetscOptionsGetBool(PETSC_NULLPTR, "-is_quasi_static", &quasi_static,
                               PETSC_NULLPTR);
    CHKERR PetscOptionsGetBool(PETSC_NULLPTR, "-is_linear", &is_linear,
                               PETSC_NULLPTR);
 
    isQuasiStatic = quasi_static;
    isLinear = is_linear;
 
    MoFEMFunctionReturn(0);
  };

◆ getHistoryParam()

string BasicBoundaryConditionsInterface::getHistoryParam ( string prefix )

inline

Definition at line 427 of file BasicBoundaryConditionsInterface.hpp.

                                        {
    char load_hist_file[255] = "hist.in";
    PetscBool ctg_flag = PETSC_FALSE;
    string new_param_file = string("-") + prefix + string("_history");
    CHKERR PetscOptionsGetString(PETSC_NULLPTR, PETSC_NULLPTR, new_param_file.c_str(),
                                 load_hist_file, 255, &ctg_flag);
    if (ctg_flag)
      return new_param_file;
    return string("-load_history");
  };

◆ postProcessElement()

MoFEMErrorCode BasicBoundaryConditionsInterface::postProcessElement ( int step )

inlineoverridevirtual

Implements GenericElementInterface.

Definition at line 425 of file BasicBoundaryConditionsInterface.hpp.

425{ return 0; };

◆ setOperators()

MoFEMErrorCode BasicBoundaryConditionsInterface::setOperators ( )

inlineoverridevirtual

Implements GenericElementInterface.

Definition at line 207 of file BasicBoundaryConditionsInterface.hpp.

                                         {
    MoFEMFunctionBeginHot;
    CHKERR MetaNodalForces::setOperators(mField, nodal_forces, PETSC_NULLPTR,
                                         positionField);
    CHKERR MetaEdgeForces::setOperators(mField, edge_forces, PETSC_NULLPTR,
                                        positionField);
 
    CHKERR MetaNeumannForces::setMomentumFluxOperators(
        mField, neumann_forces, PETSC_NULLPTR, positionField);
    springLhsPtr = boost::make_shared<FaceElementForcesAndSourcesCore>(mField);
    springRhsPtr = boost::make_shared<FaceElementForcesAndSourcesCore>(mField);
    bodyForceRhsPtr =
        boost::make_shared<VolumeElementForcesAndSourcesCore>(mField);
    bodyForceLhsPtr =
        boost::make_shared<VolumeElementForcesAndSourcesCore>(mField);
 
    CHKERR MetaSpringBC::setSpringOperators(mField, springLhsPtr, springRhsPtr,
                                            positionField,
                                            meshNodeField);
 
    
    fluidPressureElementPtr->setNeumannFluidPressureFiniteElementOperators(
        positionField, PETSC_NULLPTR, true, true);
 
    // KelvinVoigtDamper::CommonData &common_data =
    // damperElementPtr->commonData;
    CHKERR damperElementPtr->setOperators(3);
 
    // auto dm = mField.getInterface<Simple>()->getDM();
 
    auto get_id_block_param = [&](string base_name, int id) {
      char load_hist_file[255] = "hist.in";
      PetscBool ctg_flag = PETSC_FALSE;
      string param_name_with_id = "-" + base_name + "_" + to_string(id);
      CHKERR PetscOptionsGetString(PETSC_NULLPTR, PETSC_NULLPTR,
                                   param_name_with_id.c_str(), load_hist_file,
                                   255, &ctg_flag);
      if (ctg_flag)
        return param_name_with_id;
      
      param_name_with_id = "-" + base_name;
      CHKERR PetscOptionsGetString(PETSC_NULLPTR, PETSC_NULLPTR,
                                   param_name_with_id.c_str(), load_hist_file,
                                   255, &ctg_flag);
      if (ctg_flag) {
        MOFEM_LOG("WORLD", Sev::verbose)
            << "Setting one accelerogram for all blocks!";
        return param_name_with_id;
      }
      
      return string("");
    };
 
    auto get_adj_ents = [&](const Range &ents) {
      Range verts;
      CHKERR mField.get_moab().get_connectivity(ents, verts, true);
      for (size_t d = 1; d < 3; ++d)
        CHKERR mField.get_moab().get_adjacencies(ents, d, false, verts,
                                                 moab::Interface::UNION);
      verts.merge(ents);
      CHKERR mField.getInterface<CommInterface>()->synchroniseEntities(verts);
      return verts;
    };
 
    for (_IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(mField, BLOCKSET, it)) {
      const std::string block_name = "BODY_FORCE";
      if (it->getName().compare(0, block_name.size(), block_name) == 0) {
        std::vector<double> attr;
        CHKERR it->getAttributes(attr);
        if (attr.size() > 3) {
 
          const int id = it->getMeshsetId();
 
          Range bc_ents;
          CHKERR it->getMeshsetIdEntitiesByDimension(mField.get_moab(), 3,
                                                     bc_ents, true);
          auto bc_ents_ptr = boost::make_shared<Range>(get_adj_ents(bc_ents));
 
          // the first parameter is density!!! FIXME:
 
          VectorDouble acc({attr[1], attr[2], attr[3]});
          double density = attr[0];
          bool inertia_flag =
              attr.size() > 4 ? bool(std::floor(attr[4])) : true;
          // if accelerogram is provided then change the acceleration,
          // otherwise use whatever is in that block TODO:
          std::vector<boost::shared_ptr<TimeScaleVector3>> methods_for_scaling;
          std::string param_name_for_scaling =
              get_id_block_param("accelerogram", id);
 
          if (!param_name_for_scaling.empty())
            methods_for_scaling.push_back(
                boost::make_shared<BasicBCVectorScale>(density,
                                                       param_name_for_scaling));
          else
            methods_for_scaling.push_back(
                boost::make_shared<BasicBCVectorConst>(
                    density,
                    FTensor::Tensor1<double, 3>({acc(0), acc(1), acc(2)})));
 
          // FIXME: this require correction for large strains, multiply by det_F
          auto get_rho = [&](double, double, double) {
            auto &fe_domain_lhs = bodyForceLhsPtr;
            return density * fe_domain_lhs->ts_aa;
          };
 
          auto &pipeline_rhs = bodyForceRhsPtr->getOpPtrVector();
          auto &pipeline_lhs = bodyForceLhsPtr->getOpPtrVector();
 
          CHKERR AddHOOps<3, 3, 3>::add(
              bodyForceRhsPtr->getOpPtrVector(), {H1}, meshNodeField);
          CHKERR AddHOOps<3, 3, 3>::add(
              bodyForceLhsPtr->getOpPtrVector(), {H1}, meshNodeField);
 
          //FIXME: fix for large strains
          pipeline_rhs.push_back(
              new OpSetBc(positionField, true, mBoundaryMarker));
 
          // using new way of adding BCs
          CHKERR
          DomainNaturalBC::AddFluxToPipeline<OpBodyForceVector>::add(
              pipeline_rhs, mField, "U", {}, methods_for_scaling,
              it->getName(), Sev::inform);
 
          if (!isQuasiStatic && inertia_flag) {
            pipeline_lhs.push_back(
                new OpSetBc(positionField, true, mBoundaryMarker));
            pipeline_lhs.push_back(
                new OpMass(positionField, positionField, get_rho, bc_ents_ptr));
            auto mat_acceleration = boost::make_shared<MatrixDouble>();
            pipeline_rhs.push_back(new OpCalculateVectorFieldValuesDotDot<3>(
                positionField, mat_acceleration));
            pipeline_rhs.push_back(new OpInertiaForce(
                positionField, mat_acceleration,
                [&](double, double, double) { return density; }, bc_ents_ptr));
            pipeline_lhs.push_back(new OpUnSetBc(positionField));
          }
          pipeline_rhs.push_back(new OpUnSetBc(positionField));
 
        } else {
          SETERRQ(
              PETSC_COMM_SELF, MOFEM_INVALID_DATA,
              "There should be (1 density + 3 accelerations ) attributes in "
              "BODY_FORCE blockset, but is %ld. Optionally, you can set 5th "
              "parameter to inertia flag.",
              attr.size());
        }
      }
    }
 
    auto integration_rule_vol = [](int, int, int approx_order) {
      return 2 * approx_order + 1;
    };
    auto integration_rule_boundary = [](int, int, int approx_order) {
      return 2 * approx_order + 1;
    };
 
    springLhsPtr->getRuleHook = integration_rule_boundary;
    springRhsPtr->getRuleHook = integration_rule_boundary;
    bodyForceLhsPtr->getRuleHook = integration_rule_vol;
    bodyForceRhsPtr->getRuleHook = integration_rule_vol;
 
    // set other boundary conditions
    auto bc_mng = mField.getInterface<BcManager>();
    auto *pipeline_mng = mField.getInterface<PipelineManager>();
 
    CHKERR bc_mng->removeBlockDOFsOnEntities(domainProblemName, "REMOVE_X",
                                             positionField, 0, 0, true,
                                             isPartitioned);
    CHKERR bc_mng->removeBlockDOFsOnEntities(domainProblemName, "REMOVE_Y",
                                             positionField, 1, 1, true,
                                             isPartitioned);
    CHKERR bc_mng->removeBlockDOFsOnEntities(domainProblemName, "REMOVE_Z",
                                             positionField, 2, 2, true,
                                             isPartitioned);
    CHKERR bc_mng->removeBlockDOFsOnEntities(domainProblemName, "REMOVE_ALL",
                                             positionField, 0, 2, true,
                                             isPartitioned);
 
    CHKERR bc_mng->pushMarkDOFsOnEntities(domainProblemName, "FIX_X",
                                          positionField, 0, 0);
    CHKERR bc_mng->pushMarkDOFsOnEntities(domainProblemName, "FIX_Y",
                                          positionField, 1, 1);
    CHKERR bc_mng->pushMarkDOFsOnEntities(domainProblemName, "FIX_Z",
                                          positionField, 2, 2);
    CHKERR bc_mng->pushMarkDOFsOnEntities(domainProblemName, "FIX_ALL",
                                          positionField, 0, 2);
    CHKERR bc_mng->pushMarkDOFsOnEntities(domainProblemName, "ROTATE",
                                          positionField, 0, 2);
 
    mBoundaryMarker =
        bc_mng->getMergedBlocksMarker(vector<string>{"FIX_", "ROTATE"});
 
    MoFEMFunctionReturnHot(0);
  };

◆ setupSolverFunction()

template<typename T >

MoFEMErrorCode BasicBoundaryConditionsInterface::setupSolverFunction ( const TSType type = IM )

inline

Definition at line 439 of file BasicBoundaryConditionsInterface.hpp.

                                                             {
    CHKERR setupSolverImpl<T, true>(type);
    MoFEMFunctionReturnHot(0);
  }

◆ setupSolverFunctionSNES()

MoFEMErrorCode BasicBoundaryConditionsInterface::setupSolverFunctionSNES ( )

inlineoverridevirtual

Reimplemented from GenericElementInterface.

Definition at line 577 of file BasicBoundaryConditionsInterface.hpp.

                                                    {
    MoFEMFunctionBegin;
    CHKERR this->setupSolverFunction<SNES>();
    MoFEMFunctionReturn(0);
  }

◆ setupSolverFunctionTS()

MoFEMErrorCode BasicBoundaryConditionsInterface::setupSolverFunctionTS ( const TSType type )

inlineoverridevirtual

Implements GenericElementInterface.

Definition at line 588 of file BasicBoundaryConditionsInterface.hpp.

                                                    {
    MoFEMFunctionBegin;
    CHKERR this->setupSolverFunction<TS>(type);
    MoFEMFunctionReturn(0);
  }

◆ setupSolverImpl()

template<typename T , bool RHS>

MoFEMErrorCode BasicBoundaryConditionsInterface::setupSolverImpl ( const TSType type = IM )

inline

Definition at line 451 of file BasicBoundaryConditionsInterface.hpp.

                                                         {
    MoFEMFunctionBeginHot;
    // auto dm = dM;
    // boost::shared_ptr<FEMethod> null;
    
    auto set_solver_pipelines =
        [&](PetscErrorCode (*function)(DM, const char fe_name[], MoFEM::FEMethod *,
                                       MoFEM::BasicMethod *,
                                       MoFEM::BasicMethod *),
            PetscErrorCode (*jacobian)(DM, const char fe_name[], MoFEM::FEMethod *,
                                       MoFEM::BasicMethod *,
                                       MoFEM::BasicMethod *)) {
 
          MoFEMFunctionBeginHot;
          if (RHS) {
            if (std::is_same_v<T, TS>)
              dirichletBcPtr->methodsOp.push_back(
                  new TimeForceScale(getHistoryParam("dirichlet"), false));
            
            CHKERR DMoFEMPreProcessFiniteElements(dM, dirichletBcPtr.get());
 
            // auto push_fmethods = [&](auto method, string element_name) {
            //   CHKERR function(dm, element_name.c_str(), method, method, method);
            // };
 
            auto set_neumann_methods = [&](auto &neumann_el, string hist_name,
                                           int dim) {
              MoFEMFunctionBeginHot;
              for (auto &&mit : neumann_el) {
                if constexpr (std::is_same_v<T, SNES>)
                  mit->second->methodsOp.push_back(
                      new LoadScale(snesLambdaLoadFactorPtr));
                if constexpr (std::is_same_v<T, TS>)
                  mit->second->methodsOp.push_back(
                      new TimeForceScale(getHistoryParam(hist_name), false));
                string element_name = mit->first;
                switch (dim) {
                case 2:
                  CHKERR AddHOOps<2, 3, 3>::add(
                      mit->second->getLoopFe().getOpPtrVector(), {},
                      meshNodeField);
                  break;
                case 1:
                  CHKERR AddHOOps<1, 2, 2>::add(
                      mit->second->getLoopFe().getOpPtrVector(), {},
                      meshNodeField);
                  break;
                case 0:
                  break;
                default:
                  break;
                }
                // CHKERR push_fmethods(&mit->second->getLoopFe(),
                // element_name);
                CHKERR function(dM, element_name.c_str(),
                                &mit->second->getLoopFe(), NULL, NULL);
              }
              MoFEMFunctionReturnHot(0);
            };
 
            CHKERR set_neumann_methods(neumann_forces, "force", 2);
            CHKERR set_neumann_methods(nodal_forces, "force", 0);
            CHKERR set_neumann_methods(edge_forces, "force", 1);
 
            CHKERR function(dM, domainElementName.c_str(), dirichletBcPtr.get(),
                            dirichletBcPtr.get(), dirichletBcPtr.get());
            CHKERR function(dM, domainElementName.c_str(),
                            bodyForceRhsPtr.get(), NULL, NULL);
            CHKERR function(dM, "SPRING", springRhsPtr.get(), NULL, NULL);
            CHKERR function(dM, "DAMPER_FE", &damperElementPtr->feRhs, NULL,
                            NULL);
            CHKERR function(dM, "FLUID_PRESSURE_FE",
                            &fluidPressureElementPtr->getLoopFe(), NULL, NULL);
          } else {
 
            CHKERR jacobian(dM, domainElementName.c_str(), dirichletBcPtr.get(),
                            dirichletBcPtr.get(), dirichletBcPtr.get());
            CHKERR jacobian(dM, domainElementName.c_str(),
                            bodyForceLhsPtr.get(), NULL, NULL);
            CHKERR jacobian(dM, "SPRING", springLhsPtr.get(), NULL, NULL);
 
            CHKERR jacobian(dM, "DAMPER_FE", &damperElementPtr->feLhs, NULL,
                            NULL);
          }
 
          MoFEMFunctionReturnHot(0);
        };
 
    if constexpr (std::is_same_v<T, SNES>) {
 
      if (!snesLambdaLoadFactorPtr)
        SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
                "SNES lambda factor pointer not set in the module constructor");
 
        CHKERR set_solver_pipelines(&DMMoFEMSNESSetFunction,
                                    &DMMoFEMSNESSetJacobian);
 
    } else if constexpr (std::is_same_v<T, TS>) {
 
      switch (type) {
      case IM:
        CHKERR set_solver_pipelines(&DMMoFEMTSSetIFunction,
                                    &DMMoFEMTSSetIJacobian);
        break;
      case IM2:
        CHKERR set_solver_pipelines(&DMMoFEMTSSetI2Function,
                                    &DMMoFEMTSSetI2Jacobian);
        break;
      case EX:
        CHKERR set_solver_pipelines(&DMMoFEMTSSetRHSFunction,
                                    &DMMoFEMTSSetRHSJacobian);
        break;
      default:
        SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
                "This TS is not yet implemented for basic BCs");
        break;
      }
 
    } else
      static_assert(!std::is_same_v<T, KSP>,
                    "this solver has not been implemented for basic BCs yet");
 
 
    MoFEMFunctionReturnHot(0);
  }

◆ setupSolverJacobian()

template<typename T >

MoFEMErrorCode BasicBoundaryConditionsInterface::setupSolverJacobian ( const TSType type = IM )

inline

Definition at line 445 of file BasicBoundaryConditionsInterface.hpp.

                                                             {
    CHKERR setupSolverImpl<T, false>(type);
    MoFEMFunctionReturnHot(0);
  }

◆ setupSolverJacobianSNES()

MoFEMErrorCode BasicBoundaryConditionsInterface::setupSolverJacobianSNES ( )

inlineoverridevirtual

Reimplemented from GenericElementInterface.

Definition at line 582 of file BasicBoundaryConditionsInterface.hpp.

                                                    {
    MoFEMFunctionBegin;
    CHKERR this->setupSolverJacobian<SNES>();
    MoFEMFunctionReturn(0);
  }

◆ setupSolverJacobianTS()

MoFEMErrorCode BasicBoundaryConditionsInterface::setupSolverJacobianTS ( const TSType type )

inlineoverridevirtual

Implements GenericElementInterface.

Definition at line 594 of file BasicBoundaryConditionsInterface.hpp.

                                                    {
    MoFEMFunctionBegin;
    CHKERR this->setupSolverJacobian<TS>(type);
    MoFEMFunctionReturn(0);
  }