BitRefManager

Managing BitRefLevels. More...

Collaboration diagram for BitRefManager:

Files
file	BitRefManager.hpp
	Interface managing BitRefLevels.

Classes
struct	MoFEM::BitRefManager
	Managing BitRefLevels. More...
struct	MoFEM::CommInterface
	Managing BitRefLevels. More...

Setting and shifting bits
MoFEMErrorCode	MoFEM::BitRefManager::setBitRefLevel (const Range &ents, const BitRefLevel bit, const bool only_tets=true, int verb=0, Range *adj_ents_ptr=nullptr) const
	add entities to database and set bit ref level
MoFEMErrorCode	MoFEM::BitRefManager::setElementsBitRefLevel (const Range &ents, const BitRefLevel bit=BitRefLevel(), int verb=QUIET) const
	add entities to database and set bit ref level
MoFEMErrorCode	MoFEM::BitRefManager::setEntitiesBitRefLevel (const Range &ents, const BitRefLevel bit=BitRefLevel(), int verb=QUIET) const
	add entities to database and set bit ref level
MoFEMErrorCode	MoFEM::BitRefManager::setBitLevelToMeshset (const EntityHandle meshset, const BitRefLevel bit, int verb=0) const
MoFEMErrorCode	MoFEM::BitRefManager::addBitRefLevel (const Range &ents, const BitRefLevel &bit, int verb=QUIET) const
	add bit ref level to ref entity
MoFEMErrorCode	MoFEM::BitRefManager::setNthBitRefLevel (const int n, const bool b, int verb=QUIET) const
	Set nth bit ref level to all entities in database.
MoFEMErrorCode	MoFEM::BitRefManager::shiftLeftBitRef (const int shift, const BitRefLevel mask=BitRefLevel().set(), int verb=DEFAULT_VERBOSITY) const
	left shift bit ref levelthis results of deletion of entities on far left side
MoFEMErrorCode	MoFEM::BitRefManager::shiftRightBitRef (const int shift, const BitRefLevel mask=BitRefLevel().set(), int verb=DEFAULT_VERBOSITY, MoFEMTypes mf=MF_ZERO) const
	right shift bit ref level
MoFEMErrorCode	MoFEM::BitRefManager::setFieldEntitiesBitRefLevel (const std::string field_name, const BitRefLevel bit=BitRefLevel(), int verb=QUIET) const
	Set the bit ref level to entities in the field meshset.
MoFEMErrorCode	MoFEM::BitRefManager::setBitRefLevelByDim (const EntityHandle meshset, const int dim, const BitRefLevel bit, int verb=QUIET) const
	Set the Bit Ref Level By Dim object.
MoFEMErrorCode	MoFEM::BitRefManager::setBitRefLevelByType (const EntityHandle meshset, const EntityType type, const BitRefLevel bit, int verb=QUIET) const
	Set the Bit Ref Level By Type object.
MoFEMErrorCode	MoFEM::BitRefManager::addToDatabaseBitRefLevelByType (const EntityType type, const BitRefLevel bit, const BitRefLevel mask=BitRefLevel().set(), int verb=QUIET) const
	Add entities which exist in MoAB database, and have set appropiate BitRef level tag, to multi-indices in MoFEM.
MoFEMErrorCode	MoFEM::BitRefManager::addToDatabaseBitRefLevelByDim (const int dim, const BitRefLevel bit, const BitRefLevel mask=BitRefLevel().set(), int verb=QUIET) const
	Add entities which exist in MoAB database, and have set appropiate BitRef level tag, to multi-indices in MoFEM.
MoFEMErrorCode	MoFEM::BitRefManager::lambdaBitRefLevel (boost::function< void(EntityHandle ent, BitRefLevel &bit)> fun) const
	Process bit ref level by lambda function.
MoFEMErrorCode	MoFEM::BitRefManager::lambdaBitRefLevel (const Range &ents, boost::function< void(EntityHandle ent, BitRefLevel &bit)> fun) const
	Process bit ref level by lambda function.
MoFEMErrorCode	MoFEM::BitRefManager::addBitRefLevelByDim (const EntityHandle meshset, const int dim, const BitRefLevel bit, int verb=QUIET) const
	add bit ref level by dimension
MoFEMErrorCode	MoFEM::BitRefManager::setNthBitRefLevel (const Range &ents, const int n, const bool b, int verb=QUIET) const
	Set nth bit ref level.

Entity handlers by bit ref level
MoFEMErrorCode	MoFEM::BitRefManager::getEntitiesByTypeAndRefLevel (const BitRefLevel bit, const BitRefLevel mask, const EntityType type, const EntityHandle meshset, int verb=0) const
	add all ents from ref level given by bit to meshset
MoFEMErrorCode	MoFEM::BitRefManager::getEntitiesByTypeAndRefLevel (const BitRefLevel bit, const BitRefLevel mask, const EntityType type, Range &ents, int verb=0) const
	add all ents from ref level given by bit to meshset
MoFEMErrorCode	MoFEM::BitRefManager::getEntitiesByDimAndRefLevel (const BitRefLevel bit, const BitRefLevel mask, const int dim, const EntityHandle meshset, int verb=0) const
	add all ents from ref level given by bit to meshset
MoFEMErrorCode	MoFEM::BitRefManager::getEntitiesByDimAndRefLevel (const BitRefLevel bit, const BitRefLevel mask, const int dim, Range &ents, int verb=0) const
	add all ents from ref level given by bit to meshset
MoFEMErrorCode	MoFEM::BitRefManager::getEntitiesByRefLevel (const BitRefLevel bit, const BitRefLevel mask, const EntityHandle meshset, const int verb=QUIET) const
	add all ents from ref level given by bit to meshset
MoFEMErrorCode	MoFEM::BitRefManager::getEntitiesByRefLevel (const BitRefLevel bit, const BitRefLevel mask, Range &ents, const int verb=QUIET) const
	add all ents from ref level given by bit to meshset

Get adjacencies bit ref level
virtual MoFEMErrorCode	MoFEM::BitRefManager::getAdjacenciesEquality (const EntityHandle from_entity, const int to_dimension, Range &adj_entities) const
	Get the adjacencies associated with a entity to entities of a specified dimension.
virtual MoFEMErrorCode	MoFEM::BitRefManager::getAdjacenciesAny (const EntityHandle from_entity, const int to_dimension, Range &adj_entities) const
	Get the adjacencies associated with a entity to entities of a specified dimension.
virtual MoFEMErrorCode	MoFEM::BitRefManager::getAdjacencies (const Problem *problem_ptr, const EntityHandle *from_entities, const int num_entities, const int to_dimension, Range &adj_entities, const int operation_type=moab::Interface::INTERSECT, const int verb=0) const
	Get the adjacencies associated with a entity to entities of a specified dimension.
virtual MoFEMErrorCode	MoFEM::BitRefManager::getAdjacencies (const BitRefLevel bit, const EntityHandle *from_entities, const int num_entities, const int to_dimension, Range &adj_entities, const int operation_type=moab::Interface::INTERSECT, const int verb=0) const
	Get the adjacencies associated with a entity to entities of a specified dimension.

