MoFEM::ProblemsManager Struct Reference

Problem manager is used to build and partition problems . More...

#include <src/interfaces/ProblemsManager.hpp>

Inheritance diagram for MoFEM::ProblemsManager:

Collaboration diagram for MoFEM::ProblemsManager:

Public Member Functions
MoFEMErrorCode	query_interface (const MOFEMuuid &uuid, UnknownInterface **iface) const
	ProblemsManager (const MoFEM::Core &core)
	~ProblemsManager ()
	Destructor. More...
MoFEMErrorCode	getOptions ()
MoFEMErrorCode	partitionMesh (const Range &ents, const int dim, const int adj_dim, const int n_parts, Tag *th_vertex_weights=nullptr, Tag *th_edge_weights=nullptr, Tag *th_part_weights=nullptr, int verb=VERBOSE, const bool debug=false)
	Set partition tag to each finite element in the problemThis 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 More...
MoFEMErrorCode	buildProblem (const std::string &name, const bool square_matrix, int verb=VERBOSE)
	build problem data structures More...
MoFEMErrorCode	buildProblem (Problem *problem_ptr, const bool square_matrix, int verb=VERBOSE)
	build problem data structures More...
MoFEMErrorCode	buildProblemOnDistributedMesh (const std::string &name, const bool square_matrix, int verb=VERBOSE)
	build problem data structures, assuming that mesh is distributed (collective)Mesh is distributed, that means that each processor keeps only own part of the mesh and shared entities. More...
MoFEMErrorCode	buildProblemOnDistributedMesh (Problem *problem_ptr, const bool square_matrix=true, int verb=VERBOSE)
	build problem data structures, assuming that mesh is distributed (collective)Mesh is distributed, that means that each processor keeps only own part of the mesh and shared entities. More...
MoFEMErrorCode	buildSubProblem (const std::string &out_name, const std::vector< std::string > &fields_row, const std::vector< std::string > &fields_col, const std::string &main_problem, const bool square_matrix=true, int verb=VERBOSE)
	build sub problem More...
MoFEMErrorCode	buildCompsedProblem (const std::string &out_name, const std::vector< std::string > add_row_problems, const std::vector< std::string > add_col_problems, const bool square_matrix=true, int verb=1)
	build composite problem More...
MoFEMErrorCode	inheritPartition (const std::string &name, const std::string &problem_for_rows, bool copy_rows, const std::string &problem_for_cols, bool copy_cols, int verb=VERBOSE)
	build indexing and partition problem inheriting indexing and partitioning from two other problems More...
MoFEMErrorCode	partitionSimpleProblem (const std::string &name, int verb=VERBOSE)
	partition problem dofs More...
MoFEMErrorCode	partitionProblem (const std::string &name, int verb=VERBOSE)
	partition problem dofs (collective) More...
MoFEMErrorCode	printPartitionedProblem (const Problem *problem_ptr, int verb=VERBOSE)
MoFEMErrorCode	debugPartitionedProblem (const Problem *problem_ptr, int verb=VERBOSE)
MoFEMErrorCode	partitionFiniteElements (const std::string &name, bool part_from_moab=false, int low_proc=-1, int hi_proc=-1, int verb=VERBOSE)
	partition finite elementsFunction which partition finite elements based on dofs partitioning. In addition it sets information about local row and cols dofs at given element on partition. More...
MoFEMErrorCode	partitionGhostDofs (const std::string &name, int verb=VERBOSE)
	determine ghost nodes More...
MoFEMErrorCode	partitionGhostDofsOnDistributedMesh (const std::string &name, int verb=VERBOSE)
	determine ghost nodes on distributed meshes More...
MoFEMErrorCode	getFEMeshset (const std::string &prb_name, const std::string &fe_name, EntityHandle *meshset) const
MoFEMErrorCode	getProblemElementsLayout (const std::string &name, const std::string &fe_name, PetscLayout *layout) const
	Get layout of elements in the problemIn 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 More...
Public Member Functions inherited from MoFEM::UnknownInterface
template<class IFACE >
MoFEMErrorCode	registerInterface (const MOFEMuuid &uuid, bool error_if_registration_failed=true)
	Register interface. More...
template<class IFACE , bool VERIFY = false>
MoFEMErrorCode	getInterface (const MOFEMuuid &uuid, IFACE *&iface) const
	Get interface by uuid and return reference to pointer of interface. More...
template<class IFACE >
MoFEMErrorCode	getInterface (IFACE *&iface) const
	Get interface refernce to pointer of interface. More...
template<class IFACE >
MoFEMErrorCode	getInterface (IFACE **const iface) const
	Get interface pointer to pointer of interface. More...
template<class IFACE , typename boost::enable_if< boost::is_pointer< IFACE >, int >::type = 0>
IFACE	getInterface () const
	Get interface pointer to pointer of interface. More...
template<class IFACE , typename boost::enable_if< boost::is_reference< IFACE >, int >::type = 0>
IFACE	getInterface () const
	Get reference to interface. More...
template<class IFACE >
IFACE *	getInterface () const
	Function returning pointer to interface. More...
virtual	~UnknownInterface ()
virtual MoFEMErrorCode	getLibVersion (Version &version) const
	Get library version. More...
virtual const MoFEMErrorCode	getFileVersion (moab::Interface &moab, Version &version) const
	Get database major version. More...
