v0.14.0
Public Types | Public Member Functions | Public Attributes | Private Attributes | List of all members
MoFEM::ProblemsManager Struct Reference

Problem manager is used to build and partition problems. More...

#include <src/interfaces/ProblemsManager.hpp>

Inheritance diagram for MoFEM::ProblemsManager:
[legend]
Collaboration diagram for MoFEM::ProblemsManager:
[legend]

Public Types

enum  MarkOP { OR, AND }
 

Public Member Functions

MoFEMErrorCode query_interface (boost::typeindex::type_index type_index, UnknownInterface **iface) const
 
 ProblemsManager (const MoFEM::Core &core)
 
virtual ~ProblemsManager ()=default
 
MoFEMErrorCode getOptions ()
 
DEPRECATED MoFEMErrorCode partitionMesh (const Range &ents, const int dim, const int adj_dim, const int n_parts, Tag *th_vertex_weights=nullptr, Tag *th_edge_weights=nullptr, Tag *th_part_weights=nullptr, int verb=VERBOSE, const bool debug=false)
 Set partition tag to each finite element in the problem. More...
 
MoFEMErrorCode buildProblem (const std::string name, const bool square_matrix, int verb=VERBOSE)
 build problem data structures More...
 
MoFEMErrorCode buildProblem (Problem *problem_ptr, const bool square_matrix, int verb=VERBOSE)
 build problem data structures More...
 
MoFEMErrorCode buildProblemOnDistributedMesh (const std::string name, const bool square_matrix, int verb=VERBOSE)
 build problem data structures, assuming that mesh is distributed (collective) More...
 
MoFEMErrorCode buildProblemOnDistributedMesh (Problem *problem_ptr, const bool square_matrix=true, int verb=VERBOSE)
 build problem data structures, assuming that mesh is distributed (collective) More...
 
MoFEMErrorCode buildSubProblem (const std::string out_name, const std::vector< std::string > &fields_row, const std::vector< std::string > &fields_col, const std::string main_problem, const bool square_matrix=true, const map< std::string, boost::shared_ptr< Range >> *entityMapRow=nullptr, const map< std::string, boost::shared_ptr< Range >> *entityMapCol=nullptr, int verb=VERBOSE)
 build sub problem More...
 
MoFEMErrorCode buildComposedProblem (const std::string out_name, const std::vector< std::string > add_row_problems, const std::vector< std::string > add_col_problems, const bool square_matrix=true, int verb=1)
 build composite problem More...
 
MoFEMErrorCode inheritPartition (const std::string name, const std::string problem_for_rows, bool copy_rows, const std::string problem_for_cols, bool copy_cols, int verb=VERBOSE)
 build indexing and partition problem inheriting indexing and partitioning from two other problems More...
 
MoFEMErrorCode partitionSimpleProblem (const std::string name, int verb=VERBOSE)
 partition problem dofs More...
 
MoFEMErrorCode partitionProblem (const std::string name, int verb=VERBOSE)
 partition problem dofs (collective) More...
 
MoFEMErrorCode printPartitionedProblem (const Problem *problem_ptr, int verb=VERBOSE)
 
MoFEMErrorCode debugPartitionedProblem (const Problem *problem_ptr, int verb=VERBOSE)
 
MoFEMErrorCode partitionFiniteElements (const std::string name, bool part_from_moab=false, int low_proc=-1, int hi_proc=-1, int verb=VERBOSE)
 partition finite elements More...
 
MoFEMErrorCode partitionGhostDofs (const std::string name, int verb=VERBOSE)
 determine ghost nodes More...
 
MoFEMErrorCode partitionGhostDofsOnDistributedMesh (const std::string name, int verb=VERBOSE)
 determine ghost nodes on distributed meshes More...
 
MoFEMErrorCode getFEMeshset (const std::string prb_name, const std::string &fe_name, EntityHandle *meshset) const
 create add entities of finite element in the problem More...
 
MoFEMErrorCode getProblemElementsLayout (const std::string name, const std::string &fe_name, PetscLayout *layout) const
 Get layout of elements in the problem. More...
 
MoFEMErrorCode removeDofsOnEntities (const std::string problem_name, const std::string field_name, const Range ents, const int lo_coeff=0, const int hi_coeff=MAX_DOFS_ON_ENTITY, const int lo_order=0, const int hi_order=100, int verb=VERBOSE, const bool debug=false)
 Remove DOFs from problem. More...
 
MoFEMErrorCode removeDofsOnEntitiesNotDistributed (const std::string problem_name, const std::string field_name, const Range ents, const int lo_coeff=0, const int hi_coeff=MAX_DOFS_ON_ENTITY, const int lo_order=0, const int hi_order=100, int verb=VERBOSE, const bool debug=false)
 Remove DOFs from problem. More...
 
MoFEMErrorCode removeDofsOnEntities (const std::string problem_name, const std::string field_name, const BitRefLevel bit_ref_level, const BitRefLevel bit_ref_mask, Range *ents_ptr=nullptr, const int lo_coeff=0, const int hi_coeff=MAX_DOFS_ON_ENTITY, const int lo_order=0, const int hi_order=100, int verb=VERBOSE, const bool debug=false)
 Remove DOFs from problem by bit ref level. More...
 
MoFEMErrorCode removeDofsOnEntitiesNotDistributed (const std::string problem_name, const std::string field_name, const BitRefLevel bit_ref_level, const BitRefLevel bit_ref_mask, Range *ents_ptr=nullptr, const int lo_coeff=0, const int hi_coeff=MAX_DOFS_ON_ENTITY, const int lo_order=0, const int hi_order=100, int verb=VERBOSE, const bool debug=false)
 Remove DOFs from problem. More...
 
MoFEMErrorCode removeDofs (const std::string problem_name, RowColData rc, std::vector< boost::weak_ptr< NumeredDofEntity >> &vec_dof_view, int verb=VERBOSE, const bool debug=false)
 Remove DOFs from problem on broken space. More...
 
MoFEMErrorCode getSideDofsOnBrokenSpaceEntities (std::vector< boost::weak_ptr< NumeredDofEntity >> &vec_dof_view, const std::string problem_name, RowColData rc, const std::string field_name, const Range ents, int bridge_dim, const int lo_coeff=0, const int hi_coeff=MAX_DOFS_ON_ENTITY, const int lo_order=0, const int hi_order=100, int verb=VERBOSE, const bool debug=false) const
 Get DOFs on side entities for broke space. More...
 
MoFEMErrorCode markDofs (const std::string problem_name, RowColData rc, const enum MarkOP op, const Range ents, std::vector< unsigned char > &marker) const
 Create vector with marked indices. More...
 
DEPRECATED MoFEMErrorCode markDofs (const std::string problem_name, RowColData rc, const Range ents, std::vector< unsigned char > &marker) const
 
MoFEMErrorCode modifyMarkDofs (const std::string problem_name, RowColData rc, const std::string field_name, const int lo, const int hi, const enum MarkOP op, const unsigned char c, std::vector< unsigned char > &marker) const
 Mark DOFs. More...
 
MoFEMErrorCode markDofs (const std::string problem_name, RowColData rc, std::vector< boost::weak_ptr< NumeredDofEntity >> &vec_dof_view, const enum MarkOP op, std::vector< unsigned char > &marker) const
 Create vector with marked indices. More...
 
MoFEMErrorCode addFieldToEmptyFieldBlocks (const std::string problem_name, const std::string row_field, const std::string col_field) const
 add empty block to problem More...
 
- Public Member Functions inherited from MoFEM::UnknownInterface
template<class IFACE >
MoFEMErrorCode registerInterface (bool error_if_registration_failed=true)
 Register interface. More...
 
template<class IFACE >
MoFEMErrorCode getInterface (IFACE *&iface) const
 Get interface reference to pointer of interface. More...
 
template<class IFACE >
MoFEMErrorCode getInterface (IFACE **const iface) const
 Get interface pointer to pointer of interface. More...
 
template<class IFACE , typename boost::enable_if< boost::is_pointer< IFACE >, int >::type = 0>
IFACE getInterface () const
 Get interface pointer to pointer of interface. More...
 
template<class IFACE , typename boost::enable_if< boost::is_reference< IFACE >, int >::type = 0>
IFACE getInterface () const
 Get reference to interface. More...
 
template<class IFACE >
IFACE * getInterface () const
 Function returning pointer to interface. More...
 
virtual ~UnknownInterface ()=default
 

Public Attributes

MoFEM::Core & cOre
 
PetscBool buildProblemFromFields
 
PetscBool synchroniseProblemEntities
 DOFs in fields, not from DOFs on elements. More...
 

Private Attributes

PetscLogEvent MOFEM_EVENT_ProblemsManager
 

Additional Inherited Members

