Simple interface

Implementation of simple interface for fast problem set-up. More...

Collaboration diagram for Simple interface:

Files
file	continuity_check_on_skeleton_with_simple_2d_for_h1.cpp
file	continuity_check_on_skeleton_with_simple_2d_for_hcurl.cpp
file	continuity_check_on_skeleton_with_simple_2d_for_hdiv.cpp
file	simple_interface.cpp
file	simple_l2_only.cpp
file	Simple.cpp
	Implementation of simple interface.
file	Simple.hpp
	Header file for simple interface.
file	analytical_nonlinear_poisson.cpp
file	analytical_poisson.cpp
file	analytical_poisson_field_split.cpp
file	hello_world.cpp

Classes
struct	MoFEM::BcManager
	Boundary condition manager for finite element problem setup. More...
struct	MoFEM::BcManager::BCs
	Data structure storing boundary condition markers and attributes. More...
struct	MoFEM::Simple
	Simple interface for fast problem set-up. More...

Functions
MoFEMErrorCode	MoFEM::BcManager::getOptions ()
	Get command line options for BcManager.
MoFEMErrorCode	MoFEM::BcManager::pushMarkSideDofs (const std::string problem_name, const std::string block_name, const std::string field_name, int bridge_dim, int lo, int hi)
	Mark DOFs on side entities for boundary conditions.
MoFEMErrorCode	MoFEM::BcManager::removeSideDOFs (const std::string problem_name, const std::string block_name, const std::string field_name, int bridge_dim, int lo, int hi, bool is_distributed_mesh=true)
	Remove DOFs on side entities from problem.
MoFEMErrorCode	MoFEM::BcManager::removeBlockDOFsOnEntities (const std::string problem_name, const std::string block_name, const std::string field_name, int lo, int hi, bool get_low_dim_ents=true, bool is_distributed_mesh=true)
	Remove DOFs from problem based on block entities.
MoFEMErrorCode	MoFEM::BcManager::pushMarkDOFsOnEntities (const std::string problem_name, const std::string block_name, const std::string field_name, int lo, int hi, bool get_low_dim_ents=true)
	Mark DOFs on block entities for boundary conditions.
template<typename T >
MoFEMErrorCode	MoFEM::BcManager::removeBlockDOFsOnEntities (const std::string problem_name, const std::string field_name, bool get_low_dim_ents=true, bool block_name_field_prefix=false, bool is_distributed_mesh=true)
	Remove DOFs based on boundary condition type template.
template<typename T >
MoFEMErrorCode	MoFEM::BcManager::pushMarkDOFsOnEntities (const std::string problem_name, const std::string field_name, bool get_low_dim_ents=true, bool block_name_field_prefix=false)
	Mark DOFs based on boundary condition type template.
template<typename T >
MoFEMErrorCode	MoFEM::BcManager::removeBlockDOFsOnEntities (const std::string problem_name, const std::string block_name, const std::string field_name, bool get_low_dim_ents=true, bool is_distributed_mesh=true)
	Remove DOFs with explicit block specification.
template<typename T >
MoFEMErrorCode	MoFEM::BcManager::pushMarkDOFsOnEntities (const std::string problem_name, const std::string block_name, const std::string field_name, bool get_low_dim_ents=true)
	Mark DOFs with explicit block specification.
boost::shared_ptr< BCs >	MoFEM::BcManager::popMarkDOFsOnEntities (const std::string block_name)
	Retrieve and remove boundary condition data.
auto	MoFEM::BcManager::getBcStructure (const std::string bc_id)
	Get boundary condition structure by identifier.
BcMapByBlockName &	MoFEM::BcManager::getBcMapByBlockName ()
	Get the boundary condition map.
Range	MoFEM::BcManager::getMergedBlocksRange (std::vector< std::regex > bc_regex_vec)
	Merge entity ranges from multiple boundary condition blocks.
auto	MoFEM::BcManager::getMergedBlocksRange (std::vector< string > bc_names)
	Merge entity ranges by boundary condition names.
BcMarkerPtr	MoFEM::BcManager::getMergedBlocksMarker (std::vector< std::regex > bc_regex_vec)
	Merge DOF markers from multiple boundary condition blocks.
