Interface.hpp

Go to the documentation of this file.

/** \file Interface.hpp
 * \brief MoFEM interface
 */
 
#ifndef __INTERFACE_HPP__
  #define __INTERFACE_HPP__
 
/** \brief Namespace of MoFEM library functions and classes
 */
namespace MoFEM {
 
struct MeshsetsManager;
 
/**
 * \brief Interface
 * \nosubgrouping
 * \ingroup mofem
 *
 * This interface is used by user to: <br>
 * - create approximation fields,  <br>
 * - declare elements, <br>
 * - declare problems, <br>
 *
 *  \todo Clean interface, organize groups outsource some functions to
 * independent interface
 */
struct CoreInterface : public UnknownInterface {
 
  virtual ~CoreInterface() = default;
 
  /**
   * @brief Get the core
   *
   * @return int The core value
   */
  virtual const int getValue() const = 0;
 
  /**
   * @brief Get RefEntity
   *
   * @param ent Entity handle to create reference entity from
   * @return boost::shared_ptr<RefEntityTmp<0>> Shared pointer to reference entity
   */
  virtual boost::shared_ptr<RefEntityTmp<0>>
  make_shared_ref_entity(const EntityHandle ent) = 0;
 
  /** \name Interfaces */
 
  /**@{*/
 
  /**
   * get moab instance
   * @return moab::Interface& Reference to MOAB interface
   */
  virtual moab::Interface &get_moab() = 0;
 
  /**
   * get moab instance interface
   * @return const moab::Interface& Const reference to MOAB interface
   */
  virtual const moab::Interface &get_moab() const = 0;
 
  /**
   * @brief Set the moab interface object
   *
   * @param new_moab Reference to new MOAB interface to set
   * @param verb Verbosity level (default: VERBOSE)
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  virtual MoFEMErrorCode set_moab_interface(moab::Interface &new_moab,
                                            int verb = VERBOSE) = 0;
 
  /** \brief get MeshsetsManager pointer
   * @return MeshsetsManager* Pointer to MeshsetsManager object
   */
  virtual MeshsetsManager *get_meshsets_manager_ptr() = 0;
 
  /** \brief get MeshsetsManager pointer
   * @return const MeshsetsManager* Const pointer to MeshsetsManager object
   */
  virtual const MeshsetsManager *get_meshsets_manager_ptr() const = 0;
 
  /** \brief get MeshsetsManager reference
   * @return MeshsetsManager& Reference to MeshsetsManager object
   */
  virtual MeshsetsManager &get_meshsets_manager() = 0;
 
  /** \brief get MeshsetsManager reference
   * @return const MeshsetsManager& Const reference to MeshsetsManager object
   */
  virtual const MeshsetsManager &get_meshsets_manager() const = 0;
 
  /**@}*/
 
  /** \name Basic entity */
 
  /**@{*/
 
  /**
   * \brief Get pointer to basic entity data.
   *
   * This structure keeps data like tag handles and other data used to
   * construct MoFEM entities, DOFs and finite elements.
   *
   * @return boost::shared_ptr<BasicEntityData>& Reference to shared pointer of BasicEntityData
   */
  virtual boost::shared_ptr<BasicEntityData> &get_basic_entity_data_ptr() = 0;
 
  /**@}*/
 
  /** \name Communicator */
 
  /**@{*/
 
  /**
   * get MPI communicator
   * @return MPI_Comm& Reference to MPI communicator
   */
  virtual MPI_Comm &get_comm() const = 0;
 
  /**
   * get communicator size
   * @return int Number of processes in the communicator
   */
  virtual int get_comm_size() const = 0;
 
  /**
   * get comm rank
   * @return int Rank of current process in the communicator
   */
  virtual int get_comm_rank() const = 0;
 
  /** \name Check consistency */
 
  /**@{*/
 
  /**
   * \brief check data consistency in entitiesPtr
   *
   * @param name Field name to check consistency for
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  virtual MoFEMErrorCode
  check_number_of_ents_in_ents_field(const std::string &name) const = 0;
 
  /**
   * \brief check data consistency in entitiesPtr
   *
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  virtual MoFEMErrorCode check_number_of_ents_in_ents_field() const = 0;
 
  /**
   * \brief check data consistency in entsFiniteElements
   *
   * @param name Finite element name to check consistency for
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  virtual MoFEMErrorCode check_number_of_ents_in_ents_finite_element(
      const std::string &name) const = 0;
 
  /**
   * \brief check data consistency in entsFiniteElements
   *
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  virtual MoFEMErrorCode
  check_number_of_ents_in_ents_finite_element() const = 0;
 
  /** \name Database */
 
  /**@{*/
 
  /**
   * \brief Clear database
   * @param  verb Verbosity level
   * @return      Error code
   */
  virtual MoFEMErrorCode clear_database(int verb = DEFAULT_VERBOSITY) = 0;
 
  /**
   * \brief Clear database and initialize it once again
   * @param  verb Verbosity level
   * @return      Error code
   */
  virtual MoFEMErrorCode rebuild_database(int verb = DEFAULT_VERBOSITY) = 0;
 
  /**@}*/
 
  /** \name Delete and remove */
 
  /**@{*/
 
  /**
   * @brief Remove parents from entities
   *
   * @param ents Range of entities to remove parents from
   * @param verb Verbosity level (default: DEFAULT_VERBOSITY)
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  virtual MoFEMErrorCode
  remove_parents_by_ents(const Range &ents, int verb = DEFAULT_VERBOSITY) = 0;
 
  /**
   * @brief Remove parent from entities on bit level
   *
   * Every entity created by refinement, split, or any other change on the mesh
   * can have a parent. This function removes the parent from an entity.
 
   * \note Functions making topological changes on entities should respect
   * parent–child relations. This erases that relation. If you are going to split
   * faces and create an interface, it is recommended to call this function before
   * the split operation.
   *
   * @param bit Bit level to select entities
   * @param mask Mask for bit level selection
   * @param verb Verbosity level (default: DEFAULT_VERBOSITY)
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  virtual MoFEMErrorCode
  remove_parents_by_bit_ref(const BitRefLevel bit, const BitRefLevel mask,
                            int verb = DEFAULT_VERBOSITY) = 0;
 
  /**
   * @brief Remove parents from entities having parents in passed range
   *
   * @param ents Range of parent entities to check against
   * @param verb Verbosity level (default: DEFAULT_VERBOSITY)
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  virtual MoFEMErrorCode
  remove_parents_by_parents(const Range &ents,
                            int verb = DEFAULT_VERBOSITY) = 0;
 
  /** \brief Delete entities from MoFEM and MOAB database
   *
   * @param bit Bit level to select entities
   * @param mask Mask for bit level selection
   * @param remove_parent If true, also remove parent relationships
   * @param verb Verbosity level (default: DEFAULT_VERBOSITY)
   * @param mf MoFEM type control (default: MF_ZERO)
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  virtual MoFEMErrorCode
  delete_ents_by_bit_ref(const BitRefLevel bit, const BitRefLevel mask,
                         const bool remove_parent = false,
                         int verb = DEFAULT_VERBOSITY,
                         MoFEMTypes mf = MF_ZERO) = 0;
 
  /** \brief Remove entities from MoFEM database
   * @param ents Range of entities to remove
   * @param verb Verbosity level (default: DEFAULT_VERBOSITY)
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  virtual MoFEMErrorCode remove_ents(const Range ents,
                                     int verb = DEFAULT_VERBOSITY) = 0;
 
  /** \brief Remove entities from MoFEM database
   * @param bit Bit level to select entities
   * @param mask Mask for bit level selection
   * @param verb Verbosity level (default: DEFAULT_VERBOSITY)
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  virtual MoFEMErrorCode
  remove_ents_by_bit_ref(const BitRefLevel bit, const BitRefLevel mask,
                         int verb = DEFAULT_VERBOSITY) = 0;
 
  /** \brief Delete finite element from MoFEM database
   * @param name Name of finite element to delete
   * @param verb Verbosity level (default: DEFAULT_VERBOSITY)
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  virtual MoFEMErrorCode
  delete_finite_element(const std::string name,
                        int verb = DEFAULT_VERBOSITY) = 0;
 
  /** \name Fields */
 
  /**@{*/
 
  /**
   * \brief Add field
   *
   * \note add_file is a collective, should be executed on all processors.
   * Otherwise could lead to deadlock.
   *
   * @param  name              name of the field
   * @param  space             space (L2,H1,Hdiv,Hcurl)
   * @param  base              approximation base, see FieldApproximationBase
   * @param  nb_of_coefficients number of field coefficients
   * @param  tag_type          type of the tag MB_TAG_DENSE or MB_TAG_SPARSE
   * (DENSE is faster and uses less memory, SPARSE is more flexible if you
   * define field on subdomains)
   * @param  bh                if MF_EXCL throws error if field exits, MF_ZERO no error if field exist
   * @param  verb              verbosity level
   * @return                   error code
   */
  virtual MoFEMErrorCode add_broken_field(
      const std::string name, const FieldSpace space,
      const FieldApproximationBase base,
      const FieldCoefficientsNumber nb_of_coefficients,
 
      const std::vector<
 
          std::pair<EntityType,
                    std::function<MoFEMErrorCode(BaseFunction::DofsSideMap &)>>
 
          >
          list_dof_side_map,
 
      const TagType tag_type = MB_TAG_SPARSE,
      const enum MoFEMTypes bh = MF_EXCL, int verb = DEFAULT_VERBOSITY) = 0;
 