- Static Public Member Functions inherited from MoFEM::UnknownInterface
static MoFEMErrorCode getLibVersion (Version &version)
 Get library version. More...
 
static MoFEMErrorCode getFileVersion (moab::Interface &moab, Version &version)
 Get database major version. More...
 
static MoFEMErrorCode setFileVersion (moab::Interface &moab, Version version=Version(MoFEM_VERSION_MAJOR, MoFEM_VERSION_MINOR, MoFEM_VERSION_BUILD))
 Get database major version. More...
 
static MoFEMErrorCode getInterfaceVersion (Version &version)
 Get database major version. More...
 

Detailed Description

Problem manager is used to build and partition problems.

Examples
boundary_marker.cpp, build_large_problem.cpp, build_problems.cpp, child_and_parent.cpp, continuity_check_on_contact_prism_side_ele.cpp, continuity_check_on_skeleton_3d.cpp, EshelbianPlasticity.cpp, forces_and_sources_testing_edge_element.cpp, forces_and_sources_testing_flat_prism_element.cpp, forces_and_sources_testing_users_base.cpp, free_surface.cpp, hanging_node_approx.cpp, hcurl_divergence_operator_2d.cpp, heat_method.cpp, helmholtz.cpp, level_set.cpp, mesh_insert_interface_atom.cpp, mixed_poisson.cpp, nonlinear_dynamics.cpp, nonlinear_elastic.cpp, photon_diffusion.cpp, plate.cpp, prism_elements_from_surface.cpp, prism_polynomial_approximation.cpp, quad_polynomial_approximation.cpp, reaction_diffusion.cpp, Remodeling.cpp, remove_entities_from_problem.cpp, remove_entities_from_problem_not_partitioned.cpp, seepage.cpp, test_cache_on_entities.cpp, and thermo_elastic.cpp.

Definition at line 21 of file ProblemsManager.hpp.

Member Enumeration Documentation

◆ MarkOP

enum MoFEM::ProblemsManager::MarkOP
Enumerator
OR 
AND 

Definition at line 416 of file ProblemsManager.hpp.

416 { OR, AND };

Constructor & Destructor Documentation

◆ ProblemsManager()

MoFEM::ProblemsManager::ProblemsManager ( const MoFEM::Core &  core)

Definition at line 55 of file ProblemsManager.cpp.

56  : cOre(const_cast<MoFEM::Core &>(core)),
57  buildProblemFromFields(PETSC_FALSE),
58  synchroniseProblemEntities(PETSC_FALSE) {
59  PetscLogEventRegister("ProblemsManager", 0, &MOFEM_EVENT_ProblemsManager);
60 }

◆ ~ProblemsManager()

virtual MoFEM::ProblemsManager::~ProblemsManager ( )
virtualdefault

Member Function Documentation

◆ addFieldToEmptyFieldBlocks()

MoFEMErrorCode MoFEM::ProblemsManager::addFieldToEmptyFieldBlocks ( const std::string  problem_name,
const std::string  row_field,
const std::string  col_field 
) const

add empty block to problem

MatrixManager assumes that all blocks, i.e. all fields combinations are non zero. This is not always the case, to optimise code and reduce memory usage user can specify which blocks are empty.

Parameters
problem_nameproblem name
row_fieldrow filed name
col_fieldcol field name
Returns
MoFEMErrorCode

Definition at line 3681 of file ProblemsManager.cpp.

3683  {
3684 
3685  Interface &m_field = cOre;
3686  MoFEMFunctionBegin;
3687 
3688  const auto problem_ptr = m_field.get_problem(problem_name);
3689  auto get_field_id = [&](const std::string field_name) {
3690  return m_field.get_field_structure(field_name)->getId();
3691  };
3692  const auto row_id = get_field_id(row_field);
3693  const auto col_id = get_field_id(col_field);
3694 
3695  problem_ptr->addFieldToEmptyFieldBlocks(BlockFieldPair(row_id, col_id));
3696 
3697  MoFEMFunctionReturn(0);
3698 }

◆ debugPartitionedProblem()

MoFEMErrorCode MoFEM::ProblemsManager::debugPartitionedProblem ( const Problem *  problem_ptr,
int  verb = VERBOSE 
)

Definition at line 2084 of file ProblemsManager.cpp.

2084  {
2085  MoFEM::Interface &m_field = cOre;
2086  MoFEMFunctionBeginHot;
2087 
2088  auto save_ent = [](moab::Interface &moab, const std::string name,
2089  const EntityHandle ent) {
2090  MoFEMFunctionBegin;
2091  EntityHandle out_meshset;
2092  CHKERR moab.create_meshset(MESHSET_SET, out_meshset);
2093  CHKERR moab.add_entities(out_meshset, &ent, 1);
2094  CHKERR moab.write_file(name.c_str(), "VTK", "", &out_meshset, 1);
2095  CHKERR moab.delete_entities(&out_meshset, 1);
2096  MoFEMFunctionReturn(0);
2097  };
2098 
2099  if (debug > 0) {
2100 
2101  typedef NumeredDofEntity_multiIndex::index<Idx_mi_tag>::type
2102  NumeredDofEntitysByIdx;
2103  NumeredDofEntitysByIdx::iterator dit, hi_dit;
2104  const NumeredDofEntitysByIdx *numered_dofs_ptr[] = {
2105  &(problem_ptr->numeredRowDofsPtr->get<Idx_mi_tag>()),
2106  &(problem_ptr->numeredColDofsPtr->get<Idx_mi_tag>())};
2107 
2108  int *nbdof_ptr[] = {&problem_ptr->nbDofsRow, &problem_ptr->nbDofsCol};
2109  int *local_nbdof_ptr[] = {&problem_ptr->nbLocDofsRow,
2110  &problem_ptr->nbLocDofsCol};
2111 
2112  for (int ss = 0; ss < 2; ss++) {
2113 
2114  dit = numered_dofs_ptr[ss]->begin();
2115  hi_dit = numered_dofs_ptr[ss]->end();
2116  for (; dit != hi_dit; dit++) {
2117  if ((*dit)->getPart() == (unsigned int)m_field.get_comm_rank()) {
2118  if ((*dit)->getPetscLocalDofIdx() < 0) {
2119  std::ostringstream zz;
2120  zz << "rank " << m_field.get_comm_rank() << " " << **dit;
2121  SETERRQ2(PETSC_COMM_SELF, MOFEM_IMPOSSIBLE_CASE,
2122  "local dof index for %d (0-row, 1-col) not set, i.e. has "
2123  "negative value\n %s",
2124  ss, zz.str().c_str());
2125  }
2126  if ((*dit)->getPetscLocalDofIdx() >= *local_nbdof_ptr[ss]) {
2127  std::ostringstream zz;
2128  zz << "rank " << m_field.get_comm_rank() << " " << **dit;
2129  SETERRQ2(PETSC_COMM_SELF, MOFEM_IMPOSSIBLE_CASE,
2130  "local dofs for %d (0-row, 1-col) out of range\n %s", ss,
2131  zz.str().c_str());
2132  }
2133  } else {
2134  if ((*dit)->getPetscGlobalDofIdx() < 0) {
2135 
2136  const EntityHandle ent = (*dit)->getEnt();
2137  CHKERR save_ent(
2138  m_field.get_moab(),
2139  "debug_part" +
2140  boost::lexical_cast<std::string>(m_field.get_comm_rank()) +
2141  "_negative_global_index.vtk",
2142  ent);
2143 
2144  std::ostringstream zz;
2145  zz << "rank " << m_field.get_comm_rank() << " "
2146  << dit->get()->getBitRefLevel() << " " << **dit;
2147  SETERRQ2(PETSC_COMM_SELF, MOFEM_IMPOSSIBLE_CASE,
2148  "global dof index for %d (0-row, 1-col) row not set, i.e. "
2149  "has negative value\n %s",
2150  ss, zz.str().c_str());
2151  }
2152  if ((*dit)->getPetscGlobalDofIdx() >= *nbdof_ptr[ss]) {
2153  std::ostringstream zz;
2154  zz << "rank " << m_field.get_comm_rank() << " nb_dofs "
2155  << *nbdof_ptr[ss] << " " << **dit;
2156  SETERRQ2(PETSC_COMM_SELF, MOFEM_IMPOSSIBLE_CASE,
2157  "global dofs for %d (0-row, 1-col) out of range\n %s", ss,
2158  zz.str().c_str());
2159  }
2160  }
2161  }
2162  }
2163  }
2164  MoFEMFunctionReturnHot(0);
2165 }

◆ getOptions()

MoFEMErrorCode MoFEM::ProblemsManager::getOptions ( )

Definition at line 62 of file ProblemsManager.cpp.