auto	MoFEM::BcManager::getMergedBlocksMarker (std::vector< string > bc_names)
	Merge DOF markers by boundary condition names.
BcMarkerPtr	MoFEM::BcManager::getMergedBlocksMarker (const std::vector< BcMarkerPtr > &boundary_markers_ptr_vec)
	Merge pre-existing marker vectors.
auto	MoFEM::BcManager::checkBlock (const std::pair< string, boost::shared_ptr< BCs > > &bc, std::regex reg)
	Check if boundary condition matches regular expression.
auto	MoFEM::BcManager::checkBlock (const std::pair< std::string, boost::shared_ptr< BCs > > &bc, std::string name)
	Check if boundary condition matches name pattern.
SmartPetscObj< IS >	MoFEM::BcManager::getBlockIS (const std::string block_prefix, const std::string block_name, const std::string field_name, const std::string problem_name, int lo, int hi, SmartPetscObj< IS > is_expand=SmartPetscObj< IS >())
	Create PETSc Index Set for boundary condition block.
SmartPetscObj< IS >	MoFEM::BcManager::getBlockIS (const std::string problem_name, const std::string block_name, const std::string field_name, int lo, int hi, SmartPetscObj< IS > is_expand=SmartPetscObj< IS >())
	Create PETSc Index Set for boundary condition block (simplified)

Detailed Description

Implementation of simple interface for fast problem set-up.

Function Documentation

checkBlock() [1/2]

auto MoFEM::BcManager::checkBlock ( const std::pair< std::string, boost::shared_ptr< BCs > > &  bc, std::string  name  )

inline

#include <src/interfaces/BcManager.hpp>

Check if boundary condition matches name pattern.

Tests whether a boundary condition block name contains the specified substring pattern. Automatically constructs a flexible regular expression for convenient name-based filtering.

Parameters

bc	map element containing block name and boundary condition data
name	substring pattern to search for in the block name

Returns

bool true if the block name contains the pattern

Definition at line 813 of file BcManager.hpp.

                             {
    auto full_name = std::string("(.*)_") + name + std::string("(.*)");
    return checkBlock(bc, std::regex(full_name));
  }

checkBlock() [2/2]

auto MoFEM::BcManager::checkBlock ( const std::pair< string, boost::shared_ptr< BCs > > &  bc, std::regex  reg  )

inline

#include <src/interfaces/BcManager.hpp>

Check if boundary condition matches regular expression.

Tests whether a boundary condition block name matches the provided regular expression pattern. This is used internally for filtering and selecting boundary condition blocks based on naming patterns.

Parameters

bc	map element containing block name and boundary condition data
reg	regular expression pattern for matching

Returns

bool true if the block name matches the pattern

Definition at line 795 of file BcManager.hpp.

                                       {
    return std::regex_match(bc.first, reg);
  }

getBcMapByBlockName()

BcMapByBlockName & MoFEM::BcManager::getBcMapByBlockName ( )

inline

#include <src/interfaces/BcManager.hpp>

Get the boundary condition map.

Provides access to the complete map of boundary condition blocks managed by this BcManager instance. Useful for iteration and bulk operations on multiple boundary conditions.

Returns

BcMapByBlockName& Reference to the boundary condition map

Examples

mofem/tutorials/scl-10/initial_diffusion.cpp, and mofem/tutorials/scl-10/photon_diffusion.cpp.

Definition at line 700 of file BcManager.hpp.

{ return bcMapByBlockName; }

getBcStructure()

auto MoFEM::BcManager::getBcStructure ( const std::string  bc_id )

inline

#include <src/interfaces/BcManager.hpp>

Get boundary condition structure by identifier.

Retrieves the boundary condition data structure for a specific block identifier. Provides direct access to the internal boundary condition management system for advanced operations.

Parameters

bc_id

identifier of the boundary condition block

Returns

auto Reference to the boundary condition structure

Definition at line 686 of file BcManager.hpp.

                                                    {
    return bcMapByBlockName.at(bc_id);
  }

getBlockIS() [1/2]

