Merge branch 'import_media_to_BC' into 'master'

[WellboreSimulator-part2] Import media into BC implementation. See merge request ogs/ogs!4659
ufz · Aug 15, 2023 · 25782d0 · 25782d0
2 parents 828e4e0 + 303e7a4
commit 25782d0
Show file tree

Hide file tree

Showing 28 changed files with 123 additions and 62 deletions.
diff --git a/Applications/ApplicationsLib/ProjectData.h b/Applications/ApplicationsLib/ProjectData.h
@@ -91,6 +91,12 @@ class ProjectData final
 
     MeshLib::Mesh* getMesh(std::string const& mesh_name) const;
 
+    std::map<int, std::shared_ptr<MaterialPropertyLib::Medium>> const&
+    getMedia() const
+    {
+        return _media;
+    }
+
 private:
     /// Parses the process variables configuration and creates new variables for
     /// each variable entry passing the corresponding subtree to the process

diff --git a/Applications/ApplicationsLib/Simulation.cpp b/Applications/ApplicationsLib/Simulation.cpp
@@ -101,7 +101,7 @@ void Simulation::initializeDataStructures(
     INFO("Initialize processes.");
     for (auto& p : project_data->getProcesses())
     {
-        p->initialize();
+        p->initialize(project_data->getMedia());
     }
 
     // Check intermediately that config parsing went fine.

diff --git a/ProcessLib/BoundaryConditionAndSourceTerm/BoundaryConditionCollection.cpp b/ProcessLib/BoundaryConditionAndSourceTerm/BoundaryConditionCollection.cpp
@@ -26,16 +26,17 @@ void BoundaryConditionCollection::addBCsForProcessVariables(
     std::vector<std::reference_wrapper<ProcessVariable>> const&
         process_variables,
     NumLib::LocalToGlobalIndexMap const& dof_table,
-    unsigned const integration_order, Process const& process)
+    unsigned const integration_order, Process const& process,
+    std::map<int, std::shared_ptr<MaterialPropertyLib::Medium>> const& media)
 {
     for (int variable_id = 0;
          variable_id < static_cast<int>(process_variables.size());
          ++variable_id)
     {
         ProcessVariable& pv = process_variables[variable_id];
-        auto bcs = pv.createBoundaryConditions(dof_table, variable_id,
-                                               integration_order, _parameters,
-                                               process, process_variables);
+        auto bcs = pv.createBoundaryConditions(
+            dof_table, variable_id, integration_order, _parameters, process,
+            process_variables, media);
 
         std::move(bcs.begin(), bcs.end(),
                   std::back_inserter(_boundary_conditions));

diff --git a/ProcessLib/BoundaryConditionAndSourceTerm/BoundaryConditionCollection.h b/ProcessLib/BoundaryConditionAndSourceTerm/BoundaryConditionCollection.h
@@ -11,6 +11,7 @@
 #pragma once
 
 #include "BoundaryCondition.h"
+#include "MaterialLib/MPL/Medium.h"
 #include "NumLib/IndexValueVector.h"
 #include "ProcessLib/ProcessVariable.h"
 
@@ -47,7 +48,9 @@ class BoundaryConditionCollection final
         std::vector<std::reference_wrapper<ProcessVariable>> const&
             process_variables,
         NumLib::LocalToGlobalIndexMap const& dof_table,
-        unsigned const integration_order, Process const& process);
+        unsigned const integration_order, Process const& process,
+        std::map<int, std::shared_ptr<MaterialPropertyLib::Medium>> const&
+            media);
 
     void addBoundaryCondition(std::unique_ptr<BoundaryCondition>&& bc)
     {

diff --git a/ProcessLib/BoundaryConditionAndSourceTerm/CreateBoundaryCondition.cpp b/ProcessLib/BoundaryConditionAndSourceTerm/CreateBoundaryCondition.cpp
@@ -36,7 +36,9 @@ std::unique_ptr<BoundaryCondition> createBoundaryCondition(
     const std::vector<std::unique_ptr<ParameterLib::ParameterBase>>& parameters,
     const Process& process,
     [[maybe_unused]] std::vector<std::reference_wrapper<ProcessVariable>> const&
-        all_process_variables_for_this_process)
+        all_process_variables_for_this_process,
+    std::map<int,
+             std::shared_ptr<MaterialPropertyLib::Medium>> const& /*media*/)
 {
     // Surface mesh and bulk mesh must have equal axial symmetry flags!
     if (config.boundary_mesh.isAxiallySymmetric() !=

diff --git a/ProcessLib/BoundaryConditionAndSourceTerm/CreateBoundaryCondition.h b/ProcessLib/BoundaryConditionAndSourceTerm/CreateBoundaryCondition.h
@@ -13,6 +13,7 @@
 #include <memory>
 #include <vector>
 
+#include "MaterialLib/MPL/CreateMaterialSpatialDistributionMap.h"
 namespace MeshLib
 {
 class Mesh;
@@ -41,6 +42,7 @@ std::unique_ptr<BoundaryCondition> createBoundaryCondition(
     const std::vector<std::unique_ptr<ParameterLib::ParameterBase>>& parameters,
     const Process& process,
     std::vector<std::reference_wrapper<ProcessVariable>> const&
-        all_process_variables_for_this_process);
+        all_process_variables_for_this_process,
+    std::map<int, std::shared_ptr<MaterialPropertyLib::Medium>> const& media);
 
 }  // namespace ProcessLib
diff --git a/ProcessLib/HydroMechanics/HydroMechanicsProcess.cpp b/ProcessLib/HydroMechanics/HydroMechanicsProcess.cpp
@@ -258,26 +258,28 @@ void HydroMechanicsProcess<DisplacementDim>::initializeConcreteProcess(
 }
 
 template <int DisplacementDim>
-void HydroMechanicsProcess<DisplacementDim>::initializeBoundaryConditions()
+void HydroMechanicsProcess<DisplacementDim>::initializeBoundaryConditions(
+    std::map<int, std::shared_ptr<MaterialPropertyLib::Medium>> const& media)
 {
     if (_process_data.isMonolithicSchemeUsed())
     {
         const int process_id_of_hydromechanics = 0;
         initializeProcessBoundaryConditionsAndSourceTerms(
-            *_local_to_global_index_map, process_id_of_hydromechanics);
+            *_local_to_global_index_map, process_id_of_hydromechanics, media);
         return;
     }
 
     // Staggered scheme:
     // for the equations of pressure
     const int hydraulic_process_id = 0;
     initializeProcessBoundaryConditionsAndSourceTerms(
-        *_local_to_global_index_map_with_base_nodes, hydraulic_process_id);
+        *_local_to_global_index_map_with_base_nodes, hydraulic_process_id,
+        media);
 
     // for the equations of deformation.
     const int mechanical_process_id = 1;
     initializeProcessBoundaryConditionsAndSourceTerms(
-        *_local_to_global_index_map, mechanical_process_id);
+        *_local_to_global_index_map, mechanical_process_id, media);
 }
 
 template <int DisplacementDim>