Update meshsets and ranges by children
MoFEMErrorCode	MoFEM::BitRefManager::updateMeshsetByEntitiesChildren (const EntityHandle parent, const BitRefLevel &parent_bit, const BitRefLevel &parent_mask, const BitRefLevel &child_bit, const BitRefLevel &child_mask, const EntityHandle child, EntityType child_type, const bool recursive=false, int verb=0)
	Get child entities form meshset containing parent entities.
MoFEMErrorCode	MoFEM::BitRefManager::updateMeshsetByEntitiesChildren (const EntityHandle parent, const BitRefLevel &child_bit, const EntityHandle child, EntityType child_type, const bool recursive=false, int verb=0)
	Get child entities form meshset containing parent entities.
MoFEMErrorCode	MoFEM::BitRefManager::updateFieldMeshsetByEntitiesChildren (const BitRefLevel &child_bit, int verb=0)
	update fields meshesets by child entities
MoFEMErrorCode	MoFEM::BitRefManager::updateFieldMeshsetByEntitiesChildren (const std::string name, const BitRefLevel &child_bit, int verb=0)
	update field meshset by child entities
MoFEMErrorCode	MoFEM::BitRefManager::updateFiniteElementMeshsetByEntitiesChildren (const std::string name, const BitRefLevel &child_bit, const EntityType fe_ent_type, int verb=0)
	update finite element meshset by child entities
MoFEMErrorCode	MoFEM::BitRefManager::updateRangeByChildren (const Range &parent, Range &child, MoFEMTypes bh=MF_ZERO)
	Update range by childrens.
MoFEMErrorCode	MoFEM::BitRefManager::updateRangeByParent (const Range &child_ents, Range &parent_ents, MoFEMTypes bh=MF_ZERO)
	Update range by parents.
DEPRECATED MoFEMErrorCode	MoFEM::BitRefManager::updateRange (const Range &parent, Range &child, MoFEMTypes bh=MF_ZERO)

Detailed Description

Managing BitRefLevels.

Function Documentation

addBitRefLevel()

MoFEMErrorCode MoFEM::BitRefManager::addBitRefLevel	(	const Range &	ents,
		const BitRefLevel &	bit,
		int	verb = QUIET ) const

#include <src/interfaces/BitRefManager.hpp>

add bit ref level to ref entity

Parameters

ents	range of entities
bit	bit ref level
verb	verbosity level

Returns

error code

Examples

hanging_node_approx.cpp.

Definition at line 555 of file BitRefManager.cpp.

                                                             {
  return lambdaBitRefLevel(
      ents, [&](EntityHandle ent, BitRefLevel &ent_bit) { ent_bit |= bit; });
}

addBitRefLevelByDim()

MoFEMErrorCode MoFEM::BitRefManager::addBitRefLevelByDim	(	const EntityHandle	meshset,
		const int	dim,
		const BitRefLevel	bit,
		int	verb = QUIET ) const

#include <src/interfaces/BitRefManager.hpp>

add bit ref level by dimension

Parameters

meshset
dim	dimension of entities
bit	added bit
verb	verbosity level

Returns

MoFEMErrorCode

Definition at line 562 of file BitRefManager.cpp.

                                                                  {
  MoFEM::Interface &m_field = cOre;
  moab::Interface &moab = m_field.get_moab();
  Range ents, adj;
  MoFEMFunctionBegin;
  CHKERR moab.get_entities_by_dimension(meshset, dim, ents, true);
  for (int dd = dim - 1; dd >= 0; dd--)
    CHKERR moab.get_adjacencies(ents, dd, false, adj, moab::Interface::UNION);
  ents.merge(adj);
  if (verb == VERY_NOISY)
    MOFEM_LOG("BitRefSelf", Sev::noisy) << "Add add bit ref level by dim";
  CHKERR addBitRefLevel(ents, bit, verb);
  MoFEMFunctionReturn(0);
}

addToDatabaseBitRefLevelByDim()

MoFEMErrorCode MoFEM::BitRefManager::addToDatabaseBitRefLevelByDim	(	const int	dim,
		const BitRefLevel	bit,
		const BitRefLevel	mask = BitRefLevel().set(),
		int	verb = QUIET ) const

#include <src/interfaces/BitRefManager.hpp>

Add entities which exist in MoAB database, and have set appropiate BitRef level tag, to multi-indices in MoFEM.

Note

Every entity, used for create DoFS, or elements has to have set BitRefLevel and be added to MoFEM database.

This functions add lower dimension entities by calling setEntitiesBitRefLevel

Parameters

dim	dimension of entity
bit	bit ref level
verb	verbosity level

Returns

MoFEMErrorCode

Definition at line 464 of file BitRefManager.cpp.

                    {
  MoFEMFunctionBegin;
  Range ents;
  CHKERR getEntitiesByDimAndRefLevel(bit, mask, dim, ents);
  CHKERR setBitRefLevel(ents, BitRefLevel(), false, verb);
  MoFEMFunctionReturn(0);
}

addToDatabaseBitRefLevelByType()

MoFEMErrorCode MoFEM::BitRefManager::addToDatabaseBitRefLevelByType	(	const EntityType	type,
		const BitRefLevel	bit,
		const BitRefLevel	mask = BitRefLevel().set(),
		int	verb = QUIET ) const

#include <src/interfaces/BitRefManager.hpp>

Add entities which exist in MoAB database, and have set appropiate BitRef level tag, to multi-indices in MoFEM.

Note

Every entity, used for create DoFS, or elements has to have set BitRefLevel and be added to MoFEM database.

This functions add lower dimension entities by calling setEntitiesBitRefLevel

Parameters

type	of entity
bit	bit ref level
mask
verb	verbosity level

Returns

MoFEMErrorCode

Definition at line 454 of file BitRefManager.cpp.

                    {
  MoFEMFunctionBegin;
  Range ents;
  CHKERR getEntitiesByTypeAndRefLevel(bit, mask, type, ents);
  CHKERR setBitRefLevel(ents, BitRefLevel(), false, verb);
  MoFEMFunctionReturn(0);
}

getAdjacencies() [1/2]

MoFEMErrorCode MoFEM::BitRefManager::getAdjacencies ( const BitRefLevel bit, const EntityHandle * from_entities, const int num_entities, const int to_dimension, Range & adj_entities, const int operation_type = moab::Interface::INTERSECT, const int verb = 0 ) const

virtual

#include <src/interfaces/BitRefManager.hpp>

Get the adjacencies associated with a entity to entities of a specified dimension.

bit ref level of adjacent entities is equal to bit ref level of adjacent entities