virtual MoFEMErrorCode	getInterfaceVersion (Version &version) const
	Get database major version. More...
template<>
MoFEMErrorCode	getInterface (const MOFEMuuid &uuid, UnknownInterface *&iface) const

Public Attributes
MoFEM::Core &	cOre
PetscBool	buildProblemFromFields
PetscBool	synchroniseProblemEntities
	DOFs in fields, not from DOFs on elements. More...

Private Attributes
PetscLogEvent	MOFEM_EVENT_ProblemsManager

Additional Inherited Members
Protected Member Functions inherited from MoFEM::UnknownInterface
boost::typeindex::type_index	getClassIdx (const MOFEMuuid &uid) const
	Get type name for interface Id. More...
MOFEMuuid	getUId (const boost::typeindex::type_index &class_idx) const
	Get interface Id for class name. More...

Detailed Description

Problem manager is used to build and partition problems .

Examples:

forces_and_sources_testing_edge_element.cpp.

Definition at line 34 of file ProblemsManager.hpp.

Constructor & Destructor Documentation

ProblemsManager()

MoFEM::ProblemsManager::ProblemsManager

(

const MoFEM::Core &

core

)

Definition at line 74 of file ProblemsManager.cpp.

    : cOre(const_cast<MoFEM::Core &>(core)),
      buildProblemFromFields(PETSC_FALSE),
      synchroniseProblemEntities(PETSC_FALSE) {
  PetscLogEventRegister("ProblemsManager", 0, &MOFEM_EVENT_ProblemsManager);
}

~ProblemsManager()

MoFEM::ProblemsManager::~ProblemsManager

(

)

Destructor.

Definition at line 80 of file ProblemsManager.cpp.

{}

Member Function Documentation

buildCompsedProblem()

MoFEMErrorCode MoFEM::ProblemsManager::buildCompsedProblem	(	const std::string &	out_name,
		const std::vector< std::string >	add_row_problems,
		const std::vector< std::string >	add_col_problems,
		const bool	square_matrix = true,
		int	verb = 1
	)

build composite problem

Parameters

out_name	name of build problem
add_row_problems	vector of add row problems
add_col_problems	vector of add col problems
square_matrix	true if structurally squared matrix
verb	verbosity level

Returns

error code