62  {
63  MoFEM::Interface &m_field = cOre;
64  MoFEMFunctionBeginHot;
65  CHKERR PetscOptionsBegin(m_field.get_comm(), "", "Problem manager", "none");
66  {
67  CHKERR PetscOptionsBool(
68  "-problem_build_from_fields",
69  "Add DOFs to problem directly from fields not through DOFs on elements",
70  "", buildProblemFromFields, &buildProblemFromFields, NULL);
71  }
72  ierr = PetscOptionsEnd();
73  CHKERRG(ierr);
74  MoFEMFunctionReturnHot(0);
75 }

◆ getSideDofsOnBrokenSpaceEntities()

MoFEMErrorCode MoFEM::ProblemsManager::getSideDofsOnBrokenSpaceEntities ( std::vector< boost::weak_ptr< NumeredDofEntity >> &  vec_dof_view,
const std::string  problem_name,
RowColData  rc,
const std::string  field_name,
const Range  ents,
int  bridge_dim,
const int  lo_coeff = 0,
const int  hi_coeff = MAX_DOFS_ON_ENTITY,
const int  lo_order = 0,
const int  hi_order = 100,
int  verb = VERBOSE,
const bool  debug = false 
) const

Get DOFs on side entities for broke space.

Parameters
dof_view
problem_name
rcrow or column
field_name
entsside entities
bridge_dimdimension of bridge entity (dofs are on iterator by have associated side entity)
lo_coeff
hi_coeff
lo_order
hi_order
verb
debug
Returns
MoFEMErrorCode

Definition at line 2605 of file ProblemsManager.cpp.

2613  {
2614  MoFEM::Interface &m_field = cOre;
2615  ProblemManagerFunctionBegin;
2616 
2617  switch (rc) {
2618  case ROW:
2619  case COL:
2620  break;
2621  default:
2622  SETERRQ(m_field.get_comm(), MOFEM_INVALID_DATA, "invalid RowColData");
2623  break;
2624  }
2625 
2626  const Problem *prb_ptr;
2627  CHKERR m_field.get_problem(problem_name, &prb_ptr);
2628 
2629  decltype(prb_ptr->numeredRowDofsPtr) numered_dofs[2] = {
2630  prb_ptr->numeredRowDofsPtr, nullptr};
2631  if (prb_ptr->numeredRowDofsPtr != prb_ptr->numeredColDofsPtr)
2632  numered_dofs[1] = prb_ptr->numeredColDofsPtr;
2633 
2634  Range bridge_ents;
2635  CHKERR m_field.get_moab().get_adjacencies(
2636  ents, bridge_dim, false, bridge_ents, moab::Interface::UNION);
2637 
2638  auto &moab = m_field.get_moab();
2639  const auto bit_number = m_field.get_field_bit_number(field_name);
2640  const auto nb_coeffs =
2641  m_field.get_field_structure(field_name)->getNbOfCoeffs();
2642  const auto &side_dof_map = m_field.get_field_structure(field_name)
2643  ->getDofSideMap();
2644 
2645  using NumeredDofEntity_it_view_multiIndex = multi_index_container<
2646 
2647  NumeredDofEntity_multiIndex::iterator, indexed_by<sequenced<>>
2648 
2649  >;
2650  NumeredDofEntity_it_view_multiIndex dofs_it_view;
2651 
2652  for (auto pit = bridge_ents.const_pair_begin();
2653  pit != bridge_ents.const_pair_end(); ++pit) {
2654  auto lo = numered_dofs[rc]->get<Unique_mi_tag>().lower_bound(
2655  DofEntity::getLoFieldEntityUId(bit_number, pit->first));
2656  auto hi = numered_dofs[rc]->get<Unique_mi_tag>().upper_bound(
2657  DofEntity::getHiFieldEntityUId(bit_number, pit->second));
2658 
2659  auto bride_type = moab.type_from_handle(pit->first);
2660 
2661  for (; lo != hi; ++lo) {
2662  if ((*lo)->getDofCoeffIdx() >= lo_coeff &&
2663  (*lo)->getDofCoeffIdx() <= hi_coeff &&
2664  (*lo)->getDofOrder() >= lo_order &&
2665  (*lo)->getDofOrder() <= hi_order) {
2666  auto ent_dof_index = (*lo)->getEntDofIdx();
2667  auto side_it = side_dof_map.at(bride_type)
2668  .get<EntDofIdx_mi_tag>()
2669  .find(std::floor(static_cast<double>(ent_dof_index) /
2670  nb_coeffs));
2671  if (side_it !=
2672  side_dof_map.at(bride_type).get<EntDofIdx_mi_tag>().end()) {
2673  auto bridge_ent = (*lo)->getEnt();
2674  auto type = side_it->type;
2675  auto side = side_it->side;
2676  auto dim = CN::Dimension(type);
2677  EntityHandle side_ent = 0;
2678  CHKERR moab.side_element(bridge_ent, dim, side, side_ent);
2679  if (ents.find(side_ent) != ents.end()) {
2680  dofs_it_view.emplace_back(numered_dofs[rc]->project<0>(lo));
2681  }
2682  } else {
2683 #ifndef NDEBUG
2684  MOFEM_LOG("SELF", Sev::error)
2685  << *m_field.get_field_structure(field_name);
2686  MOFEM_LOG("SELF", Sev::error)
2687  << "side not found for entity " << CN::EntityTypeName(bride_type);
2688  MOFEM_LOG("SELF", Sev::error)
2689  << "ent_dof_index / nb_coeffs "
2690  << std::floor(static_cast<double>(ent_dof_index) / nb_coeffs);
2691  MOFEM_LOG("SELF", Sev::error)
2692  << "side_dof_map.size() " << side_dof_map.size();
2693 #endif // NDEBUG
2694  SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
2695  "side not found - you will get more information in debug");
2696  }
2697  }
2698  }
2699  }
2700 
2701  if (verb > QUIET) {
2702  for (auto &dof : dofs_it_view)
2703  MOFEM_LOG("SYNC", Sev::noisy) << **dof;
2704  MOFEM_LOG_SEVERITY_SYNC(m_field.get_comm(), Sev::noisy);
2705  }
2706 
2707  vec_dof_view.reserve(vec_dof_view.size() + dofs_it_view.size());
2708  for (auto dit : dofs_it_view)
2709  vec_dof_view.push_back(*dit);
2710 
2711  MoFEMFunctionReturn(0);
2712 }

◆ markDofs() [1/3]

MoFEMErrorCode MoFEM::ProblemsManager::markDofs ( const std::string  problem_name,
RowColData  rc,
const enum MarkOP  op,
const Range  ents,
std::vector< unsigned char > &  marker 
) const

Create vector with marked indices.

Vector with local DOFs marked by entities

Parameters
problem_name
row
ents
marker
Returns
MoFEMErrorCode
Examples
helmholtz.cpp, and test_cache_on_entities.cpp.

Definition at line 3548 of file ProblemsManager.cpp.

3550  {
3551 
3552  Interface &m_field = cOre;
3553  const Problem *problem_ptr;
3554  ProblemManagerFunctionBegin;
3555  CHKERR m_field.get_problem(problem_name, &problem_ptr);
3556  boost::shared_ptr<NumeredDofEntity_multiIndex> dofs;
3557  switch (rc) {
3558  case ROW:
3559  dofs = problem_ptr->getNumeredRowDofsPtr();
3560  break;
3561  case COL:
3562  dofs = problem_ptr->getNumeredColDofsPtr();
3563  default:
3564  SETERRQ(PETSC_COMM_SELF, MOFEM_IMPOSSIBLE_CASE, "Should be row or column");
3565  }
3566  marker.resize(dofs->size(), 0);
3567  std::vector<unsigned char> marker_tmp;
3568 
3569  switch (op) {
3570  case MarkOP::OR:
3571  for (auto p = ents.pair_begin(); p != ents.pair_end(); ++p) {
3572  auto lo = dofs->get<Ent_mi_tag>().lower_bound(p->first);
3573  auto hi = dofs->get<Ent_mi_tag>().upper_bound(p->second);
3574  for (; lo != hi; ++lo)
3575  marker[(*lo)->getPetscLocalDofIdx()] |= 1;
3576  }
3577  break;
3578  case MarkOP::AND:
3579  marker_tmp.resize(dofs->size(), 0);
3580  for (auto p = ents.pair_begin(); p != ents.pair_end(); ++p) {
3581  auto lo = dofs->get<Ent_mi_tag>().lower_bound(p->first);
3582  auto hi = dofs->get<Ent_mi_tag>().upper_bound(p->second);
3583  for (; lo != hi; ++lo)
3584  marker_tmp[(*lo)->getPetscLocalDofIdx()] = 1;
3585  }
3586  for (int i = 0; i != marker.size(); ++i) {
3587  marker[i] &= marker_tmp[i];
3588  }
3589  break;
3590  }
3591 
3592  MoFEMFunctionReturn(0);
3593 }

