MoFEM::EssentialPreProc< MPCsType > Struct Reference

Type generating multipoint constraints. More...

#include <src/boundary_conditions/EssentialMPCsData.hpp>

Collaboration diagram for MoFEM::EssentialPreProc< MPCsType >:

Public Member Functions
	EssentialPreProc (MoFEM::Interface &m_field, boost::shared_ptr< FEMethod > fe_ptr, bool is_spatial_positions=false)
MoFEMErrorCode	operator() ()
MoFEMErrorCode	setMPCParentAdjacency ()

Static Public Member Functions
static MoFEMErrorCode	loadFileWithMPCs (Interface &m_field, const char *file_name, const char *options)
static MoFEMErrorCode	addLinksToPostProcMesh (Interface &m_field, moab::Interface &post_proc_mesh_interface, vector< std::string > field_names)

Protected Attributes
MoFEM::Interface &	mField
boost::weak_ptr< FEMethod >	fePtr
bool	isSpatialPositions

Detailed Description

Type generating multipoint constraints.

Definition at line 47 of file EssentialMPCsData.hpp.

Constructor & Destructor Documentation

EssentialPreProc()

MoFEM::EssentialPreProc< MPCsType >::EssentialPreProc	(	MoFEM::Interface &	m_field,
		boost::shared_ptr< FEMethod >	fe_ptr,
		bool	is_spatial_positions = false
	)

Definition at line 22 of file EssentialMPCsData.cpp.

    : mField(m_field), fePtr(fe_ptr), isSpatialPositions(is_spatial_positions) {
}

Member Function Documentation

addLinksToPostProcMesh()

MoFEMErrorCode MoFEM::EssentialPreProc< MPCsType >::addLinksToPostProcMesh ( Interface &  m_field, moab::Interface &  post_proc_mesh_interface, vector< std::string >  field_names  )

static

Definition at line 227 of file EssentialMPCsData.cpp.

                                   {
  MoFEMFunctionBegin;
 
  // for each link vertex find entity in mfield database
  // and add it to post_proc_mesh_interface
  // for each field give in field_names save data on appropriate tag
 
  std::array<double, 9> def;
  std::fill(def.begin(), def.end(), 0);
 
  auto get_tag = [&](const std::string name, size_t size) {
    Tag th;
    size = size <= 1 ? 1 : (size <= 3 ? 3 : 9);
    CHKERR post_proc_mesh_interface.tag_get_handle(
        name.c_str(), size, MB_TYPE_DOUBLE, th, MB_TAG_CREAT | MB_TAG_SPARSE,
        def.data());
    return th;
  };
 
  // get links from meshsets
  auto master_meshset_ptr =
      m_field.getInterface<MeshsetsManager>()->getCubitMeshsetPtr(
          std::regex((boost::format("%s(.*)") % "MPC_(.*)_LINKS").str()));
  Range links_ents;
  for (auto m : master_meshset_ptr) {
    Range ents;
    CHKERR m_field.get_moab().get_entities_by_type(m->getMeshset(), MBEDGE,
                                                           ents, true);
    links_ents.merge(ents);
  }
 
  if(links_ents.empty()) {
    MoFEMFunctionReturnHot(0);
  }
 
  // create edges in post_proc_mesh_interface
  std::vector<EntityHandle> p_links_edges(links_ents.size()); // post_proc edges
  std::vector<EntityHandle> o_nodes(links_ents.size() * 2); // original mesh nodes
  std::vector<EntityHandle> p_nodes(links_ents.size() * 2); // post_proc nodes
 
  int dd = 0;
  for (auto &link : links_ents) {
    Range verts;
    CHKERR m_field.get_moab().get_connectivity(&link, 1, verts, true);
    ublas::vector<EntityHandle> edge_conn(2);
    int gg = 0;
    for (auto &vert : verts) {
      VectorDouble coords(3);
      // fill o_nodes with vertices
      CHKERR m_field.get_moab().get_coords(&vert, 1, &coords[0]);
      CHKERR post_proc_mesh_interface.create_vertex(&coords[0], edge_conn[gg]);
      o_nodes[dd * 2 + gg] = vert;
      p_nodes[dd * 2 + gg] = edge_conn[gg];
      gg++;
    }
 
    CHKERR post_proc_mesh_interface.create_element(MBEDGE, &edge_conn[0], 2,
                                                   p_links_edges[dd++]);
  }
 
  const FieldEntity_multiIndex *field_ents;
  CHKERR m_field.get_field_ents(&field_ents);
  auto &field_ents_by_uid = field_ents->get<Unique_mi_tag>();
 
  for (auto field : field_names) {
    auto field_ptr = m_field.get_field_structure(field);
    const int nb_coefficients = field_ptr->getNbOfCoeffs();
    Tag tag = get_tag(field, nb_coefficients);
 
    int gg = 0;
    for (auto &node : o_nodes) {
      VectorDouble data(nb_coefficients);
      auto eit = field_ents_by_uid.find(FieldEntity::getLocalUniqueIdCalculate(
          m_field.get_field_bit_number(field), node));
      if (eit != field_ents_by_uid.end()) {
        noalias(data) = (*eit)->getEntFieldData();
      }
      auto ent = p_nodes[gg++];
      post_proc_mesh_interface.tag_set_data(tag, &ent, 1, &*data.begin());
    }
  }
 
  MoFEMFunctionReturn(0);
}