Definition at line 1481 of file ProblemsManager.cpp.

              {
  if (!(cOre.getBuildMoFEM() & Core::BUILD_FIELD))
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "fields not build");
  if (!(cOre.getBuildMoFEM() & Core::BUILD_FE))
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "FEs not build");
  if (!(cOre.getBuildMoFEM() & Core::BUILD_ADJ))
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "adjacencies not build");
  MoFEM::Interface &m_field = cOre;
  const Problem_multiIndex *problems_ptr;
  MoFEMFunctionBeginHot;

  ierr = m_field.clear_problem(out_name);
  CHKERRG(ierr);
  ierr = m_field.get_problems(&problems_ptr);
  CHKERRG(ierr);
  // get reference to all problems
  typedef Problem_multiIndex::index<Problem_mi_tag>::type ProblemByName;
  ProblemByName &problems_by_name =
      const_cast<ProblemByName &>(problems_ptr->get<Problem_mi_tag>());

  // Get iterators to out problem, i.e. build problem
  ProblemByName::iterator out_problem_it = problems_by_name.find(out_name);
  if (out_problem_it == problems_by_name.end()) {
    SETERRQ1(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
             "problem with name < %s > not defined (top tip check spelling)",
             out_name.c_str());
  }
  // Make data structure for composed-problem data
  out_problem_it->composedProblemsData =
      boost::make_shared<ComposedProblemsData>();
  boost::shared_ptr<ComposedProblemsData> cmp_prb_data =
      out_problem_it->getComposedProblemsData();

  const std::vector<std::string> *add_prb[] = {&add_row_problems,
                                               &add_col_problems};
  std::vector<const Problem *> *add_prb_ptr[] = {&cmp_prb_data->rowProblemsAdd,
                                                 &cmp_prb_data->colProblemsAdd};
  std::vector<IS> *add_prb_is[] = {&cmp_prb_data->rowIs, &cmp_prb_data->colIs};

  // Get local indices counter
  int *nb_local_dofs[] = {&out_problem_it->nbLocDofsRow,
                          &out_problem_it->nbLocDofsCol};
  // Get global indices counter
  int *nb_dofs[] = {&out_problem_it->nbDofsRow, &out_problem_it->nbDofsCol};

  // Set number of ghost nodes to zero
  {
    out_problem_it->nbDofsRow = 0;
    out_problem_it->nbDofsCol = 0;
    out_problem_it->nbLocDofsRow = 0;
    out_problem_it->nbLocDofsCol = 0;
    out_problem_it->nbGhostDofsRow = 0;
    out_problem_it->nbGhostDofsCol = 0;
  }
  int nb_dofs_reserve[] = {0, 0};

  // Loop over rows and columns in the main problem and sub-problems
  for (int ss = 0; ss != ((square_matrix) ? 1 : 2); ss++) {
    // cerr << "SS " << ss << endl;
    // cerr << add_prb[ss]->size() << endl;
    // cerr << add_prb_ptr[ss]->size() << endl;
    add_prb_ptr[ss]->reserve(add_prb[ss]->size());
    add_prb_is[ss]->reserve(add_prb[ss]->size());
    for (std::vector<std::string>::const_iterator vit = add_prb[ss]->begin();
         vit != add_prb[ss]->end(); vit++) {
      ProblemByName::iterator prb_it = problems_by_name.find(*vit);
      if (prb_it == problems_by_name.end()) {
        SETERRQ1(
            PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "problem with name < %s > not defined (top tip check spelling)",
            vit->c_str());
      }
      add_prb_ptr[ss]->push_back(&*prb_it);
      // set number of dofs on rows and columns
      if (ss == 0) {
        // row
        *nb_dofs[ss] += add_prb_ptr[ss]->back()->getNbDofsRow();
        *nb_local_dofs[ss] += add_prb_ptr[ss]->back()->getNbLocalDofsRow();
        nb_dofs_reserve[ss] += add_prb_ptr[ss]->back()->numeredDofsRows->size();
      } else {
        // column
        *nb_dofs[ss] += add_prb_ptr[ss]->back()->getNbDofsCol();
        *nb_local_dofs[ss] += add_prb_ptr[ss]->back()->getNbLocalDofsCol();
        nb_dofs_reserve[ss] += add_prb_ptr[ss]->back()->numeredDofsCols->size();
      }
    }
  }
  // if squre problem, rows and columns are the same
  if (square_matrix) {
    add_prb_ptr[1]->reserve(add_prb_ptr[0]->size());
    add_prb_is[1]->reserve(add_prb_ptr[0]->size());
    out_problem_it->numeredDofsCols = out_problem_it->numeredDofsRows;
    *nb_dofs[1] = *nb_dofs[0];
    *nb_local_dofs[1] = *nb_local_dofs[0];
  }

  // reserve memory for dofs
  boost::shared_ptr<std::vector<NumeredDofEntity> > dofs_array[2];
  // Reserve memory
  for (int ss = 0; ss != ((square_matrix) ? 1 : 2); ss++) {
    dofs_array[ss] = boost::make_shared<std::vector<NumeredDofEntity> >();
    dofs_array[ss]->reserve(nb_dofs_reserve[ss]);
    if (ss == 0) {
      out_problem_it->getRowDofsSequence()->push_back(dofs_array[ss]);
    }
    if (ss == 1) {
      out_problem_it->getColDofsSequence()->push_back(dofs_array[ss]);
    }
  }

  // Push back DOFs
  for (int ss = 0; ss != ((square_matrix) ? 1 : 2); ss++) {
    NumeredDofEntity_multiIndex::index<PetscGlobalIdx_mi_tag>::type::iterator
        dit,
        hi_dit;
    int shift_glob = 0;
    int shift_loc = 0;
    for (unsigned int pp = 0; pp != add_prb_ptr[ss]->size(); pp++) {
      PetscInt *dofs_out_idx_ptr;
      int nb_local_dofs = (*add_prb_ptr[ss])[pp]->getNbLocalDofsRow();
      ierr = PetscMalloc(nb_local_dofs * sizeof(int), &dofs_out_idx_ptr);
      CHKERRG(ierr);
      if (ss == 0) {
        dit = (*add_prb_ptr[ss])[pp]
                  ->numeredDofsRows->get<PetscGlobalIdx_mi_tag>()
                  .begin();
        hi_dit = (*add_prb_ptr[ss])[pp]
                     ->numeredDofsRows->get<PetscGlobalIdx_mi_tag>()
                     .end();
      } else {
        dit = (*add_prb_ptr[ss])[pp]
                  ->numeredDofsCols->get<PetscGlobalIdx_mi_tag>()
                  .begin();
        hi_dit = (*add_prb_ptr[ss])[pp]
                     ->numeredDofsCols->get<PetscGlobalIdx_mi_tag>()
                     .end();
      }
      int is_nb = 0;
      for (; dit != hi_dit; dit++) {
        // cerr << **dit << endl;
        BitRefLevel prb_bit = out_problem_it->getBitRefLevel();
        BitRefLevel prb_mask = out_problem_it->getMaskBitRefLevel();
        BitRefLevel dof_bit = dit->get()->getBitRefLevel();
        if ((dof_bit & prb_bit).none() || ((dof_bit & prb_mask) != dof_bit))
          continue;
        const int rank = m_field.get_comm_rank();
        const int part = dit->get()->getPart();
        const int glob_idx = shift_glob + dit->get()->getPetscGlobalDofIdx();
        const int loc_idx =
            (part == rank) ? (shift_loc + dit->get()->getPetscLocalDofIdx())
                           : -1;
        // if(m_field.get_comm_rank()==1) {
        //   cerr << dit->get()->getPart() << " " << loc_idx << endl;
        // }
        dofs_array[ss]->push_back(NumeredDofEntity(
            dit->get()->getDofEntityPtr(), glob_idx, glob_idx, loc_idx, part));
        if (part == rank) {
          dofs_out_idx_ptr[is_nb++] = glob_idx;
        }
      }
      if (is_nb > nb_local_dofs) {
        SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
                "Data inconsistency");
      }
      IS is;
      ierr = ISCreateGeneral(m_field.get_comm(), is_nb, dofs_out_idx_ptr,
                             PETSC_OWN_POINTER, &is);
      CHKERRG(ierr);
      // cerr << "Push " << ss << " " << pp << endl;
      (*add_prb_is[ss]).push_back(is);
      if (ss == 0) {
        shift_glob += (*add_prb_ptr[ss])[pp]->getNbDofsRow();
        shift_loc += (*add_prb_ptr[ss])[pp]->getNbLocalDofsRow();
      } else {
        shift_glob += (*add_prb_ptr[ss])[pp]->getNbDofsCol();
        shift_loc += (*add_prb_ptr[ss])[pp]->getNbLocalDofsCol();
      }
      if (square_matrix) {
        (*add_prb_ptr[1]).push_back((*add_prb_ptr[0])[pp]);
        // cerr << "Push square " << ss << " " << pp << endl;
        (*add_prb_is[1]).push_back(is);
        ierr = PetscObjectReference((PetscObject)is);
        CHKERRG(ierr);
      }
    }
  }

  if ((*add_prb_is[1]).size() != (*add_prb_is[0]).size()) {
    SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY, "Data inconsistency");
  }

  // Insert DOFs to problem multi-index
  std::vector<boost::shared_ptr<NumeredDofEntity> > dofs_shared_array;
  for (int ss = 0; ss != ((square_matrix) ? 1 : 2); ss++) {
    dofs_shared_array.clear();
    dofs_shared_array.reserve(dofs_array[ss]->size());
    for (std::vector<NumeredDofEntity>::iterator dit = dofs_array[ss]->begin();
         dit != dofs_array[ss]->end(); dit++) {
      dofs_shared_array.push_back(
          boost::shared_ptr<NumeredDofEntity>(dofs_array[ss], &*dit));
    }
    if (ss == 0) {
      out_problem_it->numeredDofsRows->insert(dofs_shared_array.begin(),
                                              dofs_shared_array.end());
    } else {
      out_problem_it->numeredDofsCols->insert(dofs_shared_array.begin(),
                                              dofs_shared_array.end());
    }
  }

  // PetscSynchronizedPrintf(m_field.get_comm(),"nb local dofs
  // %d\n",*nb_local_dofs[0]);
  // PetscSynchronizedFlush(m_field.get_comm(),PETSC_STDOUT);

  // Compress DOFs
  *nb_dofs[0] = 0;
  *nb_dofs[1] = 0;
  *nb_local_dofs[0] = 0;
  *nb_local_dofs[1] = 0;
  for (int ss = 0; ss != ((square_matrix) ? 1 : 2); ss++) {

    // if(ss == 0 && renumerate_row) continue;
    // if(ss == 1 && renumerate_col) continue;
    boost::shared_ptr<NumeredDofEntity_multiIndex> dofs_ptr;
    if (ss == 0) {
      dofs_ptr = out_problem_it->numeredDofsRows;
    } else {
      dofs_ptr = out_problem_it->numeredDofsCols;
    }
    NumeredDofEntityByUId::iterator dit, hi_dit;
    dit = dofs_ptr->get<Unique_mi_tag>().begin();
    hi_dit = dofs_ptr->get<Unique_mi_tag>().end();
    std::vector<int> idx;
    idx.reserve(std::distance(dit, hi_dit));
    // set dofs in order entity and dof number on entity
    for (; dit != hi_dit; dit++) {
      if (dit->get()->getPart() == (unsigned int)m_field.get_comm_rank()) {
        bool success = dofs_ptr->get<Unique_mi_tag>().modify(
            dit, NumeredDofEntity_local_idx_change((*nb_local_dofs[ss])++));
        if (!success) {
          SETERRQ(m_field.get_comm(), MOFEM_OPERATION_UNSUCCESSFUL,
                  "modification unsuccessful");
        }
        idx.push_back(dit->get()->getPetscGlobalDofIdx());
      } else {
        if (dit->get()->getPetscLocalDofIdx() != -1) {
          SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
                  "local index should be negative");
        }
      }
    }
    if (square_matrix) {
      *nb_local_dofs[1] = *nb_local_dofs[0];
    }

    // set new dofs mapping
    IS is;
    ierr = ISCreateGeneral(m_field.get_comm(), idx.size(), &*idx.begin(),
                           PETSC_USE_POINTER, &is);
    CHKERRG(ierr);
    ierr = ISGetSize(is, nb_dofs[ss]);
    CHKERRG(ierr);
    if (square_matrix) {
      *nb_dofs[1] = *nb_dofs[0];
    }
    // {
    //   PetscSynchronizedPrintf(m_field.get_comm(),"nb dofs %d %d
    //   %d\n",*nb_local_dofs[0],idx.size(),*nb_dofs[0]);
    //   PetscSynchronizedFlush(m_field.get_comm(),PETSC_STDOUT);
    // }
    AO ao;
    ierr = AOCreateMappingIS(is, PETSC_NULL, &ao);
    CHKERRG(ierr);
    for (unsigned int pp = 0; pp != (*add_prb_is[ss]).size(); pp++) {
      ierr = AOApplicationToPetscIS(ao, (*add_prb_is[ss])[pp]);
      CHKERRG(ierr);
    }

    // Set DOFs numeration
    {
      std::vector<int> idx_new;
      idx_new.reserve(dofs_ptr->size());
      for (NumeredDofEntityByUId::iterator dit =
               dofs_ptr->get<Unique_mi_tag>().begin();
           dit != dofs_ptr->get<Unique_mi_tag>().end(); dit++) {
        idx_new.push_back(dit->get()->getPetscGlobalDofIdx());
      }
      // set new global dofs numeration
      IS is_new;
      ierr = ISCreateGeneral(m_field.get_comm(), idx_new.size(),
                             &*idx_new.begin(), PETSC_USE_POINTER, &is_new);
      CHKERRG(ierr);
      ierr = AOApplicationToPetscIS(ao, is_new);
      CHKERRG(ierr);
      // set global indices to multi-index
      std::vector<int>::iterator vit = idx_new.begin();
      for (NumeredDofEntityByUId::iterator dit =
               dofs_ptr->get<Unique_mi_tag>().begin();
           dit != dofs_ptr->get<Unique_mi_tag>().end(); dit++) {
        bool success = dofs_ptr->modify(
            dit, NumeredDofEntity_part_change(dit->get()->getPart(), *(vit++)));
        if (!success) {
          SETERRQ(m_field.get_comm(), MOFEM_OPERATION_UNSUCCESSFUL,
                  "modification unsuccessful");
        }
      }
      ierr = ISDestroy(&is_new);
      CHKERRG(ierr);
    }
    ierr = ISDestroy(&is);
    CHKERRG(ierr);
    ierr = AODestroy(&ao);
    CHKERRG(ierr);
  }

  ierr = printPartitionedProblem(&*out_problem_it, verb);
  CHKERRG(ierr);
  ierr = debugPartitionedProblem(&*out_problem_it, verb);
  CHKERRG(ierr);

  // Inidcate that porble has been build
  cOre.getBuildMoFEM() |= Core::BUILD_PROBLEM;
  cOre.getBuildMoFEM() |= Core::PARTITION_PROBLEM;

  MoFEMFunctionReturnHot(0);
}

