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 ()

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)

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

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 add entities of finite element in 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 broke 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
	Mark DOFs.

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.

MoFEMErrorCode	addFieldToEmptyFieldBlocks (const std::string problem_name, const std::string row_field, const std::string col_field) const
	add empty block to problem

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.

Examples: EshelbianPlasticity.cpp, Remodeling.cpp, 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, 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, mofem/tutorials/vec-7/adjoint.cpp, nonlinear_dynamics.cpp, photon_diffusion.cpp, plate.cpp, prism_elements_from_surface.cpp, prism_polynomial_approximation.cpp, quad_polynomial_approximation.cpp, reaction_diffusion.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 };

MoFEM::ProblemsManager::AND

@ AND

Definition ProblemsManager.hpp:416

MoFEM::ProblemsManager::OR

@ OR

Definition ProblemsManager.hpp:416

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

◆ 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_name	problem name
row_field	row field name
col_field	col field name

Returns: MoFEMErrorCode

Definition at line 3686 of file ProblemsManager.cpp.

                                                                             {
 
  Interface &m_field = cOre;
  MoFEMFunctionBegin;
 
  const auto problem_ptr = m_field.get_problem(problem_name);
  auto get_field_id = [&](const std::string field_name) {
    return m_field.get_field_structure(field_name)->getId();
  };
  const auto row_id = get_field_id(row_field);
  const auto col_id = get_field_id(col_field);
 
  problem_ptr->addFieldToEmptyFieldBlocks(BlockFieldPair(row_id, col_id));
 
  MoFEMFunctionReturn(0);
}

◆ debugPartitionedProblem()

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

Definition at line 2080 of file ProblemsManager.cpp.

                                                                             {
  MoFEM::Interface &m_field = cOre;
  MoFEMFunctionBeginHot;
 
  auto save_ent = [](moab::Interface &moab, const std::string name,
                     const EntityHandle ent) {
    MoFEMFunctionBegin;
    EntityHandle out_meshset;
    CHKERR moab.create_meshset(MESHSET_SET, out_meshset);
    CHKERR moab.add_entities(out_meshset, &ent, 1);
    CHKERR moab.write_file(name.c_str(), "VTK", "", &out_meshset, 1);
    CHKERR moab.delete_entities(&out_meshset, 1);
    MoFEMFunctionReturn(0);
  };
 
  if (debug > 0) {
 
    typedef NumeredDofEntity_multiIndex::index<Idx_mi_tag>::type
        NumeredDofEntitysByIdx;
    NumeredDofEntitysByIdx::iterator dit, hi_dit;
    const NumeredDofEntitysByIdx *numered_dofs_ptr[] = {
        &(problem_ptr->numeredRowDofsPtr->get<Idx_mi_tag>()),
        &(problem_ptr->numeredColDofsPtr->get<Idx_mi_tag>())};
 
    int *nbdof_ptr[] = {&problem_ptr->nbDofsRow, &problem_ptr->nbDofsCol};
    int *local_nbdof_ptr[] = {&problem_ptr->nbLocDofsRow,
                              &problem_ptr->nbLocDofsCol};
 
    for (int ss = 0; ss < 2; ss++) {
 
      dit = numered_dofs_ptr[ss]->begin();
      hi_dit = numered_dofs_ptr[ss]->end();
      for (; dit != hi_dit; dit++) {
        if ((*dit)->getPart() == (unsigned int)m_field.get_comm_rank()) {
          if ((*dit)->getPetscLocalDofIdx() < 0) {
            std::ostringstream zz;
            zz << "rank " << m_field.get_comm_rank() << " " << **dit;
            SETERRQ(PETSC_COMM_SELF, MOFEM_IMPOSSIBLE_CASE,
                     "local dof index for %d (0-row, 1-col) not set, i.e. has "
                     "negative value\n %s",
                     ss, zz.str().c_str());
          }
          if ((*dit)->getPetscLocalDofIdx() >= *local_nbdof_ptr[ss]) {
            std::ostringstream zz;
            zz << "rank " << m_field.get_comm_rank() << " " << **dit;
            SETERRQ(PETSC_COMM_SELF, MOFEM_IMPOSSIBLE_CASE,
                     "local dofs for %d (0-row, 1-col) out of range\n %s", ss,
                     zz.str().c_str());
          }
        } else {
          if ((*dit)->getPetscGlobalDofIdx() < 0) {
 
            const EntityHandle ent = (*dit)->getEnt();
            CHKERR save_ent(
                m_field.get_moab(),
                "debug_part" +
                    boost::lexical_cast<std::string>(m_field.get_comm_rank()) +
                    "_negative_global_index.vtk",
                ent);
 
            std::ostringstream zz;
            zz << "rank " << m_field.get_comm_rank() << " "
               << dit->get()->getBitRefLevel() << " " << **dit;
            SETERRQ(PETSC_COMM_SELF, MOFEM_IMPOSSIBLE_CASE,
                     "global dof index for %d (0-row, 1-col) row not set, i.e. "
                     "has negative value\n %s",
                     ss, zz.str().c_str());
          }
          if ((*dit)->getPetscGlobalDofIdx() >= *nbdof_ptr[ss]) {
            std::ostringstream zz;
            zz << "rank " << m_field.get_comm_rank() << " nb_dofs "
               << *nbdof_ptr[ss] << " " << **dit;
            SETERRQ(PETSC_COMM_SELF, MOFEM_IMPOSSIBLE_CASE,
                     "global dofs for %d (0-row, 1-col) out of range\n %s", ss,
                     zz.str().c_str());
          }
        }
      }
    }
  }
  MoFEMFunctionReturnHot(0);
}

