MoFEM::MatrixManager Struct Reference

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

#include "src/interfaces/MatrixManager.hpp"

Inheritance diagram for MoFEM::MatrixManager:

Collaboration diagram for MoFEM::MatrixManager:

Public Member Functions
MoFEMErrorCode	query_interface (boost::typeindex::type_index type_index, UnknownInterface **iface) const
	MatrixManager (const MoFEM::Core &core)
virtual	~MatrixManager ()=default
	Destructor.
template<class Tag >
MoFEMErrorCode	createMPIAIJWithArrays (const std::string name, Mat *Aij, int verb=QUIET)
	Creates a MPI AIJ matrix using arrays that contain in standard CSR format the local rows.
template<class Tag >
MoFEMErrorCode	createMPIAIJWithArrays (const std::string name, SmartPetscObj< Mat > &aij_ptr, int verb=QUIET)
	Creates a MPI AIJ matrix using arrays that contain in standard CSR format the local rows.
template<class Tag >
MoFEMErrorCode	createMPIAIJCUSPARSEWithArrays (const std::string name, Mat *Aij, int verb=QUIET)
template<class Tag >
MoFEMErrorCode	createMPIAIJCUSPARSEWithArrays (const std::string name, SmartPetscObj< Mat > &aij_ptr, int verb=QUIET)
template<class Tag >
MoFEMErrorCode	createSeqAIJCUSPARSEWithArrays (const std::string name, Mat *Aij, int verb=QUIET)
template<class Tag >
MoFEMErrorCode	createSeqAIJCUSPARSEWithArrays (const std::string name, SmartPetscObj< Mat > &aij_ptr, int verb=QUIET)
template<class Tag >
MoFEMErrorCode	createMPIAIJ (const std::string name, Mat *Aij, int verb=QUIET)
	Creates a MPI AIJ matrix using arrays that contain in standard CSR format the local rows.
template<class Tag >
MoFEMErrorCode	createMPIAIJ (const std::string name, SmartPetscObj< Mat > &aij_ptr, int verb=QUIET)
	Creates a MPI AIJ matrix using arrays that contain in standard CSR format the local rows.
template<class Tag >
MoFEMErrorCode	createMPIAdjWithArrays (const std::string name, Mat *Adj, int verb=QUIET)
	Creates a sparse matrix representing an adjacency list.
template<class Tag >
MoFEMErrorCode	createSeqAIJWithArrays (const std::string name, Mat *Aij, int verb=QUIET)
	Create sequencial matrix.
template<class Tag >
MoFEMErrorCode	createSeqAIJWithArrays (const std::string name, SmartPetscObj< Mat > &aij_ptr, int verb=QUIET)
	Create sequencial matrix.
MoFEMErrorCode	checkMatrixFillIn (const std::string problem_name, int row_print, int col_print, Mat A, int verb=QUIET)
	check if matrix fill in correspond to finite element indices
template<class Tag >
MoFEMErrorCode	checkMPIAIJWithArraysMatrixFillIn (const std::string problem_name, int row_print, int col_print, int verb=QUIET)
	check if matrix fill in correspond to finite element indices
template<class Tag >
MoFEMErrorCode	checkMPIAIJMatrixFillIn (const std::string problem_name, int row_print, int col_print, int verb=QUIET)
	check if matrix fill in correspond to finite element indices
template<class Tag >
MoFEMErrorCode	createHybridL2MPIAIJ (const std::string problem_name, SmartPetscObj< Mat > &aij_ptr, int verb=QUIET)
	Create a Hybrid MPIAij object.
template<>
MoFEMErrorCode	createMPIAIJWithArrays (const std::string name, Mat *Aij, int verb)
template<>
MoFEMErrorCode	createMPIAIJCUSPARSEWithArrays (const std::string name, Mat *Aij, int verb)
template<>
MoFEMErrorCode	createSeqAIJCUSPARSEWithArrays (const std::string name, Mat *Aij, int verb)
template<>
MoFEMErrorCode	createMPIAIJ (const std::string name, Mat *Aij, int verb)
template<>
MoFEMErrorCode	createMPIAdjWithArrays (const std::string name, Mat *Adj, int verb)
template<>
MoFEMErrorCode	createSeqAIJWithArrays (const std::string name, Mat *Aij, int verb)
template<>
MoFEMErrorCode	checkMPIAIJWithArraysMatrixFillIn (const std::string problem_name, int row_print, int col_print, int verb)
template<>
MoFEMErrorCode	checkMPIAIJMatrixFillIn (const std::string problem_name, int row_print, int col_print, int verb)
template<>
MoFEMErrorCode	createHybridL2MPIAIJ (const std::string problem_name, SmartPetscObj< Mat > &aij_ptr, int verb)
template<>
MoFEMErrorCode	createMPIAIJWithArrays (const std::string name, Mat *Aij, int verb)
template<>
MoFEMErrorCode	createMPIAIJCUSPARSEWithArrays (const std::string name, Mat *Aij, int verb)
template<>
MoFEMErrorCode	createMPIAIJ (const std::string name, Mat *Aij, int verb)
template<>
MoFEMErrorCode	createMPIAdjWithArrays (const std::string name, Mat *Adj, int verb)
template<>
MoFEMErrorCode	createSeqAIJWithArrays (const std::string name, Mat *Aij, int verb)
template<>
MoFEMErrorCode	createSeqAIJCUSPARSEWithArrays (const std::string name, Mat *Aij, int verb)
template<>
MoFEMErrorCode	checkMPIAIJWithArraysMatrixFillIn (const std::string problem_name, int row_print, int col_print, int verb)
template<>
MoFEMErrorCode	checkMPIAIJMatrixFillIn (const std::string problem_name, int row_print, int col_print, int verb)
template<>
MoFEMErrorCode	createHybridL2MPIAIJ (const std::string problem_name, SmartPetscObj< Mat > &aij_ptr, int verb)
Public Member Functions inherited from MoFEM::UnknownInterface
template<class IFACE >
MoFEMErrorCode	registerInterface (bool error_if_registration_failed=true)
	Register interface.
template<class IFACE >
MoFEMErrorCode	getInterface (IFACE *&iface) const
	Get interface reference to pointer of interface.
template<class IFACE >
MoFEMErrorCode	getInterface (IFACE **const iface) const
	Get interface pointer to pointer of interface.
template<class IFACE , typename boost::enable_if< boost::is_pointer< IFACE >, int >::type = 0>
IFACE	getInterface () const
	Get interface pointer to pointer of interface.
template<class IFACE , typename boost::enable_if< boost::is_reference< IFACE >, int >::type = 0>
IFACE	getInterface () const
	Get reference to interface.
template<class IFACE >
IFACE *	getInterface () const
	Function returning pointer to interface.
virtual	~UnknownInterface ()=default

Public Attributes
MoFEM::Core &	cOre

Private Attributes
PetscLogEvent	MOFEM_EVENT_createMPIAIJ
PetscLogEvent	MOFEM_EVENT_createMPIAIJWithArrays
PetscLogEvent	MOFEM_EVENT_createMPIAdjWithArrays
PetscLogEvent	MOFEM_EVENT_createSeqAIJWithArrays
PetscLogEvent	MOFEM_EVENT_createMPIAIJCUSPARSEWithArrays
PetscLogEvent	MOFEM_EVENT_createSeqAIJCUSPARSEWithArrays
PetscLogEvent	MOFEM_EVENT_checkMatrixFillIn