buildSubProblem()

MoFEMErrorCode MoFEM::ProblemsManager::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,
		int	verb = VERBOSE
	)

build sub problem

Parameters

out_name	problem
fields_row	vector of fields composing problem
fields_col	vector of fields composing problem
main_problem	main problem

Returns

error code

Definition at line 1243 of file ProblemsManager.cpp.

                                        {
  MoFEM::Interface &m_field = cOre;
  const Problem_multiIndex *problems_ptr;
  MoFEMFunctionBegin;

  CHKERR m_field.clear_problem(out_name);
  CHKERR m_field.get_problems(&problems_ptr);

  // get reference to all problems
  typedef Problem_multiIndex::index<Problem_mi_tag>::type ProblemByName;
  ProblemByName &problems_by_name =
      const_cast<ProblemByName &>(problems_ptr->get<Problem_mi_tag>());

  // get iterators to out problem, i.e. build problem
  ProblemByName::iterator out_problem_it = problems_by_name.find(out_name);
  if (out_problem_it == problems_by_name.end()) {
    SETERRQ1(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
             "subproblem with name < %s > not defined (top tip check spelling)",
             out_name.c_str());
  }
  // get iterator to main problem, i.e. out problem is subproblem of main
  // problem
  ProblemByName::iterator main_problem_it = problems_by_name.find(main_problem);
  if (main_problem_it == problems_by_name.end()) {
    SETERRQ1(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
             "problem of subproblem with name < %s > not defined (top tip "
             "check spelling)",
             main_problem.c_str());
  }

  // get dofs for row & columns for out problem,
  boost::shared_ptr<NumeredDofEntity_multiIndex> out_problem_dofs[] = {
      out_problem_it->numeredDofsRows, out_problem_it->numeredDofsCols};
  // get dofs for row & columns for main problem
  boost::shared_ptr<NumeredDofEntity_multiIndex> main_problem_dofs[] = {
      main_problem_it->numeredDofsRows, main_problem_it->numeredDofsCols};
  // get local indices counter
  int *nb_local_dofs[] = {&out_problem_it->nbLocDofsRow,
                          &out_problem_it->nbLocDofsCol};
  // get global indices counter
  int *nb_dofs[] = {&out_problem_it->nbDofsRow, &out_problem_it->nbDofsCol};

  // set number of ghost nodes to zero
  {
    out_problem_it->nbGhostDofsRow = 0;
    out_problem_it->nbGhostDofsCol = 0;
  }

  // put rows & columns field names in array
  std::vector<std::string> fields[] = {fields_row, fields_col};

  // make data structure fos sub-problem data
  out_problem_it->subProblemData =
      boost::make_shared<Problem::SubProblemData>();

  // use to keep shared_ptr
  std::vector<boost::shared_ptr<NumeredDofEntity> > dofs_shared_array;

  // Loop over rows and columns
  for (int ss = 0; ss != (square_matrix ? 1 : 2); ++ss) {

    // reset dofs and columns counters
    (*nb_local_dofs[ss]) = 0;
    (*nb_dofs[ss]) = 0;
    // clear arrays
    out_problem_dofs[ss]->clear();

    // If DOFs are cleared clear finite elements too.
    out_problem_it->numeredFiniteElements.clear();

    // get dofs by field name and insert them in out problem multi-indices
    for (auto field : fields[ss]) {
      auto dit =
          main_problem_dofs[ss]->get<FieldName_mi_tag>().lower_bound(field);
      auto hi_dit =
          main_problem_dofs[ss]->get<FieldName_mi_tag>().upper_bound(field);

      // Following reserve memory in sequences, only two allocations are here,
      // once for array of objects, next for array of shared pointers

      // reserve memory for field  dofs
      boost::shared_ptr<std::vector<NumeredDofEntity> > dofs_array =
          boost::shared_ptr<std::vector<NumeredDofEntity> >(
              new std::vector<NumeredDofEntity>());

      if (ss == 0) {
        out_problem_it->getRowDofsSequence()->push_back(dofs_array);
      } else {
        out_problem_it->getColDofsSequence()->push_back(dofs_array);
      }
      dofs_array->reserve(std::distance(dit, hi_dit));

      // create elements objects
      for (; dit != hi_dit; dit++) {
        dofs_array->push_back(NumeredDofEntity(
            dit->get()->getDofEntityPtr(), dit->get()->getPetscGlobalDofIdx(),
            dit->get()->getPetscGlobalDofIdx(),
            dit->get()->getPetscLocalDofIdx(), dit->get()->getPart()));
      }

      // reserve memory for shared pointers now
      dofs_shared_array.clear();
      dofs_shared_array.reserve(dofs_array->size());
      for (auto vit = dofs_array->begin(); vit != dofs_array->end(); vit++) {
        dofs_shared_array.push_back(
            boost::shared_ptr<NumeredDofEntity>(dofs_array, &*vit));
      }
      // fill multi-index
      out_problem_dofs[ss]->insert(dofs_shared_array.begin(),
                                   dofs_shared_array.end());
    }
    // Set local indexes
    {
      NumeredDofEntity_multiIndex::index<Idx_mi_tag>::type::iterator dit,
          hi_dit;
      dit = out_problem_dofs[ss]->get<Idx_mi_tag>().begin();
      hi_dit = out_problem_dofs[ss]->get<Idx_mi_tag>().end();
      for (; dit != hi_dit; dit++) {
        int idx = -1; // if dof is not part of partition, set local index to -1
        if (dit->get()->getPart() == (unsigned int)m_field.get_comm_rank()) {
          idx = (*nb_local_dofs[ss])++;
        }
        bool success = out_problem_dofs[ss]->modify(
            out_problem_dofs[ss]->project<0>(dit),
            NumeredDofEntity_local_idx_change(idx));
        if (!success) {
          SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
                  "operation unsuccessful");
        }
      };
    }
    // Set global indexes, compress global indices
    {
      auto dit =
          out_problem_dofs[ss]->get<PetscLocalIdx_mi_tag>().lower_bound(0);
      auto hi_dit =
          out_problem_dofs[ss]->get<PetscLocalIdx_mi_tag>().upper_bound(
              out_problem_dofs[ss]->size());
      const int nb = distance(dit, hi_dit);
      // get main problem global indices
      std::vector<int> main_indices(nb);
      for (auto it = main_indices.begin(); dit != hi_dit; dit++, it++) {
        *it = dit->get()->getPetscGlobalDofIdx();
      }
      // crate is with global dofs
      IS is;
      CHKERR ISCreateGeneral(m_field.get_comm(), nb, &*main_indices.begin(),
                             PETSC_USE_POINTER, &is);
      // create map form main problem global indices to out problem global
      // indices
      AO ao;
      CHKERR AOCreateMappingIS(is, PETSC_NULL, &ao);
      if (ss == 0) {
        CHKERR ISDuplicate(is, &(out_problem_it->getSubData()->rowIs));
        // CHKERR ISSort(out_problem_it->getSubData()->rowIs);
        out_problem_it->getSubData()->rowMap = ao;
        CHKERR PetscObjectReference((PetscObject)ao);
      } else {
        CHKERR ISDuplicate(is, &(out_problem_it->getSubData()->colIs));
        // CHKERR ISSort(out_problem_it->getSubData()->colIs); 
        out_problem_it->getSubData()->colMap = ao;
        CHKERR PetscObjectReference((PetscObject)ao);
      }
      CHKERR AOApplicationToPetscIS(ao, is);
      // set global number of DOFs
      CHKERR ISGetSize(is, nb_dofs[ss]);
      CHKERR ISDestroy(&is);
      // set out problem global indices after applying map
      dit = out_problem_dofs[ss]->get<PetscLocalIdx_mi_tag>().lower_bound(0);
      for (std::vector<int>::iterator it = main_indices.begin(); dit != hi_dit;
           dit++, it++) {
        bool success = out_problem_dofs[ss]->modify(
            out_problem_dofs[ss]->project<0>(dit),
            NumeredDofEntity_mofem_part_and_all_index_change(
                dit->get()->getPart(), *it, *it,
                dit->get()->getPetscLocalDofIdx()));
        if (!success) {
          SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
                  "operation unsuccessful");
        }
      }
      // set global indices to nodes not on this part
      {
        NumeredDofEntityByLocalIdx::iterator dit =
            out_problem_dofs[ss]->get<PetscLocalIdx_mi_tag>().lower_bound(-1);
        NumeredDofEntityByLocalIdx::iterator hi_dit =
            out_problem_dofs[ss]->get<PetscLocalIdx_mi_tag>().upper_bound(-1);
        const int nb = distance(dit, hi_dit);
        std::vector<int> main_indices_non_local(nb);
        for (auto it = main_indices_non_local.begin(); dit != hi_dit;
             dit++, it++) {
          *it = dit->get()->getPetscGlobalDofIdx();
        }
        IS is;
        CHKERR ISCreateGeneral(m_field.get_comm(), nb,
                               &*main_indices_non_local.begin(),
                               PETSC_USE_POINTER, &is);
        CHKERR AOApplicationToPetscIS(ao, is);
        CHKERR ISDestroy(&is);
        dit = out_problem_dofs[ss]->get<PetscLocalIdx_mi_tag>().lower_bound(-1);
        for (auto it = main_indices_non_local.begin(); dit != hi_dit;
             dit++, it++) {
          bool success = out_problem_dofs[ss]->modify(
              out_problem_dofs[ss]->project<0>(dit),
              NumeredDofEntity_mofem_part_and_all_index_change(
                  dit->get()->getPart(), dit->get()->getDofIdx(), *it,
                  dit->get()->getPetscLocalDofIdx()));
          if (!success) {
            SETERRQ(PETSC_COMM_WORLD, MOFEM_ATOM_TEST_INVALID,
                    "operation unsuccessful");
          }
        }
      }
      CHKERR AODestroy(&ao);
    }
  }

  if (square_matrix) {
    out_problem_it->numeredDofsCols = out_problem_it->numeredDofsRows;
    out_problem_it->nbLocDofsCol = out_problem_it->nbLocDofsRow;
    out_problem_it->nbDofsCol = out_problem_it->nbDofsRow;
    out_problem_it->getSubData()->colIs = out_problem_it->getSubData()->rowIs;
    out_problem_it->getSubData()->colMap = out_problem_it->getSubData()->rowMap;
    CHKERR PetscObjectReference(
        (PetscObject)out_problem_it->getSubData()->rowIs);
    CHKERR PetscObjectReference(
        (PetscObject)out_problem_it->getSubData()->rowMap);
  }

  CHKERR printPartitionedProblem(&*out_problem_it, verb);
  CHKERR debugPartitionedProblem(&*out_problem_it, verb);

  MoFEMFunctionReturn(0);
}

