ProblemsManager.hpp

Go to the documentation of this file.

/** \file ProblemsManager.hpp
 * \brief Interface for building, partitioning, and managing finite element problems
 * \ingroup mofem_problems_manager
 *
 * The ProblemsManager provides comprehensive functionality for creating and managing
 * finite element problems within the MoFEM framework. It serves as the bridge between
 * the Core interface (fields, DOFs, finite elements) and PETSc's parallel computing
 * infrastructure (Discrete Manager - DM).
 *
 * Key capabilities include:
 * - Building problems from fields and finite elements
 * - Partitioning for parallel computation (distributed and non-distributed meshes)
 * - Managing sub-problems and composite multi-physics problems
 * - Handling broken DOFs for discontinuous finite element spaces
 * - DOF removal for boundary conditions and model reduction
 * - Integration with PETSc DM for parallel matrix/vector operations
 *
 */
 
#ifndef __PROBLEMSMANAGER_HPP__
#define __PROBLEMSMANAGER_HPP__
 
#include "UnknownInterface.hpp"
 
namespace MoFEM {
 
/**
 * \brief Problem manager is used to build and partition problems
 * \ingroup mofem_problems_manager
 *
 * \section pm_overview Overview
 * 
 * The ProblemsManager serves as the central interface for creating, configuring, 
 * and managing finite element problems within the MoFEM framework. It acts as a 
 * bridge between the Core interface (which manages the fundamental MoFEM data 
 * structures like fields, finite elements, and DOFs) and the PETSc Discrete 
 * Manager (DM) system for parallel computing.
 *
 * \section pm_core_connection Connection to Core Interface
 * 
 * The ProblemsManager operates on top of the MoFEM::Core interface:
 * - **Fields and DOFs**: Uses fields and DOFs defined in Core to construct problems
 * - **Finite Elements**: Manages finite elements from Core's registry
 * - **Problem Objects**: Creates Problem instances that aggregate Core's components
 * - **Data Consistency**: Ensures DOF numbering and field associations remain consistent
 *
 * \section pm_dm_integration Integration with PETSc Discrete Manager (DM)
 * 
 * The ProblemsManager creates and configures PETSc DM objects:
 * - **Matrix/Vector Layout**: Defines parallel distribution of DOFs for PETSc matrices/vectors
 * - **Ghost DOFs**: Manages inter-processor DOF dependencies for parallel assembly
 * - **Partitioning**: Distributes computational load across MPI processes
 * - **Local/Global Mappings**: Establishes DOF index mappings between local and global numbering
 *
 * \section pm_mesh_types Distributed vs Non-Distributed Meshes
 * 
 * \subsection pm_nondist Non-Distributed Meshes
 * - **Single Process Ownership**: Each mesh entity owned by exactly one processor
 * - **Sequential Building**: Problem built on rank 0, then partitioned
 * - **Simple Partitioning**: Uses METIS/ParMETIS for load balancing
 * - **Ghost Creation**: Explicit ghost DOF creation after partitioning
 * - **Use Case**: Traditional finite element problems with post-partitioning
 *
 * \subsection pm_dist Distributed Meshes  
 * - **MOAB Integration**: Leverages MOAB's parallel mesh capabilities
 * - **Pre-Partitioned**: Mesh already distributed during loading
 * - **Shared Entities**: Mesh entities can be shared between processors
 * - **Automatic Ghosts**: Ghost DOFs determined from mesh sharing information
 * - **Use Case**: Large-scale problems requiring parallel mesh I/O
 *
 * \section pm_problem_types Problem Types
 * 
 * \subsection pm_subproblems Sub-Problems
 * - **Focused Analysis**: Extract subset of DOFs/elements for specialized computation
 * - **Field Restriction**: Include only specific fields or DOF ranges
 * - **Boundary Conditions**: Apply specialized constraints to problem subset
 * - **Solver Optimization**: Use targeted solvers for specific physics
 * - **Example**: Solve only displacement DOFs while keeping pressure DOFs fixed
 *
 * \subsection pm_composite Composite Problems
 * - **Block Structure**: Combine multiple sub-problems into unified matrix system
 * - **Multi-Physics**: Couple different physical phenomena (fluid-structure, etc.)
 * - **Block Matrices**: Create structured matrix layouts for specialized solvers
 * - **Field Coupling**: Define interactions between different field types
 * - **Example**: Stokes flow with displacement-pressure-velocity blocks
 *
 * \section pm_broken_dofs Broken DOFs (Discontinuous Spaces)
 * 
 * Broken DOFs support discontinuous finite element spaces:
 * - **Element-Wise DOFs**: DOFs belong to elements rather than mesh entities
 * - **Interface Handling**: Special treatment for inter-element connections
 * - **Discontinuous Galerkin**: Support for DG methods with interface terms
 * - **Side DOFs**: DOFs associated with element faces for flux calculations
 * - **Broken Space Functions**: `getSideDofsOnBrokenSpaceEntities()` manages interface DOFs
 *
 * \section pm_dof_removal DOF Removal Operations
 * 
 * DOF removal serves multiple purposes:
 * 
 * \subsection pm_boundary_conditions Boundary Condition Enforcement
 * - **Dirichlet Constraints**: Remove DOFs with prescribed values
 * - **Symmetry Conditions**: Eliminate DOFs with geometric constraints
 * - **Contact Constraints**: Remove DOFs involved in contact conditions
 *
 * \subsection pm_model_reduction Model Reduction
 * - **Inactive Regions**: Remove DOFs in non-participating mesh regions
 * - **Dimensional Reduction**: Eliminate DOFs for plane stress/strain assumptions
 * - **Adaptive Refinement**: Remove DOFs from coarsened elements
 *
 * \subsection pm_numerical_efficiency Numerical Efficiency
 * - **Zero DOFs**: Remove DOFs that remain zero throughout simulation
 * - **Singular Systems**: Eliminate redundant DOFs to improve conditioning
 * - **Memory Optimization**: Reduce matrix storage requirements
 *
 * The removal process:
 * 1. **Identification**: Mark DOFs for removal based on criteria
 * 2. **Dependency Check**: Verify no essential DOFs depend on removed ones
 * 3. **Index Renumbering**: Compact DOF indices to eliminate gaps
 * 4. **Matrix/Vector Update**: Adjust PETSc data structures accordingly
 * 5. **Solver Configuration**: Update preconditioners and solver contexts
 *
 * \section pm_workflow Typical Workflow
 * 
 * 1. **Problem Definition**: Define fields, finite elements, and DOFs via Core
 * 2. **Problem Building**: Use `buildProblem*()` to create Problem object
 * 3. **Partitioning**: Apply `partition*()` functions for parallel distribution
 * 4. **Ghost Setup**: Configure ghost DOFs for parallel assembly
 * 5. **Constraint Application**: Remove DOFs for boundary conditions
 * 6. **DM Creation**: Generate PETSc DM for solver integration
 * 7. **Matrix Assembly**: Use Problem for parallel finite element assembly
 *
 */
struct ProblemsManager : public UnknownInterface {
 