  /**
   * \brief Add field
   *
   * \note add_file is a collective, should be executed on all processors.
   * Otherwise could lead to deadlock.
   *
   * @param  name              name of the field
   * @param  space             space (L2,H1,Hdiv,Hcurl)
   * @param  continuity        continuity (CONTINUOUS, DISCONTINUOUS)
   * @param  base              approximation base, see FieldApproximationBase
   * @param  nb_of_coefficients number of field coefficients
   * @param  tag_type          type of the tag MB_TAG_DENSE or MB_TAG_SPARSE
   * (DENSE is faster and uses less memory, SPARSE is more flexible if you
   * define field on subdomains)
   * @param  bh                if MF_EXCL throws error if field exits, MF_ZERO no error if field exist
   * @param  verb              verbosity level
   * @return                   error code
   */
  virtual MoFEMErrorCode
  add_field(const std::string name, const FieldSpace space,
            const FieldApproximationBase base,
            const FieldCoefficientsNumber nb_of_coefficients,
            const TagType tag_type = MB_TAG_SPARSE,
            const enum MoFEMTypes bh = MF_EXCL,
            int verb = DEFAULT_VERBOSITY) = 0;
 
  /**
   * @brief  Delete field
   *
   * @param name Field name to delete
   * @param verb Verbosity level (default: DEFAULT_VERBOSITY)
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  virtual MoFEMErrorCode delete_field(const std::string name,
                                      int verb = DEFAULT_VERBOSITY) = 0;
 
  /**
   * \brief Add entities to field meshset
   * \ingroup mofem_field
   *
   * \note not collective
   *
   * The lower dimension entities are added depending on the space type
   *
   * @param  ents range of entities
   * @param  dim  dimension of entities
   * @param  name name of field
   * @param  verb verbosity level
   * @return      error code
   */
  virtual MoFEMErrorCode
  add_ents_to_field_by_dim(const Range &ents, const int dim,
                           const std::string &name,
                           int verb = DEFAULT_VERBOSITY) = 0;
 
  /**
   * \brief Add entities to field meshset
   * \ingroup mofem_field
   *
   * \note not collective
   *
   * The lower dimension entities are added depending on the space type
   *
   * @param  ents range of entities
   * @param  type  type of entities
   * @param  name name of field
   * @param  verb verbosity level
   * @return      error code
   */
  virtual MoFEMErrorCode
  add_ents_to_field_by_type(const Range &ents, const EntityType type,
                            const std::string &name,
                            int verb = DEFAULT_VERBOSITY) = 0;
 
  /**
   * \brief Add entities to field meshset
   * \ingroup mofem_field
   *
   * \not collective
   *
   * The lower dimension entities are added depending on the space type
   *
   * @param  meshset
   * @param  dim  dimension
   * @param  name name of field
   * @param  recursive take entities recursively from embedded entities
   * @param  verb verbosity level
   * @return      error code
   */
  virtual MoFEMErrorCode
  add_ents_to_field_by_dim(const EntityHandle meshset, const int dim,
                           const std::string &name, const bool recursive = true,
                           int verb = DEFAULT_VERBOSITY) = 0;
 
  /**
   * \brief Add entities to field meshset
   * \ingroup mofem_field
   *
   * \note not collective
   *
   * The lower dimension entities are added depending on the space type
   *
   * @param  meshset
   * @param  type of entities
   * @param  name name of field
   * @param  recursive take entities recursively from embedded entities
   * @param  verb verbosity level
   * @return      error code
   */
  virtual MoFEMErrorCode
  add_ents_to_field_by_type(const EntityHandle meshset, const EntityType type,
                            const std::string &name,
                            const bool recursive = true,
                            int verb = DEFAULT_VERBOSITY) = 0;
 
  /**
   * @brief Create vertices and add to the field object
   *
   * Create vertices and add them to the field. Those vertices would be carrying
   * DOFs of the field.
   *
   * \note This function is typically used when NOFIELD is created, for example
   * load factor in arc-length control.
   *
   * @param name Name of the field to add vertices to
   * @param coords Array of coordinates for the vertices
   * @param size Number of vertices to create
   * @param verb Verbosity level (default: DEFAULT_VERBOSITY)
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  virtual MoFEMErrorCode
  create_vertices_and_add_to_field(const std::string name,
                                   const double coords[], int size,
                                   int verb = DEFAULT_VERBOSITY) = 0;
 
  /**
   * \brief remove entities from field
   * \ingroup mofem_field
   *
   * \note not collective
   *
   * @param bit Bit level to select entities
   * @param mask Mask for bit level selection
   * @param verb Verbosity level (default: DEFAULT_VERBOSITY)
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  virtual MoFEMErrorCode
  remove_ents_from_field_by_bit_ref(const BitRefLevel bit,
                                    const BitRefLevel mask,
                                    int verb = DEFAULT_VERBOSITY) = 0;
 
  /**
   * \brief remove entities from field
   * \ingroup mofem_field
   *
   * \note not collective
   *
   * @param name Name of the field
   * @param meshset Meshset containing entities to remove
   * @param type Type of entities to remove
   * @param verb Verbosity level (default: DEFAULT_VERBOSITY)
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  virtual MoFEMErrorCode
  remove_ents_from_field(const std::string name, const EntityHandle meshset,
                         const EntityType type,
                         int verb = DEFAULT_VERBOSITY) = 0;
 
  /**
   * \brief remove entities from field
   * \ingroup mofem_field
   *
   * \note not collective
   *
   * @param name Name of the field
   * @param ents Range of entities to remove
   * @param verb Verbosity level (default: DEFAULT_VERBOSITY)
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  virtual MoFEMErrorCode
  remove_ents_from_field(const std::string name, const Range ents,
                         int verb = DEFAULT_VERBOSITY) = 0;
 
  /**
   * \brief remove entities from all fields
   * \ingroup mofem_field
   *
   * \note not collective
   *
   * @param ents Range of entities to remove from all fields
   * @param verb Verbosity level (default: DEFAULT_VERBOSITY)
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  virtual MoFEMErrorCode
  remove_ents_from_field(const Range ents, int verb = DEFAULT_VERBOSITY) = 0;
 
  /**
   * \brief Set order approximation of the entities in the field
   * \ingroup mofem_field
   *
   * \note not collective
   *
   * \param meshset containing set of the entities (use 0 for all the entities
   * in the meshset) \param type selected type of the entities f.e. MBTET,
   * MBTRI, MBEDGE, MBVERTEX, see moab documentation \param order
   * approximation order
   */
  virtual MoFEMErrorCode set_field_order(const EntityHandle meshset,
                                         const EntityType type,
                                         const std::string &name,
                                         const ApproximationOrder order,
                                         int verb = DEFAULT_VERBOSITY) = 0;
 
  /**
   * \brief Set order approximation of the entities in the field
   * \ingroup mofem_field
   *
   * \note not collective
   *
   * \param entities
   * \param type selected type of the entities f.e. MBTET, MBTRI, MBEDGE,
   * MBVERTEX, see moab documentation \param order approximation order
   */
  virtual MoFEMErrorCode set_field_order(const Range &ents,
                                         const std::string &name,
                                         const ApproximationOrder order,
                                         int verb = DEFAULT_VERBOSITY) = 0;
 
  /**
   * \brief Set order approximation of the entities in the field
   * \ingroup mofem_field
   *
   * \note not collective
   *
   * \param bit refinement level
   * \param mask bit mask
   * \param type selected type of the entities f.e. MBTET, MBTRI, MBEDGE,
   * MBVERTEX, see moab documentation \param order approximation order
   */
  virtual MoFEMErrorCode set_field_order_by_entity_type_and_bit_ref(
      const BitRefLevel &bit, const BitRefLevel &mask, const EntityType type,
      const std::string &name, const ApproximationOrder order,
      int verb = DEFAULT_VERBOSITY) = 0;
 
  /** \brief list entities in the field
   * \ingroup mofem_field
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  virtual MoFEMErrorCode list_fields() const = 0;
 
  /** build fields
   * \ingroup mofem_field
   * @param verb Verbosity level (default: DEFAULT_VERBOSITY)
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  virtual MoFEMErrorCode build_fields(int verb = DEFAULT_VERBOSITY) = 0;
 
  /**
   * @brief build field by name
   *
   * @param field_name Name of the field to build
   * @param verb Verbosity level (default: DEFAULT_VERBOSITY)
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  virtual MoFEMErrorCode build_field(
      const std::string field_name,
      int verb = DEFAULT_VERBOSITY) = 0;
 
  /**
   * @brief Get field Id
   *
   * @param name Name of the field
   * @return BitFieldId The unique bit field identifier
   */
  virtual BitFieldId get_field_id(const std::string &name) const = 0;
 