debugPartitionedProblem()

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

Definition at line 2441 of file ProblemsManager.cpp.

                                                                             {
  MoFEM::Interface &m_field = cOre;
  MoFEMFunctionBeginHot;
  if (debug > 0) {

    typedef NumeredDofEntity_multiIndex::index<Idx_mi_tag>::type
        NumeredDofEntitysByIdx;
    NumeredDofEntitysByIdx::iterator dit, hi_dit;
    const NumeredDofEntitysByIdx *numered_dofs_ptr[] = {
        &(problem_ptr->numeredDofsRows->get<Idx_mi_tag>()),
        &(problem_ptr->numeredDofsCols->get<Idx_mi_tag>())};

    int *nbdof_ptr[] = {&problem_ptr->nbDofsRow, &problem_ptr->nbDofsCol};
    int *local_nbdof_ptr[] = {&problem_ptr->nbLocDofsRow,
                              &problem_ptr->nbLocDofsCol};

    for (int ss = 0; ss < 2; ss++) {

      dit = numered_dofs_ptr[ss]->begin();
      hi_dit = numered_dofs_ptr[ss]->end();
      for (; dit != hi_dit; dit++) {
        if ((*dit)->getPart() == (unsigned int)m_field.get_comm_rank()) {
          if ((*dit)->getPetscLocalDofIdx() < 0) {
            std::ostringstream zz;
            zz << "rank " << m_field.get_comm_rank() << " " << **dit;
            SETERRQ2(PETSC_COMM_SELF, MOFEM_IMPOSIBLE_CASE,
                     "local dof index for %d (0-row, 1-col) not set, i.e. has "
                     "negative value\n %s",
                     ss, zz.str().c_str());
          }
          if ((*dit)->getPetscLocalDofIdx() >= *local_nbdof_ptr[ss]) {
            std::ostringstream zz;
            zz << "rank " << m_field.get_comm_rank() << " " << **dit;
            SETERRQ2(PETSC_COMM_SELF, MOFEM_IMPOSIBLE_CASE,
                     "local dofs for %d (0-row, 1-col) out of range\n %s", ss,
                     zz.str().c_str());
          }
        } else {
          if ((*dit)->getPetscGlobalDofIdx() < 0) {
            std::ostringstream zz;
            zz << "rank " << m_field.get_comm_rank() << " "
               << dit->get()->getBitRefLevel() << " " << **dit;
            SETERRQ2(PETSC_COMM_SELF, MOFEM_IMPOSIBLE_CASE,
                     "global dof index for %d (0-row, 1-col) row not set, i.e. "
                     "has negative value\n %s",
                     ss, zz.str().c_str());
          }
          if ((*dit)->getPetscGlobalDofIdx() >= *nbdof_ptr[ss]) {
            std::ostringstream zz;
            zz << "rank " << m_field.get_comm_rank() << " nb_dofs "
               << *nbdof_ptr[ss] << " " << **dit;
            SETERRQ2(PETSC_COMM_SELF, MOFEM_IMPOSIBLE_CASE,
                     "global dofs for %d (0-row, 1-col) out of range\n %s", ss,
                     zz.str().c_str());
          }
        }
      }
    }
  }
  MoFEMFunctionReturnHot(0);
}

