MoFEM::SetBitRefLevelTool Struct Reference

tool class with methods used more than twp times More...

Collaboration diagram for MoFEM::SetBitRefLevelTool:

Public Member Functions
	SetBitRefLevelTool (MoFEM::Interface &m_field, const BitRefLevel &bit, const RefEntity_multiIndex *ref_ents_ptr, const RefElement_multiIndex *ref_element_ptr)
	constructor
MoFEMErrorCode	findEntsToAdd (EntityHandle f, EntityHandle s, Range &seed_ents_range) const
	find entities and change entity bit if in database
template<int N>
MoFEMErrorCode	addEntsToDatabaseImpl (const Range &seed_ents_range) const
	add entities to database
MoFEMErrorCode	addEntsToDatabase (const Range &seed_ents_range) const
MoFEMErrorCode	findElementsToAdd (EntityHandle f, EntityHandle s, Range &seed_fe_range) const
MoFEMErrorCode	addElementsToDatabase (Range &seed_fe_range) const

Public Attributes
MoFEM::Interface &	mField
const BitRefLevel &	bIt
	bit to set
const RefEntity_multiIndex *	refEntsPtr
	access to ents database
const RefElement_multiIndex *	refElementPtr
	access to fe database
boost::shared_ptr< BasicEntityData > &	baseEntData
	base entity data

Detailed Description

tool class with methods used more than twp times

Definition at line 40 of file BitRefManager.cpp.

Constructor & Destructor Documentation

SetBitRefLevelTool()

MoFEM::SetBitRefLevelTool::SetBitRefLevelTool ( MoFEM::Interface &  m_field, const BitRefLevel &  bit, const RefEntity_multiIndex *  ref_ents_ptr, const RefElement_multiIndex *  ref_element_ptr  )

inline

constructor

Definition at line 51 of file BitRefManager.cpp.

      : mField(m_field), bIt(bit), refEntsPtr(ref_ents_ptr),
        refElementPtr(ref_element_ptr),
        baseEntData(m_field.get_basic_entity_data_ptr()) {}

Member Function Documentation

addElementsToDatabase()

MoFEMErrorCode MoFEM::SetBitRefLevelTool::addElementsToDatabase ( Range &  seed_fe_range ) const

inline

Definition at line 191 of file BitRefManager.cpp.

                                                                   {
    MoFEMFunctionBeginHot;
    std::vector<boost::shared_ptr<RefElement>> shared_ref_fe_vec;
    shared_ref_fe_vec.reserve(seed_fe_range.size());
    // create ref entity instances
    for (Range::const_pair_iterator pit = seed_fe_range.const_pair_begin();
         pit != seed_fe_range.const_pair_end(); ++pit) {
      RefEntity_multiIndex::iterator rit, hi_rit;
      rit = refEntsPtr->lower_bound(pit->first);
      hi_rit = refEntsPtr->upper_bound(pit->second);
      if (static_cast<int>(std::distance(rit, hi_rit)) !=
          static_cast<int>(pit->second - pit->first + 1)) {
        SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                 "data inconsistency %ld != %ld", std::distance(rit, hi_rit),
                 pit->second - pit->first + 1);
      }
      switch ((*rit)->getEntType()) {
      case MBVERTEX: {
        boost::shared_ptr<std::vector<RefElement_VERTEX>> ref_fe_vec =
            boost::make_shared<std::vector<RefElement_VERTEX>>();
        ref_fe_vec->reserve(pit->second - pit->first + 1);
        for (; rit != hi_rit; ++rit) {
          ref_fe_vec->push_back(RefElement_VERTEX(*rit));
          shared_ref_fe_vec.push_back(
              boost::shared_ptr<RefElement>(ref_fe_vec, &ref_fe_vec->back()));
        }
      } break;
      case MBEDGE: {
        boost::shared_ptr<std::vector<RefElement_EDGE>> ref_fe_vec =
            boost::make_shared<std::vector<RefElement_EDGE>>();
        ref_fe_vec->reserve(pit->second - pit->first + 1);
        for (; rit != hi_rit; ++rit) {
          ref_fe_vec->push_back(RefElement_EDGE(*rit));
          shared_ref_fe_vec.push_back(
              boost::shared_ptr<RefElement>(ref_fe_vec, &ref_fe_vec->back()));
        }
      } break;
      case MBTRI:
      case MBQUAD: {
        boost::shared_ptr<std::vector<RefElementFace>> ref_fe_vec =
            boost::make_shared<std::vector<RefElementFace>>();
        ref_fe_vec->reserve(pit->second - pit->first + 1);
        for (; rit != hi_rit; ++rit) {
          ref_fe_vec->push_back(RefElementFace(*rit));
          shared_ref_fe_vec.push_back(
              boost::shared_ptr<RefElement>(ref_fe_vec, &ref_fe_vec->back()));
        }
      } break;
      case MBTET:
      case MBHEX: {
        boost::shared_ptr<std::vector<RefElementVolume>> ref_fe_vec =
            boost::make_shared<std::vector<RefElementVolume>>();
        ref_fe_vec->reserve(pit->second - pit->first + 1);
        for (; rit != hi_rit; ++rit) {
          ref_fe_vec->push_back(RefElementVolume(*rit));
          shared_ref_fe_vec.push_back(
              boost::shared_ptr<RefElement>(ref_fe_vec, &ref_fe_vec->back()));
        }
      } break;
      case MBPRISM: {
        boost::shared_ptr<std::vector<RefElement_PRISM>> ref_fe_vec =
            boost::make_shared<std::vector<RefElement_PRISM>>();
        ref_fe_vec->reserve(pit->second - pit->first + 1);
        for (; rit != hi_rit; ++rit) {
          ref_fe_vec->push_back(RefElement_PRISM(*rit));
          shared_ref_fe_vec.push_back(
              boost::shared_ptr<RefElement>(ref_fe_vec, &ref_fe_vec->back()));
        }
      } break;
      case MBENTITYSET: {
        boost::shared_ptr<std::vector<RefElement_MESHSET>> ref_fe_vec =
            boost::make_shared<std::vector<RefElement_MESHSET>>();
        ref_fe_vec->reserve(pit->second - pit->first + 1);
        for (; rit != hi_rit; ++rit) {
          ref_fe_vec->push_back(RefElement_MESHSET(*rit));
          shared_ref_fe_vec.push_back(
              boost::shared_ptr<RefElement>(ref_fe_vec, &ref_fe_vec->back()));
        }
      } break;
      default:
        SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED, "not implemented");
      }
    }
    // add shared pointers to database
    const_cast<RefElement_multiIndex *>(refElementPtr)
        ->insert(shared_ref_fe_vec.begin(), shared_ref_fe_vec.end());
    MoFEMFunctionReturnHot(0);
  }