Additional Inherited Members
Static Public Member Functions inherited from MoFEM::UnknownInterface
static MoFEMErrorCode	getLibVersion (Version &version)
	Get library version.
static MoFEMErrorCode	getFileVersion (moab::Interface &moab, Version &version)
	Get database major version.
static MoFEMErrorCode	setFileVersion (moab::Interface &moab, Version version=Version(MoFEM_VERSION_MAJOR, MoFEM_VERSION_MINOR, MoFEM_VERSION_BUILD))
	Get database major version.
static MoFEMErrorCode	getInterfaceVersion (Version &version)
	Get database major version.

Detailed Description

Matrix manager is used to build and partition problems.

Examples

build_large_problem.cpp, build_problems.cpp, dm_build_partitioned_mesh.cpp, dm_create_subdm.cpp, dm_partitioned_no_field.cpp, nonlinear_dynamics.cpp, prism_polynomial_approximation.cpp, quad_polynomial_approximation.cpp, remove_entities_from_problem.cpp, and remove_entities_from_problem_not_partitioned.cpp.

Definition at line 21 of file MatrixManager.hpp.

Constructor & Destructor Documentation

MatrixManager()

MoFEM::MatrixManager::MatrixManager

(

const MoFEM::Core &

core

)

Definition at line 606 of file MatrixManager.cpp.

    : cOre(const_cast<MoFEM::Core &>(core)) {
  PetscLogEventRegister("MatMngCrtMPIAIJ", 0, &MOFEM_EVENT_createMPIAIJ);
  PetscLogEventRegister("MatMngCrtMPIAIJWthArr", 0,
                        &MOFEM_EVENT_createMPIAIJWithArrays);
  PetscLogEventRegister("MatMngCrtMPIAdjWithArr", 0,
                        &MOFEM_EVENT_createMPIAdjWithArrays);
  PetscLogEventRegister("MatMngCrtMPIAIJCUSPARSEWthArr", 0,
                        &MOFEM_EVENT_createMPIAIJCUSPARSEWithArrays);
  PetscLogEventRegister("MatMngCrtSeqAIJCUSPARSEWthArrs", 0,
                        &MOFEM_EVENT_createSeqAIJCUSPARSEWithArrays);
  PetscLogEventRegister("MatMngCrtSeqAIJWthArrs", 0,
                        &MOFEM_EVENT_createSeqAIJWithArrays);
  PetscLogEventRegister("MatMngCrtCheckMPIAIJWthArrFillIn", 0,
                        &MOFEM_EVENT_checkMatrixFillIn);
}

~MatrixManager()

virtual MoFEM::MatrixManager::~MatrixManager ( )

virtualdefault

Destructor.

Member Function Documentation

checkMatrixFillIn()

MoFEMErrorCode MoFEM::MatrixManager::checkMatrixFillIn	(	const std::string	problem_name,
		int	row_print,
		int	col_print,
		Mat	A,
		int	verb = QUIET )

check if matrix fill in correspond to finite element indices

This is used to check consistency of code. If problem is notices with additional non-zero elements in matrix, this function can help detect problem. Should be used as a part of atom tests

Parameters

problem_name
row	print info at particular row
col	print info at particular col

Returns

MoFEMErrorCode