diff --git a/ProcessLib/HydroMechanics/HydroMechanicsProcess.h b/ProcessLib/HydroMechanics/HydroMechanicsProcess.h
@@ -71,7 +71,9 @@ class HydroMechanicsProcess final : public Process
         MeshLib::Mesh const& mesh,
         unsigned const integration_order) override;
 
-    void initializeBoundaryConditions() override;
+    void initializeBoundaryConditions(
+        std::map<int, std::shared_ptr<MaterialPropertyLib::Medium>> const&
+            media) override;
 
     void assembleConcreteProcess(const double t, double const /*dt*/,
                                  std::vector<GlobalVector*> const& x,

diff --git a/ProcessLib/PhaseField/PhaseFieldProcess.cpp b/ProcessLib/PhaseField/PhaseFieldProcess.cpp
@@ -166,17 +166,19 @@ void PhaseFieldProcess<DisplacementDim>::initializeConcreteProcess(
 }
 
 template <int DisplacementDim>
-void PhaseFieldProcess<DisplacementDim>::initializeBoundaryConditions()
+void PhaseFieldProcess<DisplacementDim>::initializeBoundaryConditions(
+    std::map<int, std::shared_ptr<MaterialPropertyLib::Medium>> const& media)
 {
     // Staggered scheme:
     // for the equations of deformation.
     const int mechanical_process_id = 0;
     initializeProcessBoundaryConditionsAndSourceTerms(
-        *_local_to_global_index_map, mechanical_process_id);
+        *_local_to_global_index_map, mechanical_process_id, media);
     // for the phase field
     const int phasefield_process_id = 1;
     initializeProcessBoundaryConditionsAndSourceTerms(
-        *_local_to_global_index_map_single_component, phasefield_process_id);
+        *_local_to_global_index_map_single_component, phasefield_process_id,
+        media);
 }
 
 template <int DisplacementDim>