  /** \brief get field bit number
  *
  * \param name Name of the field
  * \return FieldBitNumber The bit number assigned to the field
  * Example:\code
  auto field_number = mField.get_field_bit_number("DISPLACEMENT");
  * \endcode
  */
  virtual FieldBitNumber get_field_bit_number(const std::string name) const = 0;
 
  /**
   * @brief get field name from id
   *
   * @param id The bit field identifier
   * @return std::string The name of the field
   */
  virtual std::string get_field_name(const BitFieldId id) const = 0;
 
  /** \brief get field meshset
  *
  * \param name Name of the field
  * \return EntityHandle Handle to the meshset containing field entities
  * Example:\code
  EntityHandle disp_files_meshset = mField.get_field_meshset("DISPLACEMENT");
  * \endcode
  */
  virtual EntityHandle get_field_meshset(const std::string name) const = 0;
 
  /**
  * \brief get entities in the field by dimension
  * @param  name Field name
  * @param  dim  Dimension of entities to retrieve
  * @param  ents Range object to store the retrieved entities
  * @return      MoFEMErrorCode Error code indicating success or failure
 
  * \ingroup mofem_field
  */
  virtual MoFEMErrorCode get_field_entities_by_dimension(const std::string name,
                                                         int dim,
                                                         Range &ents) const = 0;
 
  /**
  * \brief get entities in the field by type
  * @param  name Field name
  * @param  type Entity type (MBVERTEX, MBEDGE, MBTRI, MBTET, etc.)
  * @param  ents Range object to store the retrieved entities
  * @return      MoFEMErrorCode Error code indicating success or failure
 
  * \ingroup mofem_field
  */
  virtual MoFEMErrorCode get_field_entities_by_type(const std::string name,
                                                    EntityType type,
                                                    Range &ents) const = 0;
 
  /**
  * \brief get entities in the field by handle
  * @param  name Field name
  * @param  ents Range object to store all entities in the field
  * @return      MoFEMErrorCode Error code indicating success or failure
 
  * \ingroup mofem_field
  */
  virtual MoFEMErrorCode get_field_entities_by_handle(const std::string name,
                                                      Range &ents) const = 0;
 
  /** \brief check if field is in database
   * \ingroup mofem_field
   *
   * \param name Field name to check
   * \return true If field exists in the database, false otherwise
   *
   */
  virtual bool check_field(const std::string &name) const = 0;
 
  /** \brief get field structure
   * \ingroup mofem_field
   *
   * If field is not found throw error if bh == MF_EXIST, or return
   * nullptr if bh == MF_ZERO, i.e. otherwise
   *
   * \param name Field name to retrieve
   * \param bh Controls behaviour when field is not found
   * \return const Field* Pointer to field structure, or nullptr if not found
   * and bh==MF_ZERO
   *
   */
  virtual const Field *
  get_field_structure(const std::string &name,
                      enum MoFEMTypes bh = MF_EXIST) const = 0;
 
  /**@}*/
 
  /** \name Finite elements */
 
  /**@{*/
 
  /**
   * @brief get finite element structure
   *
   * If finite element is not found throw error if bh == MF_EXIST, or return
   * nullptr if bh == MF_ZERO, i.e. otherwise
   *
   * @param name Name of the finite element
   * @param bh Controls behaviour when finite element is not found
   * @return const FiniteElement* Pointer to finite element structure, or nullptr if not found and bh==MF_ZERO
   */
  virtual const FiniteElement *
  get_finite_element_structure(const std::string &name,
                               enum MoFEMTypes bh = MF_EXIST) const = 0;
 
  /**
   * \brief Check if finite element is in database
   * @param  name Name of finite element to check
   * @return      true if element is declared in the database, false otherwise
   */
  virtual bool check_finite_element(const std::string &name) const = 0;
 
  /**
  * \brief add finite element
  * \ingroup mofem_fe
  * \param fe_name Finite element name to add
  * \param bh Controls behavior if finite element already exists (MF_EXCL throws
  error, MF_ZERO allows)
  * \param verb Verbosity level (default: DEFAULT_VERBOSITY)
  * \return MoFEMErrorCode Error code indicating success or failure
  *
  * \note add_finite_element is a collective operation, should be executed on
  all processors.
  * Otherwise could lead to deadlock.
  *
  * Example \code
  CHKERR mField.add_finite_element("ELASTIC");
  CHKERR mField.add_finite_element("PLASTIC");
  \endcode
  */
  virtual MoFEMErrorCode add_finite_element(const std::string &fe_name,
                                            enum MoFEMTypes bh = MF_EXCL,
                                            int verb = DEFAULT_VERBOSITY) = 0;
 
  /**
   * \brief modify finite element table, only for advanced user
   * \ingroup mofem_fe
   *
   * \note modify_finite_element_adjacency_table is a collective operation,
   * should be executed on all processors. Otherwise could lead to deadlock.
   *
   * Using that functions means that you like to do something not usual.
   *
   * @param fe_name Name of the finite element to modify
   * @param type Entity type to modify adjacency for
   * @param function Adjacency function to apply
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  virtual MoFEMErrorCode
  modify_finite_element_adjacency_table(const std::string &fe_name,
                                        const EntityType type,
                                        ElementAdjacencyFunct function) = 0;
 
  /** \brief set finite element field data
   * \ingroup mofem_fe
   *
   * \note modify_finite_element_add_field_data is a collective operation,
   * should be executed on all processors. Otherwise could lead to deadlock.
   *
   * \param fe_name Finite element name
   * \param name_field Field name to add data for
   * \return MoFEMErrorCode Error code indicating success or failure
   *
   * This function will set memory in the form of a vector
   */
  virtual MoFEMErrorCode
  modify_finite_element_add_field_data(const std::string &fe_name,
                                       const std::string name_field) = 0;
 
  /** \brief unset finite element field data
   * \ingroup mofem_fe
   *
   * \note modify_finite_element_off_field_data is a collective operation,
   * should be executed on all processors. Otherwise could lead to deadlock.
   *
   * \param fe_name Finite element name
   * \param name_field Field name to remove data for
   * \return MoFEMErrorCode Error code indicating success or failure
   *
   * This function will unset memory in the form of a vector
   */
  virtual MoFEMErrorCode
  modify_finite_element_off_field_data(const std::string &fe_name,
                                       const std::string name_field) = 0;
 
  /** \brief set field row which finite element use
   * \ingroup mofem_fe
   *
   * \note add_file is a collective, should be executed on all processors.
   * Otherwise could lead to deadlock.
   *
   * \param name finite element name
   * \param name field name
   */
  virtual MoFEMErrorCode
  modify_finite_element_add_field_row(const std::string &fe_name,
                                      const std::string name_row) = 0;
 
  /** \brief unset field row which finite element use
   * \ingroup mofem_fe
   *
   * \note add_file is a collective, should be executed on all processors.
   * Otherwise could lead to deadlock.
   *
   * \param name finite element name
   * \param name field name
   */
  virtual MoFEMErrorCode
  modify_finite_element_off_field_row(const std::string &fe_name,
                                      const std::string name_row) = 0;
 
  /** \brief set field col which finite element use
   * \ingroup mofem_fe
   *
   * \note add_file is a collective, should be executed on all processors.
   * Otherwise could lead to deadlock.
   *
   * \param name finite element name
   * \param name field name
   */
  virtual MoFEMErrorCode
  modify_finite_element_add_field_col(const std::string &fe_name,
                                      const std::string name_row) = 0;
 
  /** \brief unset field col which finite element use
   * \ingroup mofem_fe
   *
   * \note add_file is a collective, should be executed on all processors.
   * Otherwise could lead to deadlock.
   *
   * \param name finite element name
   * \param name field name
   */
  virtual MoFEMErrorCode
  modify_finite_element_off_field_col(const std::string &fe_name,
                                      const std::string name_row) = 0;
 
  /**
   * \brief add entities to finite element
   * \ingroup mofem_fe
   *
   * \note not collective
   *
   * @param  entities   meshset or range form were entities taken
   * @param  type      type of entity
   * @param  name      finite element name
   * @param  recursive take entities from meshsets in meshset
   * @return           error code
   */
  virtual MoFEMErrorCode add_ents_to_finite_element_by_type(
      const EntityHandle entities, const EntityType type,
      const std::string name, const bool recursive = true) = 0;
 
  /**
   * \brief add entities to finite element
   * \ingroup mofem_fe
   *
   * \note not collective
   *
   * @param  entities  meshset or range form were entities taken
   * @param  dim       dimension
   * @param  name      finite element name
   * @param  recursive take entities from meshsets in meshset
   * @return           error code
   */
  virtual MoFEMErrorCode
  add_ents_to_finite_element_by_dim(const EntityHandle entities, const int dim,
                                    const std::string name,
                                    const bool recursive = true) = 0;
 
  /**
   * \brief add entities to finite elements
   * \ingroup mofem_fe
   *
   * \note not collective
   *
   * @param  ents range of entities
   * @param  type type of entity (MBVERTEX, MBEDGE, MBTRI, ...)
   * @param  name name of finite element
   * @return      error code
   */
  virtual MoFEMErrorCode
  add_ents_to_finite_element_by_type(const Range ents, const EntityType type,
                                     const std::string name) = 0;
 