◆ markDofs() [2/3]

DEPRECATED MoFEMErrorCode MoFEM::ProblemsManager::markDofs ( const std::string  problem_name,
RowColData  rc,
const Range  ents,
std::vector< unsigned char > &  marker 
) const
inline
Deprecated:
use function with MarkOP

Definition at line 438 of file ProblemsManager.hpp.

439  {
440  return markDofs(problem_name, rc, MarkOP::OR, ents, marker);
441  }

◆ markDofs() [3/3]

MoFEMErrorCode MoFEM::ProblemsManager::markDofs ( const std::string  problem_name,
RowColData  rc,
std::vector< boost::weak_ptr< NumeredDofEntity >> &  vec_dof_view,
const enum MarkOP  op,
std::vector< unsigned char > &  marker 
) const

Create vector with marked indices.

Vector with local DOFs marked by entities

Parameters
problem_name
row
ents
marker
Returns
MoFEMErrorCode

Definition at line 3643 of file ProblemsManager.cpp.

3649  {
3650  Interface &m_field = cOre;
3651  ProblemManagerFunctionBegin;
3652 
3653  const Problem *problem_ptr;
3654  CHKERR m_field.get_problem(problem_name, &problem_ptr);
3655  boost::shared_ptr<NumeredDofEntity_multiIndex> dofs;
3656  switch (rc) {
3657  case ROW:
3658  dofs = problem_ptr->getNumeredRowDofsPtr();
3659  break;
3660  case COL:
3661  dofs = problem_ptr->getNumeredColDofsPtr();
3662  break;
3663  default:
3664  SETERRQ(PETSC_COMM_SELF, MOFEM_IMPOSSIBLE_CASE, "Should be row or column");
3665  }
3666  marker.resize(dofs->size(), 0);
3667 
3668  for (auto &dof : vec_dof_view) {
3669  if (auto dof_ptr = dof.lock()) {
3670  if (op == MarkOP::OR)
3671  marker[dof_ptr->getPetscLocalDofIdx()] |= 1;
3672  else
3673  marker[dof_ptr->getPetscLocalDofIdx()] &= 1;
3674  }
3675  }
3676 
3677  MoFEMFunctionReturn(0);
3678 }

◆ modifyMarkDofs()

MoFEMErrorCode MoFEM::ProblemsManager::modifyMarkDofs ( const std::string  problem_name,
RowColData  rc,
const std::string  field_name,
const int  lo,
const int  hi,
const enum MarkOP  op,
const unsigned char  c,
std::vector< unsigned char > &  marker 
) const

Mark DOFs.

Parameters
problem_name
rc
field_name
lo
hi
op
marker
Returns
MoFEMErrorCode

Definition at line 3595 of file ProblemsManager.cpp.

3598  {
3599 
3600  Interface &m_field = cOre;
3601  const Problem *problem_ptr;
3602  ProblemManagerFunctionBegin;
3603  CHKERR m_field.get_problem(problem_name, &problem_ptr);
3604  boost::shared_ptr<NumeredDofEntity_multiIndex> dofs;
3605  switch (rc) {
3606  case ROW:
3607  dofs = problem_ptr->getNumeredRowDofsPtr();
3608  break;
3609  case COL:
3610  dofs = problem_ptr->getNumeredColDofsPtr();
3611  default:
3612  SETERRQ(PETSC_COMM_SELF, MOFEM_IMPOSSIBLE_CASE, "Should be row or column");
3613  }
3614  marker.resize(dofs->size(), 0);
3615 
3616  auto dof_lo = dofs->get<Unique_mi_tag>().lower_bound(
3617  FieldEntity::getLoBitNumberUId(m_field.get_field_bit_number(field_name)));
3618  auto dof_hi = dofs->get<Unique_mi_tag>().upper_bound(
3619  FieldEntity::getHiBitNumberUId(m_field.get_field_bit_number(field_name)));
3620 
3621  auto marker_ref = [marker](auto &it) -> unsigned int & {
3622  return marker[(*it)->getPetscLocalDofIdx()];
3623  };
3624 
3625  switch (op) {
3626  case MarkOP::OR:
3627  for (; dof_lo != dof_hi; ++dof_lo)
3628  if ((*dof_lo)->getDofCoeffIdx() >= lo &&
3629  (*dof_lo)->getDofCoeffIdx() <= hi)
3630  marker[(*dof_lo)->getPetscLocalDofIdx()] |= c;
3631  break;
3632  case MarkOP::AND:
3633  for (; dof_lo != dof_hi; ++dof_lo)
3634  if ((*dof_lo)->getDofCoeffIdx() >= lo &&
3635  (*dof_lo)->getDofCoeffIdx() <= hi)
3636  marker[(*dof_lo)->getPetscLocalDofIdx()] &= c;
3637  break;
3638  }
3639 
3640  MoFEMFunctionReturn(0);
3641 }

◆ printPartitionedProblem()

MoFEMErrorCode MoFEM::ProblemsManager::printPartitionedProblem ( const Problem *  problem_ptr,
int  verb = VERBOSE 
)

Definition at line 2065 of file ProblemsManager.cpp.

2065  {
2066  MoFEM::Interface &m_field = cOre;
2067  ProblemManagerFunctionBegin;
2068 
2069  if (verb > QUIET) {
2070 
2071  MOFEM_LOG("SYNC", Sev::inform)
2072  << problem_ptr->getName() << " Nb. local dof "
2073  << problem_ptr->getNbLocalDofsRow() << " by "
2074  << problem_ptr->getNbLocalDofsCol() << " nb global dofs "
2075  << problem_ptr->getNbDofsRow() << " by " << problem_ptr->getNbDofsCol();
2076 
2077  MOFEM_LOG_SYNCHRONISE(m_field.get_comm())
2078  }
2079 
2080  MoFEMFunctionReturn(0);
2081 }

◆ query_interface()

MoFEMErrorCode MoFEM::ProblemsManager::query_interface ( boost::typeindex::type_index  type_index,
UnknownInterface **  iface 
) const
virtual

Implements MoFEM::UnknownInterface.

Definition at line 49 of file ProblemsManager.cpp.

50  {
51  *iface = const_cast<ProblemsManager *>(this);
52  return 0;
53 }

◆ removeDofs()

MoFEMErrorCode MoFEM::ProblemsManager::removeDofs ( const std::string  problem_name,
RowColData  rc,
std::vector< boost::weak_ptr< NumeredDofEntity >> &  vec_dof_view,
int  verb = VERBOSE,
const bool  debug = false 
)

Remove DOFs from problem on broken space.

Parameters
problem_name
field_name
ents
lo_coeff
hi_coeff
lo_order
hi_order
verb
debug
Returns
MoFEMErrorCode

Definition at line 2714 of file ProblemsManager.cpp.