  MoFEMErrorCode query_interface(boost::typeindex::type_index type_index,
                                 UnknownInterface **iface) const;
 
  MoFEM::Core &cOre;
  ProblemsManager(const MoFEM::Core &core);
  virtual ~ProblemsManager() = default;
 
  PetscBool buildProblemFromFields; ///< If set to true, problem is build from
  /// DOFs in fields, not from DOFs on elements
 
  PetscBool synchroniseProblemEntities;
 
  /**
   * \brief Get command line options for ProblemsManager
   * \ingroup mofem_problems_manager
   *
   * Retrieves configuration options from command line arguments that control
   * problem building behavior, such as buildProblemFromFields and 
   * synchroniseProblemEntities flags.
   *
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  MoFEMErrorCode getOptions();
 
  /**
   * \brief Set partition tag to each finite element in the problem
   * \deprecated Use CommInterface
   * \ingroup mofem_problems_manager
   *
   * This will use one of the mesh partitioning programs available from PETSc
   * See
   * <http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/Mat/MatPartitioningType.html>
   *
   * @param  ents        Entities to partition
   * @param  dim         Dimension of entities to partition
   * @param  adj_dim     Adjacency dimension
   * @param  n_parts     Number of partitions
   * @param  verb        Verbosity level
   * @return             Error code
   */
  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);
 