◆ getOptions()

MoFEMErrorCode MoFEM::ProblemsManager::getOptions ( )

Definition at line 62 of file ProblemsManager.cpp.

                                           {
  MoFEM::Interface &m_field = cOre;
  MoFEMFunctionBeginHot;
  PetscOptionsBegin(m_field.get_comm(), "", "Problem manager", "none");
  {
    CHKERR PetscOptionsBool(
        "-problem_build_from_fields",
        "Add DOFs to problem directly from fields not through DOFs on elements",
        "", buildProblemFromFields, &buildProblemFromFields, NULL);
  }
  PetscOptionsEnd();
  MoFEMFunctionReturnHot(0);
}

◆ 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
rc	row or column
field_name
ents	side entities
bridge_dim	dimension 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 2610 of file ProblemsManager.cpp.

        {
  MoFEM::Interface &m_field = cOre;
  ProblemManagerFunctionBegin;
 
  switch (rc) {
  case ROW:
  case COL:
    break;
  default:
    SETERRQ(m_field.get_comm(), MOFEM_INVALID_DATA, "invalid RowColData");
    break;
  }
 
  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;
 
  Range bridge_ents;
  CHKERR m_field.get_moab().get_adjacencies(
      ents, bridge_dim, false, bridge_ents, moab::Interface::UNION);
 
  auto &moab = m_field.get_moab();
  const auto bit_number = m_field.get_field_bit_number(field_name);
  const auto nb_coeffs =
      m_field.get_field_structure(field_name)->getNbOfCoeffs();
  const auto &side_dof_map = m_field.get_field_structure(field_name)
                                 ->getDofSideMap();
 
  using NumeredDofEntity_it_view_multiIndex = multi_index_container<
 
      NumeredDofEntity_multiIndex::iterator, indexed_by<sequenced<>>
 
      >;
  NumeredDofEntity_it_view_multiIndex dofs_it_view;
 
  for (auto pit = bridge_ents.const_pair_begin();
       pit != bridge_ents.const_pair_end(); ++pit) {
    auto lo = numered_dofs[rc]->get<Unique_mi_tag>().lower_bound(
        DofEntity::getLoFieldEntityUId(bit_number, pit->first));
    auto hi = numered_dofs[rc]->get<Unique_mi_tag>().upper_bound(
        DofEntity::getHiFieldEntityUId(bit_number, pit->second));
 
    auto bride_type = moab.type_from_handle(pit->first);
 
    for (; lo != hi; ++lo) {
      if ((*lo)->getDofCoeffIdx() >= lo_coeff &&
          (*lo)->getDofCoeffIdx() <= hi_coeff &&
          (*lo)->getDofOrder() >= lo_order &&
          (*lo)->getDofOrder() <= hi_order) {
        auto ent_dof_index = (*lo)->getEntDofIdx();
        auto side_it = side_dof_map.at(bride_type)
                           .get<EntDofIdx_mi_tag>()
                           .find(std::floor(static_cast<double>(ent_dof_index) /
                                            nb_coeffs));
        if (side_it !=
            side_dof_map.at(bride_type).get<EntDofIdx_mi_tag>().end()) {
          auto bridge_ent = (*lo)->getEnt();
          auto type = side_it->type;
          auto side = side_it->side;
          auto dim = CN::Dimension(type);
          EntityHandle side_ent = 0;
          CHKERR moab.side_element(bridge_ent, dim, side, side_ent);
          if (ents.find(side_ent) != ents.end()) {
            dofs_it_view.emplace_back(numered_dofs[rc]->project<0>(lo));
          }
        } else {
#ifndef NDEBUG
          MOFEM_LOG("SELF", Sev::error)
              << *m_field.get_field_structure(field_name);
          MOFEM_LOG("SELF", Sev::error)
              << "side not found for entity " << CN::EntityTypeName(bride_type);
          MOFEM_LOG("SELF", Sev::error)
              << "ent_dof_index / nb_coeffs "
              << std::floor(static_cast<double>(ent_dof_index) / nb_coeffs);
          MOFEM_LOG("SELF", Sev::error)
              << "side_dof_map.size() " << side_dof_map.size();
#endif // NDEBUG
          SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
                  "side not found - you will get more information in debug");
        }
      }
    }
  }
 
  if (verb > QUIET) {
    for (auto &dof : dofs_it_view)
      MOFEM_LOG("SYNC", Sev::noisy) << **dof;
    MOFEM_LOG_SEVERITY_SYNC(m_field.get_comm(), Sev::noisy);
  }
 
  vec_dof_view.reserve(vec_dof_view.size() + dofs_it_view.size());
  for (auto dit : dofs_it_view)
    vec_dof_view.push_back(*dit);
 
  MoFEMFunctionReturn(0);
}