SmartPetscObj< IS > MoFEM::BcManager::getBlockIS	(	const std::string	block_prefix,
		const std::string	block_name,
		const std::string	field_name,
		const std::string	problem_name,
		int	lo,
		int	hi,
		SmartPetscObj< IS >	is_expand = SmartPetscObj<IS>()
	)

#include <src/interfaces/BcManager.hpp>

Create PETSc Index Set for boundary condition block.

Generates a PETSc Index Set (IS) containing DOF indices for a specified boundary condition block. The IS can be used for matrix/vector operations, subproblem creation, and solver configuration in PETSc-based computations.

Parameters

block_prefix	prefix for block name construction
block_name	name of the boundary condition block
field_name	name of the field containing the DOFs
problem_name	name of the finite element problem
lo	lowest coefficient (rank) to include
hi	highest coefficient (rank) to include
is_expand	optional existing IS to expand with new indices

Returns

SmartPetscObj<IS> Smart pointer to PETSc Index Set

Examples

mofem/tutorials/scl-6/heat_equation.cpp, and mofem/tutorials/scl-7/wave_equation.cpp.

Definition at line 241 of file BcManager.cpp.

                                                                             {
  Interface &m_field = cOre;
 
  const std::string bc_id =
      block_prefix + "_" + field_name + "_" + block_name + "(.*)";
 
  Range bc_ents;
  for (auto bc : getBcMapByBlockName()) {
    if (std::regex_match(bc.first, std::regex(bc_id))) {
      bc_ents.merge(*(bc.second->getBcEntsPtr()));
      MOFEM_LOG("BcMngWorld", Sev::verbose)
          << "Get entities from block and add to IS. Block name " << bc.first;
    }
  }
 
  SmartPetscObj<IS> is_bc;
  auto get_is = [&]() {
    MoFEMFunctionBegin;
    CHKERR m_field.getInterface<CommInterface>()->synchroniseEntities(bc_ents);
    CHKERR m_field.getInterface<ISManager>()->isCreateProblemFieldAndRank(
        problem_name, ROW, field_name, lo, hi, is_bc, &bc_ents);
    if (is_expand) {
      IS is_tmp;
      CHKERR ISExpand(is_bc, is_expand, &is_tmp);
      is_bc = SmartPetscObj<IS>(is_tmp);
    }
    CHKERR ISSort(is_bc);
    MoFEMFunctionReturn(0);
  };
 
  if (get_is())
    CHK_THROW_MESSAGE(MOFEM_DATA_INCONSISTENCY, "IS is not created");
 
  return is_bc;
}

getBlockIS() [2/2]

SmartPetscObj< IS > MoFEM::BcManager::getBlockIS	(	const std::string	problem_name,
		const std::string	block_name,
		const std::string	field_name,
		int	lo,
		int	hi,
		SmartPetscObj< IS >	is_expand = SmartPetscObj<IS>()
	)

#include <src/interfaces/BcManager.hpp>

Create PETSc Index Set for boundary condition block (simplified)

Simplified version that generates a PETSc Index Set for a boundary condition block without requiring a separate block prefix. This is the most commonly used interface for creating IS objects for boundary condition processing.

Parameters

problem_name	name of the finite element problem
block_name	name of the boundary condition block
field_name	name of the field containing the DOFs
lo	lowest coefficient (rank) to include
hi	highest coefficient (rank) to include
is_expand	optional existing IS to expand with new indices

Returns

SmartPetscObj<IS> Smart pointer to PETSc Index Set

Definition at line 281 of file BcManager.cpp.

                                                                             {
  return getBlockIS(problem_name, block_name, field_name, problem_name, lo, hi,
                    is_expand);
}

getMergedBlocksMarker() [1/3]

BcMarkerPtr MoFEM::BcManager::getMergedBlocksMarker

(

const std::vector< BcMarkerPtr > &

boundary_markers_ptr_vec

)

#include <src/interfaces/BcManager.hpp>

Merge pre-existing marker vectors.

Combines multiple existing DOF marker vectors into a single unified marker vector. This allows for flexible composition of boundary condition constraints from different sources or processing stages.

Parameters

boundary_markers_ptr_vec

vector of marker pointers to merge

Returns

BcMarkerPtr Shared pointer to merged marker vector