Definition at line 899 of file MatrixManager.cpp.

                                                                 {
  MoFEM::CoreInterface &m_field = cOre;
  MatrixManagerFunctionBegin;
 
  PetscLogEventBegin(MOFEM_EVENT_checkMatrixFillIn, 0, 0, 0, 0);
 
  struct TestMatrixFillIn : public FEMethod {
    CoreInterface *mFieldPtr;
 
    Mat A;
 
    int rowPrint, colPrint;
 
    TestMatrixFillIn(CoreInterface *m_field_ptr, Mat a, int row_print,
                     int col_print)
        : mFieldPtr(m_field_ptr), A(a), rowPrint(row_print),
          colPrint(col_print){};
 
    MoFEMErrorCode preProcess() {
      MoFEMFunctionBeginHot;
      MoFEMFunctionReturnHot(0);
    }
 
    MoFEMErrorCode operator()() {
      MoFEMFunctionBegin;
 
      if (refinedFiniteElementsPtr->find(
              numeredEntFiniteElementPtr->getEnt()) ==
          refinedFiniteElementsPtr->end()) {
        SETERRQ(mFieldPtr->get_comm(), MOFEM_DATA_INCONSISTENCY,
                "data inconsistency");
      }
 
      auto row_dofs = getRowDofsPtr();
      auto col_dofs = getColDofsPtr();
 
      for (auto cit = col_dofs->begin(); cit != col_dofs->end(); cit++) {
 
        if (refinedEntitiesPtr->find((*cit)->getEnt()) ==
            refinedEntitiesPtr->end()) {
          SETERRQ(mFieldPtr->get_comm(), MOFEM_DATA_INCONSISTENCY,
                  "data inconsistency");
        }
        if (!(*cit)->getActive()) {
          SETERRQ(mFieldPtr->get_comm(), MOFEM_DATA_INCONSISTENCY,
                  "data inconsistency");
        }
 
        FieldEntityEntFiniteElementAdjacencyMap_multiIndex::index<
            Composite_Unique_mi_tag>::type::iterator ait;
        ait = adjacenciesPtr->get<Composite_Unique_mi_tag>().find(
            boost::make_tuple((*cit)->getFieldEntityPtr()->getLocalUniqueId(),
                              numeredEntFiniteElementPtr->getLocalUniqueId()));
        if (ait == adjacenciesPtr->end()) {
          SETERRQ(mFieldPtr->get_comm(), MOFEM_DATA_INCONSISTENCY,
                  "adjacencies data inconsistency");
        } else {
          UId uid = ait->getEntUniqueId();
          if (entitiesPtr->find(uid) == entitiesPtr->end()) {
            SETERRQ(mFieldPtr->get_comm(), MOFEM_DATA_INCONSISTENCY,
                    "data inconsistency");
          }
          if (dofsPtr->find((*cit)->getLocalUniqueId()) == dofsPtr->end()) {
            SETERRQ(mFieldPtr->get_comm(), MOFEM_DATA_INCONSISTENCY,
                    "data inconsistency");
          }
        }
 
        if ((*cit)->getEntType() != MBVERTEX) {
 
          auto range =
              col_dofs->get<Ent_mi_tag>().equal_range((*cit)->getEnt());
          int nb_dofs_on_ent = std::distance(range.first, range.second);
 
          int max_order = (*cit)->getMaxOrder();
          if ((*cit)->getNbOfCoeffs() * (*cit)->getOrderNbDofs(max_order) !=
              nb_dofs_on_ent) {
 
            /* It could be that you have
            removed DOFs from problem, and for example if this was vector field
            with components {Ux,Uy,Uz}, you removed on Uz element.*/
 
            MOFEM_LOG("SELF", Sev::warning)
                << "Warning: Number of Dofs in Col different than number "
                   "of dofs for given entity order "
                << (*cit)->getNbOfCoeffs() * (*cit)->getOrderNbDofs(max_order)
                << " " << nb_dofs_on_ent;
          }
        }
      }
 
      for (auto rit = row_dofs->begin(); rit != row_dofs->end(); rit++) {
 
        if (refinedEntitiesPtr->find((*rit)->getEnt()) ==
            refinedEntitiesPtr->end()) {
          SETERRQ(mFieldPtr->get_comm(), MOFEM_DATA_INCONSISTENCY,
                  "data inconsistency");
        }
        if (!(*rit)->getActive()) {
          SETERRQ(mFieldPtr->get_comm(), MOFEM_DATA_INCONSISTENCY,
                  "data inconsistency");
        }
 
        FieldEntityEntFiniteElementAdjacencyMap_multiIndex::index<
            Composite_Unique_mi_tag>::type::iterator ait;
        ait = adjacenciesPtr->get<Composite_Unique_mi_tag>().find(
            boost::make_tuple((*rit)->getFieldEntityPtr()->getLocalUniqueId(),
                              numeredEntFiniteElementPtr->getLocalUniqueId()));
        if (ait == adjacenciesPtr->end()) {
          MOFEM_LOG_ATTRIBUTES("SYNC", LogManager::BitScope);
          MOFEM_LOG("SELF", Sev::error) << *(*rit);
          MOFEM_LOG("SELF", Sev::error) << *(*rit);
          MOFEM_LOG("SELF", Sev::error) << *numeredEntFiniteElementPtr;
          MOFEM_LOG("SELF", Sev::error) << "dof: " << (*rit)->getBitRefLevel();
          MOFEM_LOG("SELF", Sev::error)
              << "fe: " << numeredEntFiniteElementPtr->getBitRefLevel();
          MOFEM_LOG("SELF", Sev::error)
              << "problem: " << problemPtr->getBitRefLevel();
          MOFEM_LOG("SELF", Sev::error)
              << "problem mask: " << problemPtr->getBitRefLevelMask();
          SETERRQ(mFieldPtr->get_comm(), MOFEM_DATA_INCONSISTENCY,
                  "adjacencies data inconsistency");
        } else {
          UId uid = ait->getEntUniqueId();
          if (entitiesPtr->find(uid) == entitiesPtr->end()) {
            SETERRQ(mFieldPtr->get_comm(), MOFEM_DATA_INCONSISTENCY,
                    "data inconsistency");
          }
          if (dofsPtr->find((*rit)->getLocalUniqueId()) == dofsPtr->end()) {
            SETERRQ(mFieldPtr->get_comm(), MOFEM_DATA_INCONSISTENCY,
                    "data inconsistency");
          }
        }
        int row = (*rit)->getPetscGlobalDofIdx();
 
        auto col_dofs = getColDofsPtr();
        for (auto cit = col_dofs->begin(); cit != col_dofs->end(); cit++) {
 
          int col = (*cit)->getPetscGlobalDofIdx();
 
          if (row == rowPrint && col == colPrint) {
            MOFEM_LOG("SELF", Sev::noisy) << "fe:\n"
                                          << *numeredEntFiniteElementPtr;
            MOFEM_LOG("SELF", Sev::noisy) << "row:\n" << *(*rit);
            MOFEM_LOG("SELF", Sev::noisy) << "col:\n" << *(*cit);
            MOFEM_LOG("SELF", Sev::noisy)
                << "fe:\n"
                << numeredEntFiniteElementPtr->getBitRefLevel();
            MOFEM_LOG("SELF", Sev::noisy) << "row:\n"
                                          << (*rit)->getBitRefLevel();
            MOFEM_LOG("SELF", Sev::noisy) << "col:\n"
                                          << (*cit)->getBitRefLevel();
          }
 
          CHKERR MatSetValue(A, row, col, 1, INSERT_VALUES);
        }
 
        if ((*rit)->getEntType() != MBVERTEX) {
 
          auto range =
              row_dofs->get<Ent_mi_tag>().equal_range((*rit)->getEnt());
          int nb_dofs_on_ent = std::distance(range.first, range.second);
 
          int max_order = (*rit)->getMaxOrder();
          if ((*rit)->getNbOfCoeffs() * (*rit)->getOrderNbDofs(max_order) !=
              nb_dofs_on_ent) {
 
            /* It could be that you have removed DOFs from problem, and for
             * example if this was vector field with components {Ux,Uy,Uz}, you
             * removed on Uz element. */
 
            MOFEM_LOG("SELF", Sev::warning)
                << "Warning: Number of Dofs in Row different than number "
                   "of dofs for given entity order "
                << (*rit)->getNbOfCoeffs() * (*rit)->getOrderNbDofs(max_order)
                << " " << nb_dofs_on_ent;
          }
        }
      }
 
      MoFEMFunctionReturn(0);
    }
 
    MoFEMErrorCode postProcess() {
      MoFEMFunctionBegin;
 
      // cerr << mFieldPtr->get_comm_rank() << endl;
      CHKERR MatAssemblyBegin(A, MAT_FLUSH_ASSEMBLY);
      CHKERR MatAssemblyEnd(A, MAT_FLUSH_ASSEMBLY);
 
      MoFEMFunctionReturn(0);
    }
  };
 
  // create matrix
  CHKERR MatSetOption(A, MAT_NEW_NONZERO_ALLOCATION_ERR, PETSC_TRUE);
 
  if (verb >= VERY_VERBOSE) {
    MatView(A, PETSC_VIEWER_STDOUT_WORLD);
  }
 
  if (verb >= NOISY) {
    MatView(A, PETSC_VIEWER_DRAW_WORLD);
    std::string wait;
    std::cin >> wait;
  }
 
  TestMatrixFillIn method(&m_field, A, row_print, col_print);
 
  // get problem
  auto problems_ptr = m_field.get_problems();
  auto &prb_set = problems_ptr->get<Problem_mi_tag>();
  auto p_miit = prb_set.find(problem_name);
  if (p_miit == prb_set.end())
    SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
             "problem < %s > not found (top tip: check spelling)",
             problem_name.c_str());
  MOFEM_LOG_C("WORLD", Sev::inform, "check problem < %s >",
              problem_name.c_str());
 
  // loop all elements in problem and check if assemble is without error
  auto fe_ptr = m_field.get_finite_elements();
  for (auto &fe : *fe_ptr) {
    MOFEM_LOG_C("WORLD", Sev::verbose, "\tcheck element %s",
                fe->getName().c_str());
    CHKERR m_field.loop_finite_elements(problem_name, fe->getName(), method,
                                        nullptr, MF_EXIST,
                                        CacheTupleSharedPtr(), verb);
  }
 
  CHKERR MatAssemblyBegin(A, MAT_FINAL_ASSEMBLY);
  CHKERR MatAssemblyEnd(A, MAT_FINAL_ASSEMBLY);
 
  PetscLogEventEnd(MOFEM_EVENT_checkMatrixFillIn, 0, 0, 0, 0);
 
  MoFEMFunctionReturn(0);
}

checkMPIAIJMatrixFillIn() [1/3]

template<>

MoFEMErrorCode MoFEM::MatrixManager::checkMPIAIJMatrixFillIn	(	const std::string	problem_name,
		int	row_print,
		int	col_print,
		int	verb )

Definition at line 1153 of file MatrixManager.cpp.

                                                                          {
  MatrixManagerFunctionBegin;
  // create matrix
  SmartPetscObj<Mat> A;
  CHKERR createMPIAIJ<PetscGlobalIdx_mi_tag>(problem_name, A, verb);
  CHKERR MatSetOption(A, MAT_NEW_NONZERO_ALLOCATION_ERR, PETSC_TRUE);
  CHKERR checkMatrixFillIn(problem_name, row_print, col_print, A, verb);
  MoFEMFunctionReturn(0);
}

checkMPIAIJMatrixFillIn() [2/3]

template<>

MoFEMErrorCode MoFEM::MatrixManager::checkMPIAIJMatrixFillIn	(	const std::string	problem_name,
		int	row_print,
		int	col_print,
		int	verb )