  /**
   * \brief add entities to finite elements
   * \ingroup mofem_fe
   *
   * \note not collective
   *
   * @param  ents range of entities
   * @param  dim dimension of entities
   * @param  name name of finite element
   * @return      error code
   */
  virtual MoFEMErrorCode
  add_ents_to_finite_element_by_dim(const Range ents, const int dim,
                                    const std::string name) = 0;
 
  /** \brief add TET entities from given refinement level to finite element
   * database given by name
   * \ingroup mofem_fe
   *
   * \note not collective
   *
   * \param BitRefLevel bit
   * \param BitRefLevel mask
   * \param finite element name
   * \param finite element type
   * \param verbose level
   */
  virtual MoFEMErrorCode add_ents_to_finite_element_by_bit_ref(
      const BitRefLevel bit, const BitRefLevel mask, const std::string name,
      EntityType type, int verb = DEFAULT_VERBOSITY) = 0;
 
  /** get finite element meshset
   * \ingroup mofem_fe
   *
   */
  virtual EntityHandle
  get_finite_element_meshset(const std::string name) const = 0;
 
  /**
  * \brief get entities in the finite element by dimension
  * @param  name finite element name
  * @param  dim  dim
  * @param  ents ents
  * @return      error code
 
  * \ingroup mofem_field
  */
  virtual MoFEMErrorCode
  get_finite_element_entities_by_dimension(const std::string name, int dim,
                                           Range &ents) const = 0;
 
  /**
  * \brief get entities in the finite element by type
  * @param  name finite element name
  * @param  type entity type
  * @param  ents ents
  * @return      error code
 
  * \ingroup mofem_field
  */
  virtual MoFEMErrorCode
  get_finite_element_entities_by_type(const std::string name, EntityType type,
                                      Range &ents) const = 0;
 
  /**
  * \brief get entities in the finite element by handle
  * @param  name finite element name
  * @param  ents ents
  * @return      error code
 
  * \ingroup mofem_field
  */
  virtual MoFEMErrorCode
  get_finite_element_entities_by_handle(const std::string name,
                                        Range &ents) const = 0;
 
  /** \brief remove elements from given refinement level to finite element
   * database \ingroup mofem_fe
   *
   * \param BitRefLevel bit
   * \param BitRefLevel mask
   * \param verbose level
   */
  virtual MoFEMErrorCode
  remove_ents_from_finite_element_by_bit_ref(const BitRefLevel bit,
                                             const BitRefLevel mask,
                                             int verb = DEFAULT_VERBOSITY) = 0;
 
  /** \brief remove entities from given refinement level to finite element
   * database
   *
   */
  virtual MoFEMErrorCode remove_ents_from_finite_element(
      const std::string name, const EntityHandle meshset, const EntityType type,
      int verb = DEFAULT_VERBOSITY) = 0;
 
  /** \brief remove entities from finite element database
   * \ingroup mofem_fe
   *
   */
  virtual MoFEMErrorCode
  remove_ents_from_finite_element(const std::string name, const Range ents,
                                  int verb = DEFAULT_VERBOSITY) = 0;
 
  /** \brief remove entities from finite elements in database
   * \ingroup mofem_fe
   *
   */
  virtual MoFEMErrorCode
  remove_ents_from_finite_element(const Range ents,
                                  int verb = DEFAULT_VERBOSITY) = 0;
 
  /** \brief add MESHSET element to finite element database given by name
   * \ingroup mofem_fe
   *
   * \note not collective
   *
   * \param meshset contains all entities that could be used for finite
   * element \param name Finite Element name
   */
  virtual MoFEMErrorCode
  add_ents_to_finite_element_by_MESHSET(const EntityHandle meshset,
                                        const std::string &name,
                                        const bool recursive = false) = 0;
 
  /** \brief list finite elements in database
   * \ingroup mofem_fe
   */
  virtual MoFEMErrorCode list_finite_elements() const = 0;
 
  /**@}*/
 
  /** \name Problems */
 
  /**@{*/
 
  /** \brief Add problem
   * \ingroup mofem_problems
   *
   * \note add_file is a collective, should be executed on all processors.
   * Otherwise could lead to deadlock.
   *
   */
  virtual MoFEMErrorCode add_problem(const std::string &name,
                                     enum MoFEMTypes bh = MF_EXCL,
                                     int verb = DEFAULT_VERBOSITY) = 0;
 
  /**
   * \brief check if problem exist
   * @param  name problem name
   * @return      true if problem is in database
   */
  virtual bool check_problem(const std::string name) = 0;
 
  /** \brief Delete problem
   * \ingroup mofem_problems
   *
   * \note add_file is a collective, should be executed on all processors.
   * Otherwise could lead to deadlock.
   *
   */
  virtual MoFEMErrorCode delete_problem(const std::string name) = 0;
 
  /** \brief add finite element to problem, this add entities assigned to
   * finite element to a particular problem \ingroup mofem_problems
   *
   * \note add_file is a collective, should be executed on all processors.
   * Otherwise could lead to deadlock.
   *
   * \param name Problem name
   * \param name Finite Element name
   */
  virtual MoFEMErrorCode
  modify_problem_add_finite_element(const std::string name_problem,
                                    const std::string &fe_name) = 0;
 
  /** \brief unset finite element from problem, this remove entities assigned
   * to finite element to a particular problem \ingroup mofem_problems
   *
   *  Note: If problem is build, it need to be cleaned to make this effective
   *
   * \note add_file is a collective, should be executed on all processors.
   * Otherwise could lead to deadlock.
   *
   * \param name Problem name
   * \param name Finite Element name
   */
  virtual MoFEMErrorCode
  modify_problem_unset_finite_element(const std::string name_problem,
                                      const std::string &fe_name) = 0;
 
  /** \brief add ref level to problem
   * \ingroup mofem_problems
   *
   * \note add_file is a collective, should be executed on all processors.
   * Otherwise could lead to deadlock.
   *
   * if same finite element is solved using different level of refinements,
   * than the level of refinement has to be specificied to problem in query
   *
   * \param name Problem name
   * \param BitRefLevel bitLevel
   * Example: \code
    CHKERR
  mField.modify_problem_add_finite_element("BEAM_BENDING_ON_MESH_REF1","ELASTIC");
    CHKERR
  mField.modify_problem_add_finite_element("BEAM_BENDING_ON_MESH_REF2","ELASTIC");
    CHKERR
  mField.modify_problem_ref_level_add_bit("BEAM_BENDING_ON_MESH_REF1",bit_level1);
    CHKERR
  mField.modify_problem_ref_level_add_bit("BEAM_BENDING_ON_MESH_REF2",bit_level2);
  *\endcode
  * Two Problems exist and solved independently, both are elastic, but solved
  using different mesh refinement <br>
  */
  virtual MoFEMErrorCode
  modify_problem_ref_level_add_bit(const std::string &name_problem,
                                   const BitRefLevel &bit) = 0;
 
  /** \brief set dof mask ref level for problem
   * \ingroup mofem_problems
   *
   */
  virtual MoFEMErrorCode
  modify_problem_mask_ref_level_add_bit(const std::string &name_problem,
                                        const BitRefLevel &bit) = 0;
 
  /** \brief set ref level for problem
   * \ingroup mofem_problems
   *
   * \note add_file is a collective, should be executed on all processors.
   * Otherwise could lead to deadlock.
   *
   * if same finite element is solved using different level of refinements,
   * than the level of refinement has to be specificied to problem in query
   *
   * \param name Problem name
   * \param BitRefLevel bitLevel
   * Example: \code
   CHKERR
   mField.modify_problem_add_finite_element("BEAM_BENDING_ON_MESH_REF1","ELASTIC");
   CHKERR
   mField.modify_problem_add_finite_element("BEAM_BENDING_ON_MESH_REF2","ELASTIC");
 
   CHKERR
   mField.modify_problem_ref_level_set_bit("BEAM_BENDING_ON_MESH_REF1",bit_level1);
   CHKERR
   mField.modify_problem_ref_level_set_bit("BEAM_BENDING_ON_MESH_REF2",bit_level2);
   * \endcode
   * Two Problems exist and solved independently, both are elastic, but solved
   * using different mesh refinement <br>
   *
   */
  virtual MoFEMErrorCode
  modify_problem_ref_level_set_bit(const std::string &name_problem,
                                   const BitRefLevel &bit) = 0;
 
  /** \brief set dof mask ref level for problem
   * \ingroup mofem_problems
   *
   * \note add_file is a collective, should be executed on all processors.
   * Otherwise could lead to deadlock.
   *
   */
  virtual MoFEMErrorCode
  modify_problem_mask_ref_level_set_bit(const std::string &name_problem,
                                        const BitRefLevel &bit) = 0;
 
  /** \brief list problems
   * \ingroup mofem_problems
   */
  virtual MoFEMErrorCode list_problem() const = 0;
 
  /**@}*/
 
  /** \name Clear dofs and entities */
 
  /**@{*/
 
