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, photon_diffusion.cpp, plastic.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 3667 of file ProblemsManager.cpp.

3669  {
3670 
3671  Interface &m_field = cOre;
3672  MoFEMFunctionBegin;
3673 
3674  const auto problem_ptr = m_field.get_problem(problem_name);
3675  auto get_field_id = [&](const std::string field_name) {
3676  return m_field.get_field_structure(field_name)->getId();
3677  };
3678  const auto row_id = get_field_id(row_field);
3679  const auto col_id = get_field_id(col_field);
3680 
3681  problem_ptr->addFieldToEmptyFieldBlocks(BlockFieldPair(row_id, col_id));
3682 
3683  MoFEMFunctionReturn(0);
3684 }

◆ 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[bride_type].get<EntDofIdx_mi_tag>().find(
2668  std::floor(static_cast<double>(ent_dof_index) / nb_coeffs));
2669  if (side_it != side_dof_map[bride_type].get<EntDofIdx_mi_tag>().end()) {
2670  auto bridge_ent = (*lo)->getEnt();
2671  auto type = side_it->type;
2672  auto side = side_it->side;
2673  auto dim = CN::Dimension(type);
2674  EntityHandle side_ent = 0;
2675  CHKERR moab.side_element(bridge_ent, dim, side, side_ent);
2676  if (ents.find(side_ent) != ents.end()) {
2677  dofs_it_view.emplace_back(numered_dofs[rc]->project<0>(lo));
2678  }
2679  } else {
2680  SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
2681  "side not found");
2682  }
2683  }
2684  }
2685  }
2686 
2687  if (verb > QUIET) {
2688  for (auto &dof : dofs_it_view)
2689  MOFEM_LOG("SYNC", Sev::noisy) << **dof;
2690  MOFEM_LOG_SEVERITY_SYNC(m_field.get_comm(), Sev::noisy);
2691  }
2692 
2693  vec_dof_view.reserve(vec_dof_view.size() + dofs_it_view.size());
2694  for (auto dit : dofs_it_view)
2695  vec_dof_view.push_back(*dit);
2696 
2697  MoFEMFunctionReturn(0);
2698 }

◆ 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 3534 of file ProblemsManager.cpp.

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

◆ 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 3629 of file ProblemsManager.cpp.

3635  {
3636  Interface &m_field = cOre;
3637  ProblemManagerFunctionBegin;
3638 
3639  const Problem *problem_ptr;
3640  CHKERR m_field.get_problem(problem_name, &problem_ptr);
3641  boost::shared_ptr<NumeredDofEntity_multiIndex> dofs;
3642  switch (rc) {
3643  case ROW:
3644  dofs = problem_ptr->getNumeredRowDofsPtr();
3645  break;
3646  case COL:
3647  dofs = problem_ptr->getNumeredColDofsPtr();
3648  break;
3649  default:
3650  SETERRQ(PETSC_COMM_SELF, MOFEM_IMPOSSIBLE_CASE, "Should be row or column");
3651  }
3652  marker.resize(dofs->size(), 0);
3653 
3654  for (auto &dof : vec_dof_view) {
3655  if (auto dof_ptr = dof.lock()) {
3656  if (op == MarkOP::OR)
3657  marker[dof_ptr->getPetscLocalDofIdx()] |= 1;
3658  else
3659  marker[dof_ptr->getPetscLocalDofIdx()] &= 1;
3660  }
3661  }
3662 
3663  MoFEMFunctionReturn(0);
3664 }

◆ 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 3581 of file ProblemsManager.cpp.

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

◆ 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 2700 of file ProblemsManager.cpp.

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

◆ 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 3506 of file ProblemsManager.cpp.

3510  {
3511  MoFEM::Interface &m_field = cOre;
3512  MoFEMFunctionBegin;
3513 
3514  auto bit_manager = m_field.getInterface<BitRefManager>();
3515 
3516  Range ents;
3517  if (ents_ptr) {
3518  ents = *ents_ptr;
3519  CHKERR bit_manager->filterEntitiesByRefLevel(bit_ref_level, bit_ref_mask,
3520  ents, verb);
3521  } else {
3522  CHKERR bit_manager->getEntitiesByRefLevel(bit_ref_level, bit_ref_mask, ents,
3523  verb);
3524  }
3525 
3526  CHKERR removeDofsOnEntitiesNotDistributed(problem_name, field_name, ents,
3527  lo_coeff, hi_coeff, lo_order,
3528  hi_order, verb, debug);
3529 
3530  MoFEMFunctionReturn(0);
3531 }

◆ 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 3212 of file ProblemsManager.cpp.

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

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::Field::getDofSideMap
std::array< BaseFunction::DofsSideMap, MBMAXTYPE > & getDofSideMap() const
Get the dofs side map.
Definition: FieldMultiIndices.hpp:291
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::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:3212
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:3534
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