diff --git a/ProcessLib/PhaseField/PhaseFieldProcess.h b/ProcessLib/PhaseField/PhaseFieldProcess.h
@@ -52,7 +52,9 @@ class PhaseFieldProcess final : public Process
 
     void constructDofTable() override;
 
-    void initializeBoundaryConditions() override;
+    void initializeBoundaryConditions(
+        std::map<int, std::shared_ptr<MaterialPropertyLib::Medium>> const&
+            media) override;
 
     void initializeConcreteProcess(
         NumLib::LocalToGlobalIndexMap const& dof_table,

diff --git a/ProcessLib/Process.cpp b/ProcessLib/Process.cpp
@@ -68,20 +68,22 @@ Process::Process(
 }
 
 void Process::initializeProcessBoundaryConditionsAndSourceTerms(
-    const NumLib::LocalToGlobalIndexMap& dof_table, const int process_id)
+    const NumLib::LocalToGlobalIndexMap& dof_table, const int process_id,
+    std::map<int, std::shared_ptr<MaterialPropertyLib::Medium>> const& media)
 {
     auto const& per_process_variables = _process_variables[process_id];
     auto& per_process_BCs = _boundary_conditions[process_id];
 
     per_process_BCs.addBCsForProcessVariables(per_process_variables, dof_table,
-                                              _integration_order, *this);
+                                              _integration_order, *this, media);
 
     auto& per_process_sts = _source_term_collections[process_id];
     per_process_sts.addSourceTermsForProcessVariables(
         per_process_variables, dof_table, _integration_order);
 }
 
-void Process::initializeBoundaryConditions()
+void Process::initializeBoundaryConditions(
+    std::map<int, std::shared_ptr<MaterialPropertyLib::Medium>> const& media)
 {
     // The number of processes is identical to the size of _process_variables,
     // the vector contains variables for different processes. See the
@@ -90,11 +92,12 @@ void Process::initializeBoundaryConditions()
     for (std::size_t pcs_id = 0; pcs_id < number_of_processes; pcs_id++)
     {
         initializeProcessBoundaryConditionsAndSourceTerms(
-            *_local_to_global_index_map, pcs_id);
+            *_local_to_global_index_map, pcs_id, media);
     }
 }
 
-void Process::initialize()
+void Process::initialize(
+    std::map<int, std::shared_ptr<MaterialPropertyLib::Medium>> const& media)
 {
     DBUG("Initialize process.");
 
@@ -111,7 +114,7 @@ void Process::initialize()
                               _integration_order);
 
     DBUG("Initialize boundary conditions.");
