MoFEM::ProblemsManager Struct Reference

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

#include "src/interfaces/ProblemsManager.hpp"

Inheritance diagram for MoFEM::ProblemsManager:

Collaboration diagram for MoFEM::ProblemsManager:

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 ()
	Get command line options for ProblemsManager.
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.
MoFEMErrorCode	buildProblem (const std::string name, const bool square_matrix, int verb=VERBOSE)
	build problem data structures
MoFEMErrorCode	buildProblem (Problem *problem_ptr, const bool square_matrix, int verb=VERBOSE)
	build problem data structures
MoFEMErrorCode	buildProblemOnDistributedMesh (const std::string name, const bool square_matrix, int verb=VERBOSE)
	build problem data structures, assuming that mesh is distributed (collective)
MoFEMErrorCode	buildProblemOnDistributedMesh (Problem *problem_ptr, const bool square_matrix=true, int verb=VERBOSE)
	build problem data structures, assuming that mesh is distributed (collective)
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
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
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
MoFEMErrorCode	partitionSimpleProblem (const std::string name, int verb=VERBOSE)
	partition problem dofs
MoFEMErrorCode	partitionProblem (const std::string name, int verb=VERBOSE)
	partition problem dofs (collective)
MoFEMErrorCode	printPartitionedProblem (const Problem *problem_ptr, int verb=VERBOSE)
	Print partition information for debugging.
MoFEMErrorCode	debugPartitionedProblem (const Problem *problem_ptr, int verb=VERBOSE)
	Debug partition information.
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
MoFEMErrorCode	partitionGhostDofs (const std::string name, int verb=VERBOSE)
	determine ghost nodes
MoFEMErrorCode	partitionGhostDofsOnDistributedMesh (const std::string name, int verb=VERBOSE)
	determine ghost nodes on distributed meshes
MoFEMErrorCode	getFEMeshset (const std::string prb_name, const std::string &fe_name, EntityHandle *meshset) const
	Create finite element meshset for the problem.
MoFEMErrorCode	getProblemElementsLayout (const std::string name, const std::string &fe_name, PetscLayout *layout) const
	Get layout of elements in the problem.
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.
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.
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.
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.
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.
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 broken space.
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.
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
	Modify DOF markers for specific field and coefficient range.
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 DOF indices based on DOF view.
MoFEMErrorCode	addFieldToEmptyFieldBlocks (const std::string problem_name, const std::string row_field, const std::string col_field) const
	Add empty field blocks to optimize matrix storage.
Public Member Functions inherited from MoFEM::UnknownInterface
template<class IFACE >
MoFEMErrorCode	registerInterface (bool error_if_registration_failed=true)
	Register interface.
template<class IFACE >
MoFEMErrorCode	getInterface (IFACE *&iface) const
	Get interface reference to pointer of interface.
template<class IFACE >
MoFEMErrorCode	getInterface (IFACE **const iface) const
	Get interface pointer to pointer of interface.
template<class IFACE , typename boost::enable_if< boost::is_pointer< IFACE >, int >::type = 0>
IFACE	getInterface () const
	Get interface pointer to pointer of interface.
template<class IFACE , typename boost::enable_if< boost::is_reference< IFACE >, int >::type = 0>
IFACE	getInterface () const
	Get reference to interface.
template<class IFACE >
IFACE *	getInterface () const
	Function returning pointer to interface.
virtual	~UnknownInterface ()=default

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

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.
static MoFEMErrorCode	getFileVersion (moab::Interface &moab, Version &version)
	Get database major version.
static MoFEMErrorCode	setFileVersion (moab::Interface &moab, Version version=Version(MoFEM_VERSION_MAJOR, MoFEM_VERSION_MINOR, MoFEM_VERSION_BUILD))
	Get database major version.
static MoFEMErrorCode	getInterfaceVersion (Version &version)
	Get database major version.

Detailed Description

Problem manager is used to build and partition problems.

Overview

