Multi-index containers, data structures for problems and other low-level functions. More...

Classes
struct	MoFEM::ComposedProblemsData

struct	MoFEM::Problem
	keeps basic data about problem More...

struct	MoFEM::Problem::SubProblemData
	Subproblem problem data. More...

struct	MoFEM::ProblemChangeRefLevelBitAdd
	add ref level to problem More...

struct	MoFEM::ProblemChangeRefLevelBitSet
	set ref level to problem More...

struct	MoFEM::ProblemChangeRefLevelBitDofMaskSet
	set prof dof bit ref mask More...

struct	MoFEM::ProblemFiniteElementChangeBitAdd
	add finite element to problem More...

struct	MoFEM::ProblemChangeRefLevelBitDofMaskAdd
	set prof dof bit ref mask More...

struct	MoFEM::ProblemFiniteElementChangeBitUnSet
	remove finite element from problem More...

struct	MoFEM::ProblemZeroNbRowsChange
	zero nb. of DOFs in row More...

struct	MoFEM::ProblemZeroNbColsChange
	zero nb. of DOFs in col More...

struct	MoFEM::ProblemClearNumeredFiniteElementsChange
	clear problem finite elements More...

struct	MoFEM::ProblemClearSubProblemData
	Clear sub-problem data structure. More...

struct	MoFEM::ProblemClearComposedProblemData
	Clear composed problem data structure. More...

Namespaces
namespace	MoFEM
	implementation of Data Operators for Forces and Sources

Macros
#define	_IT_NUMEREDDOF_ROW_FOR_LOOP_(PROBLEMPTR, IT)
	use with loops to iterate row DOFs

#define	_IT_NUMEREDDOF_COL_FOR_LOOP_(PROBLEMPTR, IT)

#define	_IT_NUMEREDDOF_ROW_BY_LOCIDX_FOR_LOOP_(PROBLEMPTR, IT)
	use with loops to iterate row DOFs

#define	_IT_NUMEREDDOF_COL_BY_LOCIDX_FOR_LOOP_(PROBLEMPTR, IT)
	use with loops to iterate col DOFs

#define	_IT_NUMEREDDOF_ROW_BY_ENT_FOR_LOOP_(PROBLEMPTR, ENT, IT)
	use with loops to iterate row DOFs

#define	_IT_NUMEREDDOF_COL_BY_ENT_FOR_LOOP_(PROBLEMPTR, ENT, IT)
	use with loops to iterate col DOFs

#define	_IT_NUMEREDDOF_ROW_BY_BITNUMBER_FOR_LOOP_(PROBLEMPTR, FIELD_BIT_NUMBER, IT)

#define	_IT_NUMEREDDOF_COL_BY_BITNUMBER_FOR_LOOP_(PROBLEMPTR, FIELD_BIT_NUMBER, IT)
	use with loops to iterate col DOFs

Typedefs
using	MoFEM::BlockFieldPair = Problem::BlockFieldPair

using	MoFEM::EmptyFieldBlocks = Problem::EmptyFieldBlocks

typedef multi_index_container< Problem, indexed_by< ordered_unique< tag< Meshset_mi_tag >, member< Problem, EntityHandle, &Problem::meshset > >, hashed_unique< tag< BitProblemId_mi_tag >, const_mem_fun< Problem, BitProblemId, &Problem::getId >, HashBit< BitProblemId >, EqBit< BitProblemId > >, hashed_unique< tag< Problem_mi_tag >, const_mem_fun< Problem, std::string, &Problem::getName > > > >	Problem_multiIndex
	MultiIndex for entities for Problem.

Detailed Description

Multi-index containers, data structures for problems and other low-level functions.

Definition in file ProblemsMultiIndices.hpp.

Macro Definition Documentation

◆ _IT_NUMEREDDOF_COL_BY_LOCIDX_FOR_LOOP_

#define _IT_NUMEREDDOF_COL_BY_LOCIDX_FOR_LOOP_	(	PROBLEMPTR,
		IT
	)

Value:

  NumeredDofEntityByUId::iterator IT =                                         \
      PROBLEMPTR->getNumeredColDofsByLocIdxBegin(0);                           \
  IT != PROBLEMPTR->getNumeredColDofsByLocIdxEnd(                              \
            PROBLEMPTR->getNbLocalDofsRow() - 1);                              \
  IT++

