[PL/MatL] Use MeL::materialIDs. Drop has_mat_ids.

The main change was in the creation of liquid flow process;
the succeeding changes are just adoptation to a pointer,
instead of a reference with boolean.

MaterialLib/PorousMedium/CreatePorousMediaProperties.cpp

@@ -76,19 +76,11 @@ PorousMediaProperties createPorousMediaProperties(
     BaseLib::reorderVector(porosity_models, mat_ids);
     BaseLib::reorderVector(storage_models, mat_ids);
 
-    std::vector<int> material_ids(mesh.getNumberOfElements());
-    if (mesh.getProperties().existsPropertyVector<int>(
-            "MaterialIDs", MeshLib::MeshItemType::Cell, 1))
-    {
-        auto const& mesh_material_ids =
-            mesh.getProperties().getPropertyVector<int>(
-                "MaterialIDs", MeshLib::MeshItemType::Cell, 1);
-        material_ids.reserve(mesh_material_ids->size());
-        std::copy(mesh_material_ids->cbegin(), mesh_material_ids->cend(),
-                  material_ids.begin());
-    }
+    auto const material_ids = materialIDs(mesh);
     int const max_material_id =
-        *std::max_element(material_ids.cbegin(), material_ids.cend());
+        !material_ids
+            ? 0
+            : *std::max_element(begin(*material_ids), end(*material_ids));
 
     if (max_material_id > static_cast<int>(mat_ids.size() - 1))
         OGS_FATAL(
@@ -112,8 +104,7 @@ PorousMediaProperties createPorousMediaProperties(
 
     return PorousMediaProperties{std::move(porosity_models),
                                  std::move(intrinsic_permeability_models),
-                                 std::move(storage_models),
-                                 std::move(material_ids)};
+                                 std::move(storage_models), material_ids};
 }
 
 }  // namespace ComponentTransport

MaterialLib/PorousMedium/PorousMediaProperties.cpp

@@ -18,8 +18,7 @@ namespace PorousMedium
 int PorousMediaProperties::getMaterialID(
     ProcessLib::SpatialPosition const& pos) const
 {
-    int const element_id = pos.getElementID().get();
-    return _material_ids[element_id];
+    return _material_ids ? (*_material_ids)[pos.getElementID().get()] : 0;
 }
 
 MaterialLib::PorousMedium::Porosity const& PorousMediaProperties::getPorosity(

MaterialLib/PorousMedium/PorousMediaProperties.h

@@ -36,23 +36,16 @@ public:
             intrinsic_permeability_models,
         std::vector<std::unique_ptr<MaterialLib::PorousMedium::Storage>>&&
             specific_storage_models,
-        std::vector<int>&& material_ids)
+        MeshLib::PropertyVector<int> const* const material_ids)
         : _porosity_models(std::move(porosity_models)),
           _intrinsic_permeability_models(
               std::move(intrinsic_permeability_models)),
           _specific_storage_models(std::move(specific_storage_models)),
-          _material_ids(std::move(material_ids))
+          _material_ids(material_ids)
     {
     }
 
-    PorousMediaProperties(PorousMediaProperties&& other)
-        : _porosity_models(std::move(other._porosity_models)),
-          _intrinsic_permeability_models(
-              std::move(other._intrinsic_permeability_models)),
-          _specific_storage_models(std::move(other._specific_storage_models)),
-          _material_ids(other._material_ids)
-    {
-    }
+    PorousMediaProperties(PorousMediaProperties&& other) = default;
 
     MaterialLib::PorousMedium::Porosity const& getPorosity(
         double t, ProcessLib::SpatialPosition const& pos) const;
@@ -72,7 +65,7 @@ private:
         _intrinsic_permeability_models;
     std::vector<std::unique_ptr<MaterialLib::PorousMedium::Storage>>
         _specific_storage_models;
-    std::vector<int> _material_ids;
+    MeshLib::PropertyVector<int> const* const _material_ids;
 };
 
 }

ProcessLib/LiquidFlow/CreateLiquidFlowMaterialProperties.cpp

@@ -40,8 +40,7 @@ std::unique_ptr<LiquidFlowMaterialProperties>
 createLiquidFlowMaterialProperties(
     BaseLib::ConfigTree const& config,
     std::vector<std::unique_ptr<ParameterBase>> const& parameters,
-    bool const has_material_ids,
-    MeshLib::PropertyVector<int> const& material_ids)
+    MeshLib::PropertyVector<int> const* const material_ids)
 {
     DBUG("Reading material properties of liquid flow process.");
 
@@ -99,8 +98,7 @@ createLiquidFlowMaterialProperties(
 
     return std::make_unique<LiquidFlowMaterialProperties>(
         std::move(fluid_properties), std::move(intrinsic_permeability_models),
-        std::move(porosity_models), std::move(storage_models), has_material_ids,
-        material_ids);
+        std::move(porosity_models), std::move(storage_models), material_ids);
 }
 
 }  // end of namespace

ProcessLib/LiquidFlow/CreateLiquidFlowMaterialProperties.h

@@ -45,8 +45,7 @@ std::unique_ptr<LiquidFlowMaterialProperties>
 createLiquidFlowMaterialProperties(
     BaseLib::ConfigTree const& config,
     std::vector<std::unique_ptr<ParameterBase>> const& parameters,
-    bool const has_material_ids,
-    MeshLib::PropertyVector<int> const& material_ids);
+    MeshLib::PropertyVector<int> const* const material_ids);
 
 }  // end of namespace
 }  // end of namespace

ProcessLib/LiquidFlow/CreateLiquidFlowProcess.cpp