The ProblemsManager serves as the central interface for creating, configuring, and managing finite element problems within the MoFEM framework. It acts as a bridge between the Core interface (which manages the fundamental MoFEM data structures like fields, finite elements, and DOFs) and the PETSc Discrete Manager (DM) system for parallel computing.

Connection to Core Interface

The ProblemsManager operates on top of the MoFEM::Core interface:

• Fields and DOFs: Uses fields and DOFs defined in Core to construct problems
• Finite Elements: Manages finite elements from Core's registry
• Problem Objects: Creates Problem instances that aggregate Core's components
• Data Consistency: Ensures DOF numbering and field associations remain consistent

Integration with PETSc Discrete Manager (DM)

The ProblemsManager creates and configures PETSc DM objects:

• Matrix/Vector Layout: Defines parallel distribution of DOFs for PETSc matrices/vectors
• Ghost DOFs: Manages inter-processor DOF dependencies for parallel assembly
• Partitioning: Distributes computational load across MPI processes
• Local/Global Mappings: Establishes DOF index mappings between local and global numbering

Distributed vs Non-Distributed Meshes

Non-Distributed Meshes

• Single Process Ownership: Each mesh entity owned by exactly one processor
• Sequential Building: Problem built on rank 0, then partitioned
• Simple Partitioning: Uses METIS/ParMETIS for load balancing
• Ghost Creation: Explicit ghost DOF creation after partitioning
• Use Case: Traditional finite element problems with post-partitioning

Distributed Meshes <br>

• MOAB Integration: Leverages MOAB's parallel mesh capabilities
• Pre-Partitioned: Mesh already distributed during loading
• Shared Entities: Mesh entities can be shared between processors
• Automatic Ghosts: Ghost DOFs determined from mesh sharing information
• Use Case: Large-scale problems requiring parallel mesh I/O

Problem Types

Sub-Problems

• Focused Analysis: Extract subset of DOFs/elements for specialized computation
• Field Restriction: Include only specific fields or DOF ranges
• Boundary Conditions: Apply specialized constraints to problem subset
• Solver Optimization: Use targeted solvers for specific physics
• Example: Solve only displacement DOFs while keeping pressure DOFs fixed

Composite Problems

• Block Structure: Combine multiple sub-problems into unified matrix system
• Multi-Physics: Couple different physical phenomena (fluid-structure, etc.)
• Block Matrices: Create structured matrix layouts for specialized solvers
• Field Coupling: Define interactions between different field types
• Example: Stokes flow with displacement-pressure-velocity blocks

Broken DOFs (Discontinuous Spaces)

Broken DOFs support discontinuous finite element spaces:

• Element-Wise DOFs: DOFs belong to elements rather than mesh entities
• Interface Handling: Special treatment for inter-element connections
• Discontinuous Galerkin: Support for DG methods with interface terms
• Side DOFs: DOFs associated with element faces for flux calculations
• Broken Space Functions: getSideDofsOnBrokenSpaceEntities() manages interface DOFs

DOF Removal Operations

DOF removal serves multiple purposes:

Boundary Condition Enforcement

• Dirichlet Constraints: Remove DOFs with prescribed values
• Symmetry Conditions: Eliminate DOFs with geometric constraints
• Contact Constraints: Remove DOFs involved in contact conditions

Model Reduction

• Inactive Regions: Remove DOFs in non-participating mesh regions
• Dimensional Reduction: Eliminate DOFs for plane stress/strain assumptions
• Adaptive Refinement: Remove DOFs from coarsened elements

Numerical Efficiency

• Zero DOFs: Remove DOFs that remain zero throughout simulation
• Singular Systems: Eliminate redundant DOFs to improve conditioning
• Memory Optimization: Reduce matrix storage requirements

The removal process:

1. Identification: Mark DOFs for removal based on criteria
2. Dependency Check: Verify no essential DOFs depend on removed ones
3. Index Renumbering: Compact DOF indices to eliminate gaps
4. Matrix/Vector Update: Adjust PETSc data structures accordingly
5. Solver Configuration: Update preconditioners and solver contexts

Typical Workflow