getMergedBlocksMarker() [2/3]

BcManager::BcMarkerPtr MoFEM::BcManager::getMergedBlocksMarker

(

std::vector< std::regex >

bc_regex_vec

)

#include <src/interfaces/BcManager.hpp>

Merge DOF markers from multiple boundary condition blocks.

Combines DOF marker vectors from multiple boundary condition blocks that match the provided regular expression patterns. The resulting marker vector represents the union of all DOF constraints from the matching blocks.

Parameters

bc_regex_vec

vector of regular expressions for block name matching

Returns

BcMarkerPtr Shared pointer to merged marker vector

Definition at line 210 of file BcManager.cpp.

                                                                 {
  BcManager::BcMarkerPtr boundary_marker_ptr;
  if (bcMapByBlockName.size()) {
    for (auto b : bcMapByBlockName) {
      for (auto &reg_name : bc_regex_vec) {
        if (std::regex_match(b.first, reg_name)) {
          if (!boundary_marker_ptr)
            boundary_marker_ptr =
                boost::make_shared<std::vector<char unsigned>>();
          boundary_marker_ptr->resize(b.second->bcMarkers.size(), 0);
          for (int i = 0; i != b.second->bcMarkers.size(); ++i) {
            (*boundary_marker_ptr)[i] |= b.second->bcMarkers[i];
          }
        }
      }
    }
  }
  return boundary_marker_ptr;
}

getMergedBlocksMarker() [3/3]

auto MoFEM::BcManager::getMergedBlocksMarker ( std::vector< string >  bc_names )

inline

#include <src/interfaces/BcManager.hpp>

Merge DOF markers by boundary condition names.

Convenience function that merges DOF marker vectors from boundary condition blocks with names containing the specified substrings. Useful for combining markers from related boundary conditions into a single constraint system.

Parameters

bc_names

vector of boundary condition name patterns to match

Returns

BcMarkerPtr Shared pointer to merged marker vector

Definition at line 760 of file BcManager.hpp.

                                                                {
    std::vector<std::regex> reg_vec(bc_names.size());
    for (int i = 0; i != bc_names.size(); ++i) {
      auto full_name = std::string("(.*)_") + bc_names[i] + std::string("(.*)");
      reg_vec[i] = std::regex(full_name);
    }
    return getMergedBlocksMarker(reg_vec);
  }

getMergedBlocksRange() [1/2]

Range MoFEM::BcManager::getMergedBlocksRange

(

std::vector< std::regex >

bc_regex_vec

)

#include <src/interfaces/BcManager.hpp>

Merge entity ranges from multiple boundary condition blocks.

Combines entity ranges from multiple boundary condition blocks that match the provided regular expression patterns. This is useful for creating composite boundary conditions or applying operations to multiple related boundary condition blocks simultaneously.

Parameters

bc_regex_vec

vector of regular expressions for block name matching

Returns

Range Merged range containing entities from all matching blocks

Definition at line 195 of file BcManager.cpp.

                                                                      {
  Range ents;
  if (bcMapByBlockName.size()) {
    for (auto b : bcMapByBlockName) {
      for (auto &reg_name : bc_regex_vec) {
        if (std::regex_match(b.first, reg_name)) {
          ents.merge(b.second->bcEnts);
        }
      }
    }
  }
  return ents;
}

getMergedBlocksRange() [2/2]

auto MoFEM::BcManager::getMergedBlocksRange ( std::vector< string >  bc_names )

inline

#include <src/interfaces/BcManager.hpp>

Merge entity ranges by boundary condition names.

Convenience function that merges entity ranges from boundary condition blocks with names containing the specified substrings. Automatically constructs regular expressions for flexible name matching.

Parameters

bc_names

vector of boundary condition name patterns to match

Returns

Range Merged range containing entities from all matching blocks

Definition at line 727 of file BcManager.hpp.

                                                               {
    std::vector<std::regex> reg_vec(bc_names.size());
    for (int i = 0; i != bc_names.size(); ++i) {
      auto full_name = std::string("(.*)_") + bc_names[i] + std::string("(.*)");
      reg_vec[i] = std::regex(full_name);
    }
    return getMergedBlocksRange(reg_vec);
  }

