Remove utils namespace

Author: bwirthl

src/porofluid_pressure_based/4C_porofluid_pressure_based_dyn.cpp

@@ -86,7 +86,7 @@ void porofluidmultiphase_dyn(int restart)
       case Inpar::ArteryNetwork::ArteryPoroMultiphaseScatraCouplingMethod::ntp:
       {
         actdis->fill_complete();
-        nearbyelepairs = POROFLUIDMULTIPHASE::Utils::extended_ghosting_artery_discretization(
+        nearbyelepairs = POROFLUIDMULTIPHASE::extended_ghosting_artery_discretization(
             *actdis, arterydis, evaluate_on_lateral_surface, arterycoupl);
         break;
       }
@@ -123,7 +123,7 @@ void porofluidmultiphase_dyn(int restart)
       Teuchos::getIntegralValue<POROFLUIDMULTIPHASE::TimeIntegrationScheme>(porodyn, "TIMEINTEGR");
 
   // build poro fluid time integrator
-  std::shared_ptr<Adapter::PoroFluidMultiphase> algo = POROFLUIDMULTIPHASE::Utils::create_algorithm(
+  std::shared_ptr<Adapter::PoroFluidMultiphase> algo = POROFLUIDMULTIPHASE::create_algorithm(
       timintscheme, actdis, linsolvernumber, porodyn, porodyn, output);
 
   // initialize
@@ -140,7 +140,7 @@ void porofluidmultiphase_dyn(int restart)
   // assign poro material for evaluation of porosity
   // note: to be done after potential restart, as in read_restart()
   //       the secondary material is destroyed
-  POROFLUIDMULTIPHASE::Utils::setup_material(comm, struct_disname, fluid_disname);
+  POROFLUIDMULTIPHASE::setup_material(comm, struct_disname, fluid_disname);
 
   // 4.- Run of the actual problem.
   algo->time_loop();

src/porofluid_pressure_based/4C_porofluid_pressure_based_meshtying_strategy_artery.cpp

@@ -86,7 +86,7 @@ POROFLUIDMULTIPHASE::MeshtyingStrategyArtery::MeshtyingStrategyArtery(
       });
 
   // initialize mesh tying object
-  arttoporofluidcoupling_ = PoroMultiPhaseScaTra::Utils::create_and_init_artery_coupling_strategy(
+  arttoporofluidcoupling_ = PoroMultiPhaseScaTra::create_and_init_artery_coupling_strategy(
       arterydis_, porofluidmultitimint->discretization(), poroparams.sublist("ARTERY COUPLING"),
       couplingcondname, "COUPLEDDOFS_ART", "COUPLEDDOFS_PORO", evaluate_on_lateral_surface);
 
@@ -219,25 +219,25 @@ void POROFLUIDMULTIPHASE::MeshtyingStrategyArtery::calculate_norms(std::vector<d
   incprenorm.resize(2);
   prenorm.resize(2);
 
-  prenorm[0] = Utils::calculate_vector_norm(vectornorminc_, *porofluidmultitimint_->phinp());
-  prenorm[1] = Utils::calculate_vector_norm(vectornorminc_, *artnettimint_->pressurenp());
+  prenorm[0] = calculate_vector_norm(vectornorminc_, *porofluidmultitimint_->phinp());
+  prenorm[1] = calculate_vector_norm(vectornorminc_, *artnettimint_->pressurenp());
 
   std::shared_ptr<const Core::LinAlg::Vector<double>> arterypressinc;
   std::shared_ptr<const Core::LinAlg::Vector<double>> porofluidinc;
 
   arttoporofluidcoupling_->extract_single_field_vectors(
       comb_increment_, porofluidinc, arterypressinc);
 
-  incprenorm[0] = Utils::calculate_vector_norm(vectornorminc_, *porofluidinc);
-  incprenorm[1] = Utils::calculate_vector_norm(vectornorminc_, *arterypressinc);
+  incprenorm[0] = calculate_vector_norm(vectornorminc_, *porofluidinc);
+  incprenorm[1] = calculate_vector_norm(vectornorminc_, *arterypressinc);
 
   std::shared_ptr<const Core::LinAlg::Vector<double>> arterypressrhs;
   std::shared_ptr<const Core::LinAlg::Vector<double>> porofluidrhs;
 
   arttoporofluidcoupling_->extract_single_field_vectors(rhs_, porofluidrhs, arterypressrhs);
 
-  preresnorm[0] = Utils::calculate_vector_norm(vectornormfres_, *porofluidrhs);
-  preresnorm[1] = Utils::calculate_vector_norm(vectornormfres_, *arterypressrhs);
+  preresnorm[0] = calculate_vector_norm(vectornormfres_, *porofluidrhs);
+  preresnorm[1] = calculate_vector_norm(vectornormfres_, *arterypressrhs);
 
   return;
 }

src/porofluid_pressure_based/4C_porofluid_pressure_based_meshtying_strategy_std.cpp

@@ -78,9 +78,9 @@ void POROFLUIDMULTIPHASE::MeshtyingStrategyStd::calculate_norms(std::vector<doub
   incprenorm.resize(1);
   prenorm.resize(1);
 
-  preresnorm[0] = Utils::calculate_vector_norm(vectornormfres_, *porofluidmultitimint_->rhs());
-  incprenorm[0] = Utils::calculate_vector_norm(vectornorminc_, *increment);
-  prenorm[0] = Utils::calculate_vector_norm(vectornorminc_, *porofluidmultitimint_->phinp());
+  preresnorm[0] = calculate_vector_norm(vectornormfres_, *porofluidmultitimint_->rhs());
+  incprenorm[0] = calculate_vector_norm(vectornorminc_, *increment);
+  prenorm[0] = calculate_vector_norm(vectornorminc_, *porofluidmultitimint_->phinp());
 
   return;
 }

src/porofluid_pressure_based/4C_porofluid_pressure_based_timint_implicit.cpp

@@ -634,7 +634,7 @@ void POROFLUIDMULTIPHASE::TimIntImpl::collect_runtime_output_data()
   {
     // convert dof-based Epetra vector into node-based Epetra multi-vector for postprocessing
     std::shared_ptr<Core::LinAlg::MultiVector<double>> solidpressure_multi =
-        POROFLUIDMULTIPHASE::Utils::convert_dof_vector_to_node_based_multi_vector(
+        POROFLUIDMULTIPHASE::convert_dof_vector_to_node_based_multi_vector(
             *discret_, *solidpressure_, nds_solidpressure_, 1);
 
     visualization_writer_->append_result_data_vector_with_context(
@@ -650,7 +650,7 @@ void POROFLUIDMULTIPHASE::TimIntImpl::collect_runtime_output_data()
 
     // convert dof-based Epetra vector into node-based Epetra multi-vector for postprocessing
     std::shared_ptr<Core::LinAlg::MultiVector<double>> dispnp_multi =
-        POROFLUIDMULTIPHASE::Utils::convert_dof_vector_to_node_based_multi_vector(
+        POROFLUIDMULTIPHASE::convert_dof_vector_to_node_based_multi_vector(
             *discret_, *dispnp, nds_disp_, nsd_);
 
     std::vector<std::optional<std::string>> context(nsd_, "ale-displacement");
@@ -721,7 +721,7 @@ void POROFLUIDMULTIPHASE::TimIntImpl::collect_runtime_output_data()
   {
     // convert dof-based Epetra vector into node-based Epetra multi-vector for postprocessing
     std::shared_ptr<Core::LinAlg::MultiVector<double>> porosity_multi =
-        POROFLUIDMULTIPHASE::Utils::convert_dof_vector_to_node_based_multi_vector(
+        POROFLUIDMULTIPHASE::convert_dof_vector_to_node_based_multi_vector(
             *discret_, *porosity_, nds_solidpressure_, 1);
 
     visualization_writer_->append_result_data_vector_with_context(

src/porofluid_pressure_based/4C_porofluid_pressure_based_utils.cpp

@@ -65,7 +65,7 @@ namespace
 
 /*----------------------------------------------------------------------*/
 /*----------------------------------------------------------------------*/
-void POROFLUIDMULTIPHASE::Utils::setup_material(
+void POROFLUIDMULTIPHASE::setup_material(
     MPI_Comm comm, const std::string& struct_disname, const std::string& fluid_disname)
 {
   // get the fluid discretization
@@ -131,7 +131,7 @@ void POROFLUIDMULTIPHASE::Utils::setup_material(
 /*----------------------------------------------------------------------*/
 /*----------------------------------------------------------------------*/
 std::shared_ptr<Core::LinAlg::MultiVector<double>>
-POROFLUIDMULTIPHASE::Utils::convert_dof_vector_to_node_based_multi_vector(
+POROFLUIDMULTIPHASE::convert_dof_vector_to_node_based_multi_vector(
     const Core::FE::Discretization& dis, const Core::LinAlg::Vector<double>& vector, const int nds,
     const int numdofpernode)
 {
@@ -158,7 +158,7 @@ POROFLUIDMULTIPHASE::Utils::convert_dof_vector_to_node_based_multi_vector(
 /*----------------------------------------------------------------------*
  | create algorithm                                                      |
  *----------------------------------------------------------------------*/
-std::shared_ptr<Adapter::PoroFluidMultiphase> POROFLUIDMULTIPHASE::Utils::create_algorithm(
+std::shared_ptr<Adapter::PoroFluidMultiphase> POROFLUIDMULTIPHASE::create_algorithm(
     POROFLUIDMULTIPHASE::TimeIntegrationScheme timintscheme,
     std::shared_ptr<Core::FE::Discretization> dis, const int linsolvernumber,
     const Teuchos::ParameterList& probparams, const Teuchos::ParameterList& poroparams,
@@ -192,7 +192,7 @@ std::shared_ptr<Adapter::PoroFluidMultiphase> POROFLUIDMULTIPHASE::Utils::create
 /*--------------------------------------------------------------------------*
  | perform extended ghosting for artery dis                kremheller 03/19 |
  *--------------------------------------------------------------------------*/
-std::map<int, std::set<int>> POROFLUIDMULTIPHASE::Utils::extended_ghosting_artery_discretization(
+std::map<int, std::set<int>> POROFLUIDMULTIPHASE::extended_ghosting_artery_discretization(
     Core::FE::Discretization& contdis, std::shared_ptr<Core::FE::Discretization> artdis,
     const bool evaluate_on_lateral_surface,
     const Inpar::ArteryNetwork::ArteryPoroMultiphaseScatraCouplingMethod couplingmethod)
@@ -287,7 +287,7 @@ std::map<int, std::set<int>> POROFLUIDMULTIPHASE::Utils::extended_ghosting_arter
  | create the fully overlapping artery discretization      kremheller 03/19 |
  *--------------------------------------------------------------------------*/
 std::shared_ptr<Core::FE::Discretization>
-POROFLUIDMULTIPHASE::Utils::create_fully_overlapping_artery_discretization(
+POROFLUIDMULTIPHASE::create_fully_overlapping_artery_discretization(
     Core::FE::Discretization& artdis, std::string disname, bool doboundaryconditions)
 {
   // we clone a search discretization of the artery discretization on which the search will be
@@ -305,10 +305,10 @@ POROFLUIDMULTIPHASE::Utils::create_fully_overlapping_artery_discretization(
 
 /*----------------------------------------------------------------------*
  *----------------------------------------------------------------------*/
-std::map<int, std::set<int>> POROFLUIDMULTIPHASE::Utils::oct_tree_search(
-    Core::FE::Discretization& contdis, Core::FE::Discretization& artdis,
-    Core::FE::Discretization& artsearchdis, const bool evaluate_on_lateral_surface,
-    const std::vector<int> artEleGIDs, std::set<int>& elecolset, std::set<int>& nodecolset)
+std::map<int, std::set<int>> POROFLUIDMULTIPHASE::oct_tree_search(Core::FE::Discretization& contdis,
+    Core::FE::Discretization& artdis, Core::FE::Discretization& artsearchdis,
+    const bool evaluate_on_lateral_surface, const std::vector<int> artEleGIDs,
+    std::set<int>& elecolset, std::set<int>& nodecolset)
 {
   // this map will be filled
   std::map<int, std::set<int>> nearbyelepairs;
@@ -401,7 +401,7 @@ std::map<int, std::set<int>> POROFLUIDMULTIPHASE::Utils::oct_tree_search(
 /*----------------------------------------------------------------------*
  | get axis-aligned bounding box of element            kremheller 03/19 |
  *----------------------------------------------------------------------*/
-Core::LinAlg::Matrix<3, 2> POROFLUIDMULTIPHASE::Utils::get_aabb(Core::Elements::Element* ele,
+Core::LinAlg::Matrix<3, 2> POROFLUIDMULTIPHASE::get_aabb(Core::Elements::Element* ele,
     std::map<int, Core::LinAlg::Matrix<3, 1>>& positions, const bool evaluate_on_lateral_surface)
 {
   const Core::LinAlg::SerialDenseMatrix xyze_element(
@@ -432,7 +432,7 @@ Core::LinAlg::Matrix<3, 2> POROFLUIDMULTIPHASE::Utils::get_aabb(Core::Elements::
 /*----------------------------------------------------------------------*
  | get nodal positions                                 kremheller 10/19 |
  *----------------------------------------------------------------------*/
-std::map<int, Core::LinAlg::Matrix<3, 1>> POROFLUIDMULTIPHASE::Utils::get_nodal_positions(
+std::map<int, Core::LinAlg::Matrix<3, 1>> POROFLUIDMULTIPHASE::get_nodal_positions(
     Core::FE::Discretization& dis, const Core::LinAlg::Map* nodemap)
 {
   std::map<int, Core::LinAlg::Matrix<3, 1>> positions;
@@ -453,7 +453,7 @@ std::map<int, Core::LinAlg::Matrix<3, 1>> POROFLUIDMULTIPHASE::Utils::get_nodal_
 /*----------------------------------------------------------------------*
  | get maximum nodal distance                          kremheller 05/18 |
  *----------------------------------------------------------------------*/
-double POROFLUIDMULTIPHASE::Utils::get_max_nodal_distance(
+double POROFLUIDMULTIPHASE::get_max_nodal_distance(
     Core::Elements::Element* ele, Core::FE::Discretization& dis)
 {
   double maxdist = 0.0;
@@ -493,7 +493,7 @@ double POROFLUIDMULTIPHASE::Utils::get_max_nodal_distance(
 /*----------------------------------------------------------------------*
  | calculate vector norm                             kremheller 12/17   |
  *----------------------------------------------------------------------*/
-double POROFLUIDMULTIPHASE::Utils::calculate_vector_norm(
+double POROFLUIDMULTIPHASE::calculate_vector_norm(
     const enum POROFLUIDMULTIPHASE::VectorNorm norm, const Core::LinAlg::Vector<double>& vect)
 {
   // L1 norm