1. Problem Definition: Define fields, finite elements, and DOFs via Core
2. Problem Building: Use buildProblem*() to create Problem object
3. Partitioning: Apply partition*() functions for parallel distribution
4. Ghost Setup: Configure ghost DOFs for parallel assembly
5. Constraint Application: Remove DOFs for boundary conditions
6. DM Creation: Generate PETSc DM for solver integration
7. Matrix Assembly: Use Problem for parallel finite element assembly

Examples

mofem/atom_tests/boundary_marker.cpp, mofem/atom_tests/build_composite_problem.cpp, mofem/atom_tests/build_large_problem.cpp, mofem/atom_tests/build_problems.cpp, mofem/atom_tests/child_and_parent.cpp, mofem/atom_tests/continuity_check_on_contact_prism_side_ele.cpp, mofem/atom_tests/continuity_check_on_skeleton_3d.cpp, mofem/atom_tests/forces_and_sources_testing_edge_element.cpp, mofem/atom_tests/forces_and_sources_testing_flat_prism_element.cpp, mofem/atom_tests/forces_and_sources_testing_users_base.cpp, mofem/atom_tests/hanging_node_approx.cpp, mofem/atom_tests/hcurl_divergence_operator_2d.cpp, mofem/atom_tests/mesh_insert_interface_atom.cpp, mofem/atom_tests/prism_elements_from_surface.cpp, mofem/atom_tests/prism_polynomial_approximation.cpp, mofem/atom_tests/quad_polynomial_approximation.cpp, mofem/atom_tests/remove_entities_from_problem.cpp, mofem/atom_tests/remove_entities_from_problem_not_partitioned.cpp, mofem/atom_tests/test_cache_on_entities.cpp, mofem/tutorials/adv-2/thermo_elastic.cpp, mofem/tutorials/adv-3/level_set.cpp, mofem/tutorials/adv-5/seepage.cpp, mofem/tutorials/clx-0/helmholtz.cpp, mofem/tutorials/cor-9/reaction_diffusion.cpp, mofem/tutorials/mix-0/mixed_poisson.cpp, mofem/tutorials/scl-10/initial_diffusion.cpp, mofem/tutorials/scl-10/photon_diffusion.cpp, mofem/tutorials/scl-9/heat_method.cpp, mofem/tutorials/vec-5/free_surface.cpp, mofem/tutorials/vec-6/plate.cpp, mofem/tutorials/vec-7/adjoint.cpp, mofem/users_modules/basic_finite_elements/nonlinear_elasticity/nonlinear_dynamics.cpp, mofem/users_modules/bone_remodelling/src/impl/Remodeling.cpp, and mofem/users_modules/eshelbian_plasticity/src/impl/EshelbianPlasticity.cpp.

Definition at line 133 of file ProblemsManager.hpp.

Member Enumeration Documentation

MarkOP

enum MoFEM::ProblemsManager::MarkOP

Enumerator
OR
AND

Definition at line 598 of file ProblemsManager.hpp.

{ OR, AND };

Constructor & Destructor Documentation

ProblemsManager()

MoFEM::ProblemsManager::ProblemsManager

(

const MoFEM::Core &

core

)

Definition at line 55 of file ProblemsManager.cpp.

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

~ProblemsManager()

virtual MoFEM::ProblemsManager::~ProblemsManager ( )

virtualdefault

Member Function Documentation

markDofs() [1/2]

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

mofem/atom_tests/boundary_marker.cpp, mofem/atom_tests/test_cache_on_entities.cpp, and mofem/tutorials/clx-0/helmholtz.cpp.