Definition at line 989 of file BitRefManager.cpp.

                                                    {
  MoFEM::Interface &m_field = cOre;
  moab::Interface &moab(m_field.get_moab());
  MoFEMFunctionBegin;
 
  if (verb > VERBOSE) {
    MOFEM_LOG_FUNCTION();
    MOFEM_LOG("BitRef", Sev::noisy) << "from: " << bit;
  }
 
  CHKERR moab.get_adjacencies(from_entities, num_entities, to_dimension, false,
                              adj_entities, operation_type);
  std::vector<BitRefLevel> bit_levels(adj_entities.size());
  CHKERR moab.tag_get_data(cOre.get_th_RefBitLevel(), adj_entities,
                           &*bit_levels.begin());
  std::vector<BitRefLevel>::iterator b_it = bit_levels.begin();
  for (Range::iterator eit = adj_entities.begin(); eit != adj_entities.end();
       b_it++) {
 
    if (verb > VERBOSE) {
      RefEntity adj_entity(m_field.get_basic_entity_data_ptr(), *eit);
      MOFEM_LOG_FUNCTION();
      MOFEM_LOG("BitRef", Sev::noisy)
          << "to: " << adj_entity.getBitRefLevel() << " : " << adj_entity;
    }
 
    if (!((*b_it) & bit).any()) {
      eit = adj_entities.erase(eit);
    } else {
      eit++;
    }
  }
  if (b_it != bit_levels.end()) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "Data inconsistency");
  }
  MoFEMFunctionReturn(0);
}

getAdjacencies() [2/2]

MoFEMErrorCode MoFEM::BitRefManager::getAdjacencies ( const Problem * problem_ptr, const EntityHandle * from_entities, const int num_entities, const int to_dimension, Range & adj_entities, const int operation_type = moab::Interface::INTERSECT, const int verb = 0 ) const

virtual

#include <src/interfaces/BitRefManager.hpp>

Get the adjacencies associated with a entity to entities of a specified dimension.

bit ref level of adjacent entities is equal to bit ref level of adjacent entities

Definition at line 978 of file BitRefManager.cpp.

                                                    {
  MoFEMFunctionBegin;
  BitRefLevel bit = problem_ptr->getBitRefLevel();
  CHKERR getAdjacencies(bit, from_entities, num_entities, to_dimension,
                        adj_entities, operation_type);
  MoFEMFunctionReturn(0);
}

getAdjacenciesAny()

MoFEMErrorCode MoFEM::BitRefManager::getAdjacenciesAny ( const EntityHandle from_entity, const int to_dimension, Range & adj_entities ) const

virtual

#include <src/interfaces/BitRefManager.hpp>

Get the adjacencies associated with a entity to entities of a specified dimension.

bit ref level of adjacent entities is any of bit ref level of adjacent entities

Definition at line 952 of file BitRefManager.cpp.

                                                                           {
  MoFEM::Interface &m_field = cOre;
  moab::Interface &moab(m_field.get_moab());
  MoFEMFunctionBeginHot;
  BitRefLevel bit_from_entity;
  CHKERR moab.tag_get_data(cOre.get_th_RefBitLevel(), &from_entity, 1,
                           &bit_from_entity);
  CHKERR moab.get_adjacencies(&from_entity, 1, to_dimension, false,
                              adj_entities);
  std::vector<BitRefLevel> bit_levels(adj_entities.size());
  CHKERR moab.tag_get_data(cOre.get_th_RefBitLevel(), adj_entities,
                           &*bit_levels.begin());
  std::vector<BitRefLevel>::iterator b_it = bit_levels.begin();
  Range::iterator eit = adj_entities.begin();
  for (; eit != adj_entities.end(); b_it++) {
    if (!(bit_from_entity & (*b_it)).any()) {
      eit = adj_entities.erase(eit);
    } else {
      eit++;
    }
  }
  MoFEMFunctionReturnHot(0);
}

getAdjacenciesEquality()

MoFEMErrorCode MoFEM::BitRefManager::getAdjacenciesEquality ( const EntityHandle from_entity, const int to_dimension, Range & adj_entities ) const

virtual

#include <src/interfaces/BitRefManager.hpp>

Get the adjacencies associated with a entity to entities of a specified dimension.

bit ref level of adjacent entities is equal to bit ref level of adjacent entities

Definition at line 926 of file BitRefManager.cpp.

                                                                 {
  MoFEM::Interface &m_field = cOre;
  moab::Interface &moab(m_field.get_moab());
  MoFEMFunctionBegin;
  BitRefLevel bit_from_entity;
  CHKERR moab.tag_get_data(cOre.get_th_RefBitLevel(), &from_entity, 1,
                           &bit_from_entity);
  CHKERR moab.get_adjacencies(&from_entity, 1, to_dimension, false,
                              adj_entities);
  std::vector<BitRefLevel> bit_levels(adj_entities.size());
  CHKERR moab.tag_get_data(cOre.get_th_RefBitLevel(), adj_entities,
                           &*bit_levels.begin());
  auto b_it = bit_levels.begin();
  auto eit = adj_entities.begin();
  for (; eit != adj_entities.end(); b_it++) {
    if (bit_from_entity != *b_it) {
      eit = adj_entities.erase(eit);
    } else {
      eit++;
    }
  }
  MoFEMFunctionReturn(0);
}

getEntitiesByDimAndRefLevel() [1/2]

MoFEMErrorCode MoFEM::BitRefManager::getEntitiesByDimAndRefLevel	(	const BitRefLevel	bit,
		const BitRefLevel	mask,
		const int	dim,
		const EntityHandle	meshset,
		int	verb = 0 ) const

#include <src/interfaces/BitRefManager.hpp>

add all ents from ref level given by bit to meshset

Note

Entities NOT have to be added to MoFEM database

Parameters

BitRefLevel	bitLevel
BitRefLevel	mask
EntityType	dimension of entities

Return values

ents

Examples

free_surface.cpp, and hanging_node_approx.cpp.

Definition at line 823 of file BitRefManager.cpp.

                                                {
  MoFEM::Interface &m_field = cOre;
  moab::Interface &moab(m_field.get_moab());
  MoFEMFunctionBegin;
  Range ents;
  CHKERR getEntitiesByDimAndRefLevel(bit, mask, dim, ents, verb);
  CHKERR moab.add_entities(meshset, ents);
  MoFEMFunctionReturn(0);
}

getEntitiesByDimAndRefLevel() [2/2]

MoFEMErrorCode MoFEM::BitRefManager::getEntitiesByDimAndRefLevel	(	const BitRefLevel	bit,
		const BitRefLevel	mask,
		const int	dim,
		Range &	ents,
		int	verb = 0 ) const

#include <src/interfaces/BitRefManager.hpp>

add all ents from ref level given by bit to meshset

Note

Entities NOT have to be added to MoFEM database

Parameters

BitRefLevel	bitLevel
BitRefLevel	mask
EntityType	dimension of entities

Return values

ents

Definition at line 835 of file BitRefManager.cpp.

                    {
  MoFEM::Interface &m_field = cOre;
  moab::Interface &moab(m_field.get_moab());
  MoFEMFunctionBegin;
  CHKERR moab.get_entities_by_dimension(0, dim, ents, false);
  CHKERR filterEntitiesByRefLevel(bit, mask, ents, verb);
  MoFEMFunctionReturn(0);
}

getEntitiesByRefLevel() [1/2]

MoFEMErrorCode MoFEM::BitRefManager::getEntitiesByRefLevel	(	const BitRefLevel	bit,
		const BitRefLevel	mask,
		const EntityHandle	meshset,
		const int	verb = QUIET ) const

#include <src/interfaces/BitRefManager.hpp>

add all ents from ref level given by bit to meshset