◆ 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: boundary_marker.cpp, helmholtz.cpp, and test_cache_on_entities.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)
        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)
        marker_tmp[(*lo)->getPetscLocalDofIdx()] = 1;
    }
    for (int i = 0; i != marker.size(); ++i) {
      marker[i] &= marker_tmp[i];
    }
    break;
  }
 
  MoFEMFunctionReturn(0);
}

◆ 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.

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

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

        {
  Interface &m_field = cOre;
  ProblemManagerFunctionBegin;
 
  const Problem *problem_ptr;
  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();
    break;
  default:
    SETERRQ(PETSC_COMM_SELF, MOFEM_IMPOSSIBLE_CASE, "Should be row or column");
  }
  marker.resize(dofs->size(), 0);
 
  for (auto &dof : vec_dof_view) {
    if (auto dof_ptr = dof.lock()) {
      if (op == MarkOP::OR)
        marker[dof_ptr->getPetscLocalDofIdx()] |= 1;
      else
        marker[dof_ptr->getPetscLocalDofIdx()] &= 1;
    }
  }
 
  MoFEMFunctionReturn(0);
}

◆ 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 3600 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);
 
  auto dof_lo = dofs->get<Unique_mi_tag>().lower_bound(
      FieldEntity::getLoBitNumberUId(m_field.get_field_bit_number(field_name)));
  auto dof_hi = dofs->get<Unique_mi_tag>().upper_bound(
      FieldEntity::getHiBitNumberUId(m_field.get_field_bit_number(field_name)));
 
  auto marker_ref = [marker](auto &it) -> unsigned int & {
    return marker[(*it)->getPetscLocalDofIdx()];
  };
 
  switch (op) {
  case MarkOP::OR:
    for (; dof_lo != dof_hi; ++dof_lo)
      if ((*dof_lo)->getDofCoeffIdx() >= lo &&
          (*dof_lo)->getDofCoeffIdx() <= hi)
        marker[(*dof_lo)->getPetscLocalDofIdx()] |= c;
    break;
  case MarkOP::AND:
    for (; dof_lo != dof_hi; ++dof_lo)
      if ((*dof_lo)->getDofCoeffIdx() >= lo &&
          (*dof_lo)->getDofCoeffIdx() <= hi)
        marker[(*dof_lo)->getPetscLocalDofIdx()] &= c;
    break;
  }
 
  MoFEMFunctionReturn(0);
}

◆ printPartitionedProblem()

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