Definition at line 3553 of file ProblemsManager.cpp.

                                                                  {
 
  Interface &m_field = cOre;
  const Problem *problem_ptr;
  ProblemManagerFunctionBegin;
  CHKERR m_field.get_problem(problem_name, &problem_ptr);
  boost::shared_ptr<NumeredDofEntity_multiIndex> dofs;
  switch (rc) {
  case ROW:
    dofs = problem_ptr->getNumeredRowDofsPtr();
    break;
  case COL:
    dofs = problem_ptr->getNumeredColDofsPtr();
  default:
    SETERRQ(PETSC_COMM_SELF, MOFEM_IMPOSSIBLE_CASE, "Should be row or column");
  }
  marker.resize(dofs->size(), 0);
  std::vector<unsigned char> marker_tmp;
 
  switch (op) {
  case MarkOP::OR:
    for (auto p = ents.pair_begin(); p != ents.pair_end(); ++p) {
      auto lo = dofs->get<Ent_mi_tag>().lower_bound(p->first);
      auto hi = dofs->get<Ent_mi_tag>().upper_bound(p->second);
      for (; lo != hi; ++lo) {
        if ((*lo)->getPetscLocalDofIdx() < 0)
          continue;
        marker[(*lo)->getPetscLocalDofIdx()] |= 1;
      }
    }
    break;
  case MarkOP::AND:
    marker_tmp.resize(dofs->size(), 0);
    for (auto p = ents.pair_begin(); p != ents.pair_end(); ++p) {
      auto lo = dofs->get<Ent_mi_tag>().lower_bound(p->first);
      auto hi = dofs->get<Ent_mi_tag>().upper_bound(p->second);
      for (; lo != hi; ++lo) {
        if ((*lo)->getPetscLocalDofIdx() < 0)
          continue;
        marker_tmp[(*lo)->getPetscLocalDofIdx()] = 1;
      }
    }
    for (int i = 0; i != marker.size(); ++i) {
      marker[i] &= marker_tmp[i];
    }
    break;
  }
 
  MoFEMFunctionReturn(0);
}

markDofs() [2/2]

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 620 of file ProblemsManager.hpp.

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

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.

                                                                 {
  *iface = const_cast<ProblemsManager *>(this);
  return 0;
}

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_name	name of the problem
field_name	name of the field
ents	entities on which DOFs are removed
lo_coeff	low dof coefficient (rank)
hi_coeff	high dof coefficient (rank)
verb	verbosity level
debug	to debug and seek for inconsistencies set to true

Returns

MoFEMErrorCode

Note

Use this function for non distributed meshes

Definition at line 3525 of file ProblemsManager.cpp.

                                                    {
  MoFEM::Interface &m_field = cOre;
  MoFEMFunctionBegin;
 
  auto bit_manager = m_field.getInterface<BitRefManager>();
 
  Range ents;
  if (ents_ptr) {
    ents = *ents_ptr;
    CHKERR bit_manager->filterEntitiesByRefLevel(bit_ref_level, bit_ref_mask,
                                                 ents, verb);
  } else {
    CHKERR bit_manager->getEntitiesByRefLevel(bit_ref_level, bit_ref_mask, ents,
                                              verb);
  }
 
  CHKERR removeDofsOnEntitiesNotDistributed(problem_name, field_name, ents,
                                            lo_coeff, hi_coeff, lo_order,
                                            hi_order, verb, debug);
 
  MoFEMFunctionReturn(0);
}

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_name	name of the problem
field_name	name of the field
ents	entities on which DOFs are removed
lo_coeff	low dof coefficient (rank)
hi_coeff	high dof coefficient (rank)
verb	verbosity level
debug	to debug and seek for inconsistencies set to true

Returns

MoFEMErrorCode

Note

Use this function for non-distributed meshes

Examples

mofem/atom_tests/remove_entities_from_problem_not_partitioned.cpp.

