Merge branch 'SmallFixes' into 'master'

SmallFixes

See merge request ogs/ogs!4721

Applications/DataHolderLib/Project.cpp

@@ -77,7 +77,7 @@ bool Project::getUniqueName(std::string& name) const
             cpName = cpName + "-" + std::to_string(count);
         }
 
-        for (auto& mesh : _mesh_vec)
+        for (auto const& mesh : _mesh_vec)
         {
             if (cpName == mesh->getName())
             {

Applications/FileIO/GMSInterface.cpp

@@ -147,10 +147,10 @@ void GMSInterface::writeBoreholesToGMS(
 
     for (auto station_as_point : *stations)
     {
-        auto* station = static_cast<GeoLib::StationBorehole*>(station_as_point);
-        std::vector<GeoLib::Point*> profile = station->getProfile();
-        std::vector<std::string> soilNames = station->getSoilNames();
-        // std::size_t idx = 0;
+        auto const* station =
+            static_cast<GeoLib::StationBorehole*>(station_as_point);
+        std::vector<GeoLib::Point*> const& profile = station->getProfile();
+        std::vector<std::string> const& soilNames = station->getSoilNames();
         std::string current_soil_name;
 
         std::size_t nLayers = profile.size();

Applications/FileIO/Gmsh/GMSHPolygonTree.cpp

@@ -461,7 +461,7 @@ void GMSHPolygonTree::writeAdditionalPointData(std::size_t& pnt_id_offset,
                                                std::size_t sfc_number,
                                                std::ostream& out) const
 {
-    if (auto* adaptive_mesh_density =
+    if (auto const* adaptive_mesh_density =
             dynamic_cast<GMSHAdaptiveMeshDensity*>(&_mesh_density_strategy))
     {
         std::vector<GeoLib::Point*> steiner_pnts;

Applications/FileIO/GocadIO/GocadAsciiReader.cpp

@@ -355,7 +355,7 @@ bool parseNodes(std::ifstream& in,
 
 /// Parses the segments of the current line
 bool parseLineSegments(std::ifstream& in,
-                       std::vector<MeshLib::Node*>& nodes,
+                       std::vector<MeshLib::Node*> const& nodes,
                        std::vector<MeshLib::Element*>& elems,
                        std::map<std::size_t, std::size_t> const& node_id_map,
                        MeshLib::Properties& mesh_prop)

Applications/FileIO/GocadIO/GocadSGridReader.cpp

@@ -711,9 +711,9 @@ void GocadSGridReader::applySplitInformation(
     }
 }
 
-void GocadSGridReader::modifyElement(MeshLib::Element* hex,
-                                     MeshLib::Node const* node2sub,
-                                     MeshLib::Node* substitute_node)
+void GocadSGridReader::modifyElement(MeshLib::Element const* const hex,
+                                     MeshLib::Node const* const node2sub,
+                                     MeshLib::Node* const substitute_node)
 {
     // get the node pointers of the cell
     MeshLib::Node* const* hex_nodes(hex->getNodes());

Applications/FileIO/GocadIO/GocadSGridReader.h

@@ -74,7 +74,7 @@ class GocadSGridReader final
     void applySplitInformation(
         std::vector<MeshLib::Node*>& nodes,
         std::vector<MeshLib::Element*> const& elements) const;
-    static void modifyElement(MeshLib::Element* hex,
+    static void modifyElement(MeshLib::Element const* hex,
                               MeshLib::Node const* node2sub,
                               MeshLib::Node* substitute_node);
 

Applications/FileIO/Legacy/createSurface.cpp

@@ -95,7 +95,7 @@ bool createSurface(GeoLib::Polyline const& ply,
         WARN("Call to '{:s}' returned non-zero value {:d}.", gmsh_command,
              gmsh_return_value);
     }
-    auto surface_mesh = MeshLib::IO::readMeshFromFile(msh_file.string());
+    auto const* surface_mesh = MeshLib::IO::readMeshFromFile(msh_file.string());
     if (!surface_mesh)
     {
         WARN("The surface mesh could not be created.");

Applications/Utils/MeshEdit/NodeReordering.cpp

@@ -140,11 +140,9 @@ void reorderNonlinearNodes(MeshLib::Mesh& mesh)
     }
 
     BaseLib::makeVectorUnique(base_nodes,
-                              [](MeshLib::Node* a, MeshLib::Node* b)
-                              { return a->getID() < b->getID(); });
+                              MeshLib::idsComparator<MeshLib::Node*>);
     BaseLib::makeVectorUnique(nonlinear_nodes,
-                              [](MeshLib::Node* a, MeshLib::Node* b)
-                              { return a->getID() < b->getID(); });
+                              MeshLib::idsComparator<MeshLib::Node*>);
 
     std::vector<MeshLib::Node*>& allnodes =
         const_cast<std::vector<MeshLib::Node*>&>(mesh.getNodes());

ChemistryLib/CreateChemicalSolverInterface.cpp

@@ -158,7 +158,7 @@ createChemicalSolverInterface<ChemicalSolver::PhreeqcKernel>(
     auto const ls_name =
         //! \ogs_file_param{prj__chemical_system__linear_solver}
         config.getConfigParameter<std::string>("linear_solver");
-    auto& linear_solver = BaseLib::getOrError(
+    auto const& linear_solver = BaseLib::getOrError(
         linear_solvers, ls_name,
         "A linear solver with the given name does not exist.");
 

ChemistryLib/PhreeqcIO.cpp

@@ -636,7 +636,7 @@ std::ostream& operator<<(std::ostream& os, PhreeqcIO const& phreeqc_io)
     return os;
 }
 
-void PhreeqcIO::callPhreeqc()
+void PhreeqcIO::callPhreeqc() const
 {
     INFO("Phreeqc: Executing chemical calculation.");
     if (RunFile(phreeqc_instance_id, _phreeqc_input_file.c_str()) != IPQ_OK)
@@ -826,11 +826,12 @@ std::istream& operator>>(std::istream& in, PhreeqcIO& phreeqc_io)
                     auto const& secondary_variables =
                         user_punch->secondary_variables;
                     // Update values of secondary variables
-                    auto& secondary_variable = BaseLib::findElementOrError(
-                        secondary_variables.begin(), secondary_variables.end(),
-                        compare_by_name,
-                        "Could not find secondary variable '" + item_name +
-                            "'.");
+                    auto const& secondary_variable =
+                        BaseLib::findElementOrError(
+                            secondary_variables.begin(),
+                            secondary_variables.end(), compare_by_name,
+                            "Could not find secondary variable '" + item_name +
+                                "'.");
                     (*secondary_variable.value)[chemical_system_id] =
                         accepted_items[item_id];
                     break;
@@ -896,13 +897,14 @@ void PhreeqcIO::computeSecondaryVariable(
     std::size_t const ele_id,
     std::vector<GlobalIndexType> const& chemical_system_indices)
 {
-    for (auto& kinetic_reactant : _chemical_system->kinetic_reactants)
+    for (auto const& kinetic_reactant : _chemical_system->kinetic_reactants)
     {
         (*kinetic_reactant.mesh_prop_molality)[ele_id] =
             averageReactantMolality(kinetic_reactant, chemical_system_indices);
     }
 
-    for (auto& equilibrium_reactant : _chemical_system->equilibrium_reactants)
+    for (auto const& equilibrium_reactant :
+         _chemical_system->equilibrium_reactants)
     {
         (*equilibrium_reactant.mesh_prop_molality)[ele_id] =
             averageReactantMolality(equilibrium_reactant,

ChemistryLib/PhreeqcIO.h

@@ -97,7 +97,7 @@ class PhreeqcIO final : public ChemicalSolverInterface
 private:
     void writeInputsToFile(double const dt);
 
-    void callPhreeqc();
+    void callPhreeqc() const;
 
     void readOutputsFromFile();
 

ChemistryLib/PhreeqcKernel.cpp

@@ -192,6 +192,7 @@ static bool isHydrogen(std::string_view const element)
 void PhreeqcKernel::setAqueousSolutions(
     std::vector<GlobalVector*> const& process_solutions)
 {
+    assert(!process_solutions.empty());
     // Loop over chemical systems
     std::size_t const num_chemical_systems = process_solutions[0]->size();
     for (std::size_t chemical_system_id = 0;

ChemistryLib/PhreeqcKernelData/CreateKineticReactant.cpp

@@ -43,7 +43,7 @@ std::unique_ptr<Kinetics> createKineticReactants(
             //! \ogs_file_param{prj__chemical_system__kinetic_reactants__kinetic_reactant__initial_amount}
             reactant_config.getConfigParameter<double>("initial_amount");
 
-        auto amount = MeshLib::getOrCreateMeshProperty<double>(
+        auto* const amount = MeshLib::getOrCreateMeshProperty<double>(
             const_cast<MeshLib::Mesh&>(mesh),
             name,
             MeshLib::MeshItemType::Node,

GeoLib/GEOObjects.cpp

@@ -222,9 +222,9 @@ const PolylineVec* GEOObjects::getPolylineVecObj(const std::string& name) const
 bool GEOObjects::removePolylineVec(std::string const& name)
 {
     _callbacks->removePolylineVec(name);
-    auto it =
-        std::find_if(_ply_vecs.begin(), _ply_vecs.end(),
-                     [&name](PolylineVec* v) { return v->getName() == name; });
+    auto it = std::find_if(_ply_vecs.begin(), _ply_vecs.end(),
+                           [&name](PolylineVec const* const v)
+                           { return v->getName() == name; });
     if (it != _ply_vecs.end())
     {
         delete *it;
@@ -342,7 +342,7 @@ void GEOObjects::getStationVectorNames(std::vector<std::string>& names) const
 std::vector<std::string> GEOObjects::getGeometryNames() const
 {
     std::vector<std::string> names;
-    for (auto point : _pnt_vecs)
+    for (auto const point : _pnt_vecs)
     {
         if (point->getType() == PointVec::PointType::POINT)
         {
@@ -385,10 +385,7 @@ int GEOObjects::mergeGeometries(std::vector<std::string> const& geo_names,
 
     std::vector<std::size_t> pnt_offsets(n_geo_names, 0);
 
-    if (!mergePoints(geo_names, merged_geo_name, pnt_offsets))
-    {
-        return 1;
-    }
+    mergePoints(geo_names, merged_geo_name, pnt_offsets);
 
     mergePolylines(geo_names, merged_geo_name, pnt_offsets);
 
@@ -397,7 +394,7 @@ int GEOObjects::mergeGeometries(std::vector<std::string> const& geo_names,
     return 0;
 }
 
-bool GEOObjects::mergePoints(std::vector<std::string> const& geo_names,
+void GEOObjects::mergePoints(std::vector<std::string> const& geo_names,
                              std::string& merged_geo_name,
                              std::vector<std::size_t>& pnt_offsets)
 {
@@ -442,7 +439,6 @@ bool GEOObjects::mergePoints(std::vector<std::string> const& geo_names,
 
     addPointVec(std::move(merged_points), merged_geo_name,
                 std::move(merged_pnt_names), 1e-6);
-    return true;
 }
 
 void GEOObjects::mergePolylines(std::vector<std::string> const& geo_names,

GeoLib/GEOObjects.h

@@ -323,9 +323,8 @@ class GEOObjects final
      * @param merged_geo_name The (new) name of the geometry resulting from
      * merging.
      * @param pnt_offsets offsets in the merged vector storing the points
-     * @return true, if merging the points succeeded, else false
      */
-    bool mergePoints(std::vector<std::string> const& geo_names,
+    void mergePoints(std::vector<std::string> const& geo_names,
                      std::string& merged_geo_name,
                      std::vector<std::size_t>& pnt_offsets);
 

GeoLib/Grid.h

@@ -204,10 +204,9 @@ Grid<POINT>::Grid(InputIterator first, InputIterator last,
         {max[0] - min[0], max[1] - min[1], max[2] - min[2]}};
 
     // enlarge delta
-    for (auto& d : delta)
-    {
-        d = std::nextafter(d, std::numeric_limits<double>::max());
-    }
+    constexpr double direction = std::numeric_limits<double>::max();
+    std::transform(begin(delta), end(delta), begin(delta),
+                   [](double const d) { return std::nextafter(d, direction); });
 
     assert(n_pnts > 0);
     initNumberOfSteps(max_num_per_grid_cell, static_cast<std::size_t>(n_pnts),

GeoLib/Polygon.cpp

@@ -380,7 +380,7 @@ bool Polygon::getNextIntersectionPointPolygonLine(
     }
     else
     {
-        for (auto polygon : _simple_polygon_list)
+        for (auto const* polygon : _simple_polygon_list)
         {
             for (auto seg_it(polygon->begin()); seg_it != polygon->end();
                  ++seg_it)

GeoLib/Polyline.cpp

@@ -170,13 +170,6 @@ LineSegment Polyline::getSegment(std::size_t i) const
                        _ply_pnts[_ply_pnt_ids[i + 1]], false);
 }
 
-LineSegment Polyline::getSegment(std::size_t i)
-{
-    assert(i < getNumberOfSegments());
-    return LineSegment(_ply_pnts[_ply_pnt_ids[i]],
-                       _ply_pnts[_ply_pnt_ids[i + 1]], false);
-}
-
 void Polyline::setPointID(std::size_t idx, std::size_t id)
 {
     assert(idx < _ply_pnt_ids.size());

GeoLib/Polyline.h

@@ -222,7 +222,6 @@ class Polyline : public GeoObject
     std::vector<std::size_t> _ply_pnt_ids;
 
     LineSegment getSegment(std::size_t i) const;
-    LineSegment getSegment(std::size_t i);
 };
 
 bool containsEdge (const Polyline& ply, std::size_t id0, std::size_t id1);

GeoLib/QuadTree.h

@@ -115,15 +115,11 @@ template <typename POINT> class QuadTree
             return false;
         }
 
-        if (!_is_leaf) {
-            for (auto& child : _children)
-            {
-                if (child->addPoint(pnt))
-                {
-                    return true;
-                }
-            }
-            return false;
+        if (!_is_leaf)
+        {
+            return std::any_of(begin(_children), end(_children),
+                               [&pnt](auto* child)
+                               { return child->addPoint(pnt); });
         }
 
         // check if point is already in quadtree
@@ -540,7 +536,7 @@ template <typename POINT> class QuadTree
         _is_leaf = false;
     }
 
-    static bool needToRefine (QuadTree<POINT>* node)
+    static bool needToRefine(QuadTree<POINT> const* const node)
     {
         QuadTree<POINT>* north_neighbor (node->getNorthNeighbor ());
         if (north_neighbor != nullptr)

GeoLib/Station.cpp

@@ -22,12 +22,13 @@
 
 namespace GeoLib
 {
-Station::Station(double x, double y, double z, std::string name)
+Station::Station(double const x, double const y, double const z,
+                 std::string name)
     : Point(x, y, z), _name(std::move(name))
 {
 }
 
-Station::Station(Point* coords, std::string name)
+Station::Station(Point const* const coords, std::string name)
     : Point(*coords), _name(std::move(name))
 {
 }

GeoLib/Station.h

@@ -48,7 +48,7 @@ class Station : public Point
     explicit Station(double x = 0.0, double y = 0.0, double z = 0.0,
                      std::string name = "");
 
-    explicit Station(Point* coords, std::string name = "");
+    explicit Station(Point const* coords, std::string name = "");
 
     /**
      * Constructor copies the source object

MaterialLib/MPL/CheckMaterialSpatialDistributionMap.h

@@ -28,10 +28,8 @@ void checkMaterialSpatialDistributionMap(
     ContainerLiquid const& required_properties_liquid_phase,
     ContainerGas const& required_properties_gas_phase)
 {
-    for (auto const& element : mesh.getElements())
+    for (auto const element_id : mesh.getElements() | MeshLib::views::ids)
     {
-        auto const element_id = element->getID();
-
         auto const& medium = *media_map.getMedium(element_id);
         if (!required_properties_medium.empty())
         {

MaterialLib/MPL/Properties/PermeabilityMohrCoulombFailureIndexModel.cpp

@@ -120,10 +120,9 @@ PermeabilityMohrCoulombFailureIndexModel<DisplacementDim>::value(
     if (f >= 1.0)
     {
         const double exp_value = std::exp(b_ * f);
-        for (auto& k_i : k_data)
-        {
-            k_i = std::min(k_i + kr_ * exp_value, k_max_);
-        }
+        std::transform(begin(k_data), end(k_data), begin(k_data),
+                       [&](double const k_i)
+                       { return std::min(k_i + kr_ * exp_value, k_max_); });
     }
 
     // Local coordinate transformation is only applied for the case that the

MeshGeoToolsLib/AppendLinesAlongPolyline.cpp

@@ -45,7 +45,7 @@ std::unique_ptr<MeshLib::Mesh> appendLinesAlongPolylines(
     // for each polyline
     for (std::size_t k(0); k < n_ply; k++)
     {
-        auto* ply = ply_vec.getVector()[k];
+        auto const* const ply = ply_vec.getVector()[k];
 
         // search nodes on the polyline
         MeshGeoToolsLib::MeshNodesAlongPolyline mshNodesAlongPoly(

MeshGeoToolsLib/MeshNodesAlongSurface.cpp

@@ -35,7 +35,7 @@ MeshNodesAlongSurface::MeshNodesAlongSurface(MeshLib::Mesh const& mesh,
     // loop over all nodes
     for (std::size_t i = 0; i < n_nodes; i++)
     {
-        auto* node = mesh_nodes[i];
+        auto const* const node = mesh_nodes[i];
         if (!sfc.isPntInBoundingVolume(*node, epsilon_radius))
         {
             continue;