2717  {
2718 
2719  MoFEM::Interface &m_field = cOre;
2720  ProblemManagerFunctionBegin;
2721 
2722  switch (rc) {
2723  case ROW:
2724  case COL:
2725  break;
2726  default:
2727  SETERRQ(PETSC_COMM_SELF, MOFEM_IMPOSSIBLE_CASE, "Should be row or column");
2728  }
2729 
2730  const Problem *prb_ptr;
2731  CHKERR m_field.get_problem(problem_name, &prb_ptr);
2732 
2733  decltype(prb_ptr->numeredRowDofsPtr) numered_dofs[2] = {
2734  prb_ptr->numeredRowDofsPtr, nullptr};
2735  if (prb_ptr->numeredRowDofsPtr != prb_ptr->numeredColDofsPtr)
2736  numered_dofs[1] = prb_ptr->numeredColDofsPtr;
2737 
2738  int *nbdof_ptr[] = {&prb_ptr->nbDofsRow, &prb_ptr->nbDofsCol};
2739  int *local_nbdof_ptr[] = {&prb_ptr->nbLocDofsRow, &prb_ptr->nbLocDofsCol};
2740  int *ghost_nbdof_ptr[] = {&prb_ptr->nbGhostDofsRow, &prb_ptr->nbGhostDofsCol};
2741 
2742  const int nb_init_row_dofs = prb_ptr->getNbDofsRow();
2743  const int nb_init_col_dofs = prb_ptr->getNbDofsCol();
2744  const int nb_init_loc_row_dofs = prb_ptr->getNbLocalDofsRow();
2745  const int nb_init_ghost_row_dofs = prb_ptr->getNbGhostDofsRow();
2746  const int nb_init_ghost_col_dofs = prb_ptr->getNbGhostDofsCol();
2747 
2748  if (numered_dofs[rc]) {
2749 
2750  if (verb >= NOISY)
2751  MOFEM_LOG_C("SYNC", Sev::noisy,
2752  "Number of DOFs in multi-index %d and to delete %d\n",
2753  numered_dofs[rc]->size(), vec_dof_view.size());
2754 
2755  // erase dofs from problem
2756  for (auto weak_dit : vec_dof_view)
2757  if (auto dit = weak_dit.lock()) {
2758  numered_dofs[rc]->erase(dit->getLocalUniqueId());
2759  }
2760 
2761  if (verb >= NOISY)
2762  MOFEM_LOG_C("SYNC", Sev::noisy,
2763  "Number of DOFs in multi-index after delete %d\n",
2764  numered_dofs[rc]->size());
2765 
2766  // get current number of ghost dofs
2767  int nb_local_dofs = 0;
2768  int nb_ghost_dofs = 0;
2769  for (auto dit = numered_dofs[rc]->get<PetscLocalIdx_mi_tag>().begin();
2770  dit != numered_dofs[rc]->get<PetscLocalIdx_mi_tag>().end(); ++dit) {
2771  if ((*dit)->getPetscLocalDofIdx() >= 0 &&
2772  (*dit)->getPetscLocalDofIdx() < *(local_nbdof_ptr[rc]))
2773  ++nb_local_dofs;
2774  else if ((*dit)->getPetscLocalDofIdx() >= *(local_nbdof_ptr[rc]))
2775  ++nb_ghost_dofs;
2776  else
2777  SETERRQ1(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
2778  "Impossible case. You could run problem on no distributed "
2779  "mesh. That is not implemented. Dof local index is %d",
2780  (*dit)->getPetscLocalDofIdx());
2781  }
2782 
2783  // get indices
2784  auto get_indices_by_tag = [&](auto tag, auto &indices, bool only_local) {
2785  const int nb_dofs = numered_dofs[rc]->size();
2786  indices.clear();
2787  indices.reserve(nb_dofs);
2788  for (auto dit = numered_dofs[rc]->get<decltype(tag)>().begin();
2789  dit != numered_dofs[rc]->get<decltype(tag)>().end(); ++dit) {
2790  bool add = true;
2791  if (only_local) {
2792  if ((*dit)->getPetscLocalDofIdx() < 0 ||
2793  (*dit)->getPetscLocalDofIdx() >= *(local_nbdof_ptr[rc])) {
2794  add = false;
2795  }
2796  }
2797  if (add)
2798  indices.push_back(decltype(tag)::get_index(dit));
2799  }
2800  };
2801 
2802  auto get_indices_by_uid = [&](auto tag, auto &indices) {
2803  const int nb_dofs = numered_dofs[rc]->size();
2804  indices.clear();
2805  indices.reserve(nb_dofs);
2806  for (auto dit = numered_dofs[rc]->begin(); dit != numered_dofs[rc]->end();
2807  ++dit)
2808  indices.push_back(decltype(tag)::get_index(dit));
2809  };
2810 
2811  auto get_sub_ao = [&](auto sub_data) {
2812  if (rc == 0) {
2813  return sub_data->getSmartRowMap();
2814  } else {
2815  return sub_data->getSmartColMap();
2816  }
2817  };
2818 
2819  auto set_sub_is_and_ao = [&rc, &prb_ptr](auto sub_data, auto is, auto ao) {
2820  if (rc == ROW) {
2821  sub_data->rowIs = is;
2822  sub_data->rowMap = ao;
2823  sub_data->colIs = is; // if square problem col is equal to row
2824  sub_data->colMap = ao;
2825  } else {
2826  sub_data->colIs = is;
2827  sub_data->colMap = ao;
2828  }
2829  };
2830 
2831  auto apply_symmetry = [&rc, &prb_ptr](auto sub_data) {
2832  if (rc == ROW) {
2833  if (prb_ptr->numeredRowDofsPtr == prb_ptr->numeredColDofsPtr) {
2834  sub_data->colIs = sub_data->getSmartRowIs();
2835  sub_data->colMap = sub_data->getSmartRowMap();
2836  }
2837  }
2838  };
2839 
2840  auto concatenate_dofs = [&](auto tag, auto &indices,
2841  const auto local_only) {
2842  MoFEMFunctionBegin;
2843  get_indices_by_tag(tag, indices, local_only);
2844 
2845  SmartPetscObj<AO> ao;
2846  // Create AO from app indices (i.e. old), to pestc indices (new after
2847  // remove)
2848  if (local_only)
2849  ao = createAOMapping(m_field.get_comm(), indices.size(),
2850  &*indices.begin(), PETSC_NULL);
2851  else
2852  ao = createAOMapping(PETSC_COMM_SELF, indices.size(), &*indices.begin(),
2853  PETSC_NULL);
2854 
2855  // Set mapping to sub dm data
2856  if (local_only) {
2857  if (auto sub_data = prb_ptr->getSubData()) {
2858  // create is and then map it to main problem of sub-problem
2859  auto sub_is = createISGeneral(m_field.get_comm(), indices.size(),
2860  &*indices.begin(), PETSC_COPY_VALUES);
2861  // get old app, i.e. oroginal befor sub indices, and ao, from app,
2862  // to petsc sub indices.
2863  auto sub_ao = get_sub_ao(sub_data);
2864  CHKERR AOPetscToApplicationIS(sub_ao, sub_is);
2865  sub_ao = createAOMappingIS(sub_is, PETSC_NULL);
2866  // set new sub ao
2867  set_sub_is_and_ao(sub_data, sub_is, sub_ao);
2868  apply_symmetry(sub_data);
2869  } else {
2870  // create sub data
2871  prb_ptr->getSubData() = boost::make_shared<Problem::SubProblemData>();
2872  auto sub_is = createISGeneral(m_field.get_comm(), indices.size(),
2873  &*indices.begin(), PETSC_COPY_VALUES);
2874  // set sub is ao
2875  set_sub_is_and_ao(prb_ptr->getSubData(), sub_is, ao);
2876  apply_symmetry(prb_ptr->getSubData());
2877  }
2878  }
2879 
2880  get_indices_by_uid(tag, indices);
2881  CHKERR AOApplicationToPetsc(ao, indices.size(), &*indices.begin());
2882 
2883  MoFEMFunctionReturn(0);
2884  };
2885 
2886  // set indices index
2887  auto set_concatenated_indices = [&]() {
2888  std::vector<int> global_indices;
2889  std::vector<int> local_indices;
2890  MoFEMFunctionBegin;
2891  CHKERR concatenate_dofs(PetscGlobalIdx_mi_tag(), global_indices, true);
2892  CHKERR concatenate_dofs(PetscLocalIdx_mi_tag(), local_indices, false);
2893  auto gi = global_indices.begin();
2894  auto li = local_indices.begin();
2895  for (auto dit = numered_dofs[rc]->begin(); dit != numered_dofs[rc]->end();
2896  ++dit) {
2897  auto mod = NumeredDofEntity_part_and_all_indices_change(
2898  (*dit)->getPart(), (*dit)->getDofIdx(), *gi, *li);
2899  bool success = numered_dofs[rc]->modify(dit, mod);
2900  if (!success)
2901  SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
2902  "can not set negative indices");
2903  ++gi;
2904  ++li;
2905  }
2906  MoFEMFunctionReturn(0);
2907  };
2908  CHKERR set_concatenated_indices();
2909 
2910  MPI_Allreduce(&nb_local_dofs, nbdof_ptr[rc], 1, MPI_INT, MPI_SUM,
2911  m_field.get_comm());
2912  *(local_nbdof_ptr[rc]) = nb_local_dofs;
2913  *(ghost_nbdof_ptr[rc]) = nb_ghost_dofs;
2914 
2915  if (debug)
2916  for (auto dof : (*numered_dofs[rc])) {
2917  if (dof->getPetscGlobalDofIdx() < 0) {
2918  SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
2919  "Negative global idx");
2920  }
2921  if (dof->getPetscLocalDofIdx() < 0) {
2922  SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
2923  "Negative local idx");
2924  }
2925  }
2926 
2927  } else {
2928 
2929  *(nbdof_ptr[1]) = *(nbdof_ptr[0]);
2930  *(local_nbdof_ptr[1]) = *(local_nbdof_ptr[0]);
2931  *(ghost_nbdof_ptr[1]) = *(ghost_nbdof_ptr[0]);
2932  }
2933 
2934  if (verb > QUIET) {
2935  MOFEM_LOG_C(
2936  "WORLD", Sev::inform,
2937  "Removed DOFs from problem %s dofs [%d / %d (before %d / %d) global]",
2938  prb_ptr->getName().c_str(), prb_ptr->getNbDofsRow(),
2939  prb_ptr->getNbDofsCol(), nb_init_row_dofs, nb_init_col_dofs);
2940  MOFEM_LOG_C("SYNC", Sev::verbose,
2941  "Removed DOFs from problem %s dofs [ %d / %d "
2942  "(before %d / %d) local, %d / %d (before %d / %d)]",
2943  prb_ptr->getName().c_str(), prb_ptr->getNbLocalDofsRow(),
2944  prb_ptr->getNbLocalDofsCol(), nb_init_loc_row_dofs,
2945  nb_init_loc_row_dofs, prb_ptr->getNbGhostDofsRow(),
2946  prb_ptr->getNbGhostDofsCol(), nb_init_ghost_row_dofs,
2947  nb_init_ghost_col_dofs);
2948  MOFEM_LOG_SEVERITY_SYNC(m_field.get_comm(), Sev::verbose);
2949  }
2950 
2951  MoFEMFunctionReturn(0);
2952 }