getOptions()

MoFEMErrorCode MoFEM::BcManager::getOptions

(

)

#include <src/interfaces/BcManager.hpp>

Get command line options for BcManager.

Retrieves configuration options from command line arguments that control boundary condition processing behavior and integration settings.

Returns

MoFEMErrorCode Error code indicating success or failure

Definition at line 65 of file BcManager.cpp.

                                     {
  MoFEMFunctionBeginHot;
  PetscOptionsBegin(PETSC_COMM_WORLD, "", "BcManager options", "none");
  PetscOptionsEnd();
  MoFEMFunctionReturnHot(0);
}

popMarkDOFsOnEntities()

boost::shared_ptr< BcManager::BCs > MoFEM::BcManager::popMarkDOFsOnEntities

(

const std::string

block_name

)

#include <src/interfaces/BcManager.hpp>

Retrieve and remove boundary condition data.

Retrieves the boundary condition data structure for a specified block and removes it from the internal management system. This is typically used when transferring boundary condition data to other processing stages or when cleaning up after boundary condition application.

Parameters

block_name

name of the boundary condition block to retrieve

Returns

boost::shared_ptr<BCs> Shared pointer to boundary condition data structure

Definition at line 185 of file BcManager.cpp.

                                                           {
  auto bc_it = bcMapByBlockName.find(block_name);
  if (bc_it != bcMapByBlockName.end()) {
    auto bc = bc_it->second;
    bcMapByBlockName.erase(bc_it);
    return bc;
  }
  return boost::shared_ptr<BCs>();
}

pushMarkDOFsOnEntities() [1/3]

template<typename T >

MoFEMErrorCode MoFEM::BcManager::pushMarkDOFsOnEntities	(	const std::string	problem_name,
		const std::string	block_name,
		const std::string	field_name,
		bool	get_low_dim_ents = true
	)

#include <src/interfaces/BcManager.hpp>

Mark DOFs with explicit block specification.

Template-based DOF marking with explicit block name specification. Creates internal data structures for the specified boundary condition block while maintaining type-safe boundary condition handling.

Template Parameters

T	boundary condition type template parameter

Parameters

problem_name	name of the finite element problem
block_name	specific name of the boundary condition block
field_name	name of the field containing the DOFs
get_low_dim_ents	include lower dimensional entities

Returns

MoFEMErrorCode Error code indicating success or failure

pushMarkDOFsOnEntities() [2/3]

MoFEMErrorCode MoFEM::BcManager::pushMarkDOFsOnEntities	(	const std::string	problem_name,
		const std::string	block_name,
		const std::string	field_name,
		int	lo,
		int	hi,
		bool	get_low_dim_ents = true
	)

#include <src/interfaces/BcManager.hpp>

Mark DOFs on block entities for boundary conditions.

Marks DOFs associated with entities in a specified block for boundary condition processing. This creates internal data structures needed for subsequent boundary condition application or DOF removal operations.

Parameters

problem_name	name of the finite element problem
block_name	name of the boundary condition block/meshset
field_name	name of the field containing the DOFs to mark
lo	lowest coefficient (rank) to mark
hi	highest coefficient (rank) to mark
get_low_dim_ents	include lower dimensional entities in the operation

Returns

MoFEMErrorCode Error code indicating success or failure

Examples

mofem/users_modules/eshelbian_plasticity/src/impl/EshelbianPlasticity.cpp.