-    initializeBoundaryConditions();
+    initializeBoundaryConditions(media);
 }
 
 void Process::setInitialConditions(

diff --git a/ProcessLib/Process.h b/ProcessLib/Process.h
@@ -14,6 +14,7 @@
 #include <tuple>
 
 #include "AbstractJacobianAssembler.h"
+#include "MaterialLib/MPL/Medium.h"
 #include "MathLib/LinAlg/GlobalMatrixVectorTypes.h"
 #include "MeshLib/Utils/IntegrationPointWriter.h"
 #include "NumLib/ODESolver/NonlinearSolver.h"
@@ -87,7 +88,9 @@ class Process
 
     NumLib::IterationResult postIteration(GlobalVector const& x) final;
 
-    void initialize();
+    void initialize(
+        std::map<int, std::shared_ptr<MaterialPropertyLib::Medium>> const&
+            media);
 
     void setInitialConditions(
         std::vector<GlobalVector*>& process_solutions,
@@ -205,7 +208,9 @@ class Process
      * initializeBoundaryConditions().
      */
     void initializeProcessBoundaryConditionsAndSourceTerms(
-        const NumLib::LocalToGlobalIndexMap& dof_table, const int process_id);
+        const NumLib::LocalToGlobalIndexMap& dof_table, const int process_id,
+        std::map<int, std::shared_ptr<MaterialPropertyLib::Medium>> const&
+            media);
 
 private:
     /// Process specific initialization called by initialize().
@@ -216,7 +221,9 @@ class Process
 
     /// Member function to initialize the boundary conditions for all coupled
     /// processes. It is called by initialize().
-    virtual void initializeBoundaryConditions();
+    virtual void initializeBoundaryConditions(
+        std::map<int, std::shared_ptr<MaterialPropertyLib::Medium>> const&
+            media);
 
     virtual void setInitialConditionsConcreteProcess(
         std::vector<GlobalVector*>& /*x*/,

diff --git a/ProcessLib/ProcessVariable.cpp b/ProcessLib/ProcessVariable.cpp
@@ -225,7 +225,8 @@ ProcessVariable::createBoundaryConditions(
     std::vector<std::unique_ptr<ParameterLib::ParameterBase>> const& parameters,
     Process const& process,
     std::vector<std::reference_wrapper<ProcessVariable>> const&
-        all_process_variables_for_this_process)
+        all_process_variables_for_this_process,
+    std::map<int, std::shared_ptr<MaterialPropertyLib::Medium>> const& media)
 {
     std::vector<std::unique_ptr<BoundaryCondition>> bcs;
     bcs.reserve(_bc_configs.size());
@@ -235,7 +236,7 @@ ProcessVariable::createBoundaryConditions(
         auto bc = createBoundaryCondition(
             config, dof_table, _mesh, variable_id, integration_order,
             _shapefunction_order, parameters, process,
-            all_process_variables_for_this_process);
+            all_process_variables_for_this_process, media);
 #ifdef USE_PETSC
         if (bc == nullptr)
         {

diff --git a/ProcessLib/ProcessVariable.h b/ProcessLib/ProcessVariable.h
@@ -16,6 +16,7 @@
 #include <vector>
 
 #include "BaseLib/ConfigTree-fwd.h"
+#include "MaterialLib/MPL/Medium.h"
 
 namespace MathLib
 {
@@ -98,7 +99,9 @@ class ProcessVariable
             parameters,
         Process const& process,
         std::vector<std::reference_wrapper<ProcessVariable>> const&
-            all_process_variables_for_this_process);
+            all_process_variables_for_this_process,
+        std::map<int, std::shared_ptr<MaterialPropertyLib::Medium>> const&
+            media);
 
     std::vector<std::unique_ptr<SourceTerm>> createSourceTerms(
         const NumLib::LocalToGlobalIndexMap& dof_table, const int variable_id,

diff --git a/ProcessLib/RichardsMechanics/RichardsMechanicsProcess.cpp b/ProcessLib/RichardsMechanics/RichardsMechanicsProcess.cpp
@@ -290,26 +290,28 @@ void RichardsMechanicsProcess<DisplacementDim>::initializeConcreteProcess(
 }
 
 template <int DisplacementDim>
-void RichardsMechanicsProcess<DisplacementDim>::initializeBoundaryConditions()
+void RichardsMechanicsProcess<DisplacementDim>::initializeBoundaryConditions(
+    std::map<int, std::shared_ptr<MaterialPropertyLib::Medium>> const& media)
 {
     if (_use_monolithic_scheme)
     {
         const int monolithic_process_id = 0;
         initializeProcessBoundaryConditionsAndSourceTerms(
-            *_local_to_global_index_map, monolithic_process_id);
+            *_local_to_global_index_map, monolithic_process_id, media);
         return;
     }
 
     // Staggered scheme:
     // for the equations of pressure
     const int hydraulic_process_id = 0;
     initializeProcessBoundaryConditionsAndSourceTerms(
-        *_local_to_global_index_map_with_base_nodes, hydraulic_process_id);
+        *_local_to_global_index_map_with_base_nodes, hydraulic_process_id,
+        media);
 
     // for the equations of deformation.
     const int mechanical_process_id = 1;
     initializeProcessBoundaryConditionsAndSourceTerms(
-        *_local_to_global_index_map, mechanical_process_id);
+        *_local_to_global_index_map, mechanical_process_id, media);
 }
 
 template <int DisplacementDim>