loadFileWithMPCs()

MoFEMErrorCode MoFEM::EssentialPreProc< MPCsType >::loadFileWithMPCs ( Interface &  m_field, const char *  file_name, const char *  options  )

static

Definition at line 28 of file EssentialMPCsData.cpp.

                                                                    {
  MoFEMFunctionBegin;
 
  auto simple = m_field.getInterface<Simple>();
  auto &moab = m_field.get_moab();
 
  // CHKERR moab.load_file(file_name, 0, options);
  CHKERR simple->loadFile("", file_name);
 
  constexpr bool is_debug = false;
 
  Range all_ents;
  CHKERR moab.get_entities_by_handle(0, all_ents, false);
 
  if (m_field.get_comm_size() == 1)
    MoFEMFunctionReturnHot(0);
 
  auto print_range_on_procs = [&](const Range &range, std::string name) {
    if(!is_debug) return;
    MOFEM_LOG("SYNC", Sev::inform)
        << name << " on proc [" << m_field.get_comm_rank() << "] : \n"
        << range;
    MOFEM_LOG_SYNCHRONISE(m_field.get_comm());
  };
 
  auto save_range_to_file = [&](const Range range, std::string name = "part") {
    if(!is_debug) return;
    int rr = m_field.get_comm_rank();
    ostringstream ss;
    ss << "out_" << name << "_" << rr << ".vtk";
    MOFEM_LOG("SELF", Sev::inform) << "Save debug part mesh " << ss.str();
    EntityHandle meshset;
    CHKERR moab.create_meshset(MESHSET_SET, meshset);
    CHKERR moab.add_entities(meshset, range);
    if (!range.empty())
      CHKERR moab.write_file(ss.str().c_str(), "VTK", "", &meshset, 1);
    CHKERR moab.delete_entities(&meshset, 1);
  };
 
  auto master_meshset_ptr =
      m_field.getInterface<MeshsetsManager>()->getCubitMeshsetPtr(
          std::regex((boost::format("%s(.*)") % "MPC_(.*)_LINKS").str()));
  Range mpc_ents, links_ents;
  for (auto m : master_meshset_ptr) {
 
    Range ents;
    CHKERR moab.get_entities_by_handle(m->getMeshset(), ents, true);
 
    links_ents.merge(ents);
    for (auto &link : links_ents) {
      Range verts;
      CHKERR moab.get_connectivity(&link, 1, verts, true);
      mpc_ents.merge(verts);
    }
  }
 
  if(mpc_ents.empty()) {
    MoFEMFunctionReturnHot(0);
  }
  
  save_range_to_file(all_ents, "all_ents");
  print_range_on_procs(mpc_ents, "mpc_ents");
  print_range_on_procs(links_ents, "links_ents");
 
  const int dim = simple->getDim();
 
  ParallelComm *pcomm =
      ParallelComm::get_pcomm(&moab, MYPCOMM_INDEX);
  if (pcomm == NULL)
    pcomm = new ParallelComm(&moab, PETSC_COMM_WORLD);
 
  Tag part_tag = pcomm->part_tag();
  Range tagged_sets, proc_ents, off_proc_ents, all_proc_ents;
 
  CHKERR moab.get_entities_by_type_and_tag(0, MBENTITYSET, &part_tag, NULL, 1,
                                           tagged_sets, moab::Interface::UNION);
  print_range_on_procs(tagged_sets, "tagged_sets");
  for (auto &mit : tagged_sets) {
    int part;
    CHKERR moab.tag_get_data(part_tag, &mit, 1, &part);
 
    if (part == m_field.get_comm_rank()) {
      CHKERR moab.get_entities_by_dimension(mit, dim, proc_ents, true);
      CHKERR moab.get_entities_by_handle(mit, all_proc_ents, true);
    } else {
      CHKERR moab.get_entities_by_handle(mit, off_proc_ents, true);
    }
  }
 
  print_range_on_procs(proc_ents, "proc_ents");
 
  save_range_to_file(proc_ents);
  save_range_to_file(off_proc_ents, "all_proc_ents");
  all_proc_ents = subtract(all_proc_ents, links_ents);
 
  Range all_tets;
  CHKERR moab.get_entities_by_handle(0, all_tets, true);
 
  Range tets_skin;
  Skinner skin(&moab);
  CHKERR skin.find_skin(0, all_tets.subset_by_dimension(dim), false, tets_skin);
 
 
  // Find the skin of entities on this processor
  Range proc_ents_skin[4]; // stores only entities shared with other processors
  CHKERR skin.find_skin(0, proc_ents, false, proc_ents_skin[dim - 1]);
 
 
  Range skin_verts, verts_to_add, edges_to_add;
  CHKERR moab.get_connectivity(proc_ents_skin[dim - 1],
                               skin_verts); // FIXME: check for 3D
  for (auto &link : links_ents) {
    Range verts;
    CHKERR moab.get_connectivity(&link, 1, verts);
    for (auto &vert : verts)
      if (skin_verts.find(vert) != skin_verts.end()) {
        edges_to_add.insert(link);
        verts_to_add.merge(verts);
      }
  }
 
  // Remove shared entities from the skin
  proc_ents_skin[dim - 1] = subtract(proc_ents_skin[dim - 1], tets_skin);
 
  // Get adjacent entities and their connectivity
 
  // FIXME: these are NOT (!) only shared entities (includes outside)
  if (dim > 2) {
    CHKERR moab.get_adjacencies(proc_ents_skin[2], 1, false, proc_ents_skin[1],
                                moab::Interface::UNION);
  }
  Range adj_ents;
  CHKERR moab.get_connectivity(proc_ents_skin[1], adj_ents, true);
  proc_ents_skin[0].merge(adj_ents);
 
  proc_ents_skin[1].merge(edges_to_add);
  proc_ents_skin[0].merge(verts_to_add);
 
  print_range_on_procs(edges_to_add, "edges_to_add");
  print_range_on_procs(verts_to_add, "verts_to_add");
 
  // do it as early as possible
  // it slows down all get_connectivity and get_adjacencies
 
  // Remove entities not part of this processor
  save_range_to_file(proc_ents, "proc_ents");
  save_range_to_file(off_proc_ents, "off_proc_ents");
 
  all_tets = off_proc_ents;
 
  if (edges_to_add.empty())
    all_tets.merge(links_ents);
 
  save_range_to_file(proc_ents_skin[0], "proc_ents_skin0");
  save_range_to_file(proc_ents_skin[1], "proc_ents_skin1");
 
  for (int dd = dim; dd >= 0; --dd) {
    all_tets = subtract(all_tets, proc_ents_skin[dd]);
  }
  print_range_on_procs(proc_ents, "proc_ents");
 
  Range meshsets;
  CHKERR moab.get_entities_by_type(0, MBENTITYSET, meshsets, true);
  for (auto m : meshsets) {
    CHKERR moab.remove_entities(m, all_tets);
  }
 
  print_range_on_procs(all_tets.subset_by_dimension(2), "all_tets to delete");
  save_range_to_file(all_tets.subset_by_dimension(2), "part_delete");
 
  // vertices do not need to be deleted
  for (int dd = dim; dd > 0; --dd) {
    CHKERR moab.delete_entities(all_tets.subset_by_dimension(dd));
  }
 
  // Update parallel status tag
  {
    Range all_ents;
    CHKERR moab.get_entities_by_handle(0, all_ents);
    std::vector<unsigned char> pstat_tag(all_ents.size(), 0);
    save_range_to_file(all_ents, "all_ents_part");
    CHKERR moab.tag_set_data(pcomm->pstatus_tag(), all_ents,
                             &*pstat_tag.begin());
  }
 
  Range all_ents_before;
  CHKERR moab.get_entities_by_handle(0, all_ents_before);
  save_range_to_file(all_ents_before, "all_ents_part_before");
 
  CHKERR pcomm->resolve_shared_ents(0, proc_ents, dim, -1, proc_ents_skin);
 
  Range all_ents_after;
  CHKERR moab.get_entities_by_handle(0, all_ents_after);
  save_range_to_file(all_ents_after, "all_ents_part_after");
 
  MoFEMFunctionReturn(0);
}