Definition at line 2061 of file ProblemsManager.cpp.

                                                                             {
  MoFEM::Interface &m_field = cOre;
  ProblemManagerFunctionBegin;
 
  if (verb > QUIET) {
 
    MOFEM_LOG("SYNC", Sev::inform)
        << problem_ptr->getName() << " Nb. local dof "
        << problem_ptr->getNbLocalDofsRow() << " by "
        << problem_ptr->getNbLocalDofsCol() << " nb global dofs "
        << problem_ptr->getNbDofsRow() << " by " << problem_ptr->getNbDofsCol();
 
    MOFEM_LOG_SYNCHRONISE(m_field.get_comm())
  }
 
  MoFEMFunctionReturn(0);
}

◆ 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;
}

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

                      {
 
  MoFEM::Interface &m_field = cOre;
  ProblemManagerFunctionBegin;
 
  switch (rc) {
  case ROW:
  case COL:
    break;
  default:
    SETERRQ(PETSC_COMM_SELF, MOFEM_IMPOSSIBLE_CASE, "Should be row or column");
  }
 
  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_ghost_row_dofs = prb_ptr->getNbGhostDofsRow();
  const int nb_init_ghost_col_dofs = prb_ptr->getNbGhostDofsCol();
 
  if (numered_dofs[rc]) {
 
    if (verb >= NOISY)
      MOFEM_LOG_C("SYNC", Sev::noisy,
                  "Number of DOFs in multi-index %d and to delete %d\n",
                  numered_dofs[rc]->size(), vec_dof_view.size());
 
    // erase dofs from problem
    for (auto weak_dit : vec_dof_view)
      if (auto dit = weak_dit.lock()) {
        numered_dofs[rc]->erase(dit->getLocalUniqueId());
      }
 
    if (verb >= NOISY)
      MOFEM_LOG_C("SYNC", Sev::noisy,
                  "Number of DOFs in multi-index after delete %d\n",
                  numered_dofs[rc]->size());
 
    // get current number of ghost dofs
    int nb_local_dofs = 0;
    int nb_ghost_dofs = 0;
    for (auto dit = numered_dofs[rc]->get<PetscLocalIdx_mi_tag>().begin();
         dit != numered_dofs[rc]->get<PetscLocalIdx_mi_tag>().end(); ++dit) {
      if ((*dit)->getPetscLocalDofIdx() >= 0 &&
          (*dit)->getPetscLocalDofIdx() < *(local_nbdof_ptr[rc]))
        ++nb_local_dofs;
      else if ((*dit)->getPetscLocalDofIdx() >= *(local_nbdof_ptr[rc]))
        ++nb_ghost_dofs;
      else
        SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                 "Impossible case. You could run problem on no distributed "
                 "mesh. That is not implemented. Dof local index is %d",
                 (*dit)->getPetscLocalDofIdx());
    }
 
    // get indices
    auto get_indices_by_tag = [&](auto tag, auto &indices, bool only_local) {
      const int nb_dofs = numered_dofs[rc]->size();
      indices.clear();
      indices.reserve(nb_dofs);
      for (auto dit = numered_dofs[rc]->get<decltype(tag)>().begin();
           dit != numered_dofs[rc]->get<decltype(tag)>().end(); ++dit) {
        bool add = true;
        if (only_local) {
          if ((*dit)->getPetscLocalDofIdx() < 0 ||
              (*dit)->getPetscLocalDofIdx() >= *(local_nbdof_ptr[rc])) {
            add = false;
          }
        }
        if (add)
          indices.push_back(decltype(tag)::get_index(dit));
      }
    };
 
    auto get_indices_by_uid = [&](auto tag, auto &indices) {
      const int nb_dofs = numered_dofs[rc]->size();
      indices.clear();
      indices.reserve(nb_dofs);
      for (auto dit = numered_dofs[rc]->begin(); dit != numered_dofs[rc]->end();
           ++dit)
        indices.push_back(decltype(tag)::get_index(dit));
    };
 
    auto get_sub_ao = [&](auto sub_data) {
      if (rc == 0) {
        return sub_data->getSmartRowMap();
      } else {
        return sub_data->getSmartColMap();
      }
    };
 
    auto set_sub_is_and_ao = [&rc, &prb_ptr](auto sub_data, auto is, auto ao) {
      if (rc == ROW) {
        sub_data->rowIs = is;
        sub_data->rowMap = ao;
        sub_data->colIs = is; // if square problem col is equal to row
        sub_data->colMap = ao;
      } else {
        sub_data->colIs = is;
        sub_data->colMap = ao;
      }
    };
 
    auto apply_symmetry = [&rc, &prb_ptr](auto sub_data) {
      if (rc == ROW) {
        if (prb_ptr->numeredRowDofsPtr == prb_ptr->numeredColDofsPtr) {
          sub_data->colIs = sub_data->getSmartRowIs();
          sub_data->colMap = sub_data->getSmartRowMap();
        }
      }
    };
 
    auto concatenate_dofs = [&](auto tag, auto &indices,
                                const auto local_only) {
      MoFEMFunctionBegin;
      get_indices_by_tag(tag, indices, local_only);
 
      SmartPetscObj<AO> ao;
      // Create AO from app indices (i.e. old), to pestc indices (new after
      // remove)
      if (local_only)
        ao = createAOMapping(m_field.get_comm(), indices.size(),
                             &*indices.begin(), PETSC_NULLPTR);
      else
        ao = createAOMapping(PETSC_COMM_SELF, indices.size(), &*indices.begin(),
                             PETSC_NULLPTR);
 
      // Set mapping to sub dm data
      if (local_only) {
        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 {
          // create sub data
          prb_ptr->getSubData() = boost::make_shared<Problem::SubProblemData>();
          auto sub_is = createISGeneral(m_field.get_comm(), indices.size(),
                                        &*indices.begin(), PETSC_COPY_VALUES);
          // set sub is ao
          set_sub_is_and_ao(prb_ptr->getSubData(), sub_is, ao);
          apply_symmetry(prb_ptr->getSubData());
        }
      }
 
      get_indices_by_uid(tag, indices);
      CHKERR AOApplicationToPetsc(ao, indices.size(), &*indices.begin());
 
      MoFEMFunctionReturn(0);
    };
 
    // set indices index
    auto set_concatenated_indices = [&]() {
      std::vector<int> global_indices;
      std::vector<int> local_indices;
      MoFEMFunctionBegin;
      CHKERR concatenate_dofs(PetscGlobalIdx_mi_tag(), global_indices, true);
      CHKERR concatenate_dofs(PetscLocalIdx_mi_tag(), local_indices, false);
      auto gi = global_indices.begin();
      auto li = local_indices.begin();
      for (auto dit = numered_dofs[rc]->begin(); dit != numered_dofs[rc]->end();
           ++dit) {
        auto mod = NumeredDofEntity_part_and_all_indices_change(
            (*dit)->getPart(), (*dit)->getDofIdx(), *gi, *li);
        bool success = numered_dofs[rc]->modify(dit, mod);
        if (!success)
          SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
                  "can not set negative indices");
        ++gi;
        ++li;
      }
      MoFEMFunctionReturn(0);
    };
    CHKERR set_concatenated_indices();
 
    MPI_Allreduce(&nb_local_dofs, nbdof_ptr[rc], 1, MPI_INT, MPI_SUM,
                  m_field.get_comm());
    *(local_nbdof_ptr[rc]) = nb_local_dofs;
    *(ghost_nbdof_ptr[rc]) = nb_ghost_dofs;
 
    if (debug)
      for (auto dof : (*numered_dofs[rc])) {
        if (dof->getPetscGlobalDofIdx() < 0) {
          SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
                  "Negative global idx");
        }
        if (dof->getPetscLocalDofIdx() < 0) {
          SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
                  "Negative local 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 > 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_SEVERITY_SYNC(m_field.get_comm(), Sev::verbose);
  }
 
  MoFEMFunctionReturn(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: 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 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:

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

Public Types

Public Member Functions

Public Attributes

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ MarkOP

Constructor & Destructor Documentation

◆ ProblemsManager()

◆ ~ProblemsManager()

Member Function Documentation

◆ addFieldToEmptyFieldBlocks()

◆ debugPartitionedProblem()

◆ getOptions()

◆ getSideDofsOnBrokenSpaceEntities()

◆ markDofs() [1/3]

◆ markDofs() [2/3]

◆ markDofs() [3/3]

◆ modifyMarkDofs()

◆ printPartitionedProblem()

◆ query_interface()

◆ removeDofs()

◆ removeDofsOnEntitiesNotDistributed() [1/2]

◆ removeDofsOnEntitiesNotDistributed() [2/2]

Member Data Documentation

◆ buildProblemFromFields

◆ cOre

◆ MOFEM_EVENT_ProblemsManager

◆ synchroniseProblemEntities