use with loops to iterate col DOFs

for(_IT_NUMEREDDOF_COL_BY_LOCIDX_FOR_LOOP_(PROBLEMPTR,IT)) {
  ...
}

Definition at line 239 of file ProblemsMultiIndices.hpp.

                                                                 {
    return numeredRowDofsPtr->get<PetscLocalIdx_mi_tag>().lower_bound(locidx);
  }
 
  /// get end iterator for numeredRowDofsPtr (insted you can use
  /// #_IT_NUMEREDDOF_ROW_FOR_LOOP_ for loops)
  auto getNumeredRowDofsByLocIdxEnd(const DofIdx locidx) const {
    return numeredRowDofsPtr->get<PetscLocalIdx_mi_tag>().upper_bound(locidx);
  }
 
  /// get begin iterator for numeredColDofsPtr (insted you can use
  /// #_IT_NUMEREDDOF_COL_FOR_LOOP_ for loops)
  auto getNumeredColDofsByLocIdxBegin(const DofIdx locidx) const {
    return numeredColDofsPtr->get<PetscLocalIdx_mi_tag>().lower_bound(locidx);
  }
 
  /// get end iterator for numeredColDofsPtr (insted you can use
  /// #_IT_NUMEREDDOF_COL_FOR_LOOP_ for loops)
  auto getNumeredColDofsByLocIdxEnd(const DofIdx locidx) const {
    return numeredColDofsPtr->get<PetscLocalIdx_mi_tag>().upper_bound(locidx);
  }
 
/**
 * \brief use with loops to iterate row DOFs
 * \ingroup problems_multi_indices
 *
 * \code
 * for(_IT_NUMEREDDOF_BY_ENT_ROW_FOR_LOOP_(PROBLEMPTR,ENT,IT)) {
 *   ...
 * }
 * \endcode
 *
 */
#define _IT_NUMEREDDOF_ROW_BY_ENT_FOR_LOOP_(PROBLEMPTR, ENT, IT)               \
  auto IT = PROBLEMPTR->getNumeredRowDofsByEntBegin(ENT);                      \
  IT != PROBLEMPTR->getNumeredRowDofsByEntEnd(ENT);                            \
  IT++
 
/**
 * \brief use with loops to iterate col DOFs
 * \ingroup problems_multi_indices
 *
 * \code
 * for(_IT_NUMEREDDOF_COL_BY_ENT_FOR_LOOP_(PROBLEMPTR,ENT,IT)) {
 *   ...
 * }
 * \endcode
 *
 */
#define _IT_NUMEREDDOF_COL_BY_ENT_FOR_LOOP_(PROBLEMPTR, ENT, IT)               \
  auto IT = PROBLEMPTR->getNumeredColDofsByEntBegin(ENT);                      \
  IT != PROBLEMPTR->getNumeredColDofsByEntEnd(ENT);                            \
  IT++
 
  /// get begin iterator for numeredRowDofsPtr (insted you can use
  /// #_IT_NUMEREDDOF_ROW_BY_ENT_FOR_LOOP_ for loops)
  auto getNumeredRowDofsByEntBegin(const EntityHandle ent) const {
    return numeredRowDofsPtr->get<Ent_mi_tag>().lower_bound(ent);
  }
 
  /// get end iterator for numeredRowDofsPtr (insted you can use
  /// #_IT_NUMEREDDOF_ROW_BY_ENT_FOR_LOOP_ for loops)
  auto getNumeredRowDofsByEntEnd(const EntityHandle ent) const {
    return numeredRowDofsPtr->get<Ent_mi_tag>().upper_bound(ent);
  }
 
  /// get begin iterator for numeredColDofsPtr (insted you can use
  /// #_IT_NUMEREDDOF_COL_BY_ENT_FOR_LOOP_ for loops)
  auto getNumeredColDofsByEntBegin(const EntityHandle ent) const {
    return numeredColDofsPtr->get<Ent_mi_tag>().lower_bound(ent);
  }
 
  /// get end iterator for numeredColDofsPtr (insted you can use
  /// #_IT_NUMEREDDOF_COL_BY_ENT_FOR_LOOP_ for loops)
  auto getNumeredColDofsByEntEnd(const EntityHandle ent) const {
    return numeredColDofsPtr->get<Ent_mi_tag>().upper_bound(ent);
  }
 