Definition at line 110 of file BcManager.cpp.

                                                                        {
  Interface &m_field = cOre;
  auto prb_mng = m_field.getInterface<ProblemsManager>();
  MoFEMFunctionBegin;
 
  // if(problem_name.size())
  //   MOFEM_LOG("BcMngWorld", Sev::warning)
  //       << "Argument problem_name has no effect";
 
  auto fix_disp = [&]() {
    MoFEMFunctionBegin;
 
    auto mark_fix_dofs = [&](std::vector<unsigned char> &marked_field_dofs,
                             const auto lo, const auto hi) {
      return prb_mng->modifyMarkDofs(problem_name, ROW, field_name, lo, hi,
                                     ProblemsManager::MarkOP::OR, 1,
                                     marked_field_dofs);
    };
 
    auto iterate_meshsets = [&](auto &&meshset_vec_ptr) {
      MoFEMFunctionBegin;
      for (auto m : meshset_vec_ptr) {
        auto bc = boost::make_shared<BCs>();
        CHKERR m_field.get_moab().get_entities_by_handle(m->getMeshset(),
                                                         bc->bcEnts, true);
        CHKERR m->getAttributes(bc->bcAttributes);
 
        if (problem_name.size())
          CHKERR mark_fix_dofs(bc->bcMarkers, lo, hi);
        MOFEM_LOG("BcMngWorld", Sev::verbose)
            << "Found block " << m->getName() << " number of attributes "
            << bc->bcAttributes.size();
 
        if (get_low_dim_ents) {
          auto low_dim_ents =
              BcManagerImplTools::get_adj_ents(m_field.get_moab(), bc->bcEnts);
          bc->bcEnts.swap(low_dim_ents);
        }
 
        CHKERR m_field.getInterface<CommInterface>()->synchroniseEntities(
            bc->bcEnts);
        if (problem_name.size())
          CHKERR prb_mng->markDofs(problem_name, ROW, ProblemsManager::AND,
                                   bc->bcEnts, bc->bcMarkers);
 
        const std::string bc_id =
            problem_name + "_" + field_name + "_" + m->getName();
        bcMapByBlockName[bc_id] = bc;
      }
      MoFEMFunctionReturn(0);
    };
 
    CHKERR iterate_meshsets(
 
        m_field.getInterface<MeshsetsManager>()->getCubitMeshsetPtr(std::regex(
 
            (boost::format("%s(.*)") % block_name).str()
 
                ))
 
    );
 
    MoFEMFunctionReturn(0);
  };
 
  CHKERR fix_disp();
 
  MoFEMFunctionReturn(0);
}

pushMarkDOFsOnEntities() [3/3]

template<typename T >

MoFEMErrorCode MoFEM::BcManager::pushMarkDOFsOnEntities	(	const std::string	problem_name,
		const std::string	field_name,
		bool	get_low_dim_ents = true,
		bool	block_name_field_prefix = false
	)

#include <src/interfaces/BcManager.hpp>

Mark DOFs based on boundary condition type template.

Template-based DOF marking that automatically determines the appropriate meshset type and boundary condition handling. Creates internal data structures for subsequent boundary condition processing operations.

Template Parameters

T	boundary condition type template parameter

Parameters

problem_name	name of the finite element problem
field_name	name of the field containing the DOFs
get_low_dim_ents	include lower dimensional entities
block_name_field_prefix	use field name as block name prefix

Returns

MoFEMErrorCode Error code indicating success or failure

pushMarkSideDofs()

MoFEMErrorCode MoFEM::BcManager::pushMarkSideDofs	(	const std::string	problem_name,
		const std::string	block_name,
		const std::string	field_name,
		int	bridge_dim,
		int	lo,
		int	hi
	)

#include <src/interfaces/BcManager.hpp>

Mark DOFs on side entities for boundary conditions.

Marks DOFs associated with side entities (faces, edges) of a specified block for boundary condition application. This is commonly used for surface-based boundary conditions like pressure, traction, or flux conditions.

Parameters

problem_name	name of the finite element problem
block_name	name of the boundary condition block/meshset
field_name	name of the field containing the DOFs
bridge_dim	dimension of bridge entities connecting DOFs to sides
lo	lowest coefficient (rank) to mark
hi	highest coefficient (rank) to mark

Returns

MoFEMErrorCode Error code indicating success or failure