  /** \brief build problem data structures
   * \ingroup mofem_problems_manager
   *
   * \note If square_matrix is set to true, that indicate that problem is
   * structurally
   * symmetric, i.e. rows and columns have the same dofs and are indexed in the
   * same
   * way.
   *
   * @param  name          problem name
   * @param  square_matrix structurally symmetric problem
   * @param  verb          verbosity level
   * @return               error code
   *
   */
  MoFEMErrorCode buildProblem(const std::string name, const bool square_matrix,
                              int verb = VERBOSE);
 
  /** \brief build problem data structures
   * \ingroup mofem_problems_manager
   *
   * \note If square_matrix is set to true, that indicate that problem is
   * structurally
   * symmetric, i.e. rows and columns have the same dofs and are indexed in the
   * same
   * way.
   *
   * @param  problem pointer
   * @param  square_matrix structurally symmetric problem
   * @param  verb          verbosity level
   * @return               error code
   *
   */
  MoFEMErrorCode buildProblem(Problem *problem_ptr, const bool square_matrix,
                              int verb = VERBOSE);
 
  /** \brief build problem data structures, assuming that mesh is distributed (collective)
   * \ingroup mofem_problems_manager
   *
   * Mesh is distributed, that means that each processor keeps only own part of
   * the mesh and shared entities.
   *
   * Collective - need to be run on all processors in communicator, i.e. each
   * function has to call this function.
   *
   * @param name problem name to build
   * @param square_matrix true if problem has structurally symmetric matrix
   * @param verb verbosity level
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  MoFEMErrorCode buildProblemOnDistributedMesh(const std::string name,
                                               const bool square_matrix,
                                               int verb = VERBOSE);
 
  /** \brief build problem data structures, assuming that mesh is distributed (collective)
   * \ingroup mofem_problems_manager
   *
   * Mesh is distributed, that means that each processor keeps only own part of
   * the mesh and shared entities.
   *
   * Collective - need to be run on all processors in communicator, i.e. each
   * function has to call this function.
   *
   * @param problem_ptr pointer to problem structure
   * @param square_matrix true if problem has structurally symmetric matrix
   * @param verb verbosity level
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  MoFEMErrorCode buildProblemOnDistributedMesh(Problem *problem_ptr,
                                               const bool square_matrix = true,
                                               int verb = VERBOSE);
 
  /**
   * \brief build sub problem
   * \ingroup mofem_problems_manager
   * 
   * Creates a sub-problem from a main problem by selecting specific fields
   * for rows and columns. This is useful for creating focused problems that
   * operate on subsets of the full problem's fields.
   * 
   * @param out_name name of the output sub-problem to create
   * @param fields_row vector of field names for problem rows
   * @param fields_col vector of field names for problem columns
   * @param main_problem name of the main problem to extract from
   * @param square_matrix true if the sub-problem matrix is structurally symmetric
   * @param entityMapRow optional map restricting row fields to specific entities
   * @param entityMapCol optional map restricting column fields to specific entities
   * @param verb verbosity level
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  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);
 
  /**
   * \brief build composite problem
   * \ingroup mofem_problems_manager
   * 
   * Creates a composite problem by combining multiple existing problems.
   * The resulting problem contains DOFs from all constituent problems,
   * arranged in block matrix structure.
   * 
   * @param out_name name of the composite problem to create
   * @param add_row_problems vector of problem names contributing to rows
   * @param add_col_problems vector of problem names contributing to columns
   * @param square_matrix true if the composite matrix is structurally symmetric
   * @param verb verbosity level
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  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);
 
  /**
   * \brief build indexing and partition problem inheriting indexing and
   * partitioning from two other problems
   * \ingroup mofem_problems_manager
   *
   * Transfers DOF indexing and partitioning information from existing problems
   * to a new problem. This is useful for maintaining consistent partitioning
   * across related problems in multi-physics simulations.
   *
   * @param name name of the target problem to inherit partitioning
   * @param problem_for_rows source problem for row DOF indexing and partitioning
   * @param copy_rows if true, copy row DOF indices; if false, only copy partition info
   * @param problem_for_cols source problem for column DOF indexing and partitioning  
   * @param copy_cols if true, copy column DOF indices; if false, only copy partition info
   * @param verb verbosity level
   * @return MoFEMErrorCode Error code indicating success or failure
   *
   * If copy_rows/copy_cols is set to false only partition is copied between
   * problems.
   */
  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);
 
  /** \brief partition problem dofs
   * \ingroup mofem_problems_manager
   *
   * Partitions DOFs for sequential/simple problems where the mesh is not
   * distributed across processors. Creates local DOF numbering and assigns
   * ownership to processors.
   *
   * @param name problem name to partition
   * @param verb verbosity level
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  MoFEMErrorCode partitionSimpleProblem(const std::string name,
                                        int verb = VERBOSE);
 
  /** \brief partition problem dofs (collective)
   * \ingroup mofem_problems_manager
   *
   * Partitions DOFs for distributed problems where the mesh is already
   * distributed across processors. Must be called collectively on all
   * processors in the communicator.
   *
   * @param name problem name to partition
   * @param verb verbosity level
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  MoFEMErrorCode partitionProblem(const std::string name, int verb = VERBOSE);
 
  /**
   * \brief Print partition information for debugging
   * \ingroup mofem_problems_manager
   *
   * Outputs detailed information about how DOFs and finite elements are
   * distributed across processors for the given problem.
   *
   * @param problem_ptr pointer to the problem structure
   * @param verb verbosity level
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  MoFEMErrorCode printPartitionedProblem(const Problem *problem_ptr,
                                         int verb = VERBOSE);
 
  /**
   * \brief Debug partition information
   * \ingroup mofem_problems_manager
   *
   * Performs detailed analysis and validation of problem partitioning,
   * checking for inconsistencies and reporting partition quality metrics.
   *
   * @param problem_ptr pointer to the problem structure
   * @param verb verbosity level
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  MoFEMErrorCode debugPartitionedProblem(const Problem *problem_ptr,
                                         int verb = VERBOSE);
 
  /** \brief partition finite elements
   * \ingroup mofem_problems_manager
   *
   * Function which partition finite elements based on dofs partitioning.
   * In addition it sets information about local row and cols dofs at given
   * element on partition. Can optionally use MOAB's partitioning information
   * or restrict partitioning to specific processor ranges.
   *
   * @param name problem name to partition finite elements for
   * @param part_from_moab if true, use MOAB's existing partition information
   * @param low_proc lowest processor rank to include (-1 for all)
   * @param hi_proc highest processor rank to include (-1 for all)
   * @param verb verbosity level
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  MoFEMErrorCode partitionFiniteElements(const std::string name,
                                         bool part_from_moab = false,
                                         int low_proc = -1, int hi_proc = -1,
                                         int verb = VERBOSE);
 
  /** \brief determine ghost nodes
   * \ingroup mofem_problems_manager
   *
   * Identifies and marks DOFs as ghost DOFs for parallel computations.
   * DOFs are ghost dofs if they are used by elements on a given partition
   * but not owned by that partition.
   *
   * @param name problem name to determine ghost DOFs for
   * @param verb verbosity level
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  MoFEMErrorCode partitionGhostDofs(const std::string name, int verb = VERBOSE);
 
  /** \brief determine ghost nodes on distributed meshes
   * \ingroup mofem_problems_manager
   *
   * Identifies and marks DOFs as ghost DOFs specifically for distributed meshes.
   * This function is similar to partitionGhostDofs but exploits the fact that
   * the mesh is distributed across processors. DOFs are ghosted if they are
   * shared but not owned by the current partition.
   *
   * @param name problem name to determine ghost DOFs for
   * @param verb verbosity level
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  MoFEMErrorCode partitionGhostDofsOnDistributedMesh(const std::string name,
                                                     int verb = VERBOSE);
 
  /**
   * @brief Create finite element meshset for the problem
   * \ingroup mofem_problems_manager
   *
   * Creates or retrieves the meshset entity that contains all finite elements
   * of a specific type within a problem. The meshset entity must be created
   * before calling this function.
   * 
   * @param prb_name name of the problem
   * @param fe_name name of the finite element type
   * @param meshset pointer to store the meshset handle
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  MoFEMErrorCode getFEMeshset(const std::string prb_name,
                              const std::string &fe_name,
                              EntityHandle *meshset) const;
 
  /**
   * \brief Get layout of elements in the problem
   * \ingroup mofem_problems_manager
   *
   * In layout is stored information how many elements is on each processor, for
   * more information look int petsc documentation
   * <http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/IS/PetscLayoutCreate.html#PetscLayoutCreate>
   *
   * @param  name    problem name
   * @param  fe_name finite elements
   * @param  layout  layout
   * @param  verb    verbosity level
   * @return         error code
   */
  MoFEMErrorCode getProblemElementsLayout(const std::string name,
                                          const std::string &fe_name,
                                          PetscLayout *layout) const;
 
  /**
   * @brief Remove DOFs from problem
   * @ingroup mofem_problems_manager
   *
   * 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
   *
   * @param problem_name name of the problem
   * @param field_name name of the field
   * @param ents entities on which DOFs are removed
   * @param lo_coeff low dof coefficient (rank)
   * @param hi_coeff high dof coefficient (rank)
   * @param verb  verbosity level
   * @param debug to debug and seek for inconsistencies set to true
   * @return MoFEMErrorCode
   */
  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);
 
  /**
   * @copydoc removeDofsOnEntities
   *
   * \note Use this function for non-distributed meshes
   */
  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);
 
  /**
   * @brief Remove DOFs from problem by bit ref level
   * @ingroup mofem_problems_manager
   *
   * See for more detail other implementation for removeDofsOnEntities.
   *
   * @param problem_name name of the problem
   * @param field_name name of the field
   * @param bit_ref_level bit ref level on which DOFs are removed
   * @param bit_ref_mask bit ref mask on which DOFs are removed
   * @param ents_ptr filter entities with given bit and mask
   * @param lo_coeff low dof coefficient (rank)
   * @param hi_coeff high dof coefficient (rank)
   * @param verb  verbosity level
   * @param debug to debug and seek for inconsistencies set to true
   * @return MoFEMErrorCode
   */
  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);
 
  /**
   * @copydoc removeDofsOnEntities
   *
   * \note Use this function for non distributed meshes
   */
  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);
 
 
  /**
   * @brief Remove DOFs from problem on broken space
   * \ingroup mofem_problems_manager
   * 
   * Removes specified DOFs from the problem for broken (discontinuous) spaces.
   * The DOFs are marked as inactive by setting their indices to -1, which
   * causes them to be skipped during assembly operations.
   * 
   * @param problem_name name of the problem
   * @param rc row or column data specification
   * @param vec_dof_view vector of DOF entities to remove
   * @param verb verbosity level
   * @param debug enable debug output for inconsistency checking
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  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);
 
  /**
   * @brief Get DOFs on side entities for broken space
   * \ingroup mofem_problems_manager
   *
   * Retrieves DOFs associated with side entities in broken (discontinuous) spaces.
   * The DOFs are connected through a bridge entity of specified dimension.
   * This is useful for implementing interface conditions in discontinuous Galerkin methods.
   *
   * @param vec_dof_view output vector to store the DOF entities
   * @param problem_name name of the problem
   * @param rc row or column data specification
   * @param field_name name of the field
   * @param ents range of side entities to process
   * @param bridge_dim dimension of bridge entity connecting DOFs to side entities
   * @param lo_coeff lowest coefficient (rank) to include
   * @param hi_coeff highest coefficient (rank) to include
   * @param lo_order lowest polynomial order to include
   * @param hi_order highest polynomial order to include
   * @param verb verbosity level
   * @param debug enable debug output for inconsistency checking
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  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;
  
 
  enum MarkOP { OR, AND };
 
  /**
   * @brief Create vector with marked indices 
   * 
   * Vector with local DOFs marked by entities 
   * 
   * 
   * @param problem_name 
   * @param row 
   * @param ents 
   * @param marker 
   * @return MoFEMErrorCode 
   */
  MoFEMErrorCode markDofs(const std::string problem_name, RowColData rc,
                          const enum MarkOP op, const Range ents,
                          std::vector<unsigned char> &marker) const;
 
  /**
   * @deprecated use function with MarkOP
   */
  inline DEPRECATED MoFEMErrorCode
  markDofs(const std::string problem_name, RowColData rc, const Range ents,
           std::vector<unsigned char> &marker) const {
    return markDofs(problem_name, rc, MarkOP::OR, ents, marker);
  }
 
  /**
   * @brief Modify DOF markers for specific field and coefficient range
   * \ingroup mofem_problems_manager
   *
   * Modifies the marker flags for DOFs associated with a specific field within
   * a defined coefficient range. This allows selective marking/unmarking of DOFs
   * based on field and polynomial order criteria using bitwise operations.
   *
   * @param problem_name name of the problem
   * @param rc row or column data specification
   * @param field_name name of the field to process
   * @param lo lowest coefficient (rank) to include
   * @param hi highest coefficient (rank) to include
   * @param op marking operation (OR, AND, XOR) to apply
   * @param c marker value to apply with the operation
   * @param marker reference to marker vector to modify
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  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;
 
  /**
   * @brief Create vector with marked DOF indices based on DOF view
   * \ingroup mofem_problems_manager
   *
   * Creates or modifies a marker vector based on a DOF view, allowing selective
   * marking of DOFs that are present in the view. This is useful for creating
   * masks or index sets for specific DOF collections in matrix/vector operations.
   *
   * @param problem_name name of the problem
   * @param rc row or column data specification
   * @param vec_dof_view vector of DOF entities to process for marking
   * @param op marking operation (OR, AND, XOR) to apply
   * @param marker reference to marker vector to create/modify
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  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;
 
  /**
   * @brief Add empty field blocks to optimize matrix storage
   * \ingroup mofem_problems_manager
   *
   * Marks field combinations as empty blocks in the matrix structure to optimize
   * memory usage and computational efficiency. The MatrixManager assumes all field
   * combinations result in non-zero blocks, but this allows specification of
   * blocks that will remain zero for the entire problem duration.
   *
   * @param problem_name name of the problem to modify
   * @param row_field name of the field for matrix row blocks
   * @param col_field name of the field for matrix column blocks
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  MoFEMErrorCode addFieldToEmptyFieldBlocks(const std::string problem_name,
                                            const std::string row_field,
                                            const std::string col_field) const;
 
private:
  PetscLogEvent MOFEM_EVENT_ProblemsManager;
};
} // namespace MoFEM
 
#endif //__PROBLEMSMANAGER_HPP__
 
/**
 * \defgroup mofem_problems_manager ProblemsManager
 * \brief Adding and managing problems
 *
 * \ingroup mofem
 */