/**
 * use with loops to iterate row DOFs
 * \ingroup problems_multi_indices
 *
 * \code
 * for(_IT_NUMEREDDOF_BY_NAME_ROW_FOR_LOOP_(PROBLEMPTR,m_field.get_field_bit_number(FIELD_BIT_NUMBER),IT))
 * {
 *   ...
 * }
 * \endcode
 *
 */
#define _IT_NUMEREDDOF_ROW_BY_BITNUMBER_FOR_LOOP_(PROBLEMPTR,                  \
                                                  FIELD_BIT_NUMBER, IT)        \
  auto IT = PROBLEMPTR->numeredRowDofsPtr->lower_bound(                        \
      FieldEntity::getLoBitNumberUId(FIELD_BIT_NUMBER));                       \
  IT != PROBLEMPTR->numeredRowDofsPtr->upper_bound(                            \
            FieldEntity::getHiBitNumberUId(FIELD_BIT_NUMBER));                 \
  IT++
 
/**
 * \brief use with loops to iterate col DOFs
 * \ingroup problems_multi_indices
 *
 * \code
 * for(_IT_NUMEREDDOF_COL_BY_BITNUMBER_FOR_LOOP_(PROBLEMPTR,m_field.get_field_bit_number(FIELD_BIT_NUMBER),IT))
 * {
 *   ...
 * }
 * \endcode
 *
 */