checkMPIAIJMatrixFillIn() [3/3]

template<class Tag >

MoFEMErrorCode MoFEM::MatrixManager::checkMPIAIJMatrixFillIn ( const std::string problem_name, int row_print, int col_print, int verb = QUIET )

inline

check if matrix fill in correspond to finite element indices

This is used to check consistency of code. If problem is notices with additional non-zero elements in matrix, this function can help detect problem. Should be used as a part of atom tests

Template Parameters

Tag

Parameters

problem_name
row	print info at particular row
col	print info at particular col

Returns

MoFEMErrorCode

Definition at line 286 of file MatrixManager.hpp.

                                                           {
    static_assert(!std::is_same<Tag, Tag>::value, "not implemented");
    return 0;
  }

checkMPIAIJWithArraysMatrixFillIn() [1/3]

template<>

MoFEMErrorCode MoFEM::MatrixManager::checkMPIAIJWithArraysMatrixFillIn	(	const std::string	problem_name,
		int	row_print,
		int	col_print,
		int	verb )

Definition at line 1140 of file MatrixManager.cpp.

                                                                          {
  MatrixManagerFunctionBegin;
  // create matrix
  SmartPetscObj<Mat> A;
  CHKERR createMPIAIJWithArrays<PetscGlobalIdx_mi_tag>(problem_name, A, verb);
  CHKERR MatSetOption(A, MAT_NEW_NONZERO_ALLOCATION_ERR, PETSC_TRUE);
  CHKERR checkMatrixFillIn(problem_name, row_print, col_print, A, verb);
  MoFEMFunctionReturn(0);
}

checkMPIAIJWithArraysMatrixFillIn() [2/3]

template<>

MoFEMErrorCode MoFEM::MatrixManager::checkMPIAIJWithArraysMatrixFillIn	(	const std::string	problem_name,
		int	row_print,
		int	col_print,
		int	verb )

checkMPIAIJWithArraysMatrixFillIn() [3/3]

template<class Tag >

MoFEMErrorCode MoFEM::MatrixManager::checkMPIAIJWithArraysMatrixFillIn ( const std::string problem_name, int row_print, int col_print, int verb = QUIET )

inline

check if matrix fill in correspond to finite element indices

This is used to check consistency of code. If problem is notices with additional non-zero elements in matrix, this function can help detect problem. Should be used as a part of atom tests

Template Parameters

Tag

Parameters

problem_name
row	print info at particular row
col	print info at particular col

Returns

MoFEMErrorCode

Definition at line 265 of file MatrixManager.hpp.

                                                      {
    static_assert(!std::is_same<Tag, Tag>::value, "not implemented");
    return 0;
  }

createHybridL2MPIAIJ() [1/3]

template<>

MoFEMErrorCode MoFEM::MatrixManager::createHybridL2MPIAIJ	(	const std::string	problem_name,
		SmartPetscObj< Mat > &	aij_ptr,
		int	verb )

Definition at line 1165 of file MatrixManager.cpp.

                                                                         {
  MoFEM::CoreInterface &m_field = cOre;
  MatrixManagerFunctionBegin;
 
  auto prb_ptr = m_field.get_problems();
  auto p_miit = prb_ptr->get<Problem_mi_tag>().find(problem_name);
  if (p_miit == prb_ptr->get<Problem_mi_tag>().end()) {
    SETERRQ(m_field.get_comm(), MOFEM_NOT_FOUND,
             "problem < %s > is not found (top tip: check spelling)",
             problem_name.c_str());
  }
 
  auto nb_rows = p_miit->getNbDofsRow();
  auto nb_cols = p_miit->getNbDofsCol();
  auto nb_loc_rows = p_miit->getNbLocalDofsRow();
  auto nb_loc_cols = p_miit->getNbLocalDofsCol();
 
  auto row_ptr = p_miit->getNumeredRowDofsPtr();
  auto col_ptr = p_miit->getNumeredColDofsPtr();
 
  BitFieldId fields_ids;
  for (auto &c : *col_ptr) {
    fields_ids |= c->getId();
  }
  auto fields = m_field.get_fields();
  std::vector<int> fields_bit_numbers;
  for (auto &f : *fields) {
    if ((fields_ids & f->getId()).any()) {
      fields_bit_numbers.push_back(f->getBitNumber());
    }
  }
 
  Range adj;
  EntityHandle prev_ent = 0;
  int prev_dim = -1;
 
  auto get_adj = [&](auto ent, auto dim) {
    if (prev_ent == ent && prev_dim == dim) {
      return adj;
    } else {
      adj.clear();
      Range bridge;
      CHKERR m_field.get_moab().get_adjacencies(&ent, 1, dim + 1, false,
                                                bridge);
      CHKERR m_field.get_moab().get_adjacencies(bridge, dim, false, adj,
                                                moab::Interface::UNION);
      prev_ent = ent;
      prev_dim = dim;
      return adj;
    }
  };
 
  int prev_bit_number = -1;
  EntityHandle prev_first_ent = 0;
  EntityHandle prev_second_ent = 0;
  using IT = boost::multi_index::index<NumeredDofEntity_multiIndex,
                                       Unique_mi_tag>::type::iterator;
  std::pair<IT, IT> pair_lo_hi;
  auto get_col_it = [&](auto bit_number, auto first_ent, auto second_ent) {
    if (bit_number == prev_bit_number && first_ent == prev_first_ent &&
        second_ent == prev_second_ent) {
      return pair_lo_hi;
    } else {
      auto lo_it = col_ptr->get<Unique_mi_tag>().lower_bound(
          DofEntity::getLoFieldEntityUId(bit_number, first_ent));
      auto hi_it = col_ptr->get<Unique_mi_tag>().upper_bound(
          DofEntity::getHiFieldEntityUId(bit_number, second_ent));
      pair_lo_hi = std::make_pair(lo_it, hi_it);
      prev_bit_number = bit_number;
      prev_first_ent = first_ent;
      prev_second_ent = second_ent;
      return pair_lo_hi;
    }
  };
 
  auto create_ghost_vec = [&]() {
    SmartPetscObj<Vec> v;
    CHKERR m_field.getInterface<VecManager>()->vecCreateGhost(problem_name, ROW,
                                                              v);
    CHKERR VecZeroEntries(v);
    CHKERR VecGhostUpdateBegin(v, INSERT_VALUES, SCATTER_FORWARD);
    CHKERR VecGhostUpdateEnd(v, INSERT_VALUES, SCATTER_FORWARD);
    return v;
  };
 
  auto v_o_nnz = create_ghost_vec();
  auto v_d_nnz = create_ghost_vec();
 
 
  double *o_nnz_real;
  CHKERR VecGetArray(v_o_nnz, &o_nnz_real);
  double *d_nnz_real;
  CHKERR VecGetArray(v_d_nnz, &d_nnz_real);
 
  for (auto r = row_ptr->begin(); r != row_ptr->end(); ++r) {
 
    auto row_loc_idx = (*r)->getPetscLocalDofIdx();
    if (row_loc_idx < 0)
      continue;
 
    auto ent = (*r)->getEnt();
    auto dim = dimension_from_handle(ent);
    auto adj = get_adj(ent, dim);
 
    for (auto p = adj.pair_begin(); p != adj.pair_end(); ++p) {
      auto first_ent = p->first;
      auto second_ent = p->second;
 
      for (auto bit_number : fields_bit_numbers) {
 
        auto [lo_it, hi_it] = get_col_it(bit_number, first_ent, second_ent);
 
        for (; lo_it != hi_it; ++lo_it) {
          auto col_loc_idx = (*lo_it)->getPetscLocalDofIdx();
          if (col_loc_idx < 0)
            continue;
 
          if (
 
              (*lo_it)->getOwnerProc() == (*r)->getOwnerProc()
 
          ) {
            d_nnz_real[row_loc_idx] += 1;
          } else {
            o_nnz_real[row_loc_idx] += 1;
          }
        }
      }
    }
  }
 
  CHKERR VecRestoreArray(v_o_nnz, &o_nnz_real);
  CHKERR VecRestoreArray(v_d_nnz, &d_nnz_real);
 
  auto update_vec = [&](auto v) {
    MoFEMFunctionBegin;
    CHKERR VecGhostUpdateBegin(v, ADD_VALUES, SCATTER_REVERSE);
    CHKERR VecGhostUpdateEnd(v, ADD_VALUES, SCATTER_REVERSE);
    CHKERR VecAssemblyBegin(v);
    CHKERR VecAssemblyEnd(v);
    MoFEMFunctionReturn(0);
  };
 
  CHKERR update_vec(v_o_nnz);
  CHKERR update_vec(v_d_nnz);
 
  int o_nz = 0;
  int d_nz = 0;
 
  CHKERR VecGetArray(v_d_nnz, &d_nnz_real);
  CHKERR VecGetArray(v_o_nnz, &o_nnz_real);
 
  std::vector<int> d_nnz(nb_loc_rows, 0);
  std::vector<int> o_nnz(nb_loc_rows, 0);
  for (auto r = row_ptr->begin(); r != row_ptr->end(); ++r) {
 
    auto row_loc_idx = (*r)->getPetscLocalDofIdx();
 
    if (
 
        row_loc_idx >= 0 && row_loc_idx < nb_loc_rows
 
    ) {
      auto row_loc_idx = (*r)->getPetscLocalDofIdx();
      d_nz += o_nnz_real[row_loc_idx];
      d_nnz[row_loc_idx] = d_nnz_real[row_loc_idx];
      o_nz += o_nnz_real[row_loc_idx];
      o_nnz[row_loc_idx] = o_nnz_real[row_loc_idx];
    } 
 
  }
 
  CHKERR VecRestoreArray(v_o_nnz, &o_nnz_real);
  CHKERR VecRestoreArray(v_d_nnz, &d_nnz_real);
 
  if (verb >= QUIET) {
    MOFEM_LOG("SYNC", Sev::verbose)
        << "Hybrid L2 matrix d_nz: " << d_nz << " o_nz: " << o_nz;
    MOFEM_LOG_SEVERITY_SYNC(m_field.get_comm(), Sev::verbose);
  }
 
  if (verb >= VERBOSE) {
    MOFEM_LOG("SYNC", Sev::noisy) << "Hybrid L2 matrix";
    int idx = 0;
    for (auto &d : d_nnz) {
      MOFEM_LOG("SYNC", Sev::noisy) << idx << ": " << d;
      ++idx;
    }
    MOFEM_LOG_SEVERITY_SYNC(m_field.get_comm(), Sev::noisy);
  }
 
  Mat a_raw;
  CHKERR MatCreateAIJ(m_field.get_comm(), nb_loc_rows, nb_loc_cols, nb_rows,
                      nb_cols, 0, &*d_nnz.begin(), 0, &*o_nnz.begin(), &a_raw);
  CHKERR MatSetOption(a_raw, MAT_NEW_NONZERO_ALLOCATION_ERR, PETSC_TRUE);
  aij_ptr = SmartPetscObj<Mat>(a_raw);
 
  MOFEM_LOG_CHANNEL("WORLD");
  MOFEM_LOG_CHANNEL("SYNC");
 
  MoFEMFunctionReturn(0);
}