◆ removeDofsOnEntitiesNotDistributed() [1/2]

MoFEMErrorCode MoFEM::ProblemsManager::removeDofsOnEntitiesNotDistributed ( const std::string  problem_name,
const std::string  field_name,
const BitRefLevel  bit_ref_level,
const BitRefLevel  bit_ref_mask,
Range *  ents_ptr = nullptr,
const int  lo_coeff = 0,
const int  hi_coeff = MAX_DOFS_ON_ENTITY,
const int  lo_order = 0,
const int  hi_order = 100,
int  verb = VERBOSE,
const bool  debug = false 
)

Remove DOFs from problem.

Remove DOFs from problem which are on entities on the given range and given field name. On the finite element level, DOFs can be still accessed however local PETSc indices and global PETSc indices are marked with the index -1.

Note
If the index is marked -1 it is not assembled and dropped by VecSetValues and MatSetValues.
Todo:
Not yet implemented update for AO maps and IS ranges if removed entities in composite problem or sub-problem
Parameters
problem_namename of the problem
field_namename of the field
entsentities on which DOFs are removed
lo_coefflow dof coefficient (rank)
hi_coeffhigh dof coefficient (rank)
verbverbosity level
debugto debug and seek for inconsistencies set to true
Returns
MoFEMErrorCode
Note
Use this function for non distributed meshes

Definition at line 3520 of file ProblemsManager.cpp.

3524  {
3525  MoFEM::Interface &m_field = cOre;
3526  MoFEMFunctionBegin;
3527 
3528  auto bit_manager = m_field.getInterface<BitRefManager>();
3529 
3530  Range ents;
3531  if (ents_ptr) {
3532  ents = *ents_ptr;
3533  CHKERR bit_manager->filterEntitiesByRefLevel(bit_ref_level, bit_ref_mask,
3534  ents, verb);
3535  } else {
3536  CHKERR bit_manager->getEntitiesByRefLevel(bit_ref_level, bit_ref_mask, ents,
3537  verb);
3538  }
3539 
3540  CHKERR removeDofsOnEntitiesNotDistributed(problem_name, field_name, ents,
3541  lo_coeff, hi_coeff, lo_order,
3542  hi_order, verb, debug);
3543 
3544  MoFEMFunctionReturn(0);
3545 }

◆ removeDofsOnEntitiesNotDistributed() [2/2]

MoFEMErrorCode MoFEM::ProblemsManager::removeDofsOnEntitiesNotDistributed ( const std::string  problem_name,
const std::string  field_name,
const Range  ents,
const int  lo_coeff = 0,
const int  hi_coeff = MAX_DOFS_ON_ENTITY,
const int  lo_order = 0,
const int  hi_order = 100,
int  verb = VERBOSE,
const bool  debug = false 
)

Remove DOFs from problem.

Remove DOFs from problem which are on entities on the given range and given field name. On the finite element level, DOFs can be still accessed however local PETSc indices and global PETSc indices are marked with the index -1.

Note
If the index is marked -1 it is not assembled and dropped by VecSetValues and MatSetValues.
Todo:
Not yet implemented update for AO maps and IS ranges if removed entities in composite problem or sub-problem
Parameters
problem_namename of the problem
field_namename of the field
entsentities on which DOFs are removed
lo_coefflow dof coefficient (rank)
hi_coeffhigh dof coefficient (rank)
verbverbosity level
debugto debug and seek for inconsistencies set to true
Returns
MoFEMErrorCode
Note
Use this function for non-distributed meshes
Examples
remove_entities_from_problem_not_partitioned.cpp.

Definition at line 3226 of file ProblemsManager.cpp.

