99  moab::Interface &moab = m_field.
get_moab();
 
  104          .lower_bound(boost::make_tuple(MBVERTEX, MBEDGE));
 
  107          .upper_bound(boost::make_tuple(MBVERTEX, MBEDGE));
 
  109  ref_parent_ents_view.insert(miit, hi_miit);
 
  111  Range edges = ents.subset_by_type(MBEDGE);
 
  114        << 
"ref level " << 
bit << 
" nb. edges to refine " << edges.size();
 
  117  std::array<std::vector<double>, 3> vert_coords;
 
  118  for (
auto &vc : vert_coords)
 
  119    vc.reserve(edges.size());
 
  121  std::vector<EntityHandle> parent_edge;
 
  122  parent_edge.reserve(edges.size());
 
  124  std::array<double, 9> coords;
 
  126      &coords[0], &coords[1], &coords[2]};
 
  128      &coords[3], &coords[4], &coords[5]};
 
  130      &coords[6], &coords[7], &coords[8]};
 
  135  for (
auto p_eit = edges.pair_begin(); p_eit != edges.pair_end(); ++p_eit) {
 
  136    auto miit_view = ref_parent_ents_view.lower_bound(p_eit->first);
 
  138    Range edge_having_parent_vertex;
 
  139    if (miit_view != ref_parent_ents_view.end()) {
 
  140      for (
auto hi_miit_view = ref_parent_ents_view.upper_bound(p_eit->second);
 
  141           miit_view != hi_miit_view; ++miit_view) {
 
  142        edge_having_parent_vertex.insert(edge_having_parent_vertex.end(),
 
  143                                         miit_view->get()->getParentEnt());
 
  144        add_bit.insert(add_bit.end(), miit_view->get()->getEnt());
 
  148    Range add_vertex_edges =
 
  149        subtract(
Range(p_eit->first, p_eit->second), edge_having_parent_vertex);
 
  151    for (
auto e : add_vertex_edges)
 
  152      parent_edge.emplace_back(e);
 
  154    for (
auto e : add_vertex_edges) {
 
  158      CHKERR moab.get_connectivity(e, conn, num_nodes, 
false);
 
  160        CHKERR moab.get_coords(conn, num_nodes, coords.data());
 
  163        for (
auto j : {0, 1, 2})
 
  164          vert_coords[
j].emplace_back(t_0(
j));
 
  166      } 
else if (num_nodes == 3) {
 
  167       for (
auto j : {0, 1, 2})
 
  168         vert_coords[
j].emplace_back(t_2(
j));
 
  171                "edge should have 2 or 3 nodes but have %d", num_nodes);
 
  178  if (!vert_coords[0].empty()) {
 
  179    ReadUtilIface *read_util;
 
  180    CHKERR moab.query_interface(read_util);
 
  181    int num_nodes = vert_coords[0].size();
 
  182    vector<double *> arrays_coord;
 
  183    CHKERR read_util->get_node_coords(3, num_nodes, 0, start_v, arrays_coord);
 
  184    Range verts(start_v, start_v + num_nodes - 1);
 
  185    for (
auto dd : {0, 1, 2}) {
 
  186      std::copy(vert_coords[dd].begin(), vert_coords[dd].end(),
 
  190                             &*parent_edge.begin());
 
 
  328                                          int verb, 
const bool debug) {
 
  331  moab::Interface &moab = m_field.
get_moab();
 
  334  ReadUtilIface *read_util;
 
  339  Range ents_to_set_bit;
 
  344  auto get_parent_ents_view = [&](
const auto type_child,
 
  345                                  const auto type_parent) {
 
  349        ref_ents.equal_range(boost::make_tuple(type_child, type_parent));
 
  353    using I = 
decltype(range.first);
 
  355    boost::function<
bool(
I it)> tester = [&](
I it) {
 
  356      return ((*it)->getBitRefLevel() & 
bit).any();
 
  360      ref_parent_ents_view.insert(f, s);
 
  366    return ref_parent_ents_view;
 
  369  auto ref_parent_ents_view = get_parent_ents_view(MBVERTEX, MBEDGE);
 
  371  auto tets = _tets.subset_by_type(MBTET);
 
  373  auto get_ele_parent_view = [&]() {
 
  374    auto &ref_ents = refined_finite_elements_ptr->get<
Ent_mi_tag>();
 
  376    for (
auto p = tets.pair_begin(); p != tets.pair_end(); ++p) {
 
  377      auto tmi = ref_ents.lower_bound(p->first);
 
  378      auto tme = ref_ents.upper_bound(p->second);
 
  379      ref_ele_parent_view.insert(tmi, tme);
 
  381    return ref_ele_parent_view;
 
  384  auto ref_ele_parent_view = get_ele_parent_view();
 
  386  std::vector<EntityHandle> parent_tets_refinded;
 
  387  std::vector<EntityHandle> vertices_of_created_tets;
 
  388  std::vector<BitRefEdges> parent_edges_bit_vec;
 
  389  std::vector<int> nb_new_tets_vec;
 
  390  std::vector<int> sub_type_vec;
 
  392  parent_tets_refinded.reserve(tets.size());
 
  393  vertices_of_created_tets.reserve(4 * tets.size());
 
  394  parent_edges_bit_vec.reserve(tets.size());
 
  395  nb_new_tets_vec.reserve(tets.size());
 
  396  sub_type_vec.reserve(tets.size());
 
  399  for (
auto tit : tets) {
 
  404    CHKERR moab.get_connectivity(tit, conn, num_nodes, 
true);
 
  409    int split_edges[] = {-1, -1, -1, -1, -1, -1};
 
  411    CHKERR set_edge_bits(moab, ref_parent_ents_view, tit, parent_edges_bit,
 
  412                         edge_new_nodes, split_edges);
 
  414    if (parent_edges_bit.count()) {
 
  418      std::copy(&conn[0], &conn[4], &_conn_[0]);
 
  422      std::fill(&new_tets_conns[0], &new_tets_conns[8 * 4], 
no_handle);
 
  424      int sub_type = -1, nb_new_tets = 0;
 
  425      switch (parent_edges_bit.count()) {
 
  428        tet_type_1(_conn_, split_edges[0], edge_new_nodes[split_edges[0]],
 
  434            tet_type_2(_conn_, split_edges, edge_new_nodes, new_tets_conns);
 
  435        if (sub_type & (4 | 8 | 16)) {
 
  438        } 
else if (sub_type == 1) {
 
  446            tet_type_3(_conn_, split_edges, edge_new_nodes, new_tets_conns);
 
  450        } 
else if (sub_type <= 7) {
 
  457            tet_type_4(_conn_, split_edges, edge_new_nodes, new_tets_conns);
 
  461        } 
else if (sub_type <= 7) {
 
  467        sub_type = 
tet_type_5(moab, _conn_, edge_new_nodes, new_tets_conns);
 
  472        tet_type_6(moab, _conn_, edge_new_nodes, new_tets_conns);
 
  480      auto &ref_ele_by_parent_and_ref_edges =
 
  483      auto it_by_ref_edges = ref_ele_by_parent_and_ref_edges.equal_range(
 
  484          boost::make_tuple(tit, parent_edges_bit.to_ulong()));
 
  486      std::vector<EntityHandle> ents_to_set_bit_vec;
 
  487      if (std::distance(it_by_ref_edges.first, it_by_ref_edges.second) ==
 
  488          static_cast<size_t>(nb_new_tets)) {
 
  489        ents_to_set_bit_vec.reserve(nb_new_tets);
 
  490        for (
int tt = 0; it_by_ref_edges.first != it_by_ref_edges.second;
 
  491             it_by_ref_edges.first++, tt++) {
 
  492          auto tet = (*it_by_ref_edges.first)->getEnt();
 
  493          ents_to_set_bit_vec.emplace_back(tet);
 
  497            auto ref_tet_it = refined_ents_ptr->find(tet);
 
  498            if (ref_tet_it == refined_ents_ptr->end()) {
 
  500                      "Tetrahedron should be in database");
 
  504        ents_to_set_bit.insert_list(ents_to_set_bit_vec.begin(),
 
  505                                    ents_to_set_bit_vec.end());
 
  511        parent_tets_refinded.emplace_back(tit);
 
  512        for (
int tt = 0; tt != nb_new_tets; ++tt) {
 
  513          for (
auto nn : {0, 1, 2, 3})
 
  514            vertices_of_created_tets.emplace_back(new_tets_conns[4 * tt + nn]);
 
  516        parent_edges_bit_vec.emplace_back(parent_edges_bit);
 
  517        nb_new_tets_vec.emplace_back(nb_new_tets);
 
  518        sub_type_vec.emplace_back(sub_type);
 
  523        RefEntity_multiIndex::iterator tit_miit;
 
  524        tit_miit = refined_ents_ptr->find(tit);
 
  525        if (tit_miit == refined_ents_ptr->end())
 
  527                  "can not find this tet");
 
  530      ents_to_set_bit.insert(tit);
 
  537  const int nb_new_tets = vertices_of_created_tets.size() / 4;
 
  538  read_util->get_element_connect(nb_new_tets, 4, MBTET, 0, start_e, conn_moab);
 
  539  std::copy(vertices_of_created_tets.begin(), vertices_of_created_tets.end(),
 
  541  CHKERR read_util->update_adjacencies(start_e, nb_new_tets, 4, conn_moab);
 
  542  ents_to_set_bit.insert(start_e, start_e + nb_new_tets - 1);
 
  546  for (
auto d : {1, 2}) {
 
  547    CHKERR moab.get_adjacencies(ents_to_set_bit, d, 
true, ents,
 
  548                                moab::Interface::UNION);
 
  554  for (
int idx = 0; idx != parent_tets_refinded.size(); ++idx) {
 
  557    const BitRefEdges &parent_edges_bit = parent_edges_bit_vec[idx];
 
  558    const int nb_new_tets = nb_new_tets_vec[idx];
 
  560    std::array<EntityHandle, 8> ref_tets;
 
  561    for (
int tt = 0; tt != nb_new_tets; ++tt, ++start_e)
 
  562      ref_tets[tt] = start_e;
 
  567                                 nb_new_tets, &parent_edges_bit);
 
  573          map_ref_nodes_by_edges;
 
  576      CHKERR moab.get_adjacencies(&tit, 1, 1, 
false, tit_edges);
 
  577      for (
auto edge : tit_edges) {
 
  578        auto eit = ref_parent_ents_view.find(edge);
 
  579        if (eit != ref_parent_ents_view.end()) {
 
  580          map_ref_nodes_by_edges[(*eit)->getParentEnt()] = eit->get()->getEnt();
 
  587      CHKERR moab.get_adjacencies(&tit, 1, 2, 
false, tit_faces);
 
  588      Range edges_nodes[6], faces_nodes[4];
 
  592      Range::iterator eit = tit_edges.begin();
 
  593      for (
int ee = 0; eit != tit_edges.end(); eit++, ee++) {
 
  594        CHKERR moab.get_connectivity(&*eit, 1, edges_nodes[ee], 
true);
 
  595        auto map_miit = map_ref_nodes_by_edges.find(*eit);
 
  596        if (map_miit != map_ref_nodes_by_edges.end()) {
 
  597          edges_nodes[ee].insert(map_miit->second);
 
  603      Range::iterator fit = tit_faces.begin();
 
  604      for (
int ff = 0; fit != tit_faces.end(); fit++, ff++) {
 
  605        CHKERR moab.get_connectivity(&*fit, 1, faces_nodes[ff], 
true);
 
  608        CHKERR moab.get_adjacencies(&*fit, 1, 1, 
false, fit_edges);
 
  609        for (Range::iterator eit2 = fit_edges.begin(); eit2 != fit_edges.end();
 
  611          auto map_miit = map_ref_nodes_by_edges.find(*eit2);
 
  612          if (map_miit != map_ref_nodes_by_edges.end()) {
 
  613            faces_nodes[ff].insert(map_miit->second);
 
  620      CHKERR moab.get_connectivity(&tit, 1, tet_nodes, 
true);
 
  621      for (std::map<EntityHandle, EntityHandle>::iterator map_miit =
 
  622               map_ref_nodes_by_edges.begin();
 
  623           map_miit != map_ref_nodes_by_edges.end(); map_miit++) {
 
  624        tet_nodes.insert(map_miit->second);
 
  628      CHKERR moab.get_adjacencies(ref_tets.data(), nb_new_tets, 1, 
false,
 
  629                                  ref_edges, moab::Interface::UNION);
 
  631      for (Range::iterator reit = ref_edges.begin(); reit != ref_edges.end();
 
  633        Range ref_edges_nodes;
 
  634        CHKERR moab.get_connectivity(&*reit, 1, ref_edges_nodes, 
true);
 
  638        for (; ee < 6; ee++) {
 
  642          if (intersect(edges_nodes[ee], ref_edges_nodes).size() == 2) {
 
  644            CHKERR set_parent(*reit, edge, refined_ents_ptr, 
cOre);
 
  652        for (; ff < 4; ff++) {
 
  655          if (intersect(faces_nodes[ff], ref_edges_nodes).size() == 2) {
 
  657            CHKERR set_parent(*reit, face, refined_ents_ptr, 
cOre);
 
  666        if (intersect(tet_nodes, ref_edges_nodes).size() == 2) {
 
  667          CHKERR set_parent(*reit, tit, refined_ents_ptr, 
cOre);
 
  674                "impossible refined edge");
 
  678      CHKERR moab.get_adjacencies(ref_tets.data(), nb_new_tets, 2, 
false,
 
  679                                  ref_faces, moab::Interface::UNION);
 
  680      Tag th_interface_side;
 
  681      const int def_side[] = {0};
 
  682      CHKERR moab.tag_get_handle(
"INTERFACE_SIDE", 1, MB_TYPE_INTEGER,
 
  684                                 MB_TAG_CREAT | MB_TAG_SPARSE, def_side);
 
  686      for (
auto rfit : ref_faces) {
 
  687        Range ref_faces_nodes;
 
  688        CHKERR moab.get_connectivity(&rfit, 1, ref_faces_nodes, 
true);
 
  691        for (; ff < 4; ff++) {
 
  693          if (intersect(faces_nodes[ff], ref_faces_nodes).size() == 3) {
 
  695            CHKERR set_parent(rfit, face, refined_ents_ptr, 
cOre);
 
  698            CHKERR moab.tag_get_data(th_interface_side, &face, 1, &side);
 
  699            CHKERR moab.tag_set_data(th_interface_side, &rfit, 1, &side);
 
  707        if (intersect(tet_nodes, ref_faces_nodes).size() == 3) {
 
  708          CHKERR set_parent(rfit, tit, refined_ents_ptr, 
cOre);
 
  712                "impossible refined face");
 
  717  CHKERR set_parent(refined_ents_ptr);
 
  719      ents_to_set_bit, 
bit, 
true, verb, &ents);
 
 
  726  moab::Interface &moab = m_field.
get_moab();
 
  736  ref_ele_parent_view.insert(
 
  737      refined_finite_elements_ptr->get<
Ent_mi_tag>().lower_bound(
 
  738          get_id_for_min_type<MBPRISM>()),
 
  739      refined_finite_elements_ptr->get<
Ent_mi_tag>().upper_bound(
 
  740          get_id_for_max_type<MBPRISM>()));
 
  741  auto &ref_ele_by_parent_and_ref_edges =
 
  745  auto &ref_ents_by_comp =
 
  748  ref_parent_ents_view.insert(
 
  749      ref_ents_by_comp.lower_bound(boost::make_tuple(MBVERTEX, MBEDGE)),
 
  750      ref_ents_by_comp.upper_bound(boost::make_tuple(MBVERTEX, MBEDGE)));
 
  752  CHKERR moab.get_entities_by_type(meshset, MBPRISM, prisms, 
false);
 
  753  Range::iterator pit = prisms.begin();
 
  754  for (; pit != prisms.end(); pit++) {
 
  755    auto miit_prism = refined_ents_ptr->get<
Ent_mi_tag>().find(*pit);
 
  756    if (miit_prism == refined_ents_ptr->end()) {
 
  758              "this prism is not in ref database");
 
  762          << 
"ref prism " << **miit_prism;
 
  767    CHKERR moab.get_connectivity(*pit, conn, num_nodes, 
true);
 
  768    assert(num_nodes == 6);
 
  771    for (
int ee = 0; ee < 3; ee++) {
 
  772      CHKERR moab.side_element(*pit, 1, ee, edges[ee]);
 
  774    for (
int ee = 6; ee < 9; ee++) {
 
  775      CHKERR moab.side_element(*pit, 1, ee, edges[ee - 3]);
 
  780    std::fill(&edge_nodes[0], &edge_nodes[6], 
no_handle);
 
  781    for (
int ee = 0; ee < 6; ee++) {
 
  782      RefEntity_multiIndex_view_by_hashed_parent_entity::iterator miit_view =
 
  783          ref_parent_ents_view.find(edges[ee]);
 
  784      if (miit_view != ref_parent_ents_view.end()) {
 
  785        if (((*miit_view)->getBitRefLevel() & 
bit).any()) {
 
  786          edge_nodes[ee] = (*miit_view)->getEnt();
 
  791    if (split_edges.count() == 0) {
 
  792      *(
const_cast<RefEntity *
>(miit_prism->get())->getBitRefLevelPtr()) |= 
bit;
 
  800      std::ostringstream ss;
 
  801      ss << 
"prism split edges " << split_edges << 
" count " 
  802         << split_edges.count() << std::endl;
 
  803      PetscPrintf(m_field.
get_comm(), 
"%s", ss.str().c_str());
 
  807    std::fill(&new_prism_conn[0], &new_prism_conn[4 * 6], 
no_handle);
 
  808    int nb_new_prisms = 0;
 
  809    switch (split_edges.count()) {
 
  825      std::ostringstream ss;
 
  826      ss << split_edges << 
" : [ " << conn[0] << 
" " << conn[1] << 
" " 
  827         << conn[2] << 
" " << conn[3] << 
" " << conn[4] << 
" " << conn[5]
 
  833    std::bitset<4> ref_prism_bit(0);
 
  834    auto it_by_ref_edges = ref_ele_by_parent_and_ref_edges.lower_bound(
 
  835        boost::make_tuple(*pit, split_edges.to_ulong()));
 
  836    auto hi_it_by_ref_edges = ref_ele_by_parent_and_ref_edges.upper_bound(
 
  837        boost::make_tuple(*pit, split_edges.to_ulong()));
 
  838    auto it_by_ref_edges2 = it_by_ref_edges;
 
  839    for (
int pp = 0; it_by_ref_edges2 != hi_it_by_ref_edges;
 
  840         it_by_ref_edges2++, pp++) {
 
  842      *(
const_cast<RefElement *
>(it_by_ref_edges2->get())
 
  843            ->getBitRefLevelPtr()) |= 
bit;
 
  844      ref_prism_bit.set(pp, 1);
 
  846        std::ostringstream ss;
 
  847        ss << 
"is refined " << *it_by_ref_edges2 << std::endl;
 
  848        PetscPrintf(m_field.
get_comm(), 
"%s", ss.str().c_str());
 
  851    if (it_by_ref_edges != hi_it_by_ref_edges) {
 
  852      if (ref_prism_bit.count() != (
unsigned int)nb_new_prisms)
 
  854                "data inconsistency");
 
  858      for (
int pp = 0; pp < nb_new_prisms; pp++) {
 
  860          std::ostringstream ss;
 
  861          ss << 
"ref prism " << ref_prism_bit << std::endl;
 
  862          PetscPrintf(m_field.
get_comm(), 
"%s", ss.str().c_str());
 
  864        if (!ref_prism_bit.test(pp)) {
 
  865          CHKERR moab.create_element(MBPRISM, &new_prism_conn[6 * pp], 6,
 
  868                                   &ref_prisms[pp], 1, &*pit);
 
  875                  ->insert(boost::shared_ptr<RefEntity>(
new RefEntity(
 
  877          std::pair<RefElement_multiIndex::iterator, bool> p_fe;
 
  881                    ->insert(boost::shared_ptr<RefElement>(
 
  886          ref_prism_bit.set(pp);
 
  889            std::ostringstream ss;
 
  890            ss << 
"add prism: " << **p_fe.first << std::endl;
 
  892              for (
int nn = 0; nn < 6; nn++) {
 
  893                ss << new_prism_conn[nn] << 
" ";
 
  897            PetscPrintf(m_field.
get_comm(), 
"%s", ss.str().c_str());
 
 
 1018                                          int verb, 
const bool debug) {
 
 1020  moab::Interface &moab = m_field.
get_moab();
 
 1023  ReadUtilIface *read_util;
 
 1027  auto get_parent_ents_view = [&](
const auto type_child,
 
 1028                                  const auto type_parent) {
 
 1032        ref_ents.equal_range(boost::make_tuple(type_child, type_parent));
 
 1036    using I = 
decltype(range.first);
 
 1038    boost::function<
bool(
I it)> tester = [&](
I it) {
 
 1039      return ((*it)->getBitRefLevel() & 
bit).any();
 
 1043      ref_parent_ents_view.insert(f, s);
 
 1049    return ref_parent_ents_view;
 
 1052  auto ref_parent_ents_view = get_parent_ents_view(MBVERTEX, MBEDGE);
 
 1054  auto tris = _tris.subset_by_type(MBTRI);
 
 1056  auto get_ele_parent_view = [&]() {
 
 1057    auto &ref_ents = refined_finite_elements_ptr->get<
Ent_mi_tag>();
 
 1059    for (
auto p = tris.pair_begin(); p != tris.pair_end(); ++p) {
 
 1060      auto tmi = ref_ents.lower_bound(p->first);
 
 1061      auto tme = ref_ents.upper_bound(p->second);
 
 1062      ref_ele_parent_view.insert(tmi, tme);
 
 1064    return ref_ele_parent_view;
 
 1067  auto ref_ele_parent_view = get_ele_parent_view();
 
 1069  Range ents_to_set_bit;
 
 1071  std::vector<EntityHandle> parent_tris_refined; 
 
 1072  std::vector<EntityHandle> vertices_of_created_tris;
 
 1073  std::vector<BitRefEdges> parent_edges_bit_vec;
 
 1074  std::vector<int> nb_new_tris_vec;
 
 1076  parent_tris_refined.reserve(tris.size());
 
 1077  vertices_of_created_tris.reserve(3 * tris.size());
 
 1078  parent_edges_bit_vec.reserve(tris.size());
 
 1079  nb_new_tris_vec.reserve(tris.size());
 
 1082  for (
auto tit : tris) {
 
 1087    CHKERR moab.get_connectivity(tit, conn, num_nodes, 
true);
 
 1092    int split_edges[] = {-1, -1, -1};
 
 1094    CHKERR set_edge_bits(moab, ref_parent_ents_view, tit, parent_edges_bit,
 
 1095                         edge_new_nodes, split_edges);
 
 1097    if (parent_edges_bit.count()) {
 
 1101      std::copy(&conn[0], &conn[3], &_conn_[0]);
 
 1105      std::fill(&new_tets_conns[0], &new_tets_conns[4 * 3], 
no_handle);
 
 1107      int nb_new_tris = 0;
 
 1108      switch (parent_edges_bit.count()) {
 
 1127      auto &ref_ele_by_parent_and_ref_edges =
 
 1130      auto it_by_ref_edges = ref_ele_by_parent_and_ref_edges.equal_range(
 
 1131          boost::make_tuple(tit, parent_edges_bit.to_ulong()));
 
 1133      std::vector<EntityHandle> ents_to_set_bit_vec;
 
 1134      if (std::distance(it_by_ref_edges.first, it_by_ref_edges.second) ==
 
 1135          static_cast<size_t>(nb_new_tris)) {
 
 1136        ents_to_set_bit_vec.reserve(nb_new_tris);
 
 1137        for (
int tt = 0; it_by_ref_edges.first != it_by_ref_edges.second;
 
 1138             it_by_ref_edges.first++, tt++) {
 
 1139          auto tet = (*it_by_ref_edges.first)->getEnt();
 
 1140          ents_to_set_bit_vec.emplace_back(tet);
 
 1144            auto ref_tet_it = refined_ents_ptr->find(tet);
 
 1145            if (ref_tet_it == refined_ents_ptr->end()) {
 
 1147                      "Tetrahedron should be in database");
 
 1151        ents_to_set_bit.insert_list(ents_to_set_bit_vec.begin(),
 
 1152                                    ents_to_set_bit_vec.end());
 
 1158        parent_tris_refined.emplace_back(tit);
 
 1159        for (
int tt = 0; tt != nb_new_tris; ++tt) {
 
 1160          for (
auto nn : {0, 1, 2})
 
 1161            vertices_of_created_tris.emplace_back(new_tets_conns[3 * tt + nn]);
 
 1163        parent_edges_bit_vec.emplace_back(parent_edges_bit);
 
 1164        nb_new_tris_vec.emplace_back(nb_new_tris);
 
 1169        RefEntity_multiIndex::iterator tit_miit;
 
 1170        tit_miit = refined_ents_ptr->find(tit);
 
 1171        if (tit_miit == refined_ents_ptr->end())
 
 1173                  "can not find this tet");
 
 1176      ents_to_set_bit.insert(tit);
 
 1180  const int nb_new_tris = vertices_of_created_tris.size() / 3;
 
 1188    CHKERR read_util->get_element_connect(nb_new_tris, 3, MBTRI, 0, start_e,
 
 1190    std::copy(vertices_of_created_tris.begin(), vertices_of_created_tris.end(),
 
 1192    CHKERR read_util->update_adjacencies(start_e, nb_new_tris, 3, conn_moab);
 
 1193    ents_to_set_bit.insert(start_e, start_e + nb_new_tris - 1);
 
 1197      CHKERR moab.add_entities(*meshset_ptr, ents_to_set_bit);
 
 1198      CHKERR moab.write_file(
"out_refinded_debug.vtk", 
"VTK", 
"",
 
 1199                             meshset_ptr->get_ptr(), 1);
 
 1205  for (
auto d : {1}) {
 
 1206    CHKERR moab.get_adjacencies(ents_to_set_bit, d, 
true, ents,
 
 1207                                moab::Interface::UNION);
 
 1213  for (
int idx = 0; idx != parent_tris_refined.size(); ++idx) {
 
 1215    const auto tit = parent_tris_refined[idx]; 
 
 1216    const auto &parent_edges_bit =
 
 1217        parent_edges_bit_vec[idx]; 
 
 1218    const auto nb_new_tris =
 
 1219        nb_new_tris_vec[idx]; 
 
 1222    std::array<EntityHandle, 4> ref_tris;
 
 1223    for (
int tt = 0; tt != nb_new_tris; ++tt, ++start_e)
 
 1224      ref_tris[tt] = start_e;
 
 1229                                 nb_new_tris, &parent_edges_bit);
 
 1235          map_ref_nodes_by_edges;
 
 1240      CHKERR moab.get_adjacencies(&tit, 1, 1, 
false, tit_edges);
 
 1241      for (
auto edge : tit_edges) {
 
 1242        auto eit = ref_parent_ents_view.find(edge);
 
 1243        if (eit != ref_parent_ents_view.end()) {
 
 1244          map_ref_nodes_by_edges[(*eit)->getParentEnt()] = eit->get()->getEnt();
 
 1248      Range edges_nodes[3];
 
 1252      Range::iterator eit = tit_edges.begin();
 
 1253      for (
int ee = 0; eit != tit_edges.end(); eit++, ee++) {
 
 1254        CHKERR moab.get_connectivity(&*eit, 1, edges_nodes[ee], 
true);
 
 1255        auto map_miit = map_ref_nodes_by_edges.find(*eit);
 
 1256        if (map_miit != map_ref_nodes_by_edges.end()) {
 
 1257          edges_nodes[ee].insert(map_miit->second);
 
 1264      CHKERR moab.get_connectivity(&tit, 1, tri_nodes, 
true);
 
 1265      for (
auto map_miit = map_ref_nodes_by_edges.begin();
 
 1266           map_miit != map_ref_nodes_by_edges.end(); map_miit++) {
 
 1267        tri_nodes.insert(map_miit->second);
 
 1272      CHKERR moab.get_adjacencies(ref_tris.data(), nb_new_tris, 1, 
false,
 
 1273                                  ref_edges, moab::Interface::UNION);
 
 1276      for (
auto reit = ref_edges.begin(); reit != ref_edges.end(); ++reit) {
 
 1277        Range ref_edges_nodes;
 
 1278        CHKERR moab.get_connectivity(&*reit, 1, ref_edges_nodes, 
true);
 
 1281        for (; ee < 3; ee++) {
 
 1285          if (intersect(edges_nodes[ee], ref_edges_nodes).size() == 2) {
 
 1287            CHKERR set_parent(*reit, edge, refined_ents_ptr, 
cOre);
 
 1296        if (intersect(tri_nodes, ref_edges_nodes).size() == 2) {
 
 1297          CHKERR set_parent(*reit, tit, refined_ents_ptr, 
cOre);
 
 1304                "impossible refined edge");
 
 1309  CHKERR set_parent(refined_ents_ptr);
 
 1311      ents_to_set_bit, 
bit, 
true, verb, &ents);