createHybridL2MPIAIJ() [2/3]

template<>

MoFEMErrorCode MoFEM::MatrixManager::createHybridL2MPIAIJ	(	const std::string	problem_name,
		SmartPetscObj< Mat > &	aij_ptr,
		int	verb )

createHybridL2MPIAIJ() [3/3]

template<class Tag >

MoFEMErrorCode MoFEM::MatrixManager::createHybridL2MPIAIJ ( const std::string problem_name, SmartPetscObj< Mat > & aij_ptr, int verb = QUIET )

inline

Create a Hybrid MPIAij object.

It assumes that L2 field is on skeleton, and dim+1 is bridge adjacency.

Template Parameters

Tag

Parameters

problem_name
aij_ptr
verb

Returns

MoFEMErrorCode

Definition at line 305 of file MatrixManager.hpp.

                                                      {
    static_assert(!std::is_same<Tag, Tag>::value, "not implemented");
    return 0;
  }

createMPIAdjWithArrays() [1/3]

template<>

MoFEMErrorCode MoFEM::MatrixManager::createMPIAdjWithArrays	(	const std::string	name,
		Mat *	Adj,
		int	verb )

Definition at line 820 of file MatrixManager.cpp.

                                                                      {
  MoFEM::CoreInterface &m_field = cOre;
  CreateRowCompressedADJMatrix *core_ptr =
      static_cast<CreateRowCompressedADJMatrix *>(&cOre);
  MoFEMFunctionBegin;
  PetscLogEventBegin(MOFEM_EVENT_createMPIAdjWithArrays, 0, 0, 0, 0);
 
  auto problems_ptr = m_field.get_problems();
  auto &prb = problems_ptr->get<Problem_mi_tag>();
  auto p_miit = prb.find(name);
  if (p_miit == prb.end()) {
    SETERRQ(m_field.get_comm(), MOFEM_NOT_FOUND,
             "problem < %s > is not found (top tip: check spelling)",
             name.c_str());
  }
 
  std::vector<int> i_vec, j_vec;
  j_vec.reserve(10000);
  CHKERR core_ptr->createMatArrays<Idx_mi_tag>(p_miit, MATMPIADJ, i_vec, j_vec,
                                               true, verb);
  int *_i, *_j;
  CHKERR PetscMalloc(i_vec.size() * sizeof(int), &_i);
  CHKERR PetscMalloc(j_vec.size() * sizeof(int), &_j);
  copy(i_vec.begin(), i_vec.end(), _i);
  copy(j_vec.begin(), j_vec.end(), _j);
 
  int nb_col_dofs = p_miit->getNbDofsCol();
  CHKERR MatCreateMPIAdj(m_field.get_comm(), i_vec.size() - 1, nb_col_dofs, _i,
                         _j, PETSC_NULLPTR, Adj);
  CHKERR MatSetOption(*Adj, MAT_STRUCTURALLY_SYMMETRIC, PETSC_TRUE);
 
  PetscLogEventEnd(MOFEM_EVENT_createMPIAdjWithArrays, 0, 0, 0, 0);
  MoFEMFunctionReturn(0);
}

createMPIAdjWithArrays() [2/3]

template<>

MoFEMErrorCode MoFEM::MatrixManager::createMPIAdjWithArrays	(	const std::string	name,
		Mat *	Adj,
		int	verb )

createMPIAdjWithArrays() [3/3]

template<class Tag >

MoFEMErrorCode MoFEM::MatrixManager::createMPIAdjWithArrays ( const std::string name, Mat * Adj, int verb = QUIET )

inline

Creates a sparse matrix representing an adjacency list.

The matrix does not have numerical values associated with it, but is intended for ordering (to reduce bandwidth etc) and partitioning.

See PETSc for details

Note

