7#define FECoreFunctionBegin                                                    \ 
    9  MOFEM_LOG_CHANNEL("WORLD");                                                  \ 
   10  MOFEM_LOG_CHANNEL("SYNC");                                                   \ 
   11  MOFEM_LOG_FUNCTION();                                                        \ 
   12  MOFEM_LOG_TAG("WORLD", "FECore");                                            \ 
   13  MOFEM_LOG_TAG("SYNC", "FECore"); 
 
   25          std::string(
"finite element < " + name +
 
   26                      " > not in database (top tip: check spelling)")
 
 
   46  *buildMoFEM &= 1 << 0;
 
   54  auto add_meshset_to_partition = [&](
auto meshset) {
 
   56    const void *tag_vals[] = {&rAnk};
 
   57    ParallelComm *pcomm = ParallelComm::get_pcomm(
 
   58        &get_moab(), get_basic_entity_data_ptr()->pcommID);
 
   59    Tag part_tag = pcomm->part_tag();
 
   61    CHKERR get_moab().get_entities_by_type_and_tag(0, MBENTITYSET, &part_tag,
 
   62                                                   tag_vals, 1, tagged_sets,
 
   63                                                   moab::Interface::UNION);
 
   64    for (
auto s : tagged_sets)
 
   65      CHKERR get_moab().add_entities(s, &meshset, 1);
 
   69  auto &finite_element_name_set =
 
   71  auto it_fe = finite_element_name_set.find(fe_name);
 
   74    if (it_fe != finite_element_name_set.end()) {
 
   80    if (it_fe != finite_element_name_set.end())
 
   84  CHKERR get_moab().create_meshset(MESHSET_SET, meshset);
 
   85  CHKERR add_meshset_to_partition(meshset);
 
   94  auto id = 
BitFEId().set(fe_shift);
 
   95  CHKERR get_moab().tag_set_data(th_FEId, &meshset, 1, &
id);
 
   98  void const *tag_data[] = {fe_name.c_str()};
 
  100  tag_sizes[0] = fe_name.size();
 
  101  CHKERR get_moab().tag_set_by_ptr(th_FEName, &meshset, 1, tag_data, tag_sizes);
 
  104  auto p = finiteElements.insert(
 
  105      boost::shared_ptr<FiniteElement>(
new FiniteElement(moab, meshset)));
 
  108            "FiniteElement not inserted");
 
  111    MOFEM_LOG(
"WORLD", Sev::inform) << 
"Add finite element " << fe_name;
 
 
  118                                            const EntityType type,
 
  121  *buildMoFEM &= 1 << 0;
 
  122  typedef FiniteElement_multiIndex::index<FiniteElement_name_mi_tag>::type
 
  123      FiniteElements_by_name;
 
  124  FiniteElements_by_name &finite_element_name_set =
 
  126  FiniteElements_by_name::iterator it_fe =
 
  127      finite_element_name_set.find(fe_name);
 
  128  if (it_fe == finite_element_name_set.end())
 
  130            "This finite element is not defined (advise: check spelling)");
 
  131  boost::shared_ptr<FiniteElement> fe;
 
  133  fe->elementAdjacencyTable[type] = function;
 
 
  139                                           const std::string name_data) {
 
  141  *buildMoFEM &= 1 << 0;
 
  142  typedef FiniteElement_multiIndex::index<FiniteElement_name_mi_tag>::type
 
  143      FiniteElements_by_name;
 
  144  FiniteElements_by_name &finite_element_name_set =
 
  146  FiniteElements_by_name::iterator it_fe =
 
  147      finite_element_name_set.find(fe_name);
 
  148  if (it_fe == finite_element_name_set.end())
 
  150            "This finite element is not defined (advise: check spelling)");
 
  151  bool success = finite_element_name_set.modify(
 
  155            "modification unsuccessful");
 
 
  161                                          const std::string name_row) {
 
  163  *buildMoFEM &= 1 << 0;
 
  164  typedef FiniteElement_multiIndex::index<FiniteElement_name_mi_tag>::type
 
  165      FiniteElements_by_name;
 
  166  FiniteElements_by_name &finite_element_name_set =
 
  168  FiniteElements_by_name::iterator it_fe =
 
  169      finite_element_name_set.find(fe_name);
 
  170  if (it_fe == finite_element_name_set.end())
 
  173  bool success = finite_element_name_set.modify(
 
  177            "modification unsuccessful");
 
 
  183                                          const std::string name_col) {
 
  185  *buildMoFEM &= 1 << 0;
 
  186  auto &finite_element_name_set =
 
  188  auto it_fe = finite_element_name_set.find(fe_name);
 
  189  if (it_fe == finite_element_name_set.end())
 
  191            "this FiniteElement is there");
 
  192  bool success = finite_element_name_set.modify(
 
  196            "modification unsuccessful");
 
 
  202                                           const std::string name_data) {
 
  204  *buildMoFEM &= 1 << 0;
 
  205  auto &finite_element_name_set =
 
  207  auto it_fe = finite_element_name_set.find(fe_name);
 
  208  if (it_fe == finite_element_name_set.end())
 
  210  bool success = finite_element_name_set.modify(
 
  214            "modification unsuccessful");
 
 
  220                                          const std::string name_row) {
 
  222  *buildMoFEM &= 1 << 0;
 
  223  auto &finite_element_name_set =
 
  225  auto it_fe = finite_element_name_set.find(fe_name);
 
  226  if (it_fe == finite_element_name_set.end())
 
  229  bool success = finite_element_name_set.modify(
 
  233            "modification unsuccessful");
 
 
  239                                          const std::string name_col) {
 
  241  *buildMoFEM &= 1 << 0;
 
  242  auto &finite_element_name_set =
 
  244  auto it_fe = finite_element_name_set.find(fe_name);
 
  245  if (it_fe == finite_element_name_set.end())
 
  247  bool success = finite_element_name_set.modify(
 
  251            "modification unsuccessful");
 
 
  257  auto miit = fe_by_id.find(fe_name);
 
  258  if (miit == fe_by_id.end())
 
  260        (
"finite element < " + fe_name + 
" > not found (top tip: check spelling)")
 
  262  return (*miit)->getId();
 
 
  267  auto miit = fe_by_id.find(
id);
 
  268  if (miit == fe_by_id.end())
 
  270  return (*miit)->getName();
 
 
  275  auto miit = fe_by_id.find(
id);
 
  276  if (miit == fe_by_id.end())
 
  278  return (*miit)->meshset;
 
 
  282  return get_finite_element_meshset(getBitFEId(name));
 
 
  291  EntityHandle meshset = get_finite_element_meshset(name);
 
  292  CHKERR get_moab().get_entities_by_dimension(meshset, dim, ents, 
true);
 
 
  302  EntityHandle meshset = get_finite_element_meshset(name);
 
  303  CHKERR get_moab().get_entities_by_type(meshset, type, ents, 
true);
 
 
  314  EntityHandle meshset = get_finite_element_meshset(name);
 
  315  CHKERR get_moab().get_entities_by_handle(meshset, ents, 
true);
 
 
  330    const EntityHandle meshset, 
const EntityType type, 
const std::string name,
 
  331    const bool recursive) {
 
  332  *buildMoFEM &= 1 << 0;
 
  336  idm = get_finite_element_meshset(getBitFEId(name));
 
  338  CHKERR get_moab().get_entities_by_type(meshset, type, ents, recursive);
 
  339  CHKERR getInterface<BitRefManager>()->setElementsBitRefLevel(ents);
 
  340  CHKERR get_moab().add_entities(idm, ents);
 
 
  347                                        const int dim, 
const std::string name,
 
  348                                        const bool recursive) {
 
  350  *buildMoFEM &= 1 << 0;
 
  352  idm = get_finite_element_meshset(getBitFEId(name));
 
  354  CHKERR get_moab().get_entities_by_dimension(meshset, dim, ents, recursive);
 
  355  CHKERR getInterface<BitRefManager>()->setElementsBitRefLevel(ents);
 
  356  CHKERR get_moab().add_entities(idm, ents);
 
 
  361    const Range ents, 
const EntityType type, 
const std::string name) {
 
  363  *buildMoFEM &= 1 << 0;
 
  365  idm = get_finite_element_meshset(getBitFEId(name));
 
  366  CHKERR getInterface<BitRefManager>()->setElementsBitRefLevel(
 
  367      ents.subset_by_type(type));
 
  368  CHKERR get_moab().add_entities(idm, ents.subset_by_type(type));
 
 
  374                                        const std::string name) {
 
  376  *buildMoFEM &= 1 << 0;
 
  378  idm = get_finite_element_meshset(getBitFEId(name));
 
  379  CHKERR getInterface<BitRefManager>()->setElementsBitRefLevel(
 
  380      ents.subset_by_dimension(dim));
 
  381  CHKERR get_moab().add_entities(idm, ents.subset_by_dimension(dim));
 
 
  387                                                    const std::string &name,
 
  388                                                    EntityType type, 
int verb) {
 
 
  398    EntityType type, 
int verb) {
 
  400  CHKERR add_ents_to_finite_element_by_bit_ref(
bit, mask, name, type, verb);
 
 
  407    EntityType type, 
int verb) {
 
  412  *buildMoFEM &= 1 << 0;
 
  413  const BitFEId id = getBitFEId(name);
 
  414  const EntityHandle idm = get_finite_element_meshset(
id);
 
  416  auto &ref_MoFEMFiniteElement = refinedFiniteElements.get<
Ent_mi_tag>();
 
  421  for (; miit != hi_miit; miit++) {
 
  422    const auto &bit2 = miit->get()->getBitRefLevel();
 
  423    if ((bit2 & mask) != bit2)
 
  425    if ((bit2 & 
bit).any()) {
 
  427      CHKERR get_moab().add_entities(idm, &ent, 1);
 
  433      << 
"Finite element " << name << 
" added. Nb. of elements added " 
  434      << nb_add_fes << 
" out of " << std::distance(miit, hi_miit);
 
 
  442    const EntityHandle meshset, 
const std::string &name, 
const bool recursive) {
 
  444  *buildMoFEM &= 1 << 0;
 
  445  const BitFEId id = getBitFEId(name);
 
  446  const EntityHandle idm = get_finite_element_meshset(
id);
 
  447  if (recursive == 
false) {
 
  448    CHKERR get_moab().add_entities(idm, &meshset, 1);
 
  451    CHKERR get_moab().get_entities_by_type(meshset, MBENTITYSET, meshsets,
 
  453    CHKERR get_moab().add_entities(idm, meshsets);
 
 
  460                          const Range *ents_ptr, 
int verb) {
 
  467        << 
"Build Finite Elements " << fe->getName();
 
  473  std::array<BitFieldId, LAST> fe_fields = {fe.get()->getBitFieldIdRow(),
 
  474                                            fe.get()->getBitFieldIdCol(),
 
  475                                            fe.get()->getBitFieldIdData()};
 
  478  EntityHandle meshset = get_finite_element_meshset(fe.get()->getId());
 
  482  CHKERR get_moab().get_entities_by_handle(meshset, fe_ents, 
false);
 
  485    fe_ents = intersect(fe_ents, *ents_ptr);
 
  488  typedef std::vector<boost::weak_ptr<EntFiniteElement>> VecOfWeakFEPtrs;
 
  489  VecOfWeakFEPtrs processed_fes;
 
  490  processed_fes.reserve(fe_ents.size());
 
  492  int last_data_field_ents_view_size = 0;
 
  493  int last_row_field_ents_view_size = 0;
 
  494  int last_col_field_ents_view_size = 0;
 
  497  std::vector<EntityHandle> adj_ents;
 
  500  for (Range::const_pair_iterator peit = fe_ents.const_pair_begin();
 
  501       peit != fe_ents.const_pair_end(); peit++) {
 
  503    const auto first = peit->first;
 
  504    const auto second = peit->second;
 
  510        refinedFiniteElements.get<
Ent_mi_tag>().lower_bound(first);
 
  511    auto hi_ref_fe_miit =
 
  512        refinedFiniteElements.get<
Ent_mi_tag>().upper_bound(second);
 
  513    if (std::distance(ref_fe_miit, hi_ref_fe_miit) != (second - first + 1)) {
 
  514      MOFEM_LOG(
"SELF", Sev::noisy) << 
"Finite element " << fe->getName()
 
  515                                    << 
" not defined on all entities in " 
  516                                       "the meshset, missing entities";
 
  518          << 
"Missing entities: " << first << 
" - " << second;
 
  521    EntFiniteElement_multiIndex::iterator hint_p = entsFiniteElements.end();
 
  522    for (; ref_fe_miit != hi_ref_fe_miit; ref_fe_miit++) {
 
  525      hint_p = entsFiniteElements.emplace_hint(
 
  526          hint_p, boost::make_shared<EntFiniteElement>(*ref_fe_miit, fe));
 
  527      processed_fes.emplace_back(*hint_p);
 
  528      auto fe_raw_ptr = hint_p->get();
 
  531      bool row_as_data = 
false, col_as_row = 
false;
 
  532      if (fe_fields[
DATA] == fe_fields[
ROW])
 
  534      if (fe_fields[
ROW] == fe_fields[
COL])
 
  537      fe_raw_ptr->getDataFieldEntsPtr()->reserve(
 
  538          last_data_field_ents_view_size);
 
  541        fe_raw_ptr->getRowFieldEntsPtr() = fe_raw_ptr->getDataFieldEntsPtr();
 
  544        if (fe_raw_ptr->getRowFieldEntsPtr() ==
 
  545            fe_raw_ptr->getDataFieldEntsPtr())
 
  546          fe_raw_ptr->getRowFieldEntsPtr() =
 
  547              boost::make_shared<FieldEntity_vector_view>();
 
  548        fe_raw_ptr->getRowFieldEntsPtr()->reserve(
 
  549            last_row_field_ents_view_size);
 
  552      if (row_as_data && col_as_row) {
 
  553        fe_raw_ptr->getColFieldEntsPtr() = fe_raw_ptr->getDataFieldEntsPtr();
 
  554      } 
else if (col_as_row) {
 
  555        fe_raw_ptr->getColFieldEntsPtr() = fe_raw_ptr->getRowFieldEntsPtr();
 
  559            fe_raw_ptr->getColFieldEntsPtr() ==
 
  560                fe_raw_ptr->getRowFieldEntsPtr() ||
 
  561            fe_raw_ptr->getColFieldEntsPtr() ==
 
  562                fe_raw_ptr->getDataFieldEntsPtr()
 
  565          fe_raw_ptr->getColFieldEntsPtr() =
 
  566              boost::make_shared<FieldEntity_vector_view>();
 
  567        fe_raw_ptr->getColFieldEntsPtr()->reserve(
 
  568            last_col_field_ents_view_size);
 
  572      for (
unsigned int ii = 0; ii != 
BitFieldId().size(); ++ii) {
 
  577        for (
int ss = 0; ss < LAST; ss++) {
 
  578          id_common |= fe_fields[ss] & 
BitFieldId().set(ii);
 
  580        if (id_common.none())
 
  585        auto miit = fields_by_id.find(field_id);
 
  586        if (miit == fields_by_id.end())
 
  588        auto field_bit_number = (*miit)->getBitNumber();
 
  592        const std::string 
field_name = miit->get()->getName();
 
  593        const bool add_to_data = (field_id & fe_fields[
DATA]).any();
 
  594        const bool add_to_row = (field_id & fe_fields[
ROW]).any();
 
  595        const bool add_to_col = (field_id & fe_fields[
COL]).any();
 
  600        CHKERR fe_raw_ptr->getElementAdjacency(*miit, adj_ents);
 
  602        for (
auto ent : adj_ents) {
 
  609              fe_raw_ptr->getDataFieldEntsPtr()->emplace_back(*dof_it);
 
  611            if (add_to_row && !row_as_data) {
 
  612              fe_raw_ptr->getRowFieldEntsPtr()->emplace_back(*dof_it);
 
  614            if (add_to_col && !col_as_row) {
 
  615              fe_raw_ptr->getColFieldEntsPtr()->emplace_back(*dof_it);
 
  623      auto uid_comp = [](
const auto &
a, 
const auto &b) {
 
  624        return a.lock()->getLocalUniqueId() < b.lock()->getLocalUniqueId();
 
  630      sort(fe_raw_ptr->getDataFieldEntsPtr()->begin(),
 
  631           fe_raw_ptr->getDataFieldEntsPtr()->end(), uid_comp);
 
  632      last_data_field_ents_view_size =
 
  633          fe_raw_ptr->getDataFieldEntsPtr()->size();
 
  637        sort(fe_raw_ptr->getRowFieldEntsPtr()->begin(),
 
  638             fe_raw_ptr->getRowFieldEntsPtr()->end(), uid_comp);
 
  639        last_row_field_ents_view_size =
 
  640            fe_raw_ptr->getRowFieldEntsPtr()->size();
 
  645        sort(fe_raw_ptr->getColFieldEntsPtr()->begin(),
 
  646             fe_raw_ptr->getColFieldEntsPtr()->end(), uid_comp);
 
  647        last_col_field_ents_view_size =
 
  648            fe_raw_ptr->getColFieldEntsPtr()->size();
 
 
  663  for (
auto &fe : finiteElements)
 
  664    CHKERR buildFiniteElements(fe, NULL, verb);
 
  669    for (
auto &fe : finiteElements) {
 
  670      auto miit = fe_ents.lower_bound(
 
  674              get_id_for_max_type<MBENTITYSET>(), fe->getFEUId()));
 
  675      const auto count = std::distance(miit, hi_miit);
 
  677          << 
"Finite element " << fe->getName()
 
  678          << 
" added. Nb. of elements added " << count;
 
  682      for (
auto &field : fIelds) {
 
  683        auto rec = slg.open_record(keywords::severity = Sev::verbose);
 
  685          logging::record_ostream strm(rec);
 
  686          strm << 
"Field " << field->getName() << 
" on finite element: ";
 
  687          if ((field->getId() & fe->getBitFieldIdRow()).any())
 
  689          if ((field->getId() & fe->getBitFieldIdCol()).any())
 
  691          if ((field->getId() & fe->getBitFieldIdData()).any())
 
  694          slg.push_record(boost::move(rec));
 
  702  *buildMoFEM |= 1 << 1;
 
 
  713                                           const Range *
const ents_ptr,
 
  724  CHKERR buildFiniteElements(*fe_miit, ents_ptr, verb);
 
  728    auto miit = fe_ents.lower_bound(
 
  732            get_id_for_max_type<MBENTITYSET>(), (*fe_miit)->getFEUId()));
 
  733    const auto count = std::distance(miit, hi_miit);
 
  734    MOFEM_LOG(
"SYNC", Sev::inform) << 
"Finite element " << fe_name
 
  735                                   << 
" added. Nb. of elements added " << count;
 
  739  *buildMoFEM |= 1 << 1;
 
 
  748  if (!((*buildMoFEM) & BUILD_FIELD))
 
  750  if (!((*buildMoFEM) & BUILD_FE))
 
  752  for (
auto peit = ents.pair_begin(); peit != ents.pair_end(); ++peit) {
 
  753    auto fit = entsFiniteElements.get<
Ent_mi_tag>().lower_bound(peit->first);
 
  755        entsFiniteElements.get<
Ent_mi_tag>().upper_bound(peit->second);
 
  756    for (; fit != hi_fit; ++fit) {
 
  757      if ((*fit)->getBitFieldIdRow().none() &&
 
  758          (*fit)->getBitFieldIdCol().none() &&
 
  759          (*fit)->getBitFieldIdData().none())
 
  762      if ((*fit)->getBitFieldIdRow() != (*fit)->getBitFieldIdCol())
 
  764      if ((*fit)->getBitFieldIdRow() != (*fit)->getBitFieldIdData())
 
  767      auto hint = entFEAdjacencies.end();
 
  768      for (
auto e : *(*fit)->getRowFieldEntsPtr()) {
 
  769        hint = entFEAdjacencies.emplace_hint(hint, e.lock(), *fit);
 
  770        bool success = entFEAdjacencies.modify(hint, modify_row);
 
  773                  "modification unsuccessful");
 
  775      if ((*fit)->getBitFieldIdRow() != (*fit)->getBitFieldIdCol()) {
 
  777        if ((*fit)->getBitFieldIdCol() != (*fit)->getBitFieldIdData())
 
  780        auto hint = entFEAdjacencies.end();
 
  781        for (
auto e : *(*fit)->getColFieldEntsPtr()) {
 
  782          hint = entFEAdjacencies.emplace_hint(hint, e.lock(), *fit);
 
  783          bool success = entFEAdjacencies.modify(hint, modify_col);
 
  786                    "modification unsuccessful");
 
  789      if ((*fit)->getBitFieldIdRow() != (*fit)->getBitFieldIdData() ||
 
  790          (*fit)->getBitFieldIdCol() != (*fit)->getBitFieldIdData()) {
 
  793        auto hint = entFEAdjacencies.end();
 
  794        for (
auto &e : (*fit)->getDataFieldEnts()) {
 
  795          hint = entFEAdjacencies.emplace_hint(hint, e.lock(), *fit);
 
  796          bool success = entFEAdjacencies.modify(hint, modify_data);
 
  799                    "modification unsuccessful");
 
  807        << 
"Number of adjacencies " << entFEAdjacencies.size();
 
  811  *buildMoFEM |= 1 << 2;
 
 
  823  CHKERR build_adjacencies(ents, verb);
 
 
  836EntFiniteElement_multiIndex::index<Unique_mi_tag>::type::iterator
 
  847EntFiniteElement_multiIndex::index<Unique_mi_tag>::type::iterator
 
  853            get_id_for_max_type<MBENTITYSET>(), (*miit)->getFEUId()));
 
 
  860    const std::string &name)
 const {
 
  862  FiniteElement_multiIndex::index<FiniteElement_name_mi_tag>::type::iterator it;
 
  865    SETERRQ(mofemComm, 1, 
"finite element not found < %s >", name.c_str());
 
  870  CHKERR get_moab().get_number_entities_by_handle(meshset, num_entities);
 
  872  auto counts_fes = [&]() {
 
  873    return std::distance(get_fe_by_name_begin((*it)->getName()),
 
  874                         get_fe_by_name_end((*it)->getName()));
 
  877  if (counts_fes() != 
static_cast<size_t>(num_entities)) {
 
  879             "not equal number of entities in meshset and finite elements " 
  881             (*it)->getName().c_str());
 
 
  888  FiniteElement_multiIndex::index<FiniteElement_name_mi_tag>::type::iterator it;
 
  894    CHKERR get_moab().get_number_entities_by_handle(meshset, num_entities);
 
  896    auto counts_fes = [&]() {
 
  897      return std::distance(get_fe_by_name_begin((*it)->getName()),
 
  898                           get_fe_by_name_end((*it)->getName()));
 
  901    if (counts_fes() != 
static_cast<size_t>(num_entities)) {
 
  903               "not equal number of entities in meshset and finite elements " 
  905               (*it)->getName().c_str());
 
 
  913                                           const std::string &fe_name,
 
  917  auto p_miit = prb.find(problem_name);
 
  918  if (p_miit == prb.end())
 
  920             "No such problem like < %s >", problem_name.c_str());
 
  925        p_miit->numeredFiniteElementsPtr->get<
Unique_mi_tag>().lower_bound(
 
  927                0, (*fe_miit)->getFEUId()));
 
  929        p_miit->numeredFiniteElementsPtr->get<
Unique_mi_tag>().upper_bound(
 
  931                get_id_for_max_type<MBENTITYSET>(), (*fe_miit)->getFEUId()));
 
  933    if (miit != hi_miit) {
 
  934      std::vector<EntityHandle> ents;
 
  935      ents.reserve(std::distance(miit, hi_miit));
 
  936      for (; miit != hi_miit; ++miit)
 
  937        ents.push_back((*miit)->getEnt());
 
  938      int part = (*miit)->getPart();
 
  939      CHKERR get_moab().tag_clear_data(th_Part, &*ents.begin(), ents.size(),
 
  941      CHKERR get_moab().add_entities(meshset, &*ents.begin(), ents.size());
 
 
#define FECoreFunctionBegin
#define MOFEM_LOG_SYNCHRONISE(comm)
Synchronise "SYNC" channel.
MoFEMTypes
Those types control how functions respond on arguments, f.e. error handling.
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return()
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
@ MOFEM_OPERATION_UNSUCCESSFUL
@ MOFEM_DATA_INCONSISTENCY
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
#define CHKERR
Inline error check.
#define MoFEMFunctionBeginHot
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
#define THROW_MESSAGE(msg)
Throw MoFEM exception.
boost::function< MoFEMErrorCode(Interface &moab, const Field &field, const EntFiniteElement &fe, std::vector< EntityHandle > &adjacency)> ElementAdjacencyFunct
user adjacency function
MoFEMErrorCode 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
#define MOFEM_LOG(channel, severity)
Log.
static LoggerType & getLog(const std::string channel)
Get logger by channel.
PetscErrorCode MoFEMErrorCode
MoFEM/PETSc error code.
std::bitset< BITFEID_SIZE > BitFEId
Finite element Id.
std::bitset< BITFIELDID_SIZE > BitFieldId
Field Id.
std::bitset< BITREFLEVEL_SIZE > BitRefLevel
Bit structure attached to each entity identifying to what mesh entity is attached.
implementation of Data Operators for Forces and Sources
EntityHandle get_id_for_max_type()
EntityHandle get_id_for_min_type()
const EntityHandle no_handle
No entity handle is indicated by zero handle, i.e. root meshset.
constexpr auto field_name
MoFEMErrorCode get_finite_element_entities_by_dimension(const std::string name, int dim, Range &ents) const
get entities in the finite element by dimension
MoFEMErrorCode modify_finite_element_off_field_row(const std::string &fe_name, const std::string name_row)
unset field row which finite element use
MoFEMErrorCode check_number_of_ents_in_ents_finite_element() const
check data consistency in entsFiniteElements
MoFEMErrorCode get_problem_finite_elements_entities(const std::string name, const std::string &fe_name, const EntityHandle meshset)
add finite elements to the meshset
MoFEMErrorCode modify_finite_element_add_field_col(const std::string &fe_name, const std::string name_col)
set field col which finite element use
EntityHandle get_finite_element_meshset(const BitFEId id) const
EntFiniteElement_multiIndex::index< Unique_mi_tag >::type::iterator get_fe_by_name_end(const std::string &fe_name) const
get end iterator of finite elements of given name (instead you can use IT_GET_FES_BY_NAME_FOR_LOOP(MF...
MoFEMErrorCode modify_finite_element_add_field_data(const std::string &fe_name, const std::string name_filed)
set finite element field data
MoFEMErrorCode add_finite_element(const std::string &fe_name, enum MoFEMTypes bh=MF_EXCL, int verb=DEFAULT_VERBOSITY)
add finite element
MoFEMErrorCode add_ents_to_finite_element_by_MESHSET(const EntityHandle meshset, const std::string &name, const bool recursive=false)
add MESHSET element to finite element database given by name
EntFiniteElement_multiIndex::index< Unique_mi_tag >::type::iterator get_fe_by_name_begin(const std::string &fe_name) const
get begin iterator of finite elements of given name (instead you can use IT_GET_FES_BY_NAME_FOR_LOOP(...
std::string getBitFEIdName(const BitFEId id) const
Get field name.
MoFEMErrorCode get_finite_element_entities_by_handle(const std::string name, Range &ents) const
get entities in the finite element by handle
MoFEMErrorCode modify_finite_element_off_field_col(const std::string &fe_name, const std::string name_col)
unset field col which finite element use
MoFEMErrorCode modify_finite_element_off_field_data(const std::string &fe_name, const std::string name_filed)
unset finite element field data
MoFEMErrorCode modify_finite_element_add_field_row(const std::string &fe_name, const std::string name_row)
set field row which finite element use
bool check_finite_element(const std::string &name) const
Check if finite element is in database.
MoFEMErrorCode add_ents_to_finite_element_by_dim(const EntityHandle meshset, const int dim, const std::string name, const bool recursive=true)
add entities to finite element
MoFEMErrorCode build_finite_elements(int verb=DEFAULT_VERBOSITY)
Build finite elements.
BitFEId getBitFEId(const std::string &fe_name) const
Get field Id.
DEPRECATED MoFEMErrorCode add_ents_to_finite_element_EntType_by_bit_ref(const BitRefLevel &bit, const std::string &name, EntityType type, int verb=DEFAULT_VERBOSITY)
MoFEMErrorCode build_adjacencies(const Range &ents, int verb=DEFAULT_VERBOSITY)
build adjacencies
MoFEMErrorCode add_ents_to_finite_element_by_type(const EntityHandle meshset, const EntityType type, const std::string name, const bool recursive=true)
add entities to finite element
MoFEMErrorCode add_ents_to_finite_element_by_bit_ref(const BitRefLevel bit, const BitRefLevel mask, const std::string name, EntityType type, int verb=DEFAULT_VERBOSITY)
add TET entities from given refinement level to finite element database given by name
MoFEMErrorCode buildFiniteElements(const boost::shared_ptr< FiniteElement > &fe, const Range *ents_ptr=NULL, int verb=DEFAULT_VERBOSITY)
const FiniteElement * get_finite_element_structure(const std::string &name, enum MoFEMTypes bh=MF_EXCL) const
get finite element structure
MoFEMErrorCode list_finite_elements() const
list finite elements in database
MoFEMErrorCode modify_finite_element_adjacency_table(const std::string &fe_name, const EntityType type, ElementAdjacencyFunct function)
modify finite element table, only for advanced user
MoFEMErrorCode get_finite_element_entities_by_type(const std::string name, EntityType type, Range &ents) const
get entities in the finite element by type
UId getLocalUniqueIdCalculate() const
Generate UId for finite element entity.
UId getLocalUniqueIdCalculate()
Get the Local Unique Id Calculate object.
Finite element definition.