@@ -91,39 +91,21 @@ std::unique_ptr<Process> createLiquidFlowProcess(
     //! \ogs_file_param{prj__processes__process__LIQUID_FLOW__material_property}
     auto const& mat_config = config.getConfigSubtree("material_property");
 
-    if (mesh.getProperties().existsPropertyVector<int>(
-            "MaterialIDs", MeshLib::MeshItemType::Cell, 1))
+    auto const material_ids = materialIDs(mesh);
+    if (material_ids)
     {
         INFO("The liquid flow is in heterogeneous porous media.");
-        const bool has_material_ids = true;
-        auto const& mat_ids = mesh.getProperties().getPropertyVector<int>(
-            "MaterialIDs", MeshLib::MeshItemType::Cell, 1);
-        return std::unique_ptr<Process>{new LiquidFlowProcess{
-            mesh, std::move(jacobian_assembler), parameters, integration_order,
-            std::move(process_variables), std::move(secondary_variables),
-            std::move(named_function_caller), *mat_ids, has_material_ids,
-            gravity_axis_id, g, reference_temperature, mat_config}};
     }
-
-    INFO("The liquid flow is in homogeneous porous media.");
-
-    MeshLib::Properties dummy_property;
-    // For a reference argument of LiquidFlowProcess(...).
-    auto const& dummy_property_vector =
-        dummy_property.createNewPropertyVector<int>(
-            "MaterialIDs", MeshLib::MeshItemType::Cell, 1);
-
-    // Since dummy_property_vector is only visible in this function,
-    // the following constant, has_material_ids, is employed to indicate
-    // that material_ids does not exist.
-    const bool has_material_ids = false;
+    else
+    {
+        INFO("The liquid flow is in homogeneous porous media.");
+    }
 
     return std::unique_ptr<Process>{new LiquidFlowProcess{
         mesh, std::move(jacobian_assembler), parameters, integration_order,
         std::move(process_variables), std::move(secondary_variables),
-        std::move(named_function_caller), *dummy_property_vector,
-        has_material_ids, gravity_axis_id, g, reference_temperature,
-        mat_config}};
+        std::move(named_function_caller), material_ids, gravity_axis_id, g,
+        reference_temperature, mat_config}};
 }
 
 }  // end of namespace

ProcessLib/LiquidFlow/LiquidFlowMaterialProperties.cpp

@@ -33,13 +33,13 @@ namespace LiquidFlow
 int LiquidFlowMaterialProperties::getMaterialID(
     const SpatialPosition& pos) const
 {
-    if (!_has_material_ids)
+    if (!_material_ids)
     {
         return 0;
     }
 
-    assert(pos.getElementID().get() < _material_ids.size());
-    return _material_ids[pos.getElementID().get()];
+    assert(pos.getElementID().get() < _material_ids->size());
+    return (*_material_ids)[pos.getElementID().get()];
 }
 
 double LiquidFlowMaterialProperties::getLiquidDensity(const double p,

ProcessLib/LiquidFlow/LiquidFlowMaterialProperties.h

@@ -56,10 +56,8 @@ public:
             porosity_models,
         std::vector<std::unique_ptr<MaterialLib::PorousMedium::Storage>>&&
             storage_models,
-        bool const has_material_ids,
-        MeshLib::PropertyVector<int> const& material_ids)
-        : _has_material_ids(has_material_ids),
-          _material_ids(material_ids),
+        MeshLib::PropertyVector<int> const* const material_ids)
+        : _material_ids(material_ids),
           _fluid_properties(std::move(fluid_properties)),
           _intrinsic_permeability_models(
               std::move(intrinsic_permeability_models)),
@@ -106,13 +104,10 @@ public:
                        const double porosity_variable, const double T) const;
 
 private:
-    /// A flag to indicate whether the reference member, _material_ids,
-    /// is not assigned.
-    const bool _has_material_ids;
     /** Use porous medium models for different material zones.
      *  Material IDs must be given as mesh element properties.
      */
-    MeshLib::PropertyVector<int> const& _material_ids;
+    MeshLib::PropertyVector<int> const* const _material_ids;
 
     const std::unique_ptr<MaterialLib::Fluid::FluidProperties>
         _fluid_properties;

ProcessLib/LiquidFlow/LiquidFlowProcess.cpp

@@ -39,8 +39,7 @@ LiquidFlowProcess::LiquidFlowProcess(
         process_variables,
     SecondaryVariableCollection&& secondary_variables,
     NumLib::NamedFunctionCaller&& named_function_caller,
-    MeshLib::PropertyVector<int> const& material_ids,
-    bool const has_material_ids,
+    MeshLib::PropertyVector<int> const* const material_ids,
     int const gravitational_axis_id,
     double const gravitational_acceleration,
     double const reference_temperature,
@@ -51,8 +50,8 @@ LiquidFlowProcess::LiquidFlowProcess(
       _gravitational_axis_id(gravitational_axis_id),
       _gravitational_acceleration(gravitational_acceleration),
       _reference_temperature(reference_temperature),
-      _material_properties(createLiquidFlowMaterialProperties(
-          config, parameters, has_material_ids, material_ids))
+      _material_properties(
+          createLiquidFlowMaterialProperties(config, parameters, material_ids))
 {
     DBUG("Create Liquid flow process.");
 }

ProcessLib/LiquidFlow/LiquidFlowProcess.h

@@ -66,8 +66,7 @@ public:
             process_variables,
         SecondaryVariableCollection&& secondary_variables,
         NumLib::NamedFunctionCaller&& named_function_caller,
-        MeshLib::PropertyVector<int> const& material_ids,
-        bool const has_material_ids,
+        MeshLib::PropertyVector<int> const* const material_ids,
         int const gravitational_axis_id,
         double const gravitational_acceleration,
         double const reference_temperature,