  /** list dofs
   * \ingroup mofem_field
   */
  virtual MoFEMErrorCode
  list_dofs_by_field_name(const std::string &name) const = 0;
 
  /** Clear inactive dofs
   * \ingroup mofem_field
   */
  virtual MoFEMErrorCode clear_inactive_dofs(int verb = DEFAULT_VERBOSITY) = 0;
 
  /** Clear dofs by bit level
   * \ingroup mofem_field
   */
  virtual MoFEMErrorCode
  clear_dofs_fields_by_bit_ref(const BitRefLevel bit, const BitRefLevel mask,
                               int verb = DEFAULT_VERBOSITY) = 0;
 
  /** Clear dofs by ents
   * \ingroup mofem_field
   */
  virtual MoFEMErrorCode clear_dofs_fields(const Range ents,
                                           int verb = DEFAULT_VERBOSITY) = 0;
 
  /** Clear dofs by field name and ents
   * \ingroup mofem_field
   */
  virtual MoFEMErrorCode clear_dofs_fields(const std::string name,
                                           const Range ents,
                                           int verb = DEFAULT_VERBOSITY) = 0;
 
  /** Clear entities by field name
   * \ingroup mofem_field
   */
  virtual MoFEMErrorCode clear_ents_fields(const Range ents,
                                           int verb = DEFAULT_VERBOSITY) = 0;
 
  /** Clear entities by field name
   * \ingroup mofem_field
   */
  virtual MoFEMErrorCode clear_ents_fields(const std::string name,
                                           const Range ents,
                                           int verb = DEFAULT_VERBOSITY) = 0;
 
  /** Clear ents by bit level
   * \ingroup mofem_field
   */
  virtual MoFEMErrorCode
  clear_ents_fields_by_bit_ref(const BitRefLevel bit, const BitRefLevel mask,
                               int verb = DEFAULT_VERBOSITY) = 0;
 
  /**@}*/
 
  /** \name Build fields, finite elements and problems */
 
  /**@{*/
 
  /**
   * \brief Build finite elements
   * \ingroup mofem_fe
   *
   * Build finite element data structures. Have to be run before problem and
   * adjacencies are constructed.
   *
   * @param  verb Verbosity level
   * @return      Error code
   */
  virtual MoFEMErrorCode
  build_finite_elements(int verb = DEFAULT_VERBOSITY) = 0;
 
  /**
   * \brief Build finite elements
   * \ingroup mofem_fe
   *
   * Build finite element data structures. Have to be run before problem and
   * adjacencies are constructed.
   *
   * @param  fe_name  Name of finite element
   * @param  ents_ptr Pointer to range of finite elements
   * @param  verb     Verbosity level
   * @return      Error code
   */
  virtual MoFEMErrorCode
  build_finite_elements(const string fe_name,
                        const Range *const ents_ptr = nullptr,
                        int verb = DEFAULT_VERBOSITY) = 0;
 
  /**@}*/
 
  /** \name Clear finite elements */
 
  /**@{*/
 
  /** clear finite elements
   */
  virtual MoFEMErrorCode
  clear_finite_elements_by_bit_ref(const BitRefLevel bit,
                                   const BitRefLevel mask,
                                   int verb = DEFAULT_VERBOSITY) = 0;
 
  /** clear finite elements
   */
  virtual MoFEMErrorCode
  clear_finite_elements(const Range &ents, int verb = DEFAULT_VERBOSITY) = 0;
 
  /** clear finite elements
   */
  virtual MoFEMErrorCode
  clear_finite_elements(const std::string &fe_name, const Range &ents,
                        int verb = DEFAULT_VERBOSITY) = 0;
 
  /**@}*/
 
  /** \name Build adjacencies */
 
  /**@{*/
 
  /** \brief build adjacencies
   *
   * \param list of entities
   *
   * This function will get information of adjacent finite elements and fields
   * of all entities. If this is not executed, partitioning the problem is not
   * possible. Adjacency map is based on degrees of freedom adjacent to
   * elements. This linked to geometric element connectivity.
   *
   * If new degrees of freedom or new finite elements are added to the
   * database, adjacency map has to be rebuild.
   *
   */
  virtual MoFEMErrorCode build_adjacencies(const Range &ents,
                                           int verb = DEFAULT_VERBOSITY) = 0;
 
  /** \brief build adjacencies
   *
   * \param bit adjacencies for refine level
   *
   * This function will get information of adjacent finite elements and fields
   * of all entities. If this is not executed, partitioning the problem is not
   * possible. Adjacency map is based on degrees of freedom adjacent to
   * elements. This linked to geometric element connectivity.
   *
   * If new degrees of freedom or new finite elements are added to the
   * database, adjacency map has to be rebuild.
   *
   */
  virtual MoFEMErrorCode build_adjacencies(const BitRefLevel &bit,
                                           int verb = DEFAULT_VERBOSITY) = 0;
 
  /** \brief build adjacencies
   *
   * \param bit adjacencies for refine level
   * \param mask mask for bit level
   *
   * This function will get information of adjacent finite elements and fields
   * of all entities. If this is not executed, partitioning the problem is not
   * possible. Adjacency map is based on degrees of freedom adjacent to
   * elements. This linked to geometric element connectivity.
   *
   * If new degrees of freedom or new finite elements are added to the
   * database, adjacency map has to be rebuild.
   *
   */
  virtual MoFEMErrorCode build_adjacencies(const BitRefLevel &bit,
                                           const BitRefLevel &mask,
                                           int verb = DEFAULT_VERBOSITY) = 0;
 
  /**@}*/
 
  /** \name Clear adjacencies */
 
  /**@{*/
 
  /** \brief clear adjacency map for finite elements on given bit level
   *
   * \param bit
   * \param mask
   */
  virtual MoFEMErrorCode
  clear_adjacencies_finite_elements(const BitRefLevel bit,
                                    const BitRefLevel mask,
                                    int verb = DEFAULT_VERBOSITY) = 0;
 
  /** \brief clear adjacency map for entities on given bit level
   *
   * \param bit
   * \param mask
   */
  virtual MoFEMErrorCode
  clear_adjacencies_entities(const BitRefLevel bit, const BitRefLevel mask,
                             int verb = DEFAULT_VERBOSITY) = 0;
 
  /** \brief clear adjacencies for field entities by entities
   */
  virtual MoFEMErrorCode
  clear_adjacencies_entities(const Range ents,
                             int verb = DEFAULT_VERBOSITY) = 0;
 
  /** \brief clear adjacencies for field entities by entities and field namd
   */
  virtual MoFEMErrorCode
  clear_adjacencies_entities(const std::string name, const Range ents,
                             int verb = DEFAULT_VERBOSITY) = 0;
 
  /**@}*/
 
  /** \name Problems */
 
  /**@{*/
 
  /** \brief clear problem
   * \ingroup mofem_problems
   */
  virtual MoFEMErrorCode clear_problem(const std::string name,
                                       int verb = DEFAULT_VERBOSITY) = 0;
 
  /** \brief clear problems
   * \ingroup mofem_problems
   */
  virtual MoFEMErrorCode clear_problems(int verb = DEFAULT_VERBOSITY) = 0;
 
  /**
   * \brief add finite elements to the meshset
   * \ingroup mofem_problems
   *
   * \param name is problem name
   * \param fe_name
   * \param meshset
   */
  virtual MoFEMErrorCode
  get_problem_finite_elements_entities(const std::string name,
                                       const std::string &fe_name,
                                       const EntityHandle meshset) = 0;
 
  /**@}*/
 
  /** \name Making loops on elements and entities */
 
  /**@{*/
 
  /** \brief Set data for BasicMethod
   *
   * This function set data about problem, adjacencies and other multi-indices
   * in database. This function can be used a special case when user need to
   * do some pre- and post-processing before matrix or vector is initiated, or
   * to assemble matrix for group of FEMethods. Is used by classes
   * SnesCtx and TsCtx. Look for more details there.
   *
   * FIXME: Here we need example
   *
   * \param pointer to problem data structure
   * \param method user method derived from BasicMethod
   *
   **/
  virtual MoFEMErrorCode
  problem_basic_method_preProcess(const Problem *problem_ptr,
                                  BasicMethod &method,
                                  int verb = DEFAULT_VERBOSITY) = 0;
 
  /** \brief Set data for BasicMethod
   *
   * This function set data about problem, adjacencies and other multi-indices
   * in database. This function can be used a special case when user need to
   * do some pre- and post-processing before matrix or vector is initiated, or
   * to assemble matrix for group of FEMethods. Is used by classes
   * SnesCtx and TsCtx. Look for more details there.
   *
   * FIXME: Here we need example
   *
   * \param problem_name name of the problem
   * \param method user method derived from BasicMethod
   *
   **/
  virtual MoFEMErrorCode
  problem_basic_method_preProcess(const std::string &problem_name,
                                  BasicMethod &method,
                                  int verb = DEFAULT_VERBOSITY) = 0;
 
  /** \brief Set data for BasicMethod
   * \ingroup mofem_loops
   *
   * This function set data about problem, adjacencies and other multi-indices
   * in database. This function can be used a special case when user need to
   * do some pre- and post-processing before matrix or vector is initiated, or
   * to assemble matrix for group of FEMethods. Is used by classes
   * SnesCtx and TsCtx. Look for more details there.
   *
   * FIXME: Here we need example
   *
   * \param pointer to problem data structure
   * \param method user method derived from BasicMethod
   *
   **/
  virtual MoFEMErrorCode
  problem_basic_method_postProcess(const Problem *problem_ptr,
                                   BasicMethod &method,
                                   int verb = DEFAULT_VERBOSITY) = 0;
 
  /** \brief Set data for BasicMethod
   * \ingroup mofem_loops
   *
   * This function set data about problem, adjacencies and other multi-indices
   * in database. This function can be used a special case when user need to
   * do some pre- and post-processing before matrix or vector is initiated, or
   * to assemble matrix for group of FEMethods. Is used by classes
   * SnesCtx and TsCtx. Look for more details there.
   *
   * FIXME: Here we need example
   *
   * \param problem_name name of the problem
   * \param method user method derived from BasicMethod
   *
   **/
  virtual MoFEMErrorCode
  problem_basic_method_postProcess(const std::string &problem_name,
                                   BasicMethod &method,
                                   int verb = DEFAULT_VERBOSITY) = 0;
 
  /**
   * @brief Cache variables
   *
   * @param prb_name
   * @param cache_ptr
   * @return MoFEMErrorCode
   */
  virtual MoFEMErrorCode
  cache_problem_entities(const std::string prb_name,
                         CacheTupleWeakPtr cache_ptr) = 0;
 
  /** \brief Make a loop over finite elements.
  *
  * This function is like a Swiss knife; it can be used for post-processing or
  * matrix and vector assembly. It iterates over the given finite element for a
  * given problem. The particular methods executed on each element are provided
  by a
  * class derived from Interface::FEMethod. At the beginning of each loop the
  user-
  * defined function (method) preProcess() is called; for each element
  operator() is
  * executed; at the end, the loop finalizes with the user-defined function
  (method)
  * postProcess().
  *
  * Methods are executed only for local elements on a given processor.
  *
  * For more details please look at examples.
  *
  * \note If fe_ptr is given, it is expected that the multi-index is a subset of
  * problem multi-index. If this is not the case behavior of the code is
  * undetermined.
  *
  * @param  problem_name problem consisting set of elements
  * @param  fe_name      name of element in problem
  * @param  method       class derived form Interface::FEMethod
  * @param  fe_ptr       pointer to finite elements multi-index
  * @param  bh           if bH = MF_EXIST, throws error if fe_name does not
  exist
  * @param  cache_tuple_ptr  cache
  * @param  verb         verbosity level
  * @return              error code
 
  * \ingroup mofem_loops
  **/
  virtual MoFEMErrorCode loop_finite_elements(
      const std::string problem_name, const std::string &fe_name,
      FEMethod &method,
      boost::shared_ptr<NumeredEntFiniteElement_multiIndex> fe_ptr = nullptr,
      MoFEMTypes bh = MF_EXIST,
      CacheTupleWeakPtr cache_ptr = CacheTupleSharedPtr(),
      int verb = DEFAULT_VERBOSITY) = 0;
 
  /** \brief Make a loop over finite elements on partitions from upper to
  lower rank.
  *
  * This function is like a Swiss knife; it can be used for post-processing or
  * matrix and vector assembly. It iterates over the given finite element for a
  given
  * problem. The particular methods executed on each element are provided by a
  * class derived from Interface::FEMethod. At the beginning of each loop the
  user-
  * defined function (method) preProcess() is called; for each element
  operator() is
  * executed; at the end, the loop finalizes with the user-defined function
  (method)
  * postProcess().
  *
  * \note If fe_ptr is given, it is expected that the multi-index is a subset of
  * problem multi-index. If this is not the case behavior of the code is
  * undetermined.
  *
  * For more details please look to examples.
  *
  * Interface::FEMethod
 
  * @param  problem_ptr pointer to problem consisting set of elements
  * @param  fe_name      name of element in problem
  * @param  method       class derived from Interface::FEMethod
  * @param  lower_rank   lower rank of process owning the finite element
  * @param  upper_rank   upper rank of process owning the finite element
  * @param  fe_ptr       pointer to finite elements multi-index
  * @param  bh           if bH = MF_EXIST, throws error if fe_name does not
  exist
  * @param  cache_data   cache data vector
  * @param  cache_row    cache row vector
  * @param  cache_col    cache row vector
  * @param  verb         verbosity level
  * @return              error code
 
  * \ingroup mofem_loops
  **/
  virtual MoFEMErrorCode loop_finite_elements(
      const Problem *problem_ptr, const std::string &fe_name, FEMethod &method,
      int lower_rank, int upper_rank,
      boost::shared_ptr<NumeredEntFiniteElement_multiIndex> fe_ptr = nullptr,
      MoFEMTypes bh = MF_EXIST,
      CacheTupleWeakPtr cache_ptr = CacheTupleSharedPtr(),
      int verb = DEFAULT_VERBOSITY) = 0;
 
  /** \brief Make a loop over finite elements on partitions from upper to
  lower rank.
  *
  * This function is like a Swiss knife; it can be used for post-processing or
  * matrix and vector assembly. It iterates over the given finite element for a given
  * problem. The particular methods executed on each element are provided by a
  * class derived from Interface::FEMethod. At the beginning of each loop the user-
  *  defined function (method) preProcess() is called; for each element operator() is
  * executed; at the end, the loop finalizes with the user-defined function (method)
  * postProcess().
  *
  * \note If fe_ptr is given, it is expected that the multi-index is a subset of
  * problem multi-index. If this is not the case behavior of the code is
  * undetermined.
  *
  * For more details please look to examples.
  *
  * @param  problem_name pointer to problem consisting set of elements
  * @param  fe_name      name of element in problem
  * @param  method       class derived from Interface::FEMethod
  * @param  lower_rank   lower rank of process owning the finite element
  * @param  upper_rank   upper rank of process owning the finite element
  * @param  fe_ptr       pointer to finite elements multi-index
  * @param  bh           if bH = MF_EXIST, throws error if fe_name does not
  exist
  * @param  cache_data   cache data vector
  * @param  cache_row    cache row vector
  * @param  cache_col    cache row vector
  * @param  verb         verbosity level
  * @return              error code
 
  * \ingroup mofem_loops
  **/
  virtual MoFEMErrorCode loop_finite_elements(
      const std::string problem_name, const std::string &fe_name,
      FEMethod &method, int lower_rank, int upper_rank,
      boost::shared_ptr<NumeredEntFiniteElement_multiIndex> fe_ptr = nullptr,
      MoFEMTypes bh = MF_EXIST,
      CacheTupleWeakPtr cache_ptr = CacheTupleSharedPtr(),
      int verb = DEFAULT_VERBOSITY) = 0;
 
  /** \brief Make a loop over dofs
 
  * \ingroup mofem_loops
  *
  * @param problem_ptr Pointer to problem structure
  * @param field_name Name of the field containing DOFs to loop over
  * @param rc Row/column data specification
  * @param method User-defined method to execute on each DOF
  * @param lower_rank Lower processor rank range (inclusive)
  * @param upper_rank Upper processor rank range (inclusive)
  * @param verb Verbosity level (default: DEFAULT_VERBOSITY)
  * @return MoFEMErrorCode Error code indicating success or failure
  */
  virtual MoFEMErrorCode loop_dofs(const Problem *problem_ptr,
                                   const std::string &field_name, RowColData rc,
                                   DofMethod &method, int lower_rank,
                                   int upper_rank,
                                   int verb = DEFAULT_VERBOSITY) = 0;
 
  /** \brief Make a loop over dofs
 
  * \ingroup mofem_loops
  *
  * @param problem_name Name of the problem containing DOFs
  * @param field_name Name of the field containing DOFs to loop over
  * @param rc Row/column data specification
  * @param method User-defined method to execute on each DOF
  * @param lower_rank Lower processor rank range (inclusive)
  * @param upper_rank Upper processor rank range (inclusive)
  * @param verb Verbosity level (default: DEFAULT_VERBOSITY)
  * @return MoFEMErrorCode Error code indicating success or failure
  */
  virtual MoFEMErrorCode loop_dofs(const std::string &problem_name,
                                   const std::string &field_name, RowColData rc,
                                   DofMethod &method, int lower_rank,
                                   int upper_rank,
                                   int verb = DEFAULT_VERBOSITY) = 0;
 
  /** \brief Make a loop over dofs
 
  * \ingroup mofem_loops
  *
  * @param problem_name Name of the problem containing DOFs
  * @param field_name Name of the field containing DOFs to loop over
  * @param rc Row/column data specification
  * @param method User-defined method to execute on each DOF
  * @param verb Verbosity level (default: DEFAULT_VERBOSITY)
  * @return MoFEMErrorCode Error code indicating success or failure
  */
  virtual MoFEMErrorCode loop_dofs(const std::string &problem_name,
                                   const std::string &field_name, RowColData rc,
                                   DofMethod &method,
                                   int verb = DEFAULT_VERBOSITY) = 0;
 
  /** \brief Make a loop over dofs
 
  * \ingroup mofem_field
  *
  * @param field_name Name of the field containing DOFs to loop over
  * @param method User-defined method to execute on each DOF
  * @param verb Verbosity level (default: DEFAULT_VERBOSITY)
  * @return MoFEMErrorCode Error code indicating success or failure
  */
  virtual MoFEMErrorCode loop_dofs(const std::string &field_name,
                                   DofMethod &method,
                                   int verb = DEFAULT_VERBOSITY) = 0;
 
  /**
   * @brief Loop over field entities
   * @ingroup mofem_field
   *
   * @param field_name Name of the field containing entities to loop over
   * @param method User-defined method to execute on each entity
   * @param ents If provided, loop only over subset of entities in the field
   * (default: nullptr for all entities)
   * @param verb Verbosity level (default: DEFAULT_VERBOSITY)
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  virtual MoFEMErrorCode loop_entities(const std::string field_name,
                                       EntityMethod &method,
                                       Range const *const ents = nullptr,
                                       int verb = DEFAULT_VERBOSITY) = 0;
 
  /**
   * @brief Loop over field entities in the problem
   * @ingroup mofem_field
   *
   * @param problem_ptr Pointer to problem structure
   * @param field_name Name of the field containing entities to loop over
   * @param rc Row/column data specification
   * @param method User-defined method to execute on each entity
   * @param lower_rank Lower processor rank range (inclusive)
   * @param upper_rank Upper processor rank range (inclusive)
   * @param verb Verbosity level (default: DEFAULT_VERBOSITY)
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  virtual MoFEMErrorCode loop_entities(const Problem *problem_ptr,
                                       const std::string field_name,
                                       RowColData rc, EntityMethod &method,
                                       int lower_rank, int upper_rank,
                                       int verb = DEFAULT_VERBOSITY) = 0;
 
  /**
   * @brief Loop over field entities in the problem
   * @ingroup mofem_field
   *
   * @param problem_name
   * @param field_name
   * @param rc
   * @param method
   * @param lower_rank
   * @param upper_rank
   * @param verb
   * @return MoFEMErrorCode
   */
  virtual MoFEMErrorCode loop_entities(const std::string problem_name,
                                       const std::string field_name,
                                       RowColData rc, EntityMethod &method,
                                       int lower_rank, int upper_rank,
                                       int verb = DEFAULT_VERBOSITY) = 0;
  /**
   * @brief Loop over field entities in the problem
   * @ingroup mofem_field
   *
   * @param problem_name
   * @param field_name
   * @param rc
   * @param method
   * @param verb
   * @return MoFEMErrorCode
   */
  virtual MoFEMErrorCode loop_entities(const std::string problem_name,
                                       const std::string field_name,
                                       RowColData rc, EntityMethod &method,
                                       int verb = DEFAULT_VERBOSITY) = 0;
 
  /**@}*/
 
  /** \name Get pointers to multi-index database */
 
  /**@{*/
 
  /**
   * @brief Get the fields object
   * @ingroup mofem_access
   *
   * @return const Field_multiIndex* Const pointer to fields multi-index
   */
  virtual const Field_multiIndex *get_fields() const = 0;
 
  /**
   * @brief Get the ref ents object
   * @ingroup mofem_access
   *
   * @return const RefEntity_multiIndex* Const pointer to refined entities multi-index
   */
  virtual const RefEntity_multiIndex *get_ref_ents() const = 0;
 
  /**
   * @brief Get the ref finite elements object
   * @ingroup mofem_access
   *
   * @return const RefElement_multiIndex* Const pointer to refined finite elements multi-index
   */
  virtual const RefElement_multiIndex *get_ref_finite_elements() const = 0;
 
  /**
   * @brief Get the finite elements object
   * @ingroup mofem_access
   *
   * @return const FiniteElement_multiIndex* Const pointer to finite elements multi-index
   */
  virtual const FiniteElement_multiIndex *get_finite_elements() const = 0;
 
  /**
   * @brief Get the ents finite elements object
   * @ingroup mofem_access
   *
   * @return const EntFiniteElement_multiIndex* Const pointer to entity-finite element multi-index
   */
  virtual const EntFiniteElement_multiIndex *
  get_ents_finite_elements() const = 0;
 
  /**
   * @brief Get the field ents object
   * @ingroup mofem_access
   *
   * @return const FieldEntity_multiIndex* Const pointer to field entities multi-index
   */
  virtual const FieldEntity_multiIndex *get_field_ents() const = 0;
 
  /**
   * @brief Get the dofs object
   * @ingroup mofem_access
   *
   * @return const DofEntity_multiIndex* Const pointer to DOF entities multi-index
   */
  virtual const DofEntity_multiIndex *get_dofs() const = 0;
 
  /**
   * @brief Get the problem object
   * @ingroup mofem_access
   *
   * @param problem_name Name of the problem to retrieve
   * @return const Problem* Const pointer to problem structure
   */
  virtual const Problem *get_problem(const std::string problem_name) const = 0;
 
  /**
   * @brief Get the problems object
   * @ingroup mofem_access
   *
   * @return const Problem_multiIndex* Const pointer to problems multi-index
   */
  virtual const Problem_multiIndex *get_problems() const = 0;
 
  /**
   * @brief Get the dofs elements adjacency object
   *
   * @param dofs_elements_adjacency Pointer to store the adjacency map multi-index
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  virtual MoFEMErrorCode get_ents_elements_adjacency(
      const FieldEntityEntFiniteElementAdjacencyMap_multiIndex *
          *dofs_elements_adjacency) const = 0;
 
  /**
   * @brief Get the dofs elements adjacency object
   *
   * @return const FieldEntityEntFiniteElementAdjacencyMap_multiIndex* Const pointer to adjacency map multi-index
   */
  virtual const FieldEntityEntFiniteElementAdjacencyMap_multiIndex *
  get_ents_elements_adjacency() const = 0;
 
  /** \brief Get fields multi-index from database
   * \ingroup mofem_access
   */
  virtual MoFEMErrorCode
  get_fields(const Field_multiIndex **fields_ptr) const = 0;
 
  /** \brief Get ref entities multi-index from database
   * \ingroup mofem_access
   */
  virtual MoFEMErrorCode
  get_ref_ents(const RefEntity_multiIndex **refined_ents_ptr) const = 0;
 
  /** \brief Get ref finite elements multi-index form database
   * \ingroup mofem_access
   */
  virtual MoFEMErrorCode get_ref_finite_elements(
      const RefElement_multiIndex **refined_finite_elements_ptr) const = 0;
 
  /** \brief Get finite elements multi-index
   * \ingroup mofem_access
   */
  virtual MoFEMErrorCode
  get_finite_elements(const FiniteElement_multiIndex **fe_ptr) const = 0;
 
  /** \brief Get entities finite elements multi-index
   * \ingroup mofem_access
   */
  virtual MoFEMErrorCode get_ents_finite_elements(
      const EntFiniteElement_multiIndex **fe_ent_ptr) const = 0;
 
  /** \brief Get problem database (data structure)
   * \ingroup mofem_access
   */
  virtual MoFEMErrorCode get_problem(const std::string &problem_name,
                                     const Problem **problem_ptr) const = 0;
 
  /**
   * \brief Get pointer to problems multi-index
   * \ingroup mofem_access
   */
  virtual MoFEMErrorCode
  get_problems(const Problem_multiIndex **problems_ptr) const = 0;
 
  /** \brief Get field multi index
   *
   * \ingroup mofem_access
   *
   */
  virtual MoFEMErrorCode
  get_field_ents(const FieldEntity_multiIndex **field_ents) const = 0;
 
  /** \brief Get dofs multi index
   *
   * \ingroup mofem_access
   *
   */
  virtual MoFEMErrorCode
  get_dofs(const DofEntity_multiIndex **dofs_ptr) const = 0;
 
  /**
   * \brief get begin iterator of field ents of given name (instead you can
   * use _IT_GET_ENT_FIELD_BY_NAME_FOR_LOOP_(MFIELD,NAME,IT)
   *
   * \ingroup mofem_field
   *
   * for(_IT_GET_ENT_FIELD_BY_NAME_FOR_LOOP_(MFIELD,NAME,IT)) {
   *    ...
   * }
   *
   * \param field_name Name of the field to get iterator for
   * \return FieldEntityByUId::iterator Begin iterator for field entities
   */
  virtual FieldEntityByUId::iterator
  get_ent_field_by_name_begin(const std::string &field_name) const = 0;
 
  /**
   * \brief get end iterator of field ents of given name (instead you can
   * use _IT_GET_ENT_FIELD_BY_NAME_FOR_LOOP_(MFIELD,NAME,IT)
   * \ingroup mofem_field
   *
   * for(_IT_GET_ENT_FIELD_BY_NAME_FOR_LOOP_(MFIELD,NAME,IT)) {
   *    ...
   * }
   *
   * \param field_name Name of the field to get iterator for
   * \return FieldEntityByUId::iterator End iterator for field entities
   */
  virtual FieldEntityByUId::iterator
  get_ent_field_by_name_end(const std::string &field_name) const = 0;
 
  /** \brief loop over all dofs from a moFEM field and particular field
   * \ingroup mofem_field
   */
  #define _IT_GET_ENT_FIELD_BY_NAME_FOR_LOOP_(MFIELD, NAME, IT)                \
    auto IT = (MFIELD).get_ent_field_by_name_begin(NAME);                      \
    IT != (MFIELD).get_ent_field_by_name_end(NAME);                            \
    IT++
 
  /**
   * \brief get begin iterator of field dofs of given name (instead you can
   * use _IT_GET_DOFS_FIELD_BY_NAME_FOR_LOOP_(MFIELD,NAME,IT)
   * \ingroup mofem_field
   *
   * for(_IT_GET_DOFS_FIELD_BY_NAME_FOR_LOOP_(MFIELD,NAME,IT)) {
   *    ...
   * }
   *
   * \param field_name
   */
  virtual DofEntityByUId::iterator
  get_dofs_by_name_begin(const std::string &field_name) const = 0;
 
  /**
   * \brief get begin iterator of field dofs of given name (instead you can
   * use _IT_GET_DOFS_FIELD_BY_NAME_FOR_LOOP_(MFIELD,NAME,IT)
   * \ingroup mofem_field
   *
   * for(_IT_GET_DOFS_FIELD_BY_NAME_FOR_LOOP_(MFIELD,NAME,IT)) {
   *    ...
   * }
   *
   * \param field_name
   */
  virtual DofEntityByUId::iterator
  get_dofs_by_name_end(const std::string &field_name) const = 0;
 
  /** loop over all dofs from a moFEM field and particular field
   * \ingroup mofem_field
   */
  #define _IT_GET_DOFS_FIELD_BY_NAME_FOR_LOOP_(MFIELD, NAME, IT)               \
    DofEntityByUId::iterator IT = (MFIELD).get_dofs_by_name_begin(NAME);       \
    IT != (MFIELD).get_dofs_by_name_end(NAME);                                 \
    IT++
 
  /**
   * \brief get begin iterator of field dofs of given name and ent(instead you
   * can use _IT_GET_DOFS_FIELD_BY_NAME_FOR_LOOP_(MFIELD,NAME,ENT,IT)
   *
   * \ingroup mofem_field
   *
   * for(_IT_GET_DOFS_FIELD_BY_NAME_AND_ENT_FOR_LOOP_(MFIELD,NAME,ENT,IT)) {
   *    ...
   * }
   *
   * \param field_name
   */
  virtual DofEntityByUId::iterator
  get_dofs_by_name_and_ent_begin(const std::string &field_name,
                                 const EntityHandle ent) const = 0;
 
  /**
   * \brief get end iterator of field dofs of given name and ent (instead
   * you can use _IT_GET_DOFS_FIELD_BY_NAME_FOR_LOOP_(MFIELD,NAME,ENT,IT)
   * \ingroup mofem_field
   *
   * for(_IT_GET_DOFS_FIELD_BY_NAME_AND_ENT_FOR_LOOP_(MFIELD,NAME,ENT,IT)) {
   *    ...
   * }
   *
   * \param field_name Name of the field
   * \param ent Entity handle to get DOFs for
   * \return DofEntityByUId::iterator End iterator for field DOFs on entity
   */
  virtual DofEntityByUId::iterator
  get_dofs_by_name_and_ent_end(const std::string &field_name,
                               const EntityHandle ent) const = 0;
 
  /** \brief loop over all dofs from a moFEM field and particular field
   * \ingroup mofem_access
   */
  #define _IT_GET_DOFS_FIELD_BY_NAME_AND_ENT_FOR_LOOP_(MFIELD, NAME, ENT, IT)  \
    DofEntityByUId::iterator IT =                                              \
        (MFIELD).get_dofs_by_name_and_ent_begin(NAME, ENT);                    \
    IT != (MFIELD).get_dofs_by_name_and_ent_end(NAME, ENT);                    \
    IT++
 
  /**
   * \brief get begin iterator of field dofs of given name and ent type
   * (instead you can use
   * _IT_GET_DOFS_FIELD_BY_NAME_FOR_LOOP_(MFIELD,NAME,TYPE,IT)
   *
   * \ingroup mofem_field
   *
   * for(_IT_GET_DOFS_FIELD_BY_NAME_AND_TYPE_FOR_LOOP_(MFIELD,NAME,TYPE,IT)) {
   *    ...
   * }
   *
   * \param field_name Name of the field
   * \param type Entity type to filter DOFs by
   * \return DofEntityByUId::iterator Begin iterator for field DOFs of specified
   * type
   */
  virtual DofEntityByUId::iterator
  get_dofs_by_name_and_type_begin(const std::string &field_name,
                                  const EntityType type) const = 0;
 
  /**
   * \brief get end iterator of field dofs of given name and ent
   * type(instead you can use
   * _IT_GET_DOFS_FIELD_BY_NAME_FOR_LOOP_(MFIELD,NAME,TYPE,IT)
   *
   * \ingroup mofem_field
   *
   * for(_IT_GET_DOFS_FIELD_BY_NAME_AND_TYPE_FOR_LOOP_(MFIELD,NAME,TYPE,IT)) {
   *    ...
   * }
   *
   * \param field_name Name of the field
   * \param type Entity type to filter DOFs by
   * \return DofEntityByUId::iterator End iterator for field DOFs of specified
   * type
   */
  virtual DofEntityByUId::iterator
  get_dofs_by_name_and_type_end(const std::string &field_name,
                                const EntityType type) const = 0;
 
  /** \brief loop over all dofs from a moFEM field and particular field
   * \ingroup mofem_field
   */
  #define _IT_GET_DOFS_FIELD_BY_NAME_AND_TYPE_FOR_LOOP_(MFIELD, NAME, TYPE,    \
                                                        IT)                    \
    DofEntityByUId::iterator IT =                                              \
        (MFIELD).get_dofs_by_name_and_type_begin(NAME, TYPE);                  \
    IT != (MFIELD).get_dofs_by_name_and_type_end(NAME, TYPE);                  \
    IT++
 
  /**
   * \brief get begin iterator of finite elements of given name (instead you
   * can use _IT_GET_FES_BY_NAME_FOR_LOOP_(MFIELD,NAME,IT)
   *
   * \ingroup mofem_access
   *
   * for(_IT_GET_FES_BY_NAME_FOR_LOOP_(MFIELD,NAME,IT)) {
   *    ...
   * }
   *
   * \param fe_name Name of the finite element to get iterator for
   * \return EntFiniteElement_multiIndex::index<Unique_mi_tag>::type::iterator
   * Begin iterator for finite elements
   */
  virtual EntFiniteElement_multiIndex::index<Unique_mi_tag>::type::iterator
  get_fe_by_name_begin(const std::string &fe_name) const = 0;
 
  /**
   * \brief get end iterator of finite elements of given name (instead you can
   * use _IT_GET_FES_BY_NAME_FOR_LOOP_(MFIELD,NAME,IT)
   *
   * \ingroup mofem_access
   *
   * for(_IT_GET_FES_BY_NAME_FOR_LOOP_(MFIELD,NAME,IT)) {
   *    ...
   * }
   *
   * \param fe_name
   */
  virtual EntFiniteElement_multiIndex::index<Unique_mi_tag>::type::iterator
  get_fe_by_name_end(const std::string &fe_name) const = 0;
 
  /** \brief loop over all finite elements from a moFEM field and FE
   * \ingroup mofem_access
   */
  #define _IT_GET_FES_BY_NAME_FOR_LOOP_(MFIELD, NAME, IT)                      \
    auto IT = (MFIELD).get_fe_by_name_begin(NAME);                             \
    IT != (MFIELD).get_fe_by_name_end(NAME);                                   \
    IT++
};
} // namespace MoFEM
 
  #include <DeprecatedCoreInterface.hpp>
 
namespace MoFEM {
 
using Interface = DeprecatedCoreInterface;
 
} // namespace MoFEM
 
#endif // __INTERFACE_HPP__
 
/**
 * \defgroup mofem_field Fields
 * \brief Data structure for adding and managing fields
 *
 * \ingroup mofem
 ******************************************************************************/
 
/**
 * \defgroup mofem_ref_ents Get entities and adjacencies
 * \brief Get adjacencies/entities for given BitRefLevel (mesh refinement)
 *
 * \ingroup mofem
 ******************************************************************************/
 
/**
 * \defgroup mofem_fe Finite elements
 * \brief Adding and managing finite elements
 *
 * \ingroup mofem
 ******************************************************************************/
 
/**
 * \defgroup mofem_problems Problems
 * \brief Adding and managing problems
 *
 * \ingroup mofem
 ******************************************************************************/
 
/**
 * \defgroup mofem_loops Loops
 * \brief Manages complexities for integrating over finite elements and dofs.
 *
 * \ingroup mofem
 ******************************************************************************/
 
/**
 * \defgroup mofem_access Pointers to multi-indices
 * \brief Get direct access to multi-indices in database
 *
 * \ingroup mofem
 ******************************************************************************/