diff --git a/ProcessLib/RichardsMechanics/RichardsMechanicsProcess.h b/ProcessLib/RichardsMechanics/RichardsMechanicsProcess.h
@@ -71,7 +71,9 @@ class RichardsMechanicsProcess final : public Process
         MeshLib::Mesh const& mesh,
         unsigned const integration_order) override;
 
-    void initializeBoundaryConditions() override;
+    void initializeBoundaryConditions(
+        std::map<int, std::shared_ptr<MaterialPropertyLib::Medium>> const&
+            media) override;
 
     void setInitialConditionsConcreteProcess(std::vector<GlobalVector*>& x,
                                              double const t,

diff --git a/ProcessLib/StokesFlow/StokesFlowProcess.cpp b/ProcessLib/StokesFlow/StokesFlowProcess.cpp
@@ -101,13 +101,14 @@ void StokesFlowProcess<GlobalDim>::initializeConcreteProcess(
 }
 
 template <int GlobalDim>
-void StokesFlowProcess<GlobalDim>::initializeBoundaryConditions()
+void StokesFlowProcess<GlobalDim>::initializeBoundaryConditions(
+    std::map<int, std::shared_ptr<MaterialPropertyLib::Medium>> const& media)
 {
     assert(_use_monolithic_scheme);
     {
         int const process_id = 0;
         initializeProcessBoundaryConditionsAndSourceTerms(
-            *_local_to_global_index_map, process_id);
+            *_local_to_global_index_map, process_id, media);
     }
 }
 

diff --git a/ProcessLib/StokesFlow/StokesFlowProcess.h b/ProcessLib/StokesFlow/StokesFlowProcess.h
@@ -68,7 +68,9 @@ class StokesFlowProcess final : public Process
         MeshLib::Mesh const& mesh,
         unsigned const integration_order) override;
 
-    void initializeBoundaryConditions() override;
+    void initializeBoundaryConditions(
+        std::map<int, std::shared_ptr<MaterialPropertyLib::Medium>> const&
+            media) override;
 
     void assembleConcreteProcess(const double t, double const dt,
                                  std::vector<GlobalVector*> const& x,

diff --git a/ProcessLib/TH2M/TH2MProcess.cpp b/ProcessLib/TH2M/TH2MProcess.cpp
@@ -320,12 +320,13 @@ void TH2MProcess<DisplacementDim>::initializeConcreteProcess(
 }
 
 template <int DisplacementDim>
-void TH2MProcess<DisplacementDim>::initializeBoundaryConditions()
+void TH2MProcess<DisplacementDim>::initializeBoundaryConditions(
+    std::map<int, std::shared_ptr<MaterialPropertyLib::Medium>> const& media)
 {
     if (_use_monolithic_scheme)
     {
         initializeProcessBoundaryConditionsAndSourceTerms(
-            *_local_to_global_index_map, monolithic_process_id);
+            *_local_to_global_index_map, monolithic_process_id, media);
         return;
     }
 

diff --git a/ProcessLib/TH2M/TH2MProcess.h b/ProcessLib/TH2M/TH2MProcess.h
@@ -74,7 +74,9 @@ class TH2MProcess final : public Process,
         MeshLib::Mesh const& mesh,
         unsigned const integration_order) override;
 
-    void initializeBoundaryConditions() override;
+    void initializeBoundaryConditions(
+        std::map<int, std::shared_ptr<MaterialPropertyLib::Medium>> const&
+            media) override;
 
     void setInitialConditionsConcreteProcess(std::vector<GlobalVector*>& x,
                                              double const t,