operator()()

MoFEMErrorCode MoFEM::EssentialPreProc< MPCsType >::operator()

(

)

Definition at line 314 of file EssentialMPCsData.cpp.

                                                      {
  MOFEM_LOG_CHANNEL("WORLD");
  MoFEMFunctionBegin;
 
  if (isSpatialPositions) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED, "not implemented");
  }
 
  MOFEM_LOG("BcMngWorld", Sev::warning)
      << "EssentialPreProc<MPCsType> has no effect here. ";
 
  MoFEMFunctionReturn(0);
}

setMPCParentAdjacency()

MoFEMErrorCode MoFEM::EssentialPreProc< MPCsType >::setMPCParentAdjacency

(

)

Member Data Documentation

fePtr

boost::weak_ptr<FEMethod> MoFEM::EssentialPreProc< MPCsType >::fePtr

protected

Definition at line 71 of file EssentialMPCsData.hpp.

isSpatialPositions

bool MoFEM::EssentialPreProc< MPCsType >::isSpatialPositions

protected

Definition at line 72 of file EssentialMPCsData.hpp.

mField

MoFEM::Interface& MoFEM::EssentialPreProc< MPCsType >::mField

protected

Definition at line 70 of file EssentialMPCsData.hpp.

---

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

• src/boundary_conditions/EssentialMPCsData.hpp
• src/boundary_conditions/impl/EssentialMPCsData.cpp