addEntsToDatabase()

MoFEMErrorCode MoFEM::SetBitRefLevelTool::addEntsToDatabase ( const Range &  seed_ents_range ) const

inline

Definition at line 153 of file BitRefManager.cpp.

                                                                       {
    MoFEMFunctionBeginHot;
 
    switch (mField.getValue()) {
    case -1:
      MoFEMFunctionReturnHot(addEntsToDatabaseImpl<-1>(seed_ents_range));
    case 0:
      MoFEMFunctionReturnHot(addEntsToDatabaseImpl<0>(seed_ents_range));
    case 1:
      MoFEMFunctionReturnHot(addEntsToDatabaseImpl<1>(seed_ents_range));
    default:
      SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
               "Core index can vary from -1 to %d", MAX_CORE_TMP);
    }
 
    MoFEMFunctionReturnHot(0);
  }

addEntsToDatabaseImpl()

template<int N>

MoFEMErrorCode MoFEM::SetBitRefLevelTool::addEntsToDatabaseImpl ( const Range &  seed_ents_range ) const

inline

add entities to database

Definition at line 99 of file BitRefManager.cpp.

                                                                           {
    MoFEMFunctionBeginHot;
    std::vector<boost::shared_ptr<RefEntity>> shared_ref_ents_vec;
    shared_ref_ents_vec.reserve(seed_ents_range.size());
    std::vector<const void *> tag_by_ptr;
    for (Range::const_pair_iterator pit = seed_ents_range.pair_begin();
         pit != seed_ents_range.pair_end(); pit++) {
      // add entities to database
      EntityHandle f = pit->first;
      EntityHandle s = pit->second;
 
      boost::shared_ptr<std::vector<RefEntityTmp<N>>> ref_ents_vec(
          new std::vector<RefEntityTmp<N>>());
      ref_ents_vec->reserve(s - f + 1);
 
      tag_by_ptr.resize(s - f + 1);
      CHKERR baseEntData->moab.tag_get_by_ptr(
          baseEntData->th_RefParentHandle, Range(f, s), &*tag_by_ptr.begin());
      auto tag_parent_it = tag_by_ptr.begin();
      for (auto f : Range(f, s)) {
        ref_ents_vec->emplace_back(
            baseEntData, f,
            const_cast<EntityHandle *>(
                static_cast<const EntityHandle *>(*tag_parent_it)));
        ++tag_parent_it;
      }
 
      // Set bits to range
      if (bIt.any()) {
        tag_by_ptr.resize(s - f + 1);
        CHKERR baseEntData->moab.tag_get_by_ptr(
            baseEntData->th_RefBitLevel, Range(f, s), &*tag_by_ptr.begin());
        for (auto &v_bit_ptr : tag_by_ptr)
          const_cast<BitRefLevel &>(
              *(static_cast<const BitRefLevel *>(v_bit_ptr))) |= bIt;
      }
 
      for (auto &re : *ref_ents_vec)
        shared_ref_ents_vec.emplace_back(ref_ents_vec,
                                         static_cast<RefEntity *>(&re));
    }
    if (!shared_ref_ents_vec.empty()) {
      int s0 = refEntsPtr->size();
      const_cast<RefEntity_multiIndex *>(refEntsPtr)
          ->insert(shared_ref_ents_vec.begin(), shared_ref_ents_vec.end());
      if ((refEntsPtr->size() - s0) != shared_ref_ents_vec.size()) {
        SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                "Data inconsistency %ld != %ld", refEntsPtr->size() - s0,
                shared_ref_ents_vec.size());
      }
    }
    MoFEMFunctionReturnHot(0);
  }