This matrix object does not support most matrix operations, include MatSetValues(). You must NOT free the ii, values and jj arrays yourself. PETSc will free them when the matrix is destroyed; you must allocate them with PetscMalloc(). If you call from Fortran you need not create the arrays with PetscMalloc(). Should not include the matrix diagonals.

Template Parameters

Tag

Parameters

name
Adj
verb

Returns

MoFEMErrorCode

Definition at line 166 of file MatrixManager.hpp.

                                                          {
    static_assert(!std::is_same<Tag, Tag>::value, "not implemented");
    return MOFEM_NOT_IMPLEMENTED;
  }

createMPIAIJ() [1/4]

template<>

MoFEMErrorCode MoFEM::MatrixManager::createMPIAIJ	(	const std::string	name,
		Mat *	Aij,
		int	verb )

Definition at line 750 of file MatrixManager.cpp.

                                                                       {
  MoFEM::CoreInterface &m_field = cOre;
  CreateRowCompressedADJMatrix *core_ptr =
      static_cast<CreateRowCompressedADJMatrix *>(&cOre);
  MoFEMFunctionBegin;
  PetscLogEventBegin(MOFEM_EVENT_createMPIAIJ, 0, 0, 0, 0);
 
  auto problems_ptr = m_field.get_problems();
  auto &prb = problems_ptr->get<Problem_mi_tag>();
  auto p_miit = prb.find(name);
  if (p_miit == prb.end()) {
    SETERRQ(m_field.get_comm(), MOFEM_NOT_FOUND,
             "problem < %s > is not found (top tip: check spelling)",
             name.c_str());
  }
 
  std::vector<int> i_vec, j_vec;
  j_vec.reserve(10000);
  CHKERR core_ptr->createMatArrays<PetscGlobalIdx_mi_tag>(
      p_miit, MATMPIAIJ, i_vec, j_vec, false, verb);
 
  int nb_row_dofs = p_miit->getNbDofsRow();
  int nb_col_dofs = p_miit->getNbDofsCol();
  int nb_local_dofs_row = p_miit->getNbLocalDofsRow();
  int nb_local_dofs_col = p_miit->getNbLocalDofsCol();
 
  auto get_layout = [&]() {
    int start_ranges, end_ranges;
    PetscLayout layout;
    CHKERR PetscLayoutCreate(m_field.get_comm(), &layout);
    CHKERR PetscLayoutSetBlockSize(layout, 1);
    CHKERR PetscLayoutSetLocalSize(layout, nb_local_dofs_col);
    CHKERR PetscLayoutSetUp(layout);
    CHKERR PetscLayoutGetRange(layout, &start_ranges, &end_ranges);
    CHKERR PetscLayoutDestroy(&layout);
    return std::make_pair(start_ranges, end_ranges);
  };
 
  auto get_nnz = [&](auto &d_nnz, auto &o_nnz) {
    MoFEMFunctionBeginHot;
    auto layout = get_layout();
    int j = 0;
    for (int i = 0; i != nb_local_dofs_row; ++i) {
      for (; j != i_vec[i + 1]; ++j) {
        if (j_vec[j] < layout.second && j_vec[j] >= layout.first)
          ++(d_nnz[i]);
        else
          ++(o_nnz[i]);
      }
    }
    MoFEMFunctionReturnHot(0);
  };
 
  std::vector<int> d_nnz(nb_local_dofs_row, 0), o_nnz(nb_local_dofs_row, 0);
  CHKERR get_nnz(d_nnz, o_nnz);
 
  CHKERR MatCreate(m_field.get_comm(), Aij);
  CHKERR MatSetSizes(*Aij, nb_local_dofs_row, nb_local_dofs_col, nb_row_dofs,
                     nb_col_dofs);
  CHKERR MatSetType(*Aij, MATMPIAIJ);
  CHKERR MatMPIAIJSetPreallocation(*Aij, 0, &*d_nnz.begin(), 0,
                                   &*o_nnz.begin());
 
  PetscLogEventEnd(MOFEM_EVENT_createMPIAIJ, 0, 0, 0, 0);
  MoFEMFunctionReturn(0);
}

createMPIAIJ() [2/4]

template<>

MoFEMErrorCode MoFEM::MatrixManager::createMPIAIJ	(	const std::string	name,
		Mat *	Aij,
		int	verb )

createMPIAIJ() [3/4]

template<class Tag >

MoFEMErrorCode MoFEM::MatrixManager::createMPIAIJ ( const std::string name, Mat * Aij, int verb = QUIET )

inline

Creates a MPI AIJ matrix using arrays that contain in standard CSR format the local rows.

See PETSc for details

Template Parameters

Tag

Parameters

name
Aij
verb

Returns

MoFEMErrorCode

Definition at line 123 of file MatrixManager.hpp.

                                                          {
    static_assert(!std::is_same<Tag, Tag>::value, "not implemented");
    return 0;
  }

createMPIAIJ() [4/4]

template<class Tag >

MoFEMErrorCode MoFEM::MatrixManager::createMPIAIJ ( const std::string name, SmartPetscObj< Mat > & aij_ptr, int verb = QUIET )

inline

Creates a MPI AIJ matrix using arrays that contain in standard CSR format the local rows.

See PETSc for details

Template Parameters

Tag

Parameters

name
Aij
verb

Returns

MoFEMErrorCode

Definition at line 132 of file MatrixManager.hpp.

                                                          {
    MoFEMFunctionBegin;
    Mat aij;
    CHKERR createMPIAIJ<Tag>(name, &aij, verb);
    aij_ptr.reset(aij, false);
    MoFEMFunctionReturn(0);
  }

createMPIAIJCUSPARSEWithArrays() [1/4]

template<>

MoFEMErrorCode MoFEM::MatrixManager::createMPIAIJCUSPARSEWithArrays	(	const std::string	name,
		Mat *	Aij,
		int	verb )

Definition at line 661 of file MatrixManager.cpp.

                                              {
  MoFEMFunctionBegin;
 
  MoFEM::CoreInterface &m_field = cOre;
  CreateRowCompressedADJMatrix *core_ptr =
      static_cast<CreateRowCompressedADJMatrix *>(&cOre);
  PetscLogEventBegin(MOFEM_EVENT_createMPIAIJCUSPARSEWithArrays, 0, 0, 0, 0);
 
  auto problems_ptr = m_field.get_problems();
  auto &prb = problems_ptr->get<Problem_mi_tag>();
  auto p_miit = prb.find(name);
  if (p_miit == prb.end()) {
    SETERRQ(m_field.get_comm(), MOFEM_NOT_FOUND,
             "problem < %s > is not found (top tip: check spelling)",
             name.c_str());
  }
 
  std::vector<int> i_vec, j_vec;
  j_vec.reserve(10000);
  CHKERR core_ptr->createMatArrays<PetscGlobalIdx_mi_tag>(
      p_miit, MATAIJCUSPARSE, i_vec, j_vec, false, verb);
 
  int nb_local_dofs_row = p_miit->getNbLocalDofsRow();
  int nb_local_dofs_col = p_miit->getNbLocalDofsCol();
 
  auto get_layout = [&]() {
    int start_ranges, end_ranges;
    PetscLayout layout;
    CHKERR PetscLayoutCreate(m_field.get_comm(), &layout);
    CHKERR PetscLayoutSetBlockSize(layout, 1);
    CHKERR PetscLayoutSetLocalSize(layout, nb_local_dofs_col);
    CHKERR PetscLayoutSetUp(layout);
    CHKERR PetscLayoutGetRange(layout, &start_ranges, &end_ranges);
    CHKERR PetscLayoutDestroy(&layout);
    return std::make_pair(start_ranges, end_ranges);
  };
 
  auto get_nnz = [&](auto &d_nnz, auto &o_nnz) {
    MoFEMFunctionBeginHot;
    auto layout = get_layout();
    int j = 0;
    for (int i = 0; i != nb_local_dofs_row; ++i) {
      for (; j != i_vec[i + 1]; ++j) {
        if (j_vec[j] < layout.second && j_vec[j] >= layout.first)
          ++(d_nnz[i]);
        else
          ++(o_nnz[i]);
      }
    }
    MoFEMFunctionReturnHot(0);
  };
 
  std::vector<int> d_nnz(nb_local_dofs_row, 0), o_nnz(nb_local_dofs_row, 0);
  CHKERR get_nnz(d_nnz, o_nnz);
 
#ifdef PETSC_HAVE_CUDA
  CHKERR ::MatCreateAIJCUSPARSE(m_field.get_comm(), nb_local_dofs_row,
                                nb_local_dofs_col, nb_row_dofs, nb_col_dofs, 0,
                                &*d_nnz.begin(), 0, &*o_nnz.begin(), Aij);
#else
  SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
          "Error: To use this matrix type compile PETSc with CUDA.");