Definition at line 1630 of file BcManager.cpp.

  {
  Interface &m_field = cOre;
  MoFEMFunctionBegin;
 
  if (problem_name.empty())
    MoFEMFunctionReturnHot(0);
 
  auto iterate_meshsets = [&](auto &&meshset_vec_ptr) {
    auto prb_mng = m_field.getInterface<ProblemsManager>();
    MoFEMFunctionBegin;
    for (auto m : meshset_vec_ptr) {
      auto bc = boost::make_shared<BCs>();
      CHKERR m_field.get_moab().get_entities_by_handle(m->getMeshset(),
                                                       bc->bcEnts, true);
      CHKERR m->getAttributes(bc->bcAttributes);
 
      bc->dofsViewPtr = boost::make_shared<BCs::DofsView>();
 
      CHKERR m_field.getInterface<CommInterface>()->synchroniseEntities(
          bc->bcEnts);
      CHKERR prb_mng->getSideDofsOnBrokenSpaceEntities(
          *(bc->dofsViewPtr), problem_name, ROW, field_name, bc->bcEnts,
          bridge_dim, lo, hi);
      CHKERR prb_mng->markDofs(problem_name, ROW, *(bc->dofsViewPtr),
                               ProblemsManager::OR, bc->bcMarkers);
 
      MOFEM_LOG("BcMngWorld", Sev::inform)
          << "Found block " << m->getName() << " number of attributes "
          << bc->bcAttributes.size() << " number of entities "
          << bc->bcEnts.size();
 
      const std::string bc_id =
          problem_name + "_" + field_name + "_" + m->getName();
      bcMapByBlockName[bc_id] = bc;
    }
    MoFEMFunctionReturn(0);
  };
 
  CHKERR iterate_meshsets(
 
      m_field.getInterface<MeshsetsManager>()->getCubitMeshsetPtr(std::regex(
 
          (boost::format("%s(.*)") % block_name).str()
 
              ))
 
  );
 
  MoFEMFunctionReturn(0);
}

removeBlockDOFsOnEntities() [1/3]

template<typename T >

MoFEMErrorCode MoFEM::BcManager::removeBlockDOFsOnEntities	(	const std::string	problem_name,
		const std::string	block_name,
		const std::string	field_name,
		bool	get_low_dim_ents = true,
		bool	is_distributed_mesh = true
	)

#include <src/interfaces/BcManager.hpp>

Remove DOFs with explicit block specification.

Template-based DOF removal with explicit block name specification. Provides fine-grained control over which specific block is processed while maintaining type-safe boundary condition handling.

Template Parameters

T	boundary condition type template parameter

Parameters

problem_name	name of the finite element problem
block_name	specific name of the boundary condition block
field_name	name of the field containing the DOFs
get_low_dim_ents	include lower dimensional entities
is_distributed_mesh	true if mesh is distributed across processes

Returns

MoFEMErrorCode Error code indicating success or failure

removeBlockDOFsOnEntities() [2/3]

MoFEMErrorCode MoFEM::BcManager::removeBlockDOFsOnEntities	(	const std::string	problem_name,
		const std::string	block_name,
		const std::string	field_name,
		int	lo,
		int	hi,
		bool	get_low_dim_ents = true,
		bool	is_distributed_mesh = true
	)

#include <src/interfaces/BcManager.hpp>

Remove DOFs from problem based on block entities.

Removes DOFs associated with entities in a specified block from the finite element problem. This is the primary method for enforcing Dirichlet boundary conditions by eliminating constrained DOFs from the system.

Parameters

problem_name	name of the finite element problem
block_name	name of the boundary condition block/meshset
field_name	name of the field containing the DOFs to remove
lo	lowest coefficient (rank) to remove
hi	highest coefficient (rank) to remove
get_low_dim_ents	include lower dimensional entities in the operation
is_distributed_mesh	true if mesh is distributed across processes

Returns

MoFEMErrorCode Error code indicating success or failure

Examples

mofem/atom_tests/schur_test_diag_mat.cpp, mofem/atom_tests/tensor_divergence_operator.cpp, and mofem/tutorials/scl-1/poisson_2d_homogeneous.cpp.