Note

Entities NOT have to be added to MoFEM database

Parameters

BitRefLevel	bitLevel
BitRefLevel	mask
EntityHandle	meshset

Definition at line 846 of file BitRefManager.cpp.

                                                                          {
  MoFEM::Interface &m_field = cOre;
  moab::Interface &moab(m_field.get_moab());
  MoFEMFunctionBegin;
  Range ents;
  CHKERR getEntitiesByRefLevel(bit, mask, ents, verb);
  CHKERR moab.add_entities(meshset, ents);
  MoFEMFunctionReturn(0);
}

getEntitiesByRefLevel() [2/2]

MoFEMErrorCode MoFEM::BitRefManager::getEntitiesByRefLevel	(	const BitRefLevel	bit,
		const BitRefLevel	mask,
		Range &	ents,
		const int	verb = QUIET ) const

#include <src/interfaces/BitRefManager.hpp>

add all ents from ref level given by bit to meshset

Note

Entities NOT have to be added to MoFEM database

Parameters

BitRefLevel	bitLevel
BitRefLevel	mask

Return values

ents

Definition at line 859 of file BitRefManager.cpp.

                                                                          {
  MoFEM::Interface &m_field = cOre;
  moab::Interface &moab(m_field.get_moab());
  MoFEMFunctionBegin;
  Range meshset_ents;
  CHKERR moab.get_entities_by_type(0, MBENTITYSET, meshset_ents, false);
  CHKERR moab.get_entities_by_handle(0, ents, false);
  ents.merge(meshset_ents);
  CHKERR filterEntitiesByRefLevel(bit, mask, ents, verb);
  MoFEMFunctionReturn(0);
}

getEntitiesByTypeAndRefLevel() [1/2]

MoFEMErrorCode MoFEM::BitRefManager::getEntitiesByTypeAndRefLevel	(	const BitRefLevel	bit,
		const BitRefLevel	mask,
		const EntityType	type,
		const EntityHandle	meshset,
		int	verb = 0 ) const

#include <src/interfaces/BitRefManager.hpp>

add all ents from ref level given by bit to meshset

Note

Entities NOT have to be added to MoFEM database

Parameters

BitRefLevel	bitLevel
BitRefLevel	mask
EntityType	type of entities

Return values

EntityHandle

meshset

Examples

mesh_cut.cpp.

Definition at line 735 of file BitRefManager.cpp.

                                                {
  MoFEM::Interface &m_field = cOre;
  moab::Interface &moab(m_field.get_moab());
  MoFEMFunctionBegin;
  Range ents;
  CHKERR getEntitiesByTypeAndRefLevel(bit, mask, type, ents, verb);
  CHKERR moab.add_entities(meshset, ents);
  MoFEMFunctionReturn(0);
}

getEntitiesByTypeAndRefLevel() [2/2]

MoFEMErrorCode MoFEM::BitRefManager::getEntitiesByTypeAndRefLevel	(	const BitRefLevel	bit,
		const BitRefLevel	mask,
		const EntityType	type,
		Range &	ents,
		int	verb = 0 ) const

#include <src/interfaces/BitRefManager.hpp>

add all ents from ref level given by bit to meshset

Note

Entities NOT have to be added to MoFEM database

Parameters

BitRefLevel	bitLevel
BitRefLevel	mask
EntityType	type of entities

Return values

ents

Definition at line 812 of file BitRefManager.cpp.

                                 {
  MoFEM::Interface &m_field = cOre;
  moab::Interface &moab(m_field.get_moab());
  MoFEMFunctionBegin;
  CHKERR moab.get_entities_by_type(0, type, ents, false);
  CHKERR filterEntitiesByRefLevel(bit, mask, ents, verb);
  MoFEMFunctionReturn(0);
}

lambdaBitRefLevel() [1/2]

MoFEMErrorCode MoFEM::BitRefManager::lambdaBitRefLevel

(

boost::function< void(EntityHandle ent, BitRefLevel &bit)>

fun

)

const

#include <src/interfaces/BitRefManager.hpp>

Process bit ref level by lambda function.

Note

That not apply to type of MBENTITY. To avoid problems with problem meshsets.

Parameters

fun

Returns

MoFEMErrorCode

Definition at line 525 of file BitRefManager.cpp.

                                                                       {
  MoFEM::Interface &m_field = cOre;
  MoFEMFunctionBegin;
  auto get_ents = [&]() {
    Range ents;
    CHKERR m_field.get_moab().get_entities_by_handle(
        m_field.get_moab().get_root_set(), ents, true);
    ents = subtract(ents, ents.subset_by_type(MBENTITYSET));
    return ents;
  };
  CHKERR lambdaBitRefLevel(get_ents(), fun);
  MoFEMFunctionReturn(0);
}

lambdaBitRefLevel() [2/2]

MoFEMErrorCode MoFEM::BitRefManager::lambdaBitRefLevel	(	const Range &	ents,
		boost::function< void(EntityHandle ent, BitRefLevel &bit)>	fun ) const

#include <src/interfaces/BitRefManager.hpp>

Process bit ref level by lambda function.

Parameters

fun

Returns

MoFEMErrorCode

Definition at line 540 of file BitRefManager.cpp.

                                                                       {
  MoFEM::Interface &m_field = cOre;
  MoFEMFunctionBeginHot;
  std::vector<const BitRefLevel *> ents_bits_vec;
  CHKERR RefEntity::getBitRefLevel(m_field.get_moab(), ents, ents_bits_vec);
  auto eit = ents.begin();
  for (auto &it : ents_bits_vec) {
    fun(*eit, const_cast<BitRefLevel &>(*it));
    ++eit;
  }
  MoFEMFunctionReturnHot(0);
};

setBitLevelToMeshset()

MoFEMErrorCode MoFEM::BitRefManager::setBitLevelToMeshset	(	const EntityHandle	meshset,
		const BitRefLevel	bit,
		int	verb = 0 ) const

#include <src/interfaces/BitRefManager.hpp>

brief add meshset and set bit ref level

Parameters

EntityHandle	MeshSet
BitRefLevel	bitLevel

Definition at line 474 of file BitRefManager.cpp.

                                                                   {
  MoFEM::Interface &m_field = cOre;
  auto ref_ents_ptr = m_field.get_ref_ents();
  auto ref_fe_ptr = m_field.get_ref_finite_elements();
  MoFEMFunctionBegin;
  // Add ref entity
  std::pair<RefEntity_multiIndex::iterator, bool> p_ent =
      const_cast<RefEntity_multiIndex *>(ref_ents_ptr)
          ->insert(boost::shared_ptr<RefEntity>(
              new RefEntity(m_field.get_basic_entity_data_ptr(), meshset)));
  *(const_cast<RefEntity *>(p_ent.first->get())->getBitRefLevelPtr()) |= bit;
  // Add ref element
  boost::shared_ptr<RefElement> fe_ptr =
      boost::shared_ptr<RefElement>(new RefElement_MESHSET(*p_ent.first));
  std::pair<RefElement_multiIndex::iterator, bool> p_fe =
      const_cast<RefElement_multiIndex *>(ref_fe_ptr)->insert(fe_ptr);
 
  MOFEM_LOG_FUNCTION();
  MOFEM_LOG("BitRefSelf", Sev::noisy)
      << "Add meshset as ref_ent " << **p_fe.first;
 
  MoFEMFunctionReturn(0);
}

