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. 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	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	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
virtual MoFEMErrorCode	query_interface (boost::typeindex::type_index type_index, UnknownInterface **iface) const =0

template<class IFACE >
MoFEMErrorCode	registerInterface (bool error_if_registration_failed=true)
	Register interface. More...

template<class IFACE >
MoFEMErrorCode	getInterface (IFACE *&iface) const
	Get interface refernce 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.

Definition at line 21 of file ProblemsManager.hpp.

Member Enumeration Documentation

◆ MarkOP

enum MoFEM::ProblemsManager::MarkOP

Enumerator
OR
AND

Definition at line 365 of file ProblemsManager.hpp.

365{ OR, AND };

MoFEM::ProblemsManager::AND

@ AND

Definition: ProblemsManager.hpp:365

MoFEM::ProblemsManager::OR

@ OR

Definition: ProblemsManager.hpp:365

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 specifi which blocks are empty.

Parameters

problem_name	problem name
row_field	row filed name
col_field	col field name

Returns: MoFEMErrorCode

Definition at line 3296 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(EmptyFieldBlocks(row_id, col_id));
 
  MoFEMFunctionReturn(0);
}

◆ debugPartitionedProblem()

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

Definition at line 2086 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;
            SETERRQ2(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;
            SETERRQ2(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;
            SETERRQ2(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;
            SETERRQ2(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;
  CHKERR 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);
  }
  ierr = PetscOptionsEnd();
  CHKERRG(ierr);
  MoFEMFunctionReturnHot(0);
}

◆ 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: helmholtz.cpp, and test_cache_on_entities.cpp.

Definition at line 3200 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/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 387 of file ProblemsManager.hpp.

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

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

◆ 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 nondistributed meshes

Definition at line 3172 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 nondistributed meshes

Examples: remove_entities_from_problem_not_partitioned.cpp.

Definition at line 2878 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)
          SETERRQ2(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;
        } 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_NULL);
          // 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_NULL);
          // 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 427 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()

◆ markDofs() [1/2]

◆ markDofs() [2/2]

◆ modifyMarkDofs()

◆ printPartitionedProblem()

◆ query_interface()

◆ removeDofsOnEntitiesNotDistributed() [1/2]

◆ removeDofsOnEntitiesNotDistributed() [2/2]

Member Data Documentation

◆ buildProblemFromFields

◆ cOre

◆ MOFEM_EVENT_ProblemsManager

◆ synchroniseProblemEntities