Definition at line 3231 of file ProblemsManager.cpp.

                                                                        {
 
  MoFEM::Interface &m_field = cOre;
  ProblemManagerFunctionBegin;
 
  const Problem *prb_ptr;
  CHKERR m_field.get_problem(problem_name, &prb_ptr);
 
  decltype(prb_ptr->numeredRowDofsPtr) numered_dofs[2] = {
      prb_ptr->numeredRowDofsPtr, nullptr};
  if (prb_ptr->numeredRowDofsPtr != prb_ptr->numeredColDofsPtr)
    numered_dofs[1] = prb_ptr->numeredColDofsPtr;
 
  int *nbdof_ptr[] = {&prb_ptr->nbDofsRow, &prb_ptr->nbDofsCol};
  int *local_nbdof_ptr[] = {&prb_ptr->nbLocDofsRow, &prb_ptr->nbLocDofsCol};
  int *ghost_nbdof_ptr[] = {&prb_ptr->nbGhostDofsRow, &prb_ptr->nbGhostDofsCol};
 
  const int nb_init_row_dofs = prb_ptr->getNbDofsRow();
  const int nb_init_col_dofs = prb_ptr->getNbDofsCol();
  const int nb_init_loc_row_dofs = prb_ptr->getNbLocalDofsRow();
  // const int nb_init_loc_col_dofs = prb_ptr->getNbLocalDofsCol();
  const int nb_init_ghost_row_dofs = prb_ptr->getNbGhostDofsRow();
  const int nb_init_ghost_col_dofs = prb_ptr->getNbGhostDofsCol();
 
  const std::array<int, 2> nb_init_dofs = {nb_init_row_dofs, nb_init_col_dofs};
 
  for (int s = 0; s != 2; ++s)
    if (numered_dofs[s]) {
 
      typedef multi_index_container<
 
          NumeredDofEntity_multiIndex::iterator, indexed_by<sequenced<>>
 
          >
          NumeredDofEntity_it_view_multiIndex;
 
      const auto bit_number = m_field.get_field_bit_number(field_name);
      NumeredDofEntity_it_view_multiIndex dofs_it_view;
 
      // Set -1 to global and local dofs indices
      for (auto pit = ents.const_pair_begin(); pit != ents.const_pair_end();
           ++pit) {
        auto lo = numered_dofs[s]->get<Unique_mi_tag>().lower_bound(
            DofEntity::getLoFieldEntityUId(bit_number, pit->first));
        auto hi = numered_dofs[s]->get<Unique_mi_tag>().upper_bound(
            DofEntity::getHiFieldEntityUId(bit_number, pit->second));
 
        for (; lo != hi; ++lo)
          if ((*lo)->getDofCoeffIdx() >= lo_coeff &&
              (*lo)->getDofCoeffIdx() <= hi_coeff &&
              (*lo)->getDofOrder() >= lo_order &&
              (*lo)->getDofOrder() <= hi_order)
            dofs_it_view.emplace_back(numered_dofs[s]->project<0>(lo));
      }
 
      if (verb > QUIET) {
        for (auto &dof : dofs_it_view)
          MOFEM_LOG("SYNC", Sev::noisy) << **dof;
      }
 
      // set negative index
      auto mod = NumeredDofEntity_part_and_all_indices_change(-1, -1, -1, -1);
      for (auto dit : dofs_it_view) {
        bool success = numered_dofs[s]->modify(dit, mod);
        if (!success)
          SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
                  "can not set negative indices");
      }
 
      // create weak view
      std::vector<boost::weak_ptr<NumeredDofEntity>> dosf_weak_view;
      dosf_weak_view.reserve(dofs_it_view.size());
      for (auto dit : dofs_it_view)
        dosf_weak_view.push_back(*dit);
 
      if (verb >= NOISY)
        MOFEM_LOG_C("SYNC", Sev::noisy,
                    "Number of DOFs in multi-index %d and to delete %d\n",
                    numered_dofs[s]->size(), dofs_it_view.size());
 
      // erase dofs from problem
      for (auto weak_dit : dosf_weak_view)
        if (auto dit = weak_dit.lock()) {
          numered_dofs[s]->erase(dit->getLocalUniqueId());
        }
 
      if (verb >= NOISY)
        MOFEM_LOG_C("SYNC", Sev::noisy,
                    "Number of DOFs in multi-index after delete %d\n",
                    numered_dofs[s]->size());
 
      // get current number of ghost dofs
      int nb_global_dof = 0;
      int nb_local_dofs = 0;
      int nb_ghost_dofs = 0;
 
      for (auto dit = numered_dofs[s]->begin(); dit != numered_dofs[s]->end();
           ++dit) {
 
        if ((*dit)->getDofIdx() >= 0) {
 
          if ((*dit)->getPetscLocalDofIdx() >= 0 &&
              (*dit)->getPetscLocalDofIdx() < *(local_nbdof_ptr[s]))
            ++nb_local_dofs;
          else if ((*dit)->getPetscLocalDofIdx() >= *(local_nbdof_ptr[s]))
            ++nb_ghost_dofs;
 
          ++nb_global_dof;
        }
      }
 
      if (debug) {
        MPI_Allreduce(&nb_local_dofs, nbdof_ptr[s], 1, MPI_INT, MPI_SUM,
                      m_field.get_comm());
        if (*(nbdof_ptr[s]) != nb_global_dof)
          SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                   "Number of local DOFs do not add up %d != %d",
                   *(nbdof_ptr[s]), nb_global_dof);
      }
 
      *(nbdof_ptr[s]) = nb_global_dof;
      *(local_nbdof_ptr[s]) = nb_local_dofs;
      *(ghost_nbdof_ptr[s]) = nb_ghost_dofs;
 
      // get indices
      auto get_indices_by_tag = [&](auto tag) {
        std::vector<int> indices;
        indices.resize(nb_init_dofs[s], -1);
        for (auto dit = numered_dofs[s]->get<Idx_mi_tag>().lower_bound(0);
             dit != numered_dofs[s]->get<Idx_mi_tag>().end(); ++dit) {
          indices[(*dit)->getDofIdx()] = decltype(tag)::get_index(dit);
        }
        return indices;
      };
 
      auto renumber = [&](auto tag, auto &indices) {
        MoFEMFunctionBegin;
        int idx = 0;
        for (auto dit = numered_dofs[s]->get<decltype(tag)>().lower_bound(0);
             dit != numered_dofs[s]->get<decltype(tag)>().end(); ++dit) {
          indices[(*dit)->getDofIdx()] = idx++;
        }
        MoFEMFunctionReturn(0);
      };
 
      auto get_sub_ao = [&](auto sub_data) {
        if (s == 0) {
          return sub_data->getSmartRowMap();
        } else {
          return sub_data->getSmartColMap();
        }
      };
 
      auto set_sub_is_and_ao = [&s, &prb_ptr](auto sub_data, auto is, auto ao) {
        if (s == 0) {
          sub_data->rowIs = is;
          sub_data->rowMap = ao;
          sub_data->colIs = is;
          sub_data->colMap = ao;
        } else {
          sub_data->colIs = is;
          sub_data->colMap = ao;
        }
      };
 
      auto apply_symmetry = [&s, &prb_ptr](auto sub_data) {
        if (s == 0) {
          if (prb_ptr->numeredRowDofsPtr == prb_ptr->numeredColDofsPtr) {
            sub_data->colIs = sub_data->getSmartRowIs();
            sub_data->colMap = sub_data->getSmartRowMap();
          }
        }
      };
 
      auto set_sub_data = [&](auto &indices) {
        MoFEMFunctionBegin;
        if (auto sub_data = prb_ptr->getSubData()) {
          // create is and then map it to main problem of sub-problem
          auto sub_is = createISGeneral(m_field.get_comm(), indices.size(),
                                        &*indices.begin(), PETSC_COPY_VALUES);
          // get old app, i.e. oroginal befor sub indices, and ao, from
          // app, to petsc sub indices.
          auto sub_ao = get_sub_ao(sub_data);
          CHKERR AOPetscToApplicationIS(sub_ao, sub_is);
          sub_ao = createAOMappingIS(sub_is, PETSC_NULLPTR);
          // set new sub ao
          set_sub_is_and_ao(sub_data, sub_is, sub_ao);
          apply_symmetry(sub_data);
        } else {
          prb_ptr->getSubData() = boost::make_shared<Problem::SubProblemData>();
          auto sub_is = createISGeneral(m_field.get_comm(), indices.size(),
                                        &*indices.begin(), PETSC_COPY_VALUES);
          auto sub_ao = createAOMappingIS(sub_is, PETSC_NULLPTR);
          // set sub is ao
          set_sub_is_and_ao(prb_ptr->getSubData(), sub_is, sub_ao);
          apply_symmetry(prb_ptr->getSubData());
        }
        MoFEMFunctionReturn(0);
      };
 
      auto global_indices = get_indices_by_tag(PetscGlobalIdx_mi_tag());
      auto local_indices = get_indices_by_tag(PetscLocalIdx_mi_tag());
      CHKERR set_sub_data(global_indices);
      CHKERR renumber(PetscGlobalIdx_mi_tag(), global_indices);
      CHKERR renumber(PetscLocalIdx_mi_tag(), local_indices);
 
      int i = 0;
      for (auto dit = numered_dofs[s]->begin(); dit != numered_dofs[s]->end();
           ++dit) {
        auto idx = (*dit)->getDofIdx();
        if (idx >= 0) {
          auto mod = NumeredDofEntity_part_and_all_indices_change(
              (*dit)->getPart(), i++, global_indices[idx], local_indices[idx]);
          bool success = numered_dofs[s]->modify(dit, mod);
          if (!success)
            SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
                    "can not set negative indices");
        } else {
          auto mod = NumeredDofEntity_part_and_all_indices_change(
              (*dit)->getPart(), -1, -1, -1);
          bool success = numered_dofs[s]->modify(dit, mod);
          if (!success)
            SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
                    "can not set negative indices");
        }
      };
 
      if (debug) {
        for (auto dof : (*numered_dofs[s])) {
          if (dof->getDofIdx() >= 0 && dof->getPetscGlobalDofIdx() < 0) {
            SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                    "Negative global idx");
          }
        }
      }
 
    } else {
 
      *(nbdof_ptr[1]) = *(nbdof_ptr[0]);
      *(local_nbdof_ptr[1]) = *(local_nbdof_ptr[0]);
      *(ghost_nbdof_ptr[1]) = *(ghost_nbdof_ptr[0]);
    }
 
  if (verb >= NOISY)
    MOFEM_LOG_SYNCHRONISE(m_field.get_comm());
 
  if (verb > QUIET) {
    MOFEM_LOG_C(
        "WORLD", Sev::inform,
        "Removed DOFs from problem %s dofs [%d / %d (before %d / %d) global]",
        prb_ptr->getName().c_str(), prb_ptr->getNbDofsRow(),
        prb_ptr->getNbDofsCol(), nb_init_row_dofs, nb_init_col_dofs);
    MOFEM_LOG_C("SYNC", Sev::verbose,
                "Removed DOFs from problem %s dofs [ %d / %d  "
                "(before %d / %d) local, %d / %d (before %d / %d)]",
                prb_ptr->getName().c_str(), prb_ptr->getNbLocalDofsRow(),
                prb_ptr->getNbLocalDofsCol(), nb_init_loc_row_dofs,
                nb_init_loc_row_dofs, prb_ptr->getNbGhostDofsRow(),
                prb_ptr->getNbGhostDofsCol(), nb_init_ghost_row_dofs,
                nb_init_ghost_col_dofs);
    MOFEM_LOG_SYNCHRONISE(m_field.get_comm());
  }
  MoFEMFunctionReturn(0);
}

Member Data Documentation

buildProblemFromFields

PetscBool MoFEM::ProblemsManager::buildProblemFromFields

If set to true, problem is build from

Definition at line 142 of file ProblemsManager.hpp.

cOre

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

Definition at line 138 of file ProblemsManager.hpp.

MOFEM_EVENT_ProblemsManager

PetscLogEvent MoFEM::ProblemsManager::MOFEM_EVENT_ProblemsManager

private

Definition at line 688 of file ProblemsManager.hpp.

synchroniseProblemEntities

PetscBool MoFEM::ProblemsManager::synchroniseProblemEntities

DOFs in fields, not from DOFs on elements.

Definition at line 145 of file ProblemsManager.hpp.

---

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

• src/interfaces/ProblemsManager.hpp
• src/interfaces/impl/ProblemsManager.cpp