#define _IT_NUMEREDDOF_COL_BY_BITNUMBER_FOR_LOOP_(PROBLEMPTR,                  \
                                                  FIELD_BIT_NUMBER, IT)        \
  auto IT = PROBLEMPTR->numeredColDofsPtr->lower_bound(                        \
      FieldEntity::getLoBitNumberUId(FIELD_BIT_NUMBER));                       \
  IT != PROBLEMPTR->numeredColDofsPtr->upper_bound(                            \
            FieldEntity::getHiBitNumberUId(FIELD_BIT_NUMBER));                 \
  IT++
 
  Problem(Interface &moab, const EntityHandle meshset);
 
  virtual ~Problem() = default;
 
  inline BitProblemId getId() const { return *((BitProblemId *)tagId); }
 
  inline auto getName() const {
    return std::string((char *)tagName, tagNameSize);
  }
 
  inline DofIdx getNbDofsRow() const { return nbDofsRow; }
  inline DofIdx getNbDofsCol() const { return nbDofsCol; }
  inline DofIdx getNbLocalDofsRow() const { return nbLocDofsRow; }
  inline DofIdx getNbLocalDofsCol() const { return nbLocDofsCol; }
  inline DofIdx getNbGhostDofsRow() const { return nbGhostDofsRow; }
  inline DofIdx getNbGhostDofsCol() const { return nbGhostDofsCol; }
 
  inline BitRefLevel getBitRefLevel() const { return *tagBitRefLevel; }
  inline BitRefLevel getBitRefLevelMask() const { return *tagBitRefLevelMask; }
 
  // DEPRECATED inline BitRefLevel getMaskBitRefLevel() const {
  //   return *tagBitRefLevelMask;
  // }
 
  /**
   * @brief Get the Row Dofs By Petsc Global Dof Idx object
   *
   * @param idx
   * @param dof_ptr
   * @param bh
   * @return MoFEMErrorCode
   */
  MoFEMErrorCode getRowDofsByPetscGlobalDofIdx(DofIdx idx,
                                               const NumeredDofEntity **dof_ptr,
                                               MoFEMTypes bh = MF_EXIST) const;
 
  /**
   * @brief Get the Col Dofs By Petsc Global Dof Idx object
   *
   * @param idx
   * @param dof_ptr
   * @param bh
   * @return MoFEMErrorCode
   */
  MoFEMErrorCode getColDofsByPetscGlobalDofIdx(DofIdx idx,
                                               const NumeredDofEntity **dof_ptr,
                                               MoFEMTypes bh = MF_EXIST) const;
 
  /**
   * @brief Get the Row Dofs By Petsc Global Dof Idx object
   *
   * @param idx
   * @return boost::weak_ptr<NumeredDofEntity>
   */
  boost::weak_ptr<NumeredDofEntity>
  getRowDofsByPetscGlobalDofIdx(DofIdx idx) const;
 
  /**
   * @brief Get the Col Dofs By Petsc Global Dof Idx object
   *
   * @param idx
   * @return boost::weak_ptr<NumeredDofEntity>
   */
  boost::weak_ptr<NumeredDofEntity>
  getColDofsByPetscGlobalDofIdx(DofIdx idx) const;
 
  /**
   * @brief Get the BitFEIDs in problem  
   * @return BitFEId 
   */
  BitFEId getBitFEId() const;
 
  friend std::ostream &operator<<(std::ostream &os, const Problem &e);
 
  /**
   * \brief Get number of finite elements by name on processors
   *
   * Size retuned IS is equal to size of processors.
   *
   * What PetscLayout see,
   <http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/IS/index.html>
   *
   * Example of usage for layout
   * \code
 
   PetscInt rstart, rend;
   ierr = PetscLayoutGetRange(layout, &rstart, &rend); CHKERRG(ierr);
   int global_size;
   ierr = PetscLayoutGetSize(layout,&global_size); CHKERRG(ierr);
 
   \endcode
   *
   * @param  comm Communicator
   * @param  name Finite element name
   * @param  layout Get number of elements on each processor
   * @return      error code
   */
  MoFEMErrorCode getNumberOfElementsByNameAndPart(MPI_Comm comm,
                                                  const std::string name,
                                                  PetscLayout *layout) const;
 
  /**
   * \brief Get number of finite elements on processors
   *
   * Size retuned IS is equal to size of processors.
   *
   * What PetscLayout see,
   <http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/IS/index.html>
   *
   * Example of usage for layout
   * \code
 
   PetscInt rstart, rend;
   ierr = PetscLayoutGetRange(layout, &rstart, &rend); CHKERRG(ierr);
   int global_size;
   ierr = PetscLayoutGetSize(layout,&global_size); CHKERRG(ierr);
 
   \endcode
   *
   * @param  comm Communicator
   * @param  layout Get number of elements on each processor
   * @return      error code
   */
  MoFEMErrorCode getNumberOfElementsByPart(MPI_Comm comm,
                                           PetscLayout *layout) const;
 
  typedef multi_index_container<boost::weak_ptr<std::vector<NumeredDofEntity>>,
                                indexed_by<sequenced<>>>
      SequenceDofContainer;
 
  /**
   * \brief Get reference to sequence data numbered dof container
   *
   * In sequence data container data are physically stored. The purpose of this
   * is to allocate NumeredDofEntity data in bulk, having only one allocation
   instead
   * each time entity is inserted. That makes code efficient.
   *
   * The vector in sequence is destroyed if last entity inside that vector is
   * destroyed. All MoFEM::NumeredDofEntity have aliased shared_ptr which points
   to the vector.
 
   * @return MoFEM::Problem::SequenceDofContainer
   */
  inline auto &getRowDofsSequence() const { return sequenceRowDofContainer; }
 
  /**
   * \brief Get reference to sequence data numbered dof container
   *
   * In sequence data container data are physically stored. The purpose of this
   * is to allocate NumeredDofEntity data in bulk, having only one allocation
   instead
   * each time entity is inserted. That makes code efficient.
   *
   * The vector in sequence is destroyed if last entity inside that vector is
   * destroyed. All MoFEM::NumeredDofEntity have aliased shared_ptr which points
   to the vector.
 
   * @return MoFEM::Problem::SequenceDofContainer
   */
  inline auto &getColDofsSequence() const { return sequenceColDofContainer; }
 
  using BlockFieldPair = std::pair<BitFieldId, BitFieldId>;
  using EmptyFieldBlocks = std::vector<BlockFieldPair>;
 
  /**
   * @brief Get the empty field blocks
   *
   * Emtpy field blocks is a pair contains IDs of the fields for which matrix
   * has zero entries.
   *
   * @return EmptyFieldBlocks&
   */
  inline EmptyFieldBlocks &getEmptyFieldBlocks() const {
    return emptyFieldBlocks;
  }
 
  /**
   * @brief Add fields to the empty field blocks
   *
   * Emtpy field blocks is a pair contains IDs of the fields for which matrix
   * has zero entries.
   *
   * @param add_fields
   * @return EmptyFieldBlocks&
   */
  inline BlockFieldPair &
  addFieldToEmptyFieldBlocks(const BlockFieldPair add_fields) const {
    emptyFieldBlocks.push_back(add_fields);
    return emptyFieldBlocks.back();
  }
 