Definition at line 72 of file BcManager.cpp.

                              {
  Interface &m_field = cOre;
  auto prb_mng = m_field.getInterface<ProblemsManager>();
  MoFEMFunctionBegin;
 
  CHKERR pushMarkDOFsOnEntities(problem_name, block_name, field_name, lo, hi,
                                get_low_dim_ents);
 
  auto remove_dofs_on_ents = [&](const Range &ents, const int lo,
                                 const int hi) {
    if (is_distributed_mesh)
      return prb_mng->removeDofsOnEntities(problem_name, field_name, ents, lo,
                                           hi);
    else
      return prb_mng->removeDofsOnEntitiesNotDistributed(
          problem_name, field_name, ents, lo, hi);
  };
 
  for (auto m :
       m_field.getInterface<MeshsetsManager>()->getCubitMeshsetPtr(std::regex(
 
           (boost::format("%s(.*)") % block_name).str()
 
               ))
 
  ) {
    const std::string bc_id =
        problem_name + "_" + field_name + "_" + m->getName();
    CHKERR remove_dofs_on_ents(bcMapByBlockName.at(bc_id)->bcEnts, lo, hi);
    bcMapByBlockName.at(bc_id)->bcMarkers = std::vector<unsigned char>();
  }
 
  MoFEMFunctionReturn(0);
}

removeBlockDOFsOnEntities() [3/3]

template<typename T >

MoFEMErrorCode MoFEM::BcManager::removeBlockDOFsOnEntities	(	const std::string	problem_name,
		const std::string	field_name,
		bool	get_low_dim_ents = true,
		bool	block_name_field_prefix = false,
		bool	is_distributed_mesh = true
	)

#include <src/interfaces/BcManager.hpp>

Remove DOFs based on boundary condition type template.

Template-based DOF removal that automatically determines the appropriate meshset type and boundary condition handling based on the template parameter. Supports various boundary condition types including displacement, temperature, heat flux, force, and pressure conditions.

Template Parameters

T	boundary condition type template parameter

Parameters

problem_name	name of the finite element problem
field_name	name of the field containing the DOFs
get_low_dim_ents	include lower dimensional entities
block_name_field_prefix	use field name as block name prefix
is_distributed_mesh	true if mesh is distributed across processes

Returns

MoFEMErrorCode Error code indicating success or failure

removeSideDOFs()

MoFEMErrorCode MoFEM::BcManager::removeSideDOFs	(	const std::string	problem_name,
		const std::string	block_name,
		const std::string	field_name,
		int	bridge_dim,
		int	lo,
		int	hi,
		bool	is_distributed_mesh = true
	)

#include <src/interfaces/BcManager.hpp>

Remove DOFs on side entities from problem.

Removes DOFs associated with side entities from the finite element problem. This is typically used to enforce boundary conditions by eliminating constrained DOFs from the solution system.

Parameters

problem_name	name of the finite element problem
block_name	name of the boundary condition block/meshset
field_name	name of the field containing the DOFs
bridge_dim	dimension of bridge entities connecting DOFs to sides
lo	lowest coefficient (rank) to remove
hi	highest coefficient (rank) to remove
is_distributed_mesh	true if mesh is distributed across processes

Returns

MoFEMErrorCode Error code indicating success or failure

Examples

mofem/atom_tests/test_broken_space.cpp, and mofem/tutorials/fun-2/plot_base.cpp.

Definition at line 1686 of file BcManager.cpp.

                                                                   {
  Interface &m_field = cOre;
  MoFEMFunctionBegin;
 
  CHKERR pushMarkSideDofs(problem_name, block_name, field_name, bridge_dim, lo,
                          hi);
 
  auto iterate_meshsets = [&](auto &&meshset_vec_ptr) {
    MoFEMFunctionBegin;
    auto prb_mng = m_field.getInterface<ProblemsManager>();
    for (auto m : meshset_vec_ptr) {
      const std::string bc_id =
          problem_name + "_" + field_name + "_" + m->getName();
      auto &bc = bcMapByBlockName.at(bc_id);
      CHKERR prb_mng->removeDofs(problem_name, ROW, *(bc->dofsViewPtr), lo, hi);
      CHKERR prb_mng->removeDofs(problem_name, COL, *(bc->dofsViewPtr), lo, hi);
    }
    MoFEMFunctionReturn(0);
  };
 
  if (is_distributed_mesh) {
 
    CHKERR iterate_meshsets(
 
        m_field.getInterface<MeshsetsManager>()->getCubitMeshsetPtr(std::regex(
 
            (boost::format("%s(.*)") % block_name).str()
 
                ))
 
    );
  } else {
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "Not implemented");
  }
 
  MoFEMFunctionReturn(0);
}