setBitRefLevel()

MoFEMErrorCode MoFEM::BitRefManager::setBitRefLevel	(	const Range &	ents,
		const BitRefLevel	bit,
		const bool	only_tets = true,
		int	verb = 0,
		Range *	adj_ents_ptr = nullptr ) const

#include <src/interfaces/BitRefManager.hpp>

add entities to database and set bit ref level

This function set bit ref level, add entries to core database and create ref finite elements. Finite elements are create of entities in function argument, whereas all lower dimension entities are added as a field entities

Example:

EntityHandle meshset1; //contains ent1,ent2,ent3
BitRefLevel myLevel0;
myLevel0.set(0);
m_field.getInterface<BitRefManager>()->setBitRefLevelByDim(meshset1,3,myLevel0);
//refine meshset1 into meshset2 and get new ents which are ent4, ent5
EntityHandle meshset2; //contains ent1,ent2,ent3,ent4,ent5
BitRefLevel myLevel1;
myLevel1.set(1);
m_field.getInterface<BitRefManager>()->setBitRefLevelByDim(meshset2,3,myLevel1);

So entities 1,2,3 would be assigned to bit level 0 and 1
ent1[1,1,0,0,0,0,0], ent2[1,1,0,0,0,0,0], ent3[1,1,0,0,0,0,0],
and entities 4 and 5 are assigned to bit level 1 only
ent4[0,1,0,0,0,0,0], ent5[0,1,0,0,0,0,0]

Parameters

ents	entities to set
bit	bit refinement level
only_tets	only add entities on tetrahedral (obsolete need to be fixed)
verb	verbosity level
adj_ents_ptr	if pointer is given, it is used to get adj entities by dimension/type

Returns

error code

Definition at line 281 of file BitRefManager.cpp.

                                                                        {
  MoFEM::Interface &m_field = cOre;
  auto ref_ents_ptr = m_field.get_ref_ents();
  auto ref_fe_ptr = m_field.get_ref_finite_elements();
  MoFEMFunctionBegin;
 
    MOFEM_LOG_FUNCTION();
    MOFEM_LOG_C("BitRefSelf", Sev::noisy, "Number of entities to add %d",
                ents.size());
 
    CHKERR setElementsBitRefLevel(ents, bit, verb);
 
    if (!ents.empty()) {
      for (int d = 3; d >= 1; --d) {
        Range dim_ents;
        if (only_tets && d == 3) {
          dim_ents = ents.subset_by_type(MBTET);
        } else {
          dim_ents = ents.subset_by_dimension(d);
        }
 
        MOFEM_LOG_FUNCTION();
        MOFEM_LOG_C("BitRefSelf", Sev::noisy,
                    "  Number of dim %d entities to add %d", d,
                    dim_ents.size());
 
        if (!dim_ents.empty()) {
          for (int dd = 0; dd < d; ++dd) {
            Range adj_ents;
 
            if (dd == 0) {
              rval = m_field.get_moab().get_connectivity(ents, adj_ents, true);
 
            } else {
              if (adj_ents_ptr) {
                if (dd == 1) {
                  adj_ents = adj_ents_ptr->subset_by_dimension(MBEDGE);
                } else if (dd == 2) {
                  adj_ents = adj_ents_ptr->subset_by_dimension(MBTRI);
                }
              } else {
                rval = m_field.get_moab().get_adjacencies(
                    dim_ents, dd, true, adj_ents, moab::Interface::UNION);
              }
            }
 
 
            MOFEM_LOG_FUNCTION();
            MOFEM_LOG_C("BitRefSelf", Sev::noisy,
                        "  Number of dim %d adj entities for dim %d to add %d",
                        d, dd, adj_ents.size());
 
            if (rval == MB_MULTIPLE_ENTITIES_FOUND) {
              auto log_message = [&](const auto sev) {
                MOFEM_LOG_FUNCTION();
                MOFEM_LOG_ATTRIBUTES("BitRefSelf", LogManager::BitScope);
                MOFEM_LOG("BitRefSelf", sev)
                    << "When get adjacencies moab return MB_MULTIPLE_ENTITIES_ "
                       "FOUND for dim = "
                    << dd << " and dim of entities " << d;
                MOFEM_LOG_CHANNEL("BitRefSelf"); // reset channel
              };
 
              if (verb <= QUIET)
                log_message(Sev::noisy);
              else
                log_message(Sev::warning);
 
              rval = MB_SUCCESS;
            }
            MOAB_THROW(rval);
            for (Range::pair_iterator pit = adj_ents.pair_begin();
                 pit != adj_ents.pair_end(); ++pit) {
              Range seed_ents_range;
              // get first and last element of range
              EntityHandle f = pit->first;
              EntityHandle s = pit->second;
              CHKERR SetBitRefLevelTool(m_field, bit, ref_ents_ptr, ref_fe_ptr)
                  .findEntsToAdd(f, s, seed_ents_range);
              if (!seed_ents_range.empty())
                CHKERR SetBitRefLevelTool(m_field, bit, ref_ents_ptr,
                                          ref_fe_ptr)
                    .addEntsToDatabase(seed_ents_range);
            }
          }
        }
      }
    }
 
  MoFEMFunctionReturn(0);
}

setBitRefLevelByDim()

MoFEMErrorCode MoFEM::BitRefManager::setBitRefLevelByDim	(	const EntityHandle	meshset,
		const int	dim,
		const BitRefLevel	bit,
		int	verb = QUIET ) const

#include <src/interfaces/BitRefManager.hpp>

Set the Bit Ref Level By Dim object.

Note

In THIS variant only entities in range are added. And DO NOT create elements.

Parameters

meshset
dim
bit
verb

Returns

MoFEMErrorCode

Definition at line 500 of file BitRefManager.cpp.

                                                                  {
  MoFEM::Interface &m_field = cOre;
  MoFEMFunctionBegin;
  Range ents;
  CHKERR m_field.get_moab().get_entities_by_dimension(meshset, dim, ents,
                                                      false);
  CHKERR setBitRefLevel(ents, bit, false, verb);
  MoFEMFunctionReturn(0);
}

setBitRefLevelByType()

MoFEMErrorCode MoFEM::BitRefManager::setBitRefLevelByType	(	const EntityHandle	meshset,
		const EntityType	type,
		const BitRefLevel	bit,
		int	verb = QUIET ) const

#include <src/interfaces/BitRefManager.hpp>

Set the Bit Ref Level By Type object.

Note

In THIS variant only entities in range are added. And DO NOT create elements.

Parameters

meshset
type
bit
verb

Returns

MoFEMErrorCode

Examples

mesh_cut.cpp.

Definition at line 513 of file BitRefManager.cpp.

                                                                   {
  MoFEM::Interface &m_field = cOre;
  MoFEMFunctionBegin;
  Range ents;
  CHKERR m_field.get_moab().get_entities_by_type(meshset, type, ents, false);
  CHKERR setBitRefLevel(ents, bit, false, verb);
  MoFEMFunctionReturn(0);
}