3229  {
3230 
3231  MoFEM::Interface &m_field = cOre;
3232  ProblemManagerFunctionBegin;
3233 
3234  const Problem *prb_ptr;
3235  CHKERR m_field.get_problem(problem_name, &prb_ptr);
3236 
3237  decltype(prb_ptr->numeredRowDofsPtr) numered_dofs[2] = {
3238  prb_ptr->numeredRowDofsPtr, nullptr};
3239  if (prb_ptr->numeredRowDofsPtr != prb_ptr->numeredColDofsPtr)
3240  numered_dofs[1] = prb_ptr->numeredColDofsPtr;
3241 
3242  int *nbdof_ptr[] = {&prb_ptr->nbDofsRow, &prb_ptr->nbDofsCol};
3243  int *local_nbdof_ptr[] = {&prb_ptr->nbLocDofsRow, &prb_ptr->nbLocDofsCol};
3244  int *ghost_nbdof_ptr[] = {&prb_ptr->nbGhostDofsRow, &prb_ptr->nbGhostDofsCol};
3245 
3246  const int nb_init_row_dofs = prb_ptr->getNbDofsRow();
3247  const int nb_init_col_dofs = prb_ptr->getNbDofsCol();
3248  const int nb_init_loc_row_dofs = prb_ptr->getNbLocalDofsRow();
3249  // const int nb_init_loc_col_dofs = prb_ptr->getNbLocalDofsCol();
3250  const int nb_init_ghost_row_dofs = prb_ptr->getNbGhostDofsRow();
3251  const int nb_init_ghost_col_dofs = prb_ptr->getNbGhostDofsCol();
3252 
3253  const std::array<int, 2> nb_init_dofs = {nb_init_row_dofs, nb_init_col_dofs};
3254 
3255  for (int s = 0; s != 2; ++s)
3256  if (numered_dofs[s]) {
3257 
3258  typedef multi_index_container<
3259 
3260  NumeredDofEntity_multiIndex::iterator, indexed_by<sequenced<>>
3261 
3262  >
3263  NumeredDofEntity_it_view_multiIndex;
3264 
3265  const auto bit_number = m_field.get_field_bit_number(field_name);
3266  NumeredDofEntity_it_view_multiIndex dofs_it_view;
3267 
3268  // Set -1 to global and local dofs indices
3269  for (auto pit = ents.const_pair_begin(); pit != ents.const_pair_end();
3270  ++pit) {
3271  auto lo = numered_dofs[s]->get<Unique_mi_tag>().lower_bound(
3272  DofEntity::getLoFieldEntityUId(bit_number, pit->first));
3273  auto hi = numered_dofs[s]->get<Unique_mi_tag>().upper_bound(
3274  DofEntity::getHiFieldEntityUId(bit_number, pit->second));
3275 
3276  for (; lo != hi; ++lo)
3277  if ((*lo)->getDofCoeffIdx() >= lo_coeff &&
3278  (*lo)->getDofCoeffIdx() <= hi_coeff &&
3279  (*lo)->getDofOrder() >= lo_order &&
3280  (*lo)->getDofOrder() <= hi_order)
3281  dofs_it_view.emplace_back(numered_dofs[s]->project<0>(lo));
3282  }
3283 
3284  if (verb > QUIET) {
3285  for (auto &dof : dofs_it_view)
3286  MOFEM_LOG("SYNC", Sev::noisy) << **dof;
3287  }
3288 
3289  // set negative index
3290  auto mod = NumeredDofEntity_part_and_all_indices_change(-1, -1, -1, -1);
3291  for (auto dit : dofs_it_view) {
3292  bool success = numered_dofs[s]->modify(dit, mod);
3293  if (!success)
3294  SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
3295  "can not set negative indices");
3296  }
3297 
3298  // create weak view
3299  std::vector<boost::weak_ptr<NumeredDofEntity>> dosf_weak_view;
3300  dosf_weak_view.reserve(dofs_it_view.size());
3301  for (auto dit : dofs_it_view)
3302  dosf_weak_view.push_back(*dit);
3303 
3304  if (verb >= NOISY)
3305  MOFEM_LOG_C("SYNC", Sev::noisy,
3306  "Number of DOFs in multi-index %d and to delete %d\n",
3307  numered_dofs[s]->size(), dofs_it_view.size());
3308 
3309  // erase dofs from problem
3310  for (auto weak_dit : dosf_weak_view)
3311  if (auto dit = weak_dit.lock()) {
3312  numered_dofs[s]->erase(dit->getLocalUniqueId());
3313  }
3314 
3315  if (verb >= NOISY)
3316  MOFEM_LOG_C("SYNC", Sev::noisy,
3317  "Number of DOFs in multi-index after delete %d\n",
3318  numered_dofs[s]->size());
3319 
3320  // get current number of ghost dofs
3321  int nb_global_dof = 0;
3322  int nb_local_dofs = 0;
3323  int nb_ghost_dofs = 0;
3324 
3325  for (auto dit = numered_dofs[s]->begin(); dit != numered_dofs[s]->end();
3326  ++dit) {
3327 
3328  if ((*dit)->getDofIdx() >= 0) {
3329 
3330  if ((*dit)->getPetscLocalDofIdx() >= 0 &&
3331  (*dit)->getPetscLocalDofIdx() < *(local_nbdof_ptr[s]))
3332  ++nb_local_dofs;
3333  else if ((*dit)->getPetscLocalDofIdx() >= *(local_nbdof_ptr[s]))
3334  ++nb_ghost_dofs;
3335 
3336  ++nb_global_dof;
3337  }
3338  }
3339 
3340  if (debug) {
3341  MPI_Allreduce(&nb_local_dofs, nbdof_ptr[s], 1, MPI_INT, MPI_SUM,
3342  m_field.get_comm());
3343  if (*(nbdof_ptr[s]) != nb_global_dof)
3344  SETERRQ2(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
3345  "Number of local DOFs do not add up %d != %d",
3346  *(nbdof_ptr[s]), nb_global_dof);
3347  }
3348 
3349  *(nbdof_ptr[s]) = nb_global_dof;
3350  *(local_nbdof_ptr[s]) = nb_local_dofs;
3351  *(ghost_nbdof_ptr[s]) = nb_ghost_dofs;
3352 
3353  // get indices
3354  auto get_indices_by_tag = [&](auto tag) {
3355  std::vector<int> indices;
3356  indices.resize(nb_init_dofs[s], -1);
3357  for (auto dit = numered_dofs[s]->get<Idx_mi_tag>().lower_bound(0);
3358  dit != numered_dofs[s]->get<Idx_mi_tag>().end(); ++dit) {
3359  indices[(*dit)->getDofIdx()] = decltype(tag)::get_index(dit);
3360  }
3361  return indices;
3362  };
3363 
3364  auto renumber = [&](auto tag, auto &indices) {
3365  MoFEMFunctionBegin;
3366  int idx = 0;
3367  for (auto dit = numered_dofs[s]->get<decltype(tag)>().lower_bound(0);
3368  dit != numered_dofs[s]->get<decltype(tag)>().end(); ++dit) {
3369  indices[(*dit)->getDofIdx()] = idx++;
3370  }
3371  MoFEMFunctionReturn(0);
3372  };
3373 
3374  auto get_sub_ao = [&](auto sub_data) {
3375  if (s == 0) {
3376  return sub_data->getSmartRowMap();
3377  } else {
3378  return sub_data->getSmartColMap();
3379  }
3380  };
3381 
3382  auto set_sub_is_and_ao = [&s, &prb_ptr](auto sub_data, auto is, auto ao) {
3383  if (s == 0) {
3384  sub_data->rowIs = is;
3385  sub_data->rowMap = ao;
3386  sub_data->colIs = is;
3387  sub_data->colMap = ao;
3388  } else {
3389  sub_data->colIs = is;
3390  sub_data->colMap = ao;
3391  }
3392  };
3393 
3394  auto apply_symmetry = [&s, &prb_ptr](auto sub_data) {
3395  if (s == 0) {
3396  if (prb_ptr->numeredRowDofsPtr == prb_ptr->numeredColDofsPtr) {
3397  sub_data->colIs = sub_data->getSmartRowIs();
3398  sub_data->colMap = sub_data->getSmartRowMap();
3399  }
3400  }
3401  };
3402 
3403  auto set_sub_data = [&](auto &indices) {
3404  MoFEMFunctionBegin;
3405  if (auto sub_data = prb_ptr->getSubData()) {
3406  // create is and then map it to main problem of sub-problem
3407  auto sub_is = createISGeneral(m_field.get_comm(), indices.size(),
3408  &*indices.begin(), PETSC_COPY_VALUES);
3409  // get old app, i.e. oroginal befor sub indices, and ao, from
3410  // app, to petsc sub indices.
3411  auto sub_ao = get_sub_ao(sub_data);
3412  CHKERR AOPetscToApplicationIS(sub_ao, sub_is);
3413  sub_ao = createAOMappingIS(sub_is, PETSC_NULL);
3414  // set new sub ao
3415  set_sub_is_and_ao(sub_data, sub_is, sub_ao);
3416  apply_symmetry(sub_data);
3417  } else {
3418  prb_ptr->getSubData() = boost::make_shared<Problem::SubProblemData>();
3419  auto sub_is = createISGeneral(m_field.get_comm(), indices.size(),
3420  &*indices.begin(), PETSC_COPY_VALUES);
3421  auto sub_ao = createAOMappingIS(sub_is, PETSC_NULL);
3422  // set sub is ao
3423  set_sub_is_and_ao(prb_ptr->getSubData(), sub_is, sub_ao);
3424  apply_symmetry(prb_ptr->getSubData());
3425  }
3426  MoFEMFunctionReturn(0);
3427  };
3428 
3429  auto global_indices = get_indices_by_tag(PetscGlobalIdx_mi_tag());
3430  auto local_indices = get_indices_by_tag(PetscLocalIdx_mi_tag());
3431  CHKERR set_sub_data(global_indices);
3432  CHKERR renumber(PetscGlobalIdx_mi_tag(), global_indices);
3433  CHKERR renumber(PetscLocalIdx_mi_tag(), local_indices);
3434 
3435  int i = 0;
3436  for (auto dit = numered_dofs[s]->begin(); dit != numered_dofs[s]->end();
3437  ++dit) {
3438  auto idx = (*dit)->getDofIdx();
3439  if (idx >= 0) {
3440  auto mod = NumeredDofEntity_part_and_all_indices_change(
3441  (*dit)->getPart(), i++, global_indices[idx], local_indices[idx]);
3442  bool success = numered_dofs[s]->modify(dit, mod);
3443  if (!success)
3444  SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
3445  "can not set negative indices");
3446  } else {
3447  auto mod = NumeredDofEntity_part_and_all_indices_change(
3448  (*dit)->getPart(), -1, -1, -1);
3449  bool success = numered_dofs[s]->modify(dit, mod);
3450  if (!success)
3451  SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
3452  "can not set negative indices");
3453  }
3454  };
3455 
3456  if (debug) {
3457  for (auto dof : (*numered_dofs[s])) {
3458  if (dof->getDofIdx() >= 0 && dof->getPetscGlobalDofIdx() < 0) {
3459  SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
3460  "Negative global idx");
3461  }
3462  }
3463  }
3464 
3465  } else {
3466 
3467  *(nbdof_ptr[1]) = *(nbdof_ptr[0]);
3468  *(local_nbdof_ptr[1]) = *(local_nbdof_ptr[0]);
3469  *(ghost_nbdof_ptr[1]) = *(ghost_nbdof_ptr[0]);
3470  }
3471 
3472  if (verb >= NOISY)
3473  MOFEM_LOG_SYNCHRONISE(m_field.get_comm());
3474 
3475  if (verb > QUIET) {
3476  MOFEM_LOG_C(
3477  "WORLD", Sev::inform,
3478  "Removed DOFs from problem %s dofs [%d / %d (before %d / %d) global]",
3479  prb_ptr->getName().c_str(), prb_ptr->getNbDofsRow(),
3480  prb_ptr->getNbDofsCol(), nb_init_row_dofs, nb_init_col_dofs);
3481  MOFEM_LOG_C("SYNC", Sev::verbose,
3482  "Removed DOFs from problem %s dofs [ %d / %d "
3483  "(before %d / %d) local, %d / %d (before %d / %d)]",
3484  prb_ptr->getName().c_str(), prb_ptr->getNbLocalDofsRow(),
3485  prb_ptr->getNbLocalDofsCol(), nb_init_loc_row_dofs,
3486  nb_init_loc_row_dofs, prb_ptr->getNbGhostDofsRow(),
3487  prb_ptr->getNbGhostDofsCol(), nb_init_ghost_row_dofs,
3488  nb_init_ghost_col_dofs);
3489  MOFEM_LOG_SYNCHRONISE(m_field.get_comm());
3490  }
3491  MoFEMFunctionReturn(0);
3492 }

Member Data Documentation

◆ buildProblemFromFields

PetscBool MoFEM::ProblemsManager::buildProblemFromFields

