Remove function domain_map_not_epetra

Author: knarfnitram

src/constraint/4C_constraint_solver.cpp

@@ -323,7 +323,7 @@ void CONSTRAINTS::ConstraintSolver::solve_simple(Core::LinAlg::SparseMatrix& sti
   // cast constraint operators to matrices and save transpose of constraint matrix
   Core::LinAlg::SparseMatrix constrTrans(*conrowmap, 81, false, true);
   constrTrans.add(constrT, true, 1.0, 0.0);
-  constrTrans.complete(constrT.range_map(), constrT.domain_map_not_epetra());
+  constrTrans.complete(constrT.range_map(), constrT.domain_map());
 
   // ONLY compatibility
   // dirichtoggle_ changed and we need to rebuild associated DBC maps

src/constraint_framework/4C_constraint_framework_submodelevaluator_base.cpp

@@ -82,7 +82,7 @@ void CONSTRAINTS::SUBMODELEVALUATOR::ConstraintBase::evaluate_coupling_terms(
 
   // Complete
   Q_dd_->complete();
-  Q_Ld_->complete(stiff_ptr_->domain_map_not_epetra(), *n_condition_map_);
-  Q_dL_->complete(*n_condition_map_, stiff_ptr_->domain_map_not_epetra());
+  Q_Ld_->complete(stiff_ptr_->domain_map(), *n_condition_map_);
+  Q_dL_->complete(*n_condition_map_, stiff_ptr_->domain_map());
 }
 FOUR_C_NAMESPACE_CLOSE

src/contact/4C_contact_lagrange_strategy.cpp

@@ -689,7 +689,7 @@ void CONTACT::LagrangeStrategy::evaluate_friction(
     std::shared_ptr<Core::LinAlg::SparseMatrix> kmnadd =
         Core::LinAlg::matrix_multiply(*mhataam, true, *kan, false, false, false, true);
     kmnmod->add(*kmnadd, false, 1.0, 1.0);
-    kmnmod->complete(kmn->domain_map_not_epetra(), kmn->row_map());
+    kmnmod->complete(kmn->domain_map(), kmn->row_map());
 
     // kmm: add T(mhataam)*kam
     std::shared_ptr<Core::LinAlg::SparseMatrix> kmmmod =
@@ -698,7 +698,7 @@ void CONTACT::LagrangeStrategy::evaluate_friction(
     std::shared_ptr<Core::LinAlg::SparseMatrix> kmmadd =
         Core::LinAlg::matrix_multiply(*mhataam, true, *kam, false, false, false, true);
     kmmmod->add(*kmmadd, false, 1.0, 1.0);
-    kmmmod->complete(kmm->domain_map_not_epetra(), kmm->row_map());
+    kmmmod->complete(kmm->domain_map(), kmm->row_map());
 
     // kmi: add T(mhataam)*kai
     std::shared_ptr<Core::LinAlg::SparseMatrix> kmimod;

src/contact/4C_contact_lagrange_strategy_poro.cpp

@@ -283,7 +283,7 @@ void CONTACT::LagrangeStrategyPoro::poro_initialize(
         std::make_shared<Core::LinAlg::SparseMatrix>(*falldofrowmap_, 1, true, false);
     (*porolindmatrixtransform_)(*porolindmatrix_, 1.0,
         Coupling::Adapter::CouplingMasterConverter(coupfs), *fporolindmatrix_, false);
-    fporolindmatrix_->complete(porolindmatrix_->domain_map_not_epetra(), *fgsdofrowmap_);
+    fporolindmatrix_->complete(porolindmatrix_->domain_map(), *fgsdofrowmap_);
     //
     //************************************************************************************************
     //
@@ -293,7 +293,7 @@ void CONTACT::LagrangeStrategyPoro::poro_initialize(
           std::make_shared<Core::LinAlg::SparseMatrix>(*falldofrowmap_, 1, true, false);
       (*porolinmmatrixtransform_)(*porolinmmatrix_, 1.0,
           Coupling::Adapter::CouplingMasterConverter(coupfs), *fporolinmmatrix_, false);
-      fporolinmmatrix_->complete(porolinmmatrix_->domain_map_not_epetra(), *fgmdofrowmap_);
+      fporolinmmatrix_->complete(porolinmmatrix_->domain_map(), *fgmdofrowmap_);
     }
     // porolinmmatrixtransform_ is no longer missing as twosided poro meshtying is considered!
     //
@@ -327,7 +327,7 @@ void CONTACT::LagrangeStrategyPoro::poro_initialize(
     fdhat_ = std::make_shared<Core::LinAlg::SparseMatrix>(*falldofrowmap_, 1, true, false);
     (*dhattransform_)(
         *dhat_, 1.0, Coupling::Adapter::CouplingMasterConverter(coupfs), *fdhat_, false);
-    fdhat_->complete(dhat_->domain_map_not_epetra(), *fgactivedofs_);
+    fdhat_->complete(dhat_->domain_map(), *fgactivedofs_);
     // fdhat is expected to be zero in this method but still used for condensation
     //
     //************************************************************************************************
@@ -381,7 +381,7 @@ void CONTACT::LagrangeStrategyPoro::poro_initialize(
       finvda_ = std::make_shared<Core::LinAlg::SparseMatrix>(*falldofrowmap_, 1, true, false);
       (*invDatransform_)(
           *invda_, 1.0, Coupling::Adapter::CouplingMasterConverter(coupfs), *finvda_, false);
-      finvda_->complete(invda_->domain_map_not_epetra(), *fgactivedofs_);
+      finvda_->complete(invda_->domain_map(), *fgactivedofs_);
     }
   }
 }  // CONTACT::LagrangeStrategyPoro::PoroInitialize
@@ -626,15 +626,15 @@ void CONTACT::LagrangeStrategyPoro::evaluate_mat_poro_no_pen(
     std::shared_ptr<Core::LinAlg::SparseMatrix> k_fs_mnadd =
         Core::LinAlg::matrix_multiply(*fmhataam_, true, *k_fs_an, false, false, false, true);
     k_fs_mnmod->add(*k_fs_mnadd, false, 1.0, 1.0);
-    k_fs_mnmod->complete(k_fs_mn->domain_map_not_epetra(), k_fs_mn->row_map());
+    k_fs_mnmod->complete(k_fs_mn->domain_map(), k_fs_mn->row_map());
 
     // kmm: add T(mhataam)*kam
     k_fs_mmmod = std::make_shared<Core::LinAlg::SparseMatrix>(*fgmdofrowmap_, 100);
     k_fs_mmmod->add(*k_fs_mm, false, 1.0, 1.0);
     std::shared_ptr<Core::LinAlg::SparseMatrix> k_fs_mmadd =
         Core::LinAlg::matrix_multiply(*fmhataam_, true, *k_fs_am, false, false, false, true);
     k_fs_mmmod->add(*k_fs_mmadd, false, 1.0, 1.0);
-    k_fs_mmmod->complete(k_fs_mm->domain_map_not_epetra(), k_fs_mm->row_map());
+    k_fs_mmmod->complete(k_fs_mm->domain_map(), k_fs_mm->row_map());
 
     // kmi: add T(mhataam)*kai
     if (iset)
@@ -644,7 +644,7 @@ void CONTACT::LagrangeStrategyPoro::evaluate_mat_poro_no_pen(
       std::shared_ptr<Core::LinAlg::SparseMatrix> k_fs_miadd =
           Core::LinAlg::matrix_multiply(*fmhataam_, true, *k_fs_ai, false, false, false, true);
       k_fs_mimod->add(*k_fs_miadd, false, 1.0, 1.0);
-      k_fs_mimod->complete(k_fs_mi->domain_map_not_epetra(), k_fs_mi->row_map());
+      k_fs_mimod->complete(k_fs_mi->domain_map(), k_fs_mi->row_map());
     }
 
     // kma: add T(mhataam)*kaa
@@ -655,7 +655,7 @@ void CONTACT::LagrangeStrategyPoro::evaluate_mat_poro_no_pen(
       std::shared_ptr<Core::LinAlg::SparseMatrix> k_fs_maadd =
           Core::LinAlg::matrix_multiply(*fmhataam_, true, *k_fs_aa, false, false, false, true);
       k_fs_mamod->add(*k_fs_maadd, false, 1.0, 1.0);
-      k_fs_mamod->complete(k_fs_ma->domain_map_not_epetra(), k_fs_ma->row_map());
+      k_fs_mamod->complete(k_fs_ma->domain_map(), k_fs_ma->row_map());
     }
   }
 
@@ -668,15 +668,15 @@ void CONTACT::LagrangeStrategyPoro::evaluate_mat_poro_no_pen(
   std::shared_ptr<Core::LinAlg::SparseMatrix> k_fs_inadd =
       Core::LinAlg::matrix_multiply(*fdhat_, true, *k_fs_an, false, false, false, true);
   k_fs_inmod.add(*k_fs_inadd, false, -1.0, 1.0);
-  k_fs_inmod.complete(k_fs_in->domain_map_not_epetra(), k_fs_in->row_map());
+  k_fs_inmod.complete(k_fs_in->domain_map(), k_fs_in->row_map());
 
   // kim: subtract T(dhat)*kam
   Core::LinAlg::SparseMatrix k_fs_immod(*fgidofs, 100);
   k_fs_immod.add(*k_fs_im, false, 1.0, 1.0);
   std::shared_ptr<Core::LinAlg::SparseMatrix> k_fs_imadd =
       Core::LinAlg::matrix_multiply(*fdhat_, true, *k_fs_am, false, false, false, true);
   k_fs_immod.add(*k_fs_imadd, false, -1.0, 1.0);
-  k_fs_immod.complete(k_fs_im->domain_map_not_epetra(), k_fs_im->row_map());
+  k_fs_immod.complete(k_fs_im->domain_map(), k_fs_im->row_map());
 
   // kii: subtract T(dhat)*kai
   std::shared_ptr<Core::LinAlg::SparseMatrix> k_fs_iimod;
@@ -687,7 +687,7 @@ void CONTACT::LagrangeStrategyPoro::evaluate_mat_poro_no_pen(
     std::shared_ptr<Core::LinAlg::SparseMatrix> k_fs_iiadd =
         Core::LinAlg::matrix_multiply(*fdhat_, true, *k_fs_ai, false, false, false, true);
     k_fs_iimod->add(*k_fs_iiadd, false, -1.0, 1.0);
-    k_fs_iimod->complete(k_fs_ii->domain_map_not_epetra(), k_fs_ii->row_map());
+    k_fs_iimod->complete(k_fs_ii->domain_map(), k_fs_ii->row_map());
   }
 
   // kia: subtract T(dhat)*kaa
@@ -699,7 +699,7 @@ void CONTACT::LagrangeStrategyPoro::evaluate_mat_poro_no_pen(
     std::shared_ptr<Core::LinAlg::SparseMatrix> k_fs_iaadd =
         Core::LinAlg::matrix_multiply(*fdhat_, true, *k_fs_aa, false, false, false, true);
     k_fs_iamod->add(*k_fs_iaadd, false, -1.0, 1.0);
-    k_fs_iamod->complete(k_fs_ia->domain_map_not_epetra(), k_fs_ia->row_map());
+    k_fs_iamod->complete(k_fs_ia->domain_map(), k_fs_ia->row_map());
   }
 
   //---------------------------------------------------------- FOURTH LINE
@@ -1058,7 +1058,7 @@ void CONTACT::LagrangeStrategyPoro::evaluate_other_mat_poro_no_pen(
         Core::LinAlg::matrix_multiply(*fmhataam_, true, *F_a, false, false, false, true);
     F_mmod.add(*F_madd, false, 1.0, 1.0);
   }
-  F_mmod.complete(F_m->domain_map_not_epetra(), F_m->row_map());
+  F_mmod.complete(F_m->domain_map(), F_m->row_map());
 
   //----------------------------------------------------------- THIRD LINE
   //------------------- FOR 3D QUADRATIC CASE ----------------------------
@@ -1075,7 +1075,7 @@ void CONTACT::LagrangeStrategyPoro::evaluate_other_mat_poro_no_pen(
         Core::LinAlg::matrix_multiply(*fdhat_, true, *F_a, false, false, false, true);
     F_imod.add(*F_iadd, false, -1.0, 1.0);
   }
-  F_imod.complete(F_i->domain_map_not_epetra(), F_i->row_map());
+  F_imod.complete(F_i->domain_map(), F_i->row_map());
 
   //---------------------------------------------------------- FOURTH LINE
   // nothing to do
@@ -1582,8 +1582,8 @@ void CONTACT::LagrangeStrategyPoro::poro_mt_update()
   // set dold_ mold_ and lambdaold_ after every time step
   dold_ = std::make_shared<Core::LinAlg::SparseMatrix>(*dmatrix_);
   mold_ = std::make_shared<Core::LinAlg::SparseMatrix>(*mmatrix_);
-  dold_->complete(dmatrix_->domain_map_not_epetra(), dmatrix_->range_map());
-  mold_->complete(mmatrix_->domain_map_not_epetra(), mmatrix_->range_map());
+  dold_->complete(dmatrix_->domain_map(), dmatrix_->range_map());
+  mold_->complete(mmatrix_->domain_map(), mmatrix_->range_map());
   update_poro_contact();
 }  // CONTACT::LagrangeStrategyPoro::PoroMtUpdate()
 

src/contact/4C_contact_meshtying_lagrange_strategy.cpp

@@ -498,7 +498,7 @@ void CONTACT::MtLagrangeStrategy::evaluate_meshtying(
       std::shared_ptr<Core::LinAlg::SparseMatrix> knmadd =
           Core::LinAlg::matrix_multiply(*kns, false, *mhatmatrix_, false, false, false, true);
       knmmod->add(*knmadd, false, 1.0, 1.0);
-      knmmod->complete(knm->domain_map_not_epetra(), knm->row_map());
+      knmmod->complete(knm->domain_map(), knm->row_map());
     }
 
     // kmn: add T(mbar)*ksn
@@ -508,7 +508,7 @@ void CONTACT::MtLagrangeStrategy::evaluate_meshtying(
     std::shared_ptr<Core::LinAlg::SparseMatrix> kmnadd =
         Core::LinAlg::matrix_multiply(*mhatmatrix_, true, *ksn, false, false, false, true);
     kmnmod->add(*kmnadd, false, 1.0, 1.0);
-    kmnmod->complete(kmn->domain_map_not_epetra(), kmn->row_map());
+    kmnmod->complete(kmn->domain_map(), kmn->row_map());
 
     // kmm: add T(mbar)*ksm
     std::shared_ptr<Core::LinAlg::SparseMatrix> kmmmod =
@@ -529,7 +529,7 @@ void CONTACT::MtLagrangeStrategy::evaluate_meshtying(
           Core::LinAlg::matrix_multiply(*mhatmatrix_, true, *kmmtemp, false, false, false, true);
       kmmmod->add(*kmmadd3, false, 1.0, 1.0);
     }
-    kmmmod->complete(kmm->domain_map_not_epetra(), kmm->row_map());
+    kmmmod->complete(kmm->domain_map(), kmm->row_map());
 
     // some modifications for kns, kms, (,ksn) ksm, kss if slave displacement increment is not
     // condensed
@@ -545,7 +545,7 @@ void CONTACT::MtLagrangeStrategy::evaluate_meshtying(
       std::shared_ptr<Core::LinAlg::SparseMatrix> kmsadd =
           Core::LinAlg::matrix_multiply(*mhatmatrix_, true, *kss, false, false, false, true);
       kmsmod->add(*kmsadd, false, 1.0, 1.0);
-      kmsmod->complete(kms->domain_map_not_epetra(), kms->row_map());
+      kmsmod->complete(kms->domain_map(), kms->row_map());
     }
 
     // (ksn: do nothing as block is supposed to remain zero)
@@ -556,7 +556,7 @@ void CONTACT::MtLagrangeStrategy::evaluate_meshtying(
     {
       ksmmod = std::make_shared<Core::LinAlg::SparseMatrix>(*gsdofrowmap_, 100);
       ksmmod->add(*mmatrix_, false, -1.0, 1.0);  //<---- causes problems in parallel
-      ksmmod->complete(ksm->domain_map_not_epetra(), ksm->row_map());
+      ksmmod->complete(ksm->domain_map(), ksm->row_map());
     }
 
     // kss: add dmatrix
@@ -565,7 +565,7 @@ void CONTACT::MtLagrangeStrategy::evaluate_meshtying(
     {
       kssmod = std::make_shared<Core::LinAlg::SparseMatrix>(*gsdofrowmap_, 100);
       kssmod->add(*dmatrix_, false, 1.0, 1.0);  //<---- causes problems in parallel
-      kssmod->complete(kss->domain_map_not_epetra(), kss->row_map());
+      kssmod->complete(kss->domain_map(), kss->row_map());
     }
 
     // fn: subtract kns*inv(D)*g

src/contact/4C_contact_nox_nln_contact_linearsystem.cpp

@@ -393,8 +393,7 @@ void NOX::Nln::CONTACT::LinearSystem::LinearSubProblem::extract_active_blocks(
       p_rhs_ = Teuchos::rcp(
           Core::LinAlg::extract_my_vector(rhs, active_sparse_mat->range_map()).release());
       p_lhs_ = Teuchos::rcp(
-          Core::LinAlg::extract_my_vector(lhs, active_sparse_mat->domain_map_not_epetra())
-              .release());
+          Core::LinAlg::extract_my_vector(lhs, active_sparse_mat->domain_map()).release());
 
       break;
     }

src/core/linalg/src/sparse/4C_linalg_blocksparsematrix.hpp

@@ -138,15 +138,7 @@ namespace Core::LinAlg
 
     /// total matrix domain map with all blocks (this is needed for
     /// consistency with Core::LinAlg::SparseMatrix)
-    const Epetra_Map& domain_map() const override
-    {
-      return domainmaps_.full_map()->get_epetra_map();
-    }
-
-    const Core::LinAlg::Map& domain_map_not_epetra() const override
-    {
-      return *domainmaps_.full_map();
-    }
+    const Map& domain_map() const override { return *domainmaps_.full_map(); }
 
     /// total matrix row map with all blocks
     /*!

src/core/linalg/src/sparse/4C_linalg_sparsematrixbase.hpp

@@ -126,10 +126,7 @@ namespace Core::LinAlg
     }
 
     /// Returns the Epetra_Map object associated with the domain of this matrix operator.
-    const Epetra_Map& domain_map() const override { return sysmat_->DomainMap(); }
-
-    /// This is stupid: domain_map must be inherited, therefore we need rename the domain map
-    const Core::LinAlg::Map& domain_map_not_epetra() const override
+    const Map& domain_map() const override
     {
       if (!domain_map_)
       {  // check if view is uninitialized
@@ -138,6 +135,7 @@ namespace Core::LinAlg
       return *domain_map_;
     }
 
+
     /// Returns the Epetra_Map object associated with the range of this matrix operator.
     const Core::LinAlg::Map& range_map() const
     {

src/core/linalg/src/sparse/4C_linalg_sparseoperator.hpp

@@ -226,9 +226,7 @@ namespace Core::LinAlg
         const Core::LinAlg::SparseMatrix* trafo = nullptr) const = 0;
 
     /// Returns the Epetra_Map object associated with the (full) domain of this operator.
-    virtual const Epetra_Map& domain_map() const = 0;
-
-    virtual const Map& domain_map_not_epetra() const = 0;
+    virtual const Map& domain_map() const = 0;
 
     /// Add one operator to another
     virtual void add(const Core::LinAlg::SparseOperator& A, const bool transposeA,

src/core/linalg/src/sparse/4C_linalg_utils_sparse_algebra_manipulation.cpp

@@ -363,9 +363,9 @@ bool Core::LinAlg::split_matrix2x2(std::shared_ptr<Core::LinAlg::SparseMatrix> A
 
   // check and complete input domain maps
   if (A11domainmap == nullptr && A22domainmap != nullptr)
-    A11domainmap = Core::LinAlg::split_map(A->domain_map_not_epetra(), *A22domainmap);
+    A11domainmap = Core::LinAlg::split_map(A->domain_map(), *A22domainmap);
   else if (A11domainmap != nullptr && A22domainmap == nullptr)
-    A22domainmap = Core::LinAlg::split_map(A->domain_map_not_epetra(), *A11domainmap);
+    A22domainmap = Core::LinAlg::split_map(A->domain_map(), *A11domainmap);
   else if (A11rowmap == nullptr && A22rowmap == nullptr)
     FOUR_C_THROW("Both A11domainmap and A22domainmap == null on entry");
 
@@ -377,7 +377,7 @@ bool Core::LinAlg::split_matrix2x2(std::shared_ptr<Core::LinAlg::SparseMatrix> A
   domainmaps[0] = std::make_shared<Core::LinAlg::Map>(*A11domainmap);
   domainmaps[1] = std::make_shared<Core::LinAlg::Map>(*A22domainmap);
   Core::LinAlg::MultiMapExtractor range(A->range_map(), rangemaps);
-  Core::LinAlg::MultiMapExtractor domain(A->domain_map_not_epetra(), domainmaps);
+  Core::LinAlg::MultiMapExtractor domain(A->domain_map(), domainmaps);
 
   std::shared_ptr<BlockSparseMatrix<DefaultBlockMatrixStrategy>> Ablock =
       Core::LinAlg::split_matrix<DefaultBlockMatrixStrategy>(*A, domain, range);
@@ -514,16 +514,14 @@ void Core::LinAlg::split_matrixmxn(
     const int colgid = ASparse.domain_map().GID(collid);
     if (colgid < 0) FOUR_C_THROW("Couldn't find local column ID {} in domain map!", collid);
 
-    int n(0);
-    for (n = 0; n < N; ++n)
+    for (int n = 0; n < N; ++n)
     {
       if (ABlock.domain_map(n).MyGID(colgid))
       {
         dselector[collid] = n;
         break;
       }
     }
-    if (n == N) FOUR_C_THROW("Matrix column was not found in BlockSparseMatrixBase!");
   }
   Core::LinAlg::Vector<double> selector(A.ColMap());
   Core::LinAlg::export_to(dselector, selector);