setElementsBitRefLevel()

MoFEMErrorCode MoFEM::BitRefManager::setElementsBitRefLevel	(	const Range &	ents,
		const BitRefLevel	bit = BitRefLevel(),
		int	verb = QUIET ) const

#include <src/interfaces/BitRefManager.hpp>

add entities to database and set bit ref level

Note

In THIS variant only entities in range are added and ref finite elements reated.

Parameters

ents
bit
only_tets
verb

Returns

MoFEMErrorCode setBitRefLevel

Definition at line 376 of file BitRefManager.cpp.

                                                                     {
  MoFEM::Interface &m_field = cOre;
  auto ref_ents_ptr = m_field.get_ref_ents();
  auto ref_fe_ptr = m_field.get_ref_finite_elements();
 
  MoFEMFunctionBegin;
 
  for (Range::const_pair_iterator pit = ents.pair_begin();
       pit != ents.pair_end(); pit++) {
    // get first and last element of range
    EntityHandle f = pit->first;
    EntityHandle s = pit->second;
    Range seed_ents_range; // entities seeded not in database
                           // find ents to add
    CHKERR SetBitRefLevelTool(m_field, bit, ref_ents_ptr, ref_fe_ptr)
        .findEntsToAdd(f, s, seed_ents_range);
    // add elements
    if (!seed_ents_range.empty())
      CHKERR SetBitRefLevelTool(m_field, bit, ref_ents_ptr, ref_fe_ptr)
          .addEntsToDatabase(seed_ents_range);
 
    Range seed_fe_range;
    CHKERR SetBitRefLevelTool(m_field, bit, ref_ents_ptr, ref_fe_ptr)
        .findElementsToAdd(f, s, seed_fe_range);
    if (!seed_fe_range.empty()) {
      CHKERR SetBitRefLevelTool(m_field, bit, ref_ents_ptr, ref_fe_ptr)
          .addElementsToDatabase(seed_fe_range);
    }
  }
 
  MOFEM_LOG_FUNCTION();
  MOFEM_LOG("BitRefSelf", Sev::noisy)
      << "Number of entities in database " << ref_ents_ptr->size();
  MOFEM_LOG("BitRefSelf", Sev::noisy)
      << "Number of finite element entities in database " << ref_fe_ptr->size();
 
  MoFEMFunctionReturn(0);
}

setEntitiesBitRefLevel()

MoFEMErrorCode MoFEM::BitRefManager::setEntitiesBitRefLevel	(	const Range &	ents,
		const BitRefLevel	bit = BitRefLevel(),
		int	verb = QUIET ) const

#include <src/interfaces/BitRefManager.hpp>

add entities to database and set bit ref level

Note

In THIS variant only entities in range are added. And DO NOT create elements.

Parameters

ents
bit
only_tets
verb

Returns

MoFEMErrorCode setBitRefLevel

Definition at line 417 of file BitRefManager.cpp.

                                                                     {
  MoFEM::Interface &m_field = cOre;
  auto ref_ents_ptr = m_field.get_ref_ents();
  auto ref_fe_ptr = m_field.get_ref_finite_elements();
  MoFEMFunctionBegin;
 
  for (Range::const_pair_iterator pit = ents.pair_begin();
       pit != ents.pair_end(); pit++) {
    // get first and last element of range
    EntityHandle f = pit->first;
    EntityHandle s = pit->second;
    Range seed_ents_range; // entities seeded not in database
    // find ents to add
    CHKERR SetBitRefLevelTool(m_field, bit, ref_ents_ptr, ref_fe_ptr)
        .findEntsToAdd(f, s, seed_ents_range);
    // add elements
    if (!seed_ents_range.empty())
      CHKERR SetBitRefLevelTool(m_field, bit, ref_ents_ptr, ref_fe_ptr)
          .addEntsToDatabase(seed_ents_range);
  }
  MoFEMFunctionReturn(0);
}

setFieldEntitiesBitRefLevel()

MoFEMErrorCode MoFEM::BitRefManager::setFieldEntitiesBitRefLevel	(	const std::string	field_name,
		const BitRefLevel	bit = BitRefLevel(),
		int	verb = QUIET ) const

#include <src/interfaces/BitRefManager.hpp>

Set the bit ref level to entities in the field meshset.

Parameters

field_name
bit
verb

Returns

MoFEMErrorCode

Examples

dm_partitioned_no_field.cpp.

Definition at line 442 of file BitRefManager.cpp.

                                                                       {
  MoFEM::Interface &m_field = cOre;
  MoFEMFunctionBegin;
  EntityHandle field_meshset = m_field.get_field_meshset(field_name);
  Range field_ents;
  CHKERR m_field.get_moab().get_entities_by_handle(field_meshset, field_ents,
                                                   true);
  CHKERR setEntitiesBitRefLevel(field_ents, bit, verb);
  MoFEMFunctionReturn(0);
}

setNthBitRefLevel() [1/2]

MoFEMErrorCode MoFEM::BitRefManager::setNthBitRefLevel	(	const int	n,
		const bool	b,
		int	verb = QUIET ) const

#include <src/interfaces/BitRefManager.hpp>

Set nth bit ref level to all entities in database.

Parameters

n	nth bit
b	value to set

Returns

error code

Definition at line 588 of file BitRefManager.cpp.

                                                                {
  if (verb == VERY_NOISY)
    MOFEM_LOG("BitRefSelf", Sev::noisy) << "Set bit to all entities";
  return lambdaBitRefLevel(
      [&](EntityHandle ent, BitRefLevel &ent_bit) { ent_bit[n] = b; });
}

setNthBitRefLevel() [2/2]

MoFEMErrorCode MoFEM::BitRefManager::setNthBitRefLevel	(	const Range &	ents,
		const int	n,
		const bool	b,
		int	verb = QUIET ) const

#include <src/interfaces/BitRefManager.hpp>

Set nth bit ref level.

Note

This function modify bits only on entities in RefEntity_multiindex

Parameters

ents	entities to set bit ref level
n	nth bit
b	value to set

Returns

error code

Definition at line 580 of file BitRefManager.cpp.

                                                                              {
  if (verb == VERY_NOISY)
    MOFEM_LOG("BitRefSelf", Sev::noisy) << "Set bit to " << ents;
  return lambdaBitRefLevel(
      ents, [&](EntityHandle ent, BitRefLevel &ent_bit) { ent_bit[n] = b; });
}

shiftLeftBitRef()

MoFEMErrorCode MoFEM::BitRefManager::shiftLeftBitRef	(	const int	shift,
		const BitRefLevel	mask = BitRefLevel().set(),
		int	verb = DEFAULT_VERBOSITY ) const

#include <src/interfaces/BitRefManager.hpp>

left shift bit ref levelthis results of deletion of entities on far left side

Note

Not implemented

Definition at line 596 of file BitRefManager.cpp.

                                                              {
  MoFEMFunctionBeginHot;
  SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED, "not implemented");
  MoFEMFunctionReturnHot(0);
}

shiftRightBitRef()