#endif
 
  PetscLogEventEnd(MOFEM_EVENT_createMPIAIJCUSPARSEWithArrays, 0, 0, 0, 0);
 
  MoFEMFunctionReturn(0);
}

createMPIAIJCUSPARSEWithArrays() [2/4]

template<>

MoFEMErrorCode MoFEM::MatrixManager::createMPIAIJCUSPARSEWithArrays	(	const std::string	name,
		Mat *	Aij,
		int	verb )

createMPIAIJCUSPARSEWithArrays() [3/4]

template<class Tag >

MoFEMErrorCode MoFEM::MatrixManager::createMPIAIJCUSPARSEWithArrays ( const std::string name, Mat * Aij, int verb = QUIET )

inline

Definition at line 69 of file MatrixManager.hpp.

                                                                            {
    static_assert(!std::is_same<Tag, Tag>::value, "not implemented");
    return 0;
  }

createMPIAIJCUSPARSEWithArrays() [4/4]

template<class Tag >

MoFEMErrorCode MoFEM::MatrixManager::createMPIAIJCUSPARSEWithArrays ( const std::string name, SmartPetscObj< Mat > & aij_ptr, int verb = QUIET )

inline

Definition at line 78 of file MatrixManager.hpp.

                                                                  {
    MoFEMFunctionBegin;
    Mat aij;
    CHKERR createMPIAIJCUSPARSEWithArrays<Tag>(name, &aij, verb);
    aij_ptr.reset(aij, false);
    MoFEMFunctionReturn(0);
  }

createMPIAIJWithArrays() [1/4]

template<>

MoFEMErrorCode MoFEM::MatrixManager::createMPIAIJWithArrays	(	const std::string	name,
		Mat *	Aij,
		int	verb )

Definition at line 624 of file MatrixManager.cpp.

                                              {
  MoFEMFunctionBegin;
 
  MoFEM::CoreInterface &m_field = cOre;
  CreateRowCompressedADJMatrix *core_ptr =
      static_cast<CreateRowCompressedADJMatrix *>(&cOre);
  PetscLogEventBegin(MOFEM_EVENT_createMPIAIJWithArrays, 0, 0, 0, 0);
 
  auto problems_ptr = m_field.get_problems();
  auto &prb = problems_ptr->get<Problem_mi_tag>();
  auto p_miit = prb.find(name);
  if (p_miit == prb.end()) {
    SETERRQ(m_field.get_comm(), MOFEM_NOT_FOUND,
             "problem < %s > is not found (top tip: check spelling)",
             name.c_str());
  }
 
  std::vector<int> i_vec, j_vec;
  j_vec.reserve(10000);
  CHKERR core_ptr->createMatArrays<PetscGlobalIdx_mi_tag>(
      p_miit, MATMPIAIJ, i_vec, j_vec, false, verb);
 
  int nb_row_dofs = p_miit->getNbDofsRow();
  int nb_col_dofs = p_miit->getNbDofsCol();
  int nb_local_dofs_row = p_miit->getNbLocalDofsRow();
  int nb_local_dofs_col = p_miit->getNbLocalDofsCol();
 
  CHKERR ::MatCreateMPIAIJWithArrays(
      m_field.get_comm(), nb_local_dofs_row, nb_local_dofs_col, nb_row_dofs,
      nb_col_dofs, &*i_vec.begin(), &*j_vec.begin(), PETSC_NULLPTR, Aij);
 
  PetscLogEventEnd(MOFEM_EVENT_createMPIAIJWithArrays, 0, 0, 0, 0);
  MoFEMFunctionReturn(0);
}

createMPIAIJWithArrays() [2/4]

template<>

MoFEMErrorCode MoFEM::MatrixManager::createMPIAIJWithArrays	(	const std::string	name,
		Mat *	Aij,
		int	verb )

createMPIAIJWithArrays() [3/4]

template<class Tag >

MoFEMErrorCode MoFEM::MatrixManager::createMPIAIJWithArrays ( const std::string name, Mat * Aij, int verb = QUIET )

inline

Creates a MPI AIJ matrix using arrays that contain in standard CSR format the local rows.

See PETSc for details

Template Parameters

Tag

Parameters

name
Aij
verb

Returns

MoFEMErrorCode

Definition at line 49 of file MatrixManager.hpp.

                                                          {
    static_assert(!std::is_same<Tag, Tag>::value, "not implemented");
    return 0;
  }

createMPIAIJWithArrays() [4/4]

template<class Tag >

MoFEMErrorCode MoFEM::MatrixManager::createMPIAIJWithArrays ( const std::string name, SmartPetscObj< Mat > & aij_ptr, int verb = QUIET )

inline

Creates a MPI AIJ matrix using arrays that contain in standard CSR format the local rows.

See PETSc for details

Template Parameters

Tag

Parameters

name
Aij
verb

Returns

MoFEMErrorCode

Definition at line 58 of file MatrixManager.hpp.

                                                          {
    MoFEMFunctionBegin;
    Mat aij;
    CHKERR createMPIAIJWithArrays<Tag>(name, &aij, verb);
    aij_ptr.reset(aij, false);
    MoFEMFunctionReturn(0);
  }

createSeqAIJCUSPARSEWithArrays() [1/4]

template<>

MoFEMErrorCode MoFEM::MatrixManager::createSeqAIJCUSPARSEWithArrays	(	const std::string	name,
		Mat *	Aij,
		int	verb )

Definition at line 733 of file MatrixManager.cpp.

                                              {
  MoFEMFunctionBegin;
 
#ifdef PETSC_HAVE_CUDA
  // CHKERR ::MatCreateSeqAIJCUSPARSE(MPI_Comm comm, PetscInt m, PetscInt n,
  //                                  PetscInt nz, const PetscInt nnz[], Mat
  //                                  *A);
  SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
          "Not implemented type of matrix yet, try MPI version (aijcusparse)");
#endif
 
  MoFEMFunctionReturn(0);
}

createSeqAIJCUSPARSEWithArrays() [2/4]

template<>

MoFEMErrorCode MoFEM::MatrixManager::createSeqAIJCUSPARSEWithArrays	(	const std::string	name,
		Mat *	Aij,
		int	verb )

