New data structure for multidimensional data (+some bugfixes)

Common/include/fem/fem_geometry_structure.hpp

@@ -1227,11 +1227,14 @@ class CMeshFEM_DG: public CMeshFEM {
   void SetWallDistance(su2double val) override;
 
   /*!
-   * \brief Set the wall distance based on an previously constructed ADT
-   * \param[in] config - Definition of the particular problem.
-   * \param[in] WallADT - The ADT to compute the wall distance
+   * \brief Reduce the wall distance based on an previously constructed ADT.
+   * \details The ADT might belong to another zone, giving rise to lower wall distances
+   * than those already stored.
+   * \param[in] WallADT - The ADT to reduce the wall distance
+   * \param[in] geometry - ignored
+   * \param[in] config - ignored
    */
-  void SetWallDistance(const CConfig *config, CADTElemClass* WallADT) override;
+  void SetWallDistance(CADTElemClass* WallADT, const CConfig *config = nullptr, const CGeometry* geometry = nullptr) override;
 };
 
 /*!

Common/include/geometry/CGeometry.hpp

@@ -1683,11 +1683,14 @@ class CGeometry {
   virtual std::unique_ptr<CADTElemClass> ComputeViscousWallADT(const CConfig *config) const { return nullptr; }
 
   /*!
-   * \brief Set the wall distance based on an previously constructed ADT
-   * \param[in] config - Definition of the particular problem.
-   * \param[in] WallADT - The ADT to compute the wall distance
+   * \brief Reduce the wall distance based on an previously constructed ADT.
+   * \details The ADT might belong to another zone, giving rise to lower wall distances
+   * than those already stored.
+   * \param[in] WallADT - The ADT to reduce the wall distance
+   * \param[in] geometry - Geometry associated to the ADT
+   * \param[in] config - Config associated to the ADT
    */
-  virtual void SetWallDistance(const CConfig *config, CADTElemClass* WallADT) {}
+  virtual void SetWallDistance(CADTElemClass* WallADT, const CConfig *config = nullptr, const CGeometry* geometry=nullptr) {}
 
   /*!
    * \brief Set wall distances a specific value
@@ -1702,6 +1705,11 @@ class CGeometry {
    */
   static void ComputeWallDistance(const CConfig * const *config_container, CGeometry ****geometry_container);
 
+  /*!
+   * \brief Virtual function to set roughness values.
+   */
+  virtual void SetGlobalMarkerRoughness(const CConfig* config) {}
+
   /*!
    * \brief Set the amount of nonconvex elements in the mesh.
    * \param[in] nonconvex_elems - amount of nonconvex elements in the mesh

Common/include/geometry/CPhysicalGeometry.hpp

@@ -104,11 +104,12 @@ class CPhysicalGeometry final : public CGeometry {
   unsigned long *Elem_ID_BoundTria_Linear{nullptr};
   unsigned long *Elem_ID_BoundQuad_Linear{nullptr};
 
+  su2double Streamwise_Periodic_RefNode[MAXNDIM] = {0}; /*!< \brief Coordinates of the reference node [m] on the receiving periodic marker, for recovered pressure/temperature computation only.*/
+
+public:
   vector<int> GlobalMarkerStorageDispl;
   vector<su2double> GlobalRoughness_Height;
 
-  su2double Streamwise_Periodic_RefNode[MAXNDIM] = {0}; /*!< \brief Coordinates of the reference node [m] on the receiving periodic marker, for recovered pressure/temperature computation only.*/
-
 public:
   /*--- This is to suppress Woverloaded-virtual, omitting it has no negative impact. ---*/
   using CGeometry::SetVertex;