MoFEMErrorCode MoFEM::BitRefManager::shiftRightBitRef	(	const int	shift,
		const BitRefLevel	mask = BitRefLevel().set(),
		int	verb = DEFAULT_VERBOSITY,
		MoFEMTypes	mf = MF_ZERO ) const

#include <src/interfaces/BitRefManager.hpp>

right shift bit ref level

Definition at line 604 of file BitRefManager.cpp.

                                                                    {
  MoFEM::Interface &m_field = cOre;
  auto ref_ents_ptr = m_field.get_ref_ents();
  MoFEMFunctionBegin;
  RefEntity_change_right_shift right_shift(1, mask);
  for (int ii = 0; ii < shift; ii++) {
    // delete bits on the right which are shifted to zero
    BitRefLevel delete_bits = BitRefLevel().set(0) & mask;
    if (delete_bits.any()) {
      CHKERR m_field.delete_ents_by_bit_ref(delete_bits, delete_bits, true,
                                            verb, mf);
    }
    for (RefEntity_multiIndex::iterator ent_it = ref_ents_ptr->begin();
         ent_it != ref_ents_ptr->end(); ent_it++) {
      if (verb >= NOISY) {
        MOFEM_LOG_FUNCTION();
        MOFEM_LOG("BitRefSelf", Sev::noisy)
            << (*ent_it)->getBitRefLevel() << " : ";
      }
      right_shift(const_cast<boost::shared_ptr<RefEntity> &>(*ent_it));
      if (verb == VERY_NOISY) {
        MOFEM_LOG_FUNCTION();
        MOFEM_LOG("BitRefSelf", Sev::noisy) << (*ent_it)->getBitRefLevel();
      }
    }
  }
  MoFEMFunctionReturn(0);
}

updateFieldMeshsetByEntitiesChildren() [1/2]

MoFEMErrorCode MoFEM::BitRefManager::updateFieldMeshsetByEntitiesChildren	(	const BitRefLevel &	child_bit,
		int	verb = 0 )

#include <src/interfaces/BitRefManager.hpp>

update fields meshesets by child entities

Note

This calls updateMeshsetByEntitiesChildren for all entity types.

Definition at line 1066 of file BitRefManager.cpp.

                                            {
  MoFEM::Interface &m_field = cOre;
  moab::Interface &moab = m_field.get_moab();
  auto fields_ptr = m_field.get_fields();
  MoFEMFunctionBegin;
 
  for (auto &fit : (*fields_ptr)) {
 
    const EntityHandle meshset = fit->getMeshset();
    Range parent_ents;
    CHKERR moab.get_entities_by_handle(meshset, parent_ents, true);
 
    if (verb >= VERY_VERBOSE) {
      MOFEM_LOG_FUNCTION();
      MOFEM_LOG("BitRefSelf", Sev::noisy) << "Parnets:" << std::endl
                                          << parent_ents << std::endl;
    }
 
    Range children_ents;
    CHKERR updateRangeByChildren(parent_ents, children_ents);
    CHKERR filterEntitiesByRefLevel(child_bit, BitRefLevel().set(),
                                    children_ents, verb);
 
    CHKERR moab.add_entities(meshset, children_ents);
 
    if (verb >= VERY_VERBOSE) {
      MOFEM_LOG_FUNCTION();
      MOFEM_LOG("BitRefSelf", Sev::noisy) << "Children: " << std::endl
                                          << children_ents << std::endl;
    }
  }
  MoFEMFunctionReturn(0);
}

updateFieldMeshsetByEntitiesChildren() [2/2]

MoFEMErrorCode MoFEM::BitRefManager::updateFieldMeshsetByEntitiesChildren	(	const std::string	name,
		const BitRefLevel &	child_bit,
		int	verb = 0 )

#include <src/interfaces/BitRefManager.hpp>

update field meshset by child entities

Definition at line 1101 of file BitRefManager.cpp.

                                                                  {
  MoFEM::Interface &m_field = cOre;
  moab::Interface &moab = m_field.get_moab();
  MoFEMFunctionBegin;
 
  EntityHandle field_meshset = m_field.get_field_structure(name)->getMeshset();
 
  Range parent_ents;
  CHKERR moab.get_entities_by_handle(field_meshset, parent_ents, true);
 
  if (verb >= VERBOSE) {
    MOFEM_LOG_FUNCTION();
    MOFEM_LOG("BitRefSelf", Sev::noisy) << "Parnets:" << endl
                                        << parent_ents << std::endl;
  }
 
  Range children_ents;
  CHKERR updateRangeByChildren(parent_ents, children_ents);
  CHKERR filterEntitiesByRefLevel(child_bit, BitRefLevel().set(), children_ents,
                                  verb);
 
  CHKERR moab.add_entities(field_meshset, children_ents);
 
  if (verb >= VERBOSE) {
    MOFEM_LOG_FUNCTION();
    MOFEM_LOG("BitRefSelf", Sev::noisy) << "Children: " << endl
                                        << children_ents << std::endl;
  }
 
  MoFEMFunctionReturn(0);
}

updateFiniteElementMeshsetByEntitiesChildren()

MoFEMErrorCode MoFEM::BitRefManager::updateFiniteElementMeshsetByEntitiesChildren	(	const std::string	name,
		const BitRefLevel &	child_bit,
		const EntityType	fe_ent_type,
		int	verb = 0 )

#include <src/interfaces/BitRefManager.hpp>

update finite element meshset by child entities

Definition at line 1134 of file BitRefManager.cpp.

                                            {
  MoFEM::Interface &m_field = cOre;
  MoFEMFunctionBegin;
  EntityHandle meshset = m_field.get_finite_element_meshset(name);
  CHKERR updateMeshsetByEntitiesChildren(meshset, child_bit, meshset,
                                         fe_ent_type, false, verb);
  MoFEMFunctionReturn(0);
}

updateMeshsetByEntitiesChildren() [1/2]

MoFEMErrorCode MoFEM::BitRefManager::updateMeshsetByEntitiesChildren	(	const EntityHandle	parent,
		const BitRefLevel &	child_bit,
		const EntityHandle	child,
		EntityType	child_type,
		const bool	recursive = false,
		int	verb = 0 )

#include <src/interfaces/BitRefManager.hpp>

Get child entities form meshset containing parent entities.

Search for refined entities of given type whose parent are entities in the parent meshset. It can be used for example to transfer information about boundary conditions to refined mesh or split mesh by interface elements. It is used by function refineMeshset, to update MESHSET finite elements.

Parameters

parent	meshset
parent_bit	refinement level
mask	of parent bit ref level
child_bit	refinement level
mask	of child bit ref level
child	meshset where child entities are stored (if the child meshset is set to be the parent meshset, the parent would be updated with the refined entities)
child_type	meshset is update only by entities of specified type. if type is set to MBMAXTYPE all types are updated.
recursive	if true parent meshset is searched recursively

Definition at line 1055 of file BitRefManager.cpp.

              {
  MoFEMFunctionBegin;
  CHKERR updateMeshsetByEntitiesChildren(
      parent, BitRefLevel().set(), BitRefLevel().set(), child_bit, child_bit,
      child, child_type, recursive, verb);
  MoFEMFunctionReturn(0);
}