createSeqAIJCUSPARSEWithArrays() [3/4]

template<class Tag >

MoFEMErrorCode MoFEM::MatrixManager::createSeqAIJCUSPARSEWithArrays ( const std::string name, Mat * Aij, int verb = QUIET )

inline

Definition at line 89 of file MatrixManager.hpp.

                                                                            {
    static_assert(!std::is_same<Tag, Tag>::value, "not implemented");
    return 0;
  }

createSeqAIJCUSPARSEWithArrays() [4/4]

template<class Tag >

MoFEMErrorCode MoFEM::MatrixManager::createSeqAIJCUSPARSEWithArrays ( const std::string name, SmartPetscObj< Mat > & aij_ptr, int verb = QUIET )

inline

Definition at line 98 of file MatrixManager.hpp.

                                                                  {
    MoFEMFunctionBegin;
    Mat aij;
    CHKERR createSeqAIJCUSPARSEWithArrays<Tag>(name, &aij, verb);
    aij_ptr.reset(aij, false);
    MoFEMFunctionReturn(0);
  }

createSeqAIJWithArrays() [1/4]

template<>

MoFEMErrorCode MoFEM::MatrixManager::createSeqAIJWithArrays	(	const std::string	name,
		Mat *	Aij,
		int	verb )

Definition at line 858 of file MatrixManager.cpp.

                                              {
  MoFEM::CoreInterface &m_field = cOre;
  CreateRowCompressedADJMatrix *core_ptr =
      static_cast<CreateRowCompressedADJMatrix *>(&cOre);
  MoFEMFunctionBegin;
  PetscLogEventBegin(MOFEM_EVENT_createMPIAIJWithArrays, 0, 0, 0, 0);
 
  auto problems_ptr = m_field.get_problems();
  auto &prb = problems_ptr->get<Problem_mi_tag>();
  auto p_miit = prb.find(name);
  if (p_miit == prb.end()) {
    SETERRQ(m_field.get_comm(), MOFEM_NOT_FOUND,
             "problem < %s > is not found (top tip: check spelling)",
             name.c_str());
  }
 
  std::vector<int> i_vec, j_vec;
  j_vec.reserve(10000);
  CHKERR core_ptr->createMatArrays<PetscGlobalIdx_mi_tag>(p_miit, MATAIJ, i_vec,
                                                          j_vec, false, verb);
 
  int nb_local_dofs_row = p_miit->getNbLocalDofsRow();
  int nb_local_dofs_col = p_miit->getNbLocalDofsCol();
 
  double *_a;
  CHKERR PetscMalloc(j_vec.size() * sizeof(double), &_a);
 
  Mat tmpMat;
  CHKERR ::MatCreateSeqAIJWithArrays(PETSC_COMM_SELF, nb_local_dofs_row,
                                     nb_local_dofs_col, &*i_vec.begin(),
                                     &*j_vec.begin(), _a, &tmpMat);
  CHKERR MatDuplicate(tmpMat, MAT_SHARE_NONZERO_PATTERN, Aij);
  CHKERR MatDestroy(&tmpMat);
 
  CHKERR PetscFree(_a);
 
  PetscLogEventEnd(MOFEM_EVENT_createMPIAIJWithArrays, 0, 0, 0, 0);
  MoFEMFunctionReturn(0);
}

createSeqAIJWithArrays() [2/4]

template<>

MoFEMErrorCode MoFEM::MatrixManager::createSeqAIJWithArrays	(	const std::string	name,
		Mat *	Aij,
		int	verb )

createSeqAIJWithArrays() [3/4]

template<class Tag >

MoFEMErrorCode MoFEM::MatrixManager::createSeqAIJWithArrays ( const std::string name, Mat * Aij, int verb = QUIET )

inline

Create sequencial matrix.

Creates a sparse matrix in AIJ (compressed row) format (the default parallel PETSc format). For good matrix assembly performance the user should preallocate the matrix storage by setting the parameter nz (or the array nnz). By setting these parameters accurately, performance during matrix assembly can be increased by more than a factor of 50.

See PETSc for details

Template Parameters

Tag

Parameters

name
Aij
i
j
v
verb

Returns

MoFEMErrorCode

Definition at line 195 of file MatrixManager.hpp.

                                                          {
    static_assert(!std::is_same<Tag, Tag>::value, "not implemented");
    return 0;
  }

createSeqAIJWithArrays() [4/4]

template<class Tag >

MoFEMErrorCode MoFEM::MatrixManager::createSeqAIJWithArrays ( const std::string name, SmartPetscObj< Mat > & aij_ptr, int verb = QUIET )

inline

Create sequencial matrix.

Creates a sparse matrix in AIJ (compressed row) format (the default parallel PETSc format). For good matrix assembly performance the user should preallocate the matrix storage by setting the parameter nz (or the array nnz). By setting these parameters accurately, performance during matrix assembly can be increased by more than a factor of 50.

See PETSc for details

Template Parameters

Tag

Parameters

name
Aij	(SmartPetscObj)
i
j
v
verb

Returns

MoFEMErrorCode

Definition at line 224 of file MatrixManager.hpp.

                                                          {
    MoFEMFunctionBegin;
    Mat aij;
    CHKERR createSeqAIJWithArrays<Tag>(name, &aij, verb);
    aij_ptr.reset(aij, false);
    MoFEMFunctionReturn(0);
  }

query_interface()

MoFEMErrorCode MoFEM::MatrixManager::query_interface ( boost::typeindex::type_index type_index, UnknownInterface ** iface ) const

virtual

Implements MoFEM::UnknownInterface.

Definition at line 600 of file MatrixManager.cpp.

                                                               {
  *iface = const_cast<MatrixManager *>(this);
  return 0;
}

Member Data Documentation

cOre

MoFEM::Core& MoFEM::MatrixManager::cOre

Definition at line 26 of file MatrixManager.hpp.

MOFEM_EVENT_checkMatrixFillIn

PetscLogEvent MoFEM::MatrixManager::MOFEM_EVENT_checkMatrixFillIn

private

Definition at line 319 of file MatrixManager.hpp.

MOFEM_EVENT_createMPIAdjWithArrays

PetscLogEvent MoFEM::MatrixManager::MOFEM_EVENT_createMPIAdjWithArrays

private

Definition at line 315 of file MatrixManager.hpp.

MOFEM_EVENT_createMPIAIJ

PetscLogEvent MoFEM::MatrixManager::MOFEM_EVENT_createMPIAIJ

private

Definition at line 313 of file MatrixManager.hpp.

MOFEM_EVENT_createMPIAIJCUSPARSEWithArrays

PetscLogEvent MoFEM::MatrixManager::MOFEM_EVENT_createMPIAIJCUSPARSEWithArrays

private

Definition at line 317 of file MatrixManager.hpp.

MOFEM_EVENT_createMPIAIJWithArrays

PetscLogEvent MoFEM::MatrixManager::MOFEM_EVENT_createMPIAIJWithArrays

private

Definition at line 314 of file MatrixManager.hpp.

MOFEM_EVENT_createSeqAIJCUSPARSEWithArrays

PetscLogEvent MoFEM::MatrixManager::MOFEM_EVENT_createSeqAIJCUSPARSEWithArrays

private

Definition at line 318 of file MatrixManager.hpp.

MOFEM_EVENT_createSeqAIJWithArrays

PetscLogEvent MoFEM::MatrixManager::MOFEM_EVENT_createSeqAIJWithArrays

private

Definition at line 316 of file MatrixManager.hpp.

---

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

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