private:
  // Keep vector of DoFS on entity
  mutable boost::shared_ptr<SequenceDofContainer> sequenceRowDofContainer;
  mutable boost::shared_ptr<SequenceDofContainer> sequenceColDofContainer;
 
  mutable EmptyFieldBlocks emptyFieldBlocks;
};
 
using BlockFieldPair = Problem::BlockFieldPair;
using EmptyFieldBlocks = Problem::EmptyFieldBlocks;
 
/**
 * \brief Subproblem problem data
 */
struct Problem::SubProblemData {
 
  SmartPetscObj<IS>
      rowIs; ///< indices of main problem of which sub problem is this
  SmartPetscObj<IS>
      colIs; ///< indices of main problem of which sub problem is this
  SmartPetscObj<AO>
      rowMap; ///< mapping form main problem indices to sub-problem indices
  SmartPetscObj<AO>
      colMap; ///< mapping form main problem indices to sub-problem indices
 
  inline auto getSmartRowIs() { return rowIs; }
  inline auto getSmartColIs() { return colIs; }
  inline auto getSmartRowMap() { return rowMap; }
  inline auto getSmartColMap() { return colMap; }
 
  /**
   * get row Is for sub problem
   * @param  is create is
   * @return    error code
   */
  inline MoFEMErrorCode getRowIs(IS *is) {
    MoFEMFunctionBeginHot;
    *is = rowIs;
    PetscObjectReference((PetscObject)(*is));
    MoFEMFunctionReturnHot(0);
  }
 
  /**
   * get col Is for sub problem
   * @param  is create is
   * @return    error code
   */
  inline MoFEMErrorCode getColIs(IS *is) {
    MoFEMFunctionBeginHot;
    *is = colIs;
    PetscObjectReference((PetscObject)(*is));
    MoFEMFunctionReturnHot(0);
  };
 
  /**
   * get row AO mapping for sub problem
   * @param  ao get mapping
   * @return    error code
   */
  inline MoFEMErrorCode getRowMap(AO *ao) {
    MoFEMFunctionBeginHot;
    *ao = rowMap;
    PetscObjectReference((PetscObject)(*ao));
    MoFEMFunctionReturnHot(0);
  }
 
  /**
   * get col AO mapping for sub problem
   * @param  ao get mapping
   * @return    error code
   */
  inline MoFEMErrorCode getColMap(AO *ao) {
    MoFEMFunctionBeginHot;
    *ao = colMap;
    PetscObjectReference((PetscObject)(*ao));
    MoFEMFunctionReturnHot(0);
  }
 
  SubProblemData() = default;
  virtual ~SubProblemData() = default;
};
 
using EmptyFieldBlocks = Problem::EmptyFieldBlocks;
 
/**
 * @relates multi_index_container
 * \brief MultiIndex for entities for Problem
 * \ingroup fe_multi_indices
 */
typedef multi_index_container<
    Problem,
    indexed_by<
        ordered_unique<tag<Meshset_mi_tag>,
                       member<Problem, EntityHandle, &Problem::meshset>>,
        hashed_unique<tag<BitProblemId_mi_tag>,
                      const_mem_fun<Problem, BitProblemId, &Problem::getId>,
                      HashBit<BitProblemId>, EqBit<BitProblemId>>,
        hashed_unique<tag<Problem_mi_tag>,
                      const_mem_fun<Problem, std::string, &Problem::getName>>>>
    Problem_multiIndex;
 
/** \brief add ref level to problem
 * \ingroup problems_multi_indices
 */
struct ProblemChangeRefLevelBitAdd {
  BitRefLevel bit;
  ProblemChangeRefLevelBitAdd(const BitRefLevel _bit) : bit(_bit){};
  void operator()(Problem &p) { *(p.tagBitRefLevel) |= bit; };
};
 