getFEMeshset()

MoFEMErrorCode MoFEM::ProblemsManager::getFEMeshset	(	const std::string &	prb_name,
		const std::string &	fe_name,
		EntityHandle *	meshset
	)		const

meshset problem finite elements

Definition at line 2979 of file ProblemsManager.cpp.

                                                                          {
  MoFEM::Interface &m_field = cOre;
  const Problem *problem_ptr;
  MoFEMFunctionBeginHot;
  rval = m_field.get_moab().create_meshset(MESHSET_SET, *meshset);
  CHKERRQ_MOAB(rval);
  ierr = m_field.get_problem(prb_name, &problem_ptr);
  CHKERRG(ierr);
  NumeredEntFiniteElement_multiIndex::index<
      FiniteElement_name_mi_tag>::type::iterator fit,
      hi_fe_it;
  fit = problem_ptr->numeredFiniteElements.get<FiniteElement_name_mi_tag>()
            .lower_bound(fe_name);
  hi_fe_it = problem_ptr->numeredFiniteElements.get<FiniteElement_name_mi_tag>()
                 .upper_bound(fe_name);
  std::vector<EntityHandle> fe_vec;
  fe_vec.reserve(std::distance(fit, hi_fe_it));
  for (; fit != hi_fe_it; fit++) {
    fe_vec.push_back(fit->get()->getEnt());
  }
  rval = m_field.get_moab().add_entities(*meshset, &*fe_vec.begin(),
                                         fe_vec.size());
  MoFEMFunctionReturnHot(0);
}