findElementsToAdd()

MoFEMErrorCode MoFEM::SetBitRefLevelTool::findElementsToAdd ( EntityHandle  f, EntityHandle  s, Range &  seed_fe_range  ) const

inline

Definition at line 171 of file BitRefManager.cpp.

                                                               {
    MoFEMFunctionBeginHot;
    seed_fe_range.insert(f, s);
    RefElement_multiIndex::iterator rit, hi_rit;
    // get lower bound of multi-index
    rit = refElementPtr->lower_bound(f);
    if (rit == refElementPtr->end()) {
      // all entities in range are added to database
      MoFEMFunctionReturnHot(0);
    } else {
      // some entities from range are in database
      hi_rit = refElementPtr->upper_bound(s);
      for (; rit != hi_rit; ++rit) {
        seed_fe_range.erase(rit->get()->getEnt());
      }
    }
    MoFEMFunctionReturnHot(0);
  }

findEntsToAdd()

MoFEMErrorCode MoFEM::SetBitRefLevelTool::findEntsToAdd ( EntityHandle  f, EntityHandle  s, Range &  seed_ents_range  ) const

inline

find entities and change entity bit if in database

Definition at line 59 of file BitRefManager.cpp.

                                                             {
    // MoFEMFunctionBeginHot;
 
    seed_ents_range.insert(f, s);
    // get lower bound of multi-index
    auto rit = refEntsPtr->lower_bound(f);
    if (rit == refEntsPtr->end()) {
      // all entities in range are added to database
      // MoFEMFunctionReturnHot(0);
      return 0;
    } else {
 
      // some entities from range are in database
      auto hi_rit = refEntsPtr->upper_bound(s);
 
      Range to_erase;
      insertOrdered(to_erase, RefEntExtractor(), rit, hi_rit);
      if (bIt.any())
        for (; rit != hi_rit; ++rit)
          const_cast<BitRefLevel &>((*rit)->getBitRefLevel()) |= bIt;
 
      Range::iterator lo, hi = seed_ents_range.begin();
      for (auto pt = to_erase.pair_begin(); pt != to_erase.pair_end(); ++pt) {
        lo = seed_ents_range.lower_bound(hi, seed_ents_range.end(), pt->first);
        if (lo != seed_ents_range.end()) {
          hi = seed_ents_range.upper_bound(lo, seed_ents_range.end(),
                                           pt->second);
          seed_ents_range.erase(lo, hi);
        } else
          break;
      }
    }
 
    // MoFEMFunctionReturnHot(0);
    return 0;
  }

Member Data Documentation

baseEntData

boost::shared_ptr<BasicEntityData>& MoFEM::SetBitRefLevelTool::baseEntData

base entity data

Definition at line 48 of file BitRefManager.cpp.

bIt

const BitRefLevel& MoFEM::SetBitRefLevelTool::bIt

bit to set

Definition at line 44 of file BitRefManager.cpp.

mField

MoFEM::Interface& MoFEM::SetBitRefLevelTool::mField

Definition at line 42 of file BitRefManager.cpp.

refElementPtr

const RefElement_multiIndex* MoFEM::SetBitRefLevelTool::refElementPtr

access to fe database

Definition at line 46 of file BitRefManager.cpp.

refEntsPtr

const RefEntity_multiIndex* MoFEM::SetBitRefLevelTool::refEntsPtr

access to ents database

Definition at line 45 of file BitRefManager.cpp.

---

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

• src/interfaces/impl/BitRefManager.cpp