updateMeshsetByEntitiesChildren() [2/2]

MoFEMErrorCode MoFEM::BitRefManager::updateMeshsetByEntitiesChildren	(	const EntityHandle	parent,
		const BitRefLevel &	parent_bit,
		const BitRefLevel &	parent_mask,
		const BitRefLevel &	child_bit,
		const BitRefLevel &	child_mask,
		const EntityHandle	child,
		EntityType	child_type,
		const bool	recursive = false,
		int	verb = 0 )

#include <src/interfaces/BitRefManager.hpp>

Get child entities form meshset containing parent entities.

Search for refined entities of given type whose parent are entities in the parent meshset. It can be used for example to transfer information about boundary conditions to refined mesh or split mesh by interface elements. It is used by function refineMeshset, to update MESHSET finite elements.

Parameters

parent	meshset
parent_bit	refinement level
mask	of parent bit ref level
child_bit	refinement level
mask	of child bit ref level
child	meshset where child entities are stored (if the child meshset is set to be the parent meshset, the parent would be updated with the refined entities)
child_type	meshset is update only by entities of specified type. if type is set to MBMAXTYPE all types are updated.
recursive	if true parent meshset is searched recursively

Examples

hanging_node_approx.cpp.

Definition at line 1030 of file BitRefManager.cpp.

                                                           {
  MoFEM::Interface &m_field = cOre;
  moab::Interface &moab = m_field.get_moab();
  MoFEMFunctionBegin;
  Range parent_ents;
  CHKERR moab.get_entities_by_handle(parent, parent_ents, recursive);
  CHKERR filterEntitiesByRefLevel(parent_bit, parent_mask, parent_ents, verb);
  if (verb >= VERY_VERBOSE) {
    MOFEM_LOG_FUNCTION();
    MOFEM_LOG("BitRefSelf", Sev::noisy) << "Parents: " << parent;
  }
  Range children_ents;
  CHKERR updateRangeByChildren(parent_ents, children_ents);
  if (child_type < MBMAXTYPE)
    children_ents = children_ents.subset_by_type(child_type);
  CHKERR filterEntitiesByRefLevel(child_bit, BitRefLevel().set(), children_ents,
                                  verb);
  CHKERR moab.add_entities(child, children_ents);
  MoFEMFunctionReturn(0);
}

updateRange()

DEPRECATED MoFEMErrorCode MoFEM::BitRefManager::updateRange ( const Range & parent, Range & child, MoFEMTypes bh = MF_ZERO )

inline

#include <src/interfaces/BitRefManager.hpp>

Deprecated

use updateRangeByChildren

Definition at line 598 of file BitRefManager.hpp.

                                                                          {
    return updateRangeByChildren(parent, child, bh);
  }

updateRangeByChildren()

MoFEMErrorCode MoFEM::BitRefManager::updateRangeByChildren	(	const Range &	parent,
		Range &	child,
		MoFEMTypes	bh = MF_ZERO )

#include <src/interfaces/BitRefManager.hpp>

Update range by childrens.

FIXME: NOT TESTED

Parameters

parent	parent range
child	children range

Returns

error code

Examples

hanging_node_approx.cpp.

Definition at line 1145 of file BitRefManager.cpp.

                                                                   {
  MoFEM::Interface &m_field = cOre;
  auto ref_ents_ptr = m_field.get_ref_ents();
  MoFEMFunctionBegin;
  auto &ref_ents =
      const_cast<RefEntity_multiIndex *>(ref_ents_ptr)->get<Ent_Ent_mi_tag>();
  std::vector<EntityHandle> child_ents_vec;
  child_ents_vec.reserve(ref_ents.size());
  for (Range::const_pair_iterator pit = parent_ents.const_pair_begin();
       pit != parent_ents.const_pair_end(); pit++) {
    const auto f = pit->first;
    auto it = ref_ents.lower_bound(f);
    if (it != ref_ents.end()) {
      const auto s = pit->second;
      auto hi_it = ref_ents.upper_bound(s);
      if (bh == MF_EXIST) {
        if (std::distance(it, hi_it) != (s - f) + 1) {
          SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_FOUND,
                  "Number of entities and entities parents is different %ld != "
                  "%ld ",
                  std::distance(it, hi_it), (s - f) + 1);
        }
      }
      for (; it != hi_it; it++) {
#ifndef NDEBUG
        if (it->get()->getEntType() == MBENTITYSET) {
          SETERRQ(PETSC_COMM_SELF, MOFEM_IMPOSSIBLE_CASE, 
                  "This should not happen; Entity should not have part of the "
                  "meshset. It has no children.");
        }
#endif
        child_ents_vec.emplace_back((*it)->getEnt());
      }
    } else if (bh == MF_EXIST) {
      SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_FOUND, "Entities not found");
    }
  }
  child_ents.insert_list(child_ents_vec.begin(), child_ents_vec.end());
  MoFEMFunctionReturn(0);
}

updateRangeByParent()

MoFEMErrorCode MoFEM::BitRefManager::updateRangeByParent	(	const Range &	child_ents,
		Range &	parent_ents,
		MoFEMTypes	bh = MF_ZERO )

#include <src/interfaces/BitRefManager.hpp>

Update range by parents.

FIXME: NOT TESTED

Parameters

child	parent range
parent	children range

Returns

error code

Definition at line 1188 of file BitRefManager.cpp.

                                                                 {
  MoFEM::Interface &m_field = cOre;
  auto ref_ents_ptr = m_field.get_ref_ents();
  MoFEMFunctionBegin;
  auto &ref_ents =
      const_cast<RefEntity_multiIndex *>(ref_ents_ptr)->get<Ent_mi_tag>();
  std::vector<EntityHandle> parent_ents_vec;
  parent_ents_vec.reserve(ref_ents.size());
  for (Range::const_pair_iterator pit = child_ents.const_pair_begin();
       pit != child_ents.const_pair_end(); pit++) {
    const auto f = pit->first;
    auto it = ref_ents.lower_bound(f);
    if (it != ref_ents.end()) {
      const auto s = pit->second;
      auto hi_it = ref_ents.upper_bound(s);
      if (bh == MF_EXIST) {
        if (std::distance(it, hi_it) != (s - f) + 1) {
          SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_FOUND,
                  "Number of entities and entities parents is different %ld != "
                  "%ld ",
                  std::distance(it, hi_it), (s - f) + 1);
        }
      }
      for (; it != hi_it; it++) {
#ifndef NDEBUG
        if (it->get()->getEntType() == MBENTITYSET) {
          SETERRQ(PETSC_COMM_SELF, MOFEM_IMPOSSIBLE_CASE,
                  "This should not happen; Entity should not have part of the "
                  "meshset. It has no children.");
        }
#endif
        auto parent = (*it)->getParentEnt();
        if (parent)
          parent_ents_vec.emplace_back(parent);
      }
    } else if (bh == MF_EXIST) {
      SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_FOUND, "Entities not found");
    }
  }
  parent_ents.insert_list(parent_ents_vec.begin(), parent_ents_vec.end());
  MoFEMFunctionReturn(0);
}