getOptions()

MoFEMErrorCode MoFEM::ProblemsManager::getOptions

(

)

Definition at line 82 of file ProblemsManager.cpp.

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

printPartitionedProblem()

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

Definition at line 2397 of file ProblemsManager.cpp.

                                                                             {
  MoFEM::Interface &m_field = cOre;
  MoFEMFunctionBeginHot;
  if (verb > 0) {
    std::ostringstream ss;
    ss << "partition_problem: rank = " << m_field.get_comm_rank()
       << " FEs row ghost dofs " << *problem_ptr << " Nb. local dof "
       << problem_ptr->getNbLocalDofsRow() << " nb global row dofs "
       << problem_ptr->getNbDofsRow() << std::endl;
    ss << "partition_problem: rank = " << m_field.get_comm_rank()
       << " FEs col ghost dofs " << *problem_ptr << " Nb. local dof "
       << problem_ptr->getNbLocalDofsCol() << " nb global col dofs "
       << problem_ptr->getNbDofsCol() << std::endl;
    PetscSynchronizedPrintf(m_field.get_comm(), ss.str().c_str());
    PetscSynchronizedFlush(m_field.get_comm(), PETSC_STDOUT);
  }
  if (verb > 1) {
    // FIXME mess if printed on more than one processors
    // std::ostringstream ss;
    std::cout << "rank = " << m_field.get_comm_rank() << " FEs row dofs "
              << *problem_ptr << " Nb. row dof " << problem_ptr->getNbDofsRow()
              << " Nb. local dof " << problem_ptr->getNbLocalDofsRow()
              << std::endl;
    NumeredDofEntity_multiIndex::iterator miit_dd_row =
        problem_ptr->numeredDofsRows->begin();
    for (; miit_dd_row != problem_ptr->numeredDofsRows->end(); miit_dd_row++) {
      std::cout << **miit_dd_row << std::endl;
    }
    std::cout << "rank = " << m_field.get_comm_rank() << " FEs col dofs "
              << *problem_ptr << " Nb. col dof " << problem_ptr->getNbDofsCol()
              << " Nb. local dof " << problem_ptr->getNbLocalDofsCol()
              << std::endl;
    NumeredDofEntity_multiIndex::iterator miit_dd_col =
        problem_ptr->numeredDofsCols->begin();
    for (; miit_dd_col != problem_ptr->numeredDofsCols->end(); miit_dd_col++) {
      std::cout << **miit_dd_col << std::endl;
    }
    // PetscSynchronizedPrintf(comm,ss.str().c_str());
    // PetscSynchronizedFlush(comm,PETSC_STDOUT);
  }
  MoFEMFunctionReturnHot(0);
}