If set to true, problem is build from

Definition at line 30 of file ProblemsManager.hpp.

◆ cOre

MoFEM::Core& MoFEM::ProblemsManager::cOre

Definition at line 26 of file ProblemsManager.hpp.

◆ MOFEM_EVENT_ProblemsManager

PetscLogEvent MoFEM::ProblemsManager::MOFEM_EVENT_ProblemsManager
private

Definition at line 495 of file ProblemsManager.hpp.

◆ synchroniseProblemEntities

PetscBool MoFEM::ProblemsManager::synchroniseProblemEntities

DOFs in fields, not from DOFs on elements.

Definition at line 33 of file ProblemsManager.hpp.

The documentation for this struct was generated from the following files:
MoFEMFunctionReturnHot
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:460
MoFEM::UnknownInterface::getInterface
MoFEMErrorCode getInterface(IFACE *&iface) const
Get interface reference to pointer of interface.
Definition: UnknownInterface.hpp:93
MoFEM::createAOMappingIS
auto createAOMappingIS(IS isapp, IS ispetsc)
Creates an application mapping using two index sets.
Definition: PetscSmartObj.hpp:318
MoFEM::ProblemsManager::buildProblemFromFields
PetscBool buildProblemFromFields
Definition: ProblemsManager.hpp:30
MoFEM::Field::getNbOfCoeffs
FieldCoefficientsNumber getNbOfCoeffs() const
Get number of field coefficients.
Definition: FieldMultiIndices.hpp:202
MoFEM::CoreTmp< 0 >
Core (interface) class.
Definition: Core.hpp:82
ProblemManagerFunctionBegin
#define ProblemManagerFunctionBegin
Definition: ProblemsManager.cpp:8
MOFEM_LOG_SEVERITY_SYNC
#define MOFEM_LOG_SEVERITY_SYNC(comm, severity)
Synchronise "SYNC" on curtain severity level.
Definition: LogManager.hpp:352
MoFEM::createISGeneral
auto createISGeneral(MPI_Comm comm, PetscInt n, const PetscInt idx[], PetscCopyMode mode)
Creates a data structure for an index set containing a list of integers.
Definition: PetscSmartObj.hpp:287
EntityHandle
NOISY
@ NOISY
Definition: definitions.h:224
MoFEM::CoreInterface::get_comm
virtual MPI_Comm & get_comm() const =0
MoFEM::CoreInterface::get_field_structure
virtual const Field * get_field_structure(const std::string &name, enum MoFEMTypes bh=MF_EXIST) const =0
get field structure
MoFEM::CoreInterface::get_field_bit_number
virtual FieldBitNumber get_field_bit_number(const std::string name) const =0
get field bit number
MoFEM::CoreInterface::get_comm_rank
virtual int get_comm_rank() const =0
MoFEM::CoreInterface::get_problem
virtual const Problem * get_problem(const std::string problem_name) const =0
Get the problem object.
MoFEM::ProblemsManager::OR
@ OR
Definition: ProblemsManager.hpp:416
MOFEM_IMPOSSIBLE_CASE
@ MOFEM_IMPOSSIBLE_CASE
Definition: definitions.h:35
MoFEM::Field::getDofSideMap
std::map< int, BaseFunction::DofsSideMap > & getDofSideMap() const
Get the dofs side map.
Definition: FieldMultiIndices.hpp:292
MoFEM::DeprecatedCoreInterface
Deprecated interface functions.
Definition: DeprecatedCoreInterface.hpp:16
ROW
@ ROW
Definition: definitions.h:136
MoFEM::Interface
DeprecatedCoreInterface Interface
Definition: Interface.hpp:2010
c
const double c
speed of light (cm/ns)
Definition: initial_diffusion.cpp:39
MoFEM::createAOMapping
auto createAOMapping(MPI_Comm comm, PetscInt napp, const PetscInt myapp[], const PetscInt mypetsc[])
Creates an application mapping using two integer arrays.
Definition: PetscSmartObj.hpp:338
CHKERR
#define CHKERR
Inline error check.
Definition: definitions.h:548
MoFEM::CoreInterface::get_moab
virtual moab::Interface & get_moab()=0
MoFEM::ProblemsManager::cOre
MoFEM::Core & cOre
Definition: ProblemsManager.hpp:26
MoFEM::ProblemsManager::removeDofsOnEntitiesNotDistributed
MoFEMErrorCode removeDofsOnEntitiesNotDistributed(const std::string problem_name, const std::string field_name, const Range ents, const int lo_coeff=0, const int hi_coeff=MAX_DOFS_ON_ENTITY, const int lo_order=0, const int hi_order=100, int verb=VERBOSE, const bool debug=false)
Remove DOFs from problem.
Definition: ProblemsManager.cpp:3226
MOFEM_LOG_C
#define MOFEM_LOG_C(channel, severity, format,...)
Definition: LogManager.hpp:311
convert.type
type
Definition: convert.py:64
MOFEM_LOG_SYNCHRONISE
#define MOFEM_LOG_SYNCHRONISE(comm)
Synchronise "SYNC" channel.
Definition: LogManager.hpp:345
MoFEM::FieldEntity::getLoBitNumberUId
static UId getLoBitNumberUId(const FieldBitNumber bit_number)
Definition: FieldEntsMultiIndices.hpp:222
COL
@ COL
Definition: definitions.h:136
MoFEM::ProblemsManager::markDofs
MoFEMErrorCode markDofs(const std::string problem_name, RowColData rc, const enum MarkOP op, const Range ents, std::vector< unsigned char > &marker) const
Create vector with marked indices.
Definition: ProblemsManager.cpp:3548
MoFEM::BlockFieldPair
Problem::BlockFieldPair BlockFieldPair
Definition: ProblemsMultiIndices.hpp:566
MOFEM_OPERATION_UNSUCCESSFUL
@ MOFEM_OPERATION_UNSUCCESSFUL
Definition: definitions.h:34
debug
static const bool debug
Definition: dm_create_subdm.cpp:12
i
FTensor::Index< 'i', SPACE_DIM > i
Definition: hcurl_divergence_operator_2d.cpp:27
MoFEM::DofEntity::getLoFieldEntityUId
static UId getLoFieldEntityUId(const FieldBitNumber bit, const EntityHandle ent)
Definition: DofsMultiIndices.hpp:69
field_name
constexpr auto field_name
Definition: poisson_2d_homogeneous.cpp:13
MoFEM::ProblemsManager::AND
@ AND
Definition: ProblemsManager.hpp:416
MoFEM::Problem::numeredRowDofsPtr
boost::shared_ptr< NumeredDofEntity_multiIndex > numeredRowDofsPtr
store DOFs on rows for this problem
Definition: ProblemsMultiIndices.hpp:73
Range
MoFEM::ProblemsManager::MOFEM_EVENT_ProblemsManager
PetscLogEvent MOFEM_EVENT_ProblemsManager
Definition: ProblemsManager.hpp:495
MOFEM_LOG
#define MOFEM_LOG(channel, severity)
Log.
Definition: LogManager.hpp:308
MoFEM::DofEntity::getHiFieldEntityUId
static UId getHiFieldEntityUId(const FieldBitNumber bit, const EntityHandle ent)
Definition: DofsMultiIndices.hpp:75
MoFEM::ProblemsManager::synchroniseProblemEntities
PetscBool synchroniseProblemEntities
DOFs in fields, not from DOFs on elements.
Definition: ProblemsManager.hpp:33
MoFEM::Exceptions::ierr
static MoFEMErrorCodeGeneric< PetscErrorCode > ierr
Definition: Exceptions.hpp:76
MOFEM_DATA_INCONSISTENCY
@ MOFEM_DATA_INCONSISTENCY
Definition: definitions.h:31
MoFEM::ProblemsManager::ProblemsManager
ProblemsManager(const MoFEM::Core &core)
Definition: ProblemsManager.cpp:55
MoFEM::FieldEntity::getHiBitNumberUId
static UId getHiBitNumberUId(const FieldBitNumber bit_number)
Definition: FieldEntsMultiIndices.hpp:228
marker
auto marker
set bit to marker
Definition: hanging_node_approx.cpp:82
MoFEMFunctionBeginHot
#define MoFEMFunctionBeginHot
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:453
QUIET
@ QUIET
Definition: definitions.h:221
convert.int
int
Definition: convert.py:64
MoFEMFunctionReturn
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:429
CHKERRG
#define CHKERRG(n)
Check error code of MoFEM/MOAB/PETSc function.
Definition: definitions.h:496
MoFEMFunctionBegin
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:359
MOFEM_INVALID_DATA
@ MOFEM_INVALID_DATA
Definition: definitions.h:36
Generated by Doxygen 1.8.17 and hosted at University of Glasgow