/** \brief set ref level to problem
 * \ingroup problems_multi_indices
 */
struct ProblemChangeRefLevelBitSet {
  BitRefLevel bit;
  ProblemChangeRefLevelBitSet(const BitRefLevel _bit) : bit(_bit){};
  void operator()(Problem &p) { *(p.tagBitRefLevel) = bit; };
};
 
/** \brief set prof dof bit ref mask
 * \ingroup problems_multi_indices
 */
struct ProblemChangeRefLevelBitDofMaskSet {
  BitRefLevel bit;
  ProblemChangeRefLevelBitDofMaskSet(const BitRefLevel _bit) : bit(_bit){};
  void operator()(Problem &p) { *(p.tagBitRefLevelMask) = bit; };
};
 
/** \brief add finite element to problem
 * \ingroup problems_multi_indices
 */
struct ProblemFiniteElementChangeBitAdd {
  BitFEId f_id;
  ProblemFiniteElementChangeBitAdd(const BitFEId _f_id) : f_id(_f_id){};
  void operator()(Problem &p);
};
 
/** \brief set prof dof bit ref mask
 * \ingroup problems_multi_indices
 */
struct ProblemChangeRefLevelBitDofMaskAdd {
  BitRefLevel bit;
  ProblemChangeRefLevelBitDofMaskAdd(const BitRefLevel _bit) : bit(_bit){};
  void operator()(Problem &p) { *(p.tagBitRefLevelMask) |= bit; };
};
 
/** \brief remove finite element from problem
 * \ingroup problems_multi_indices
 */
struct ProblemFiniteElementChangeBitUnSet {
  BitFEId f_id;
  ProblemFiniteElementChangeBitUnSet(const BitFEId _f_id) : f_id(_f_id){};
  void operator()(Problem &p);
};
 
/** \brief zero nb. of DOFs in row
 * \ingroup problems_multi_indices
 */
struct ProblemZeroNbRowsChange {
  void operator()(Problem &e);
};
 
/** \brief zero nb. of DOFs in col
 * \ingroup problems_multi_indices
 */
struct ProblemZeroNbColsChange {
  void operator()(Problem &e);
};
 
/** \brief clear problem finite elements
 * \ingroup problems_multi_indices
 */
struct ProblemClearNumeredFiniteElementsChange {
  void operator()(Problem &e);
};
 
/**
 * \brief Clear sub-problem data structure
 */
struct ProblemClearSubProblemData {
  void operator()(Problem &e) { e.subProblemData.reset(); }
};
 
/**
 * \brief Clear composed problem data structure
 */
struct ProblemClearComposedProblemData {
  void operator()(Problem &e) { e.composedProblemsData.reset(); }
};
 
inline MoFEMErrorCode
ComposedProblemsData::getRowIs(IS *is, const unsigned int pp) const {
  MoFEMFunctionBeginHot;
  if (pp <= rowIs.size()) {
    SETERRQ(PETSC_COMM_WORLD, MOFEM_INVALID_DATA, "Exceed size of array pp<%ld",
            rowIs.size());
  }
  *is = rowIs[pp].get();
  PetscObjectReference((PetscObject)(*is));
  MoFEMFunctionReturnHot(0);
}
 
inline MoFEMErrorCode
ComposedProblemsData::getColIs(IS *is, const unsigned int pp) const {
  MoFEMFunctionBeginHot;
  if (pp <= colIs.size()) {
    SETERRQ(PETSC_COMM_WORLD, MOFEM_INVALID_DATA, "Exceed size of array pp<%ld",
            colIs.size());
  }
  *is = colIs[pp].get();
  PetscObjectReference((PetscObject)(*is));
  MoFEMFunctionReturnHot(0);
}
 
} // namespace MoFEM
 
#endif //__PROBLEMSMULTIINDICES_HPP__
 
/**
 * \defgroup problems_multi_indices Problems structures and multi-indices
 * \ingroup mofem
 ******************************************************************************/

Classes

Namespaces

Macros

Typedefs

Detailed Description

Macro Definition Documentation

◆ _IT_NUMEREDDOF_COL_BY_LOCIDX_FOR_LOOP_