@@ -767,10 +768,14 @@ class CPhysicalGeometry final : public CGeometry {
   std::unique_ptr<CADTElemClass> ComputeViscousWallADT(const CConfig *config) const override;
 
   /*!
-   * \brief Set the wall distance based on an previously constructed ADT
-   * \param[in] WallADT - The ADT to compute the wall distance
+   * \brief Reduce the wall distance based on an previously constructed ADT.
+   * \details The ADT might belong to another zone, giving rise to lower wall distances
+   * than those already stored.
+   * \param[in] WallADT - The ADT to reduce the wall distance
+   * \param[in] geometry - Physical geometry associated to the ADT
+   * \param[in] config - Config associated to the ADT
    */
-  void SetWallDistance(const CConfig *config, CADTElemClass* WallADT) override;
+  void SetWallDistance(CADTElemClass* WallADT, const CConfig *config = nullptr, const CGeometry* geometry=nullptr) override;
 
   /*!
    * \brief Set wall distances a specific value
@@ -784,7 +789,7 @@ class CPhysicalGeometry final : public CGeometry {
   /*!
    * \brief Set roughness values for markers in a global array.
    */
-  void SetGlobalMarkerRoughness(const CConfig* config);
+  void SetGlobalMarkerRoughness(const CConfig* config) override;
 
   /*!
    * \brief For streamwise periodicity, find & store a unique reference node on the designated periodic inlet.

Common/src/fem/fem_wall_distance.cpp

@@ -172,7 +172,7 @@ void CMeshFEM_DG::SetWallDistance(su2double val){
   }
 }
 
-void CMeshFEM_DG::SetWallDistance(const CConfig *config, CADTElemClass *WallADT){
+void CMeshFEM_DG::SetWallDistance(CADTElemClass *WallADT, const CConfig *config, const CGeometry* geometry){
 
   /*--------------------------------------------------------------------------*/
   /*--- Step 3: Determine the wall distance of the integration points of   ---*/

Common/src/geometry/CGeometry.cpp

@@ -3923,14 +3923,19 @@ void CGeometry::ComputeWallDistance(const CConfig* const* config_container, CGeo
     /*--- Loop over all zones and compute the ADT based on the viscous walls in that zone ---*/
     for (int iZone = 0; iZone < nZone; iZone++){
       CGeometry *geometry = geometry_container[iZone][iInst][MESH_0];
-      unique_ptr<CADTElemClass> WallADT = geometry->ComputeViscousWallADT(config_container[iZone]);
+      const CConfig *config = config_container[iZone];
+      unique_ptr<CADTElemClass> WallADT = geometry->ComputeViscousWallADT(config);
       if (WallADT && !WallADT->IsEmpty()){
         allEmpty = false;
+        /*--- Along with finding the closest walls, we collect their roughnesses. ---*/
+        if (config_container[iZone]->GetnRoughWall() > 0)
+          geometry->SetGlobalMarkerRoughness(config);
+
         /*--- Inner loop over all zones to update the wall distances.
        * It might happen that there is a closer viscous wall in zone iZone for points in zone jZone. ---*/
         for (int jZone = 0; jZone < nZone; jZone++){
           if (wallDistanceNeeded[jZone])
-            geometry_container[jZone][iInst][MESH_0]->SetWallDistance(config_container[jZone], WallADT.get());
+            geometry_container[jZone][iInst][MESH_0]->SetWallDistance(WallADT.get(), config, geometry);
         }
       }
     }

Common/src/geometry/CPhysicalGeometry.cpp

@@ -11017,16 +11017,13 @@ std::unique_ptr<CADTElemClass> CPhysicalGeometry::ComputeViscousWallADT(const CC
 
 }
 
-void CPhysicalGeometry::SetWallDistance(const CConfig *config, CADTElemClass *WallADT) {
+void CPhysicalGeometry::SetWallDistance(CADTElemClass* WallADT, const CConfig *config, const CGeometry* geometry) {
 
   /*--------------------------------------------------------------------------*/
   /*--- Step 3: Loop over all interior mesh nodes and compute minimum      ---*/
   /*---        distance to a solid wall element                           ---*/
   /*--------------------------------------------------------------------------*/
 
-  /*--- Store marker list and roughness in a global array. ---*/
-  if (config->GetnRoughWall() > 0) SetGlobalMarkerRoughness(config);
-
   SU2_OMP_PARALLEL
   if (!WallADT->IsEmpty()) {
     /*--- Solid wall boundary nodes are present. Compute the wall
@@ -11041,12 +11038,15 @@ void CPhysicalGeometry::SetWallDistance(const CConfig *config, CADTElemClass *Wa
 
       WallADT->DetermineNearestElement(nodes->GetCoord(iPoint), dist, markerID, elemID, rankID);
 
-      nodes->SetWall_Distance(iPoint, min(dist,nodes->GetWall_Distance(iPoint)));
+      if(dist < nodes->GetWall_Distance(iPoint)){
+        nodes->SetWall_Distance(iPoint, dist);
 
-      if (config->GetnRoughWall() > 0) {
-        auto index = GlobalMarkerStorageDispl[rankID] + markerID;
-        auto localRoughness = GlobalRoughness_Height[index];
-        nodes->SetRoughnessHeight(iPoint, localRoughness);
+        if (config->GetnRoughWall() > 0) {
+          const CPhysicalGeometry* ph_geometry = dynamic_cast<const CPhysicalGeometry*>(geometry);
+          auto index = ph_geometry->GlobalMarkerStorageDispl[rankID] + markerID;
+          su2double localRoughness = ph_geometry->GlobalRoughness_Height[index];
+          nodes->SetRoughnessHeight(iPoint, localRoughness);
+        }
       }
     }
     END_SU2_OMP_FOR