query_interface()

MoFEMErrorCode MoFEM::ProblemsManager::query_interface ( const MOFEMuuid &  uuid, UnknownInterface **  iface  ) const

virtual

Implements MoFEM::UnknownInterface.

Definition at line 62 of file ProblemsManager.cpp.

                                                                 {
  MoFEMFunctionBeginHot;
  *iface = NULL;
  if (uuid == IDD_MOFEMProblemsManager) {
    *iface = const_cast<ProblemsManager *>(this);
    MoFEMFunctionReturnHot(0);
  }
  SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "unknown interface");
  MoFEMFunctionReturnHot(0);
}

Member Data Documentation

buildProblemFromFields

PetscBool MoFEM::ProblemsManager::buildProblemFromFields

If set to true, problem is build from

Definition at line 47 of file ProblemsManager.hpp.

cOre

MoFEM::Core& MoFEM::ProblemsManager::cOre

Definition at line 39 of file ProblemsManager.hpp.

MOFEM_EVENT_ProblemsManager

PetscLogEvent MoFEM::ProblemsManager::MOFEM_EVENT_ProblemsManager

private

Definition at line 289 of file ProblemsManager.hpp.

synchroniseProblemEntities

PetscBool MoFEM::ProblemsManager::synchroniseProblemEntities

DOFs in fields, not from DOFs on elements.

Definition at line 50 of file ProblemsManager.hpp.

---

The documentation for this struct was generated from the following files:

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