[WIP] jBAY and BAY vortex generator model

Common/include/CConfig.hpp

@@ -1247,6 +1247,23 @@ class CConfig {
   string* user_scalar_names;          /*!< \brief Names of the user defined (auxiliary) transported scalars .*/
   string* user_source_names;          /*!< \brief Names of the source terms for the user defined transported scalars. */
 
+  /*--- Vortex Generator model config options ---*/  // Added by Max
+  string vg_filename;
+  su2double vg_constant;
+  ENUM_VG_MODEL vg_bay;
+
+  unsigned short nVgs=0;
+  su2double ***Vg_Coordinates=nullptr;
+  su2double **Vg_SurfaceNormalDirection=nullptr,
+            **Vg_SurfaceTangentialDirection=nullptr,
+            **Vg_SurfaceCrossFlowDirection=nullptr,
+            **Vg_StreamwiseDirection=nullptr;
+  su2double *Vg_SurfaceArea=nullptr,
+            *Vg_Angle=nullptr;
+  unsigned short nPointsVG = 4;
+
+  // End by Max
+
   /*!
    * \brief Set the default values of config options not set in the config file using another config object.
    * \param config - Config object to use the default values from.
@@ -1379,6 +1396,11 @@ class CConfig {
                            unsigned short& nMarker_ActDiskBemInlet, unsigned short& nMarker_ActDiskBemOutlet, string*& Marker_ActDiskBemInlet, string*& Marker_ActDiskBemOutlet,
                            su2double**& ActDiskBem_X, su2double**& ActDiskBem_Y, su2double**& ActDiskBem_Z);
 
+  //added by max
+  // void addVgOption(const string& name, unsigned short& nVgs, su2double***& Vg_Coordinates,
+  //                su2double**& Vg_SurfaceNormalDirection, su2double**& Vg_SurfaceTangentialDirection, su2double**& Vg_SurfaceCrossFlowDirection,su2double*& Vg_SurfaceArea,ENUM_VG_MODEL& bayModel);
+  //emd added by max
+
   void addWallFunctionOption(const string &name,               unsigned short &list_size,
                              string* &string_field,            WALL_FUNCTIONS* &val_Kind_WF,
                              unsigned short** &val_IntInfo_WF, su2double** &val_DoubleInfo_WF);
@@ -9859,4 +9881,126 @@ class CConfig {
    */
   LM_ParsedOptions GetLMParsedOptions() const { return lmParsedOptions; }
 
+  //Added by Max
+  /*!
+   * \brief Check which vortex generator model is in use.
+   * \return Vortex Genrator Model.
+   */
+  ENUM_VG_MODEL GetVGModel(void) const {return vg_bay; }
+
+  /*!
+   * \brief Get VG Model calibration constant.
+   * \return Bay model calibration constant.
+   */
+  su2double GetVGConstant(void) const {return vg_constant;}
+
+  /*!
+   * \brief Set vortex generator height vector.
+   * \param[in] b - height vector.
+   */
+  void Set_bVG(su2double** b) { Vg_SurfaceNormalDirection = b; }
+
+  /*!
+   * \brief Ger vortex generator height vector.
+   * \param[in] iVg - Vortex generator index
+   * \return height vector.
+   */
+  su2double* Get_bVG(unsigned short iVg) const { return Vg_SurfaceNormalDirection[iVg]; }
+
+  /*!
+   * \brief Set vortex generator normal vector.
+   * \param[in] n - height vector.
+   */
+  void Set_nVG(su2double** n)  { Vg_SurfaceCrossFlowDirection = n; }
+
+  /*!
+   * \brief Get vortex generator normal vector.
+   * \param[in] iVg - Vortex generator index
+   * \return height vector.
+   */
+  su2double* Get_nVG(unsigned short iVg) const { return Vg_SurfaceCrossFlowDirection[iVg]; }
+
+  /*!
+   * \brief Set vortex generator tangential vector.
+   * \param[in] t - tangential vector.
+   */
+  void Set_tVG(su2double** t) { Vg_SurfaceTangentialDirection = t; }
+
+   /*!
+   * \brief Get vortex generator tangential vector.
+   * \param[in] iVg - Vortex generator index
+   * \return tangential vector.
+   */
+  su2double* Get_tVG(unsigned short iVg) const { return Vg_SurfaceTangentialDirection[iVg]; }
+
+  /*!
+   * \brief Get vortex generator coordinates.
+   * \param[in] iVg - Vortex generator index
+   * \param[in] vg_coord - vortex generator coordinates.
+   */
+  su2double** GetVGcoord(unsigned short iVg) const {return Vg_Coordinates[iVg];}
+
+  /*!
+   * \brief Set vortex generator coordinates.
+   * \param[in] vg_coord - vortex generator coordinates.
+   */
+  void SetVGCoord(su2double ***vg_coord){Vg_Coordinates=vg_coord;}
+  /*!
+   * \brief Get number of vortex generators for a specific problem.
+   * \return - Number of vortex genrators for a specific zone.
+   */
+  unsigned short Get_nVGs(void) const {return nVgs;}
+
+  /*!
+   * \brief Set number of vortex generators for a specific problem.
+   * \param[in] nVgs_zone - Number of vortex genrators for a specific zone.
+   */
+  void Set_nVGs(unsigned short nVgs_zone){nVgs=nVgs_zone;}
+
+  /*!
+   * \brief Get number of vortex generators for a specific problem.
+   * \return - Number of vortex genrators for a specific zone.
+   */
+  unsigned short Get_nPointsVg() const {return nPointsVG;};
+  /*!
+   * \brief Get vortex generators area.
+   * \param[in] iVg - Vortex generator index
+   * \return Area of the vortex generators plane.
+   */
+  su2double Get_Svg(unsigned short iVg) const {return Vg_SurfaceArea[iVg];}
+
+  /*!
+   * \brief Set vortex generators area.
+   * \param[in] Svg - Areas of the vortex generators planes.
+   */
+  void Set_Svg(su2double* Svg){Vg_SurfaceArea=Svg;}
+
+  /*!
+   * \brief Set vortex generators streawise direction.
+   * \param[in] Vg_StreamwiseDirection - Vortex generators streawise direction.
+   */
+  void Set_uhatVg(su2double** uhat){Vg_StreamwiseDirection=uhat;}
+
+  /*!
+   * \brief Get vortex generators streawise direction.
+   * \param[in] iVg - Vortex generator index
+   * \return Vortex generators streawise direction.
+   */
+  su2double* Get_uhatVg(unsigned short iVG) const {return Vg_StreamwiseDirection[iVG];}
+  /*!
+   * \brief Set vortex generators angles.
+   * \param[in] beta - Vortex generators angles.
+   */
+  void Set_betaVg(su2double *beta){Vg_Angle=beta;}
+
+  /*!
+   * \brief Get vortex generators angles.
+   * \param[in] iVg - Vortex generator index
+   * \return Vortex generator angle.
+   */
+  su2double Get_betaVg(unsigned short iVg) const {return Vg_Angle[iVg];}
+
+
+  const string& GetVGFileName() const {return vg_filename;}
+  //End added by max
 };

Common/include/option_structure.hpp

@@ -2571,6 +2571,19 @@ static const MapType<std::string, ENUM_PROJECTION_FUNCTION> Projection_Function_
   MakePair("HEAVISIDE_UP", ENUM_PROJECTION_FUNCTION::HEAVISIDE_UP)
   MakePair("HEAVISIDE_DOWN", ENUM_PROJECTION_FUNCTION::HEAVISIDE_DOWN)
 };
+//Added by max
+
+enum class ENUM_VG_MODEL{
+  NONE,
+  BAY,
+  JBAY
+};
+static const MapType<std::string,ENUM_VG_MODEL> VgModel_Map={
+  MakePair("NONE",ENUM_VG_MODEL::NONE)
+  MakePair("BAY",ENUM_VG_MODEL::BAY)
+  MakePair("JBAY",ENUM_VG_MODEL::JBAY)
+};
+//End added by max
 
 /*!
  * \brief the different validation solution

Common/include/toolboxes/geometry_toolbox.hpp

@@ -216,5 +216,100 @@ inline void TangentProjection(Int nDim, const Mat& tensor, const Scalar* vector,
 
   for (Int iDim = 0; iDim < nDim; iDim++) proj[iDim] -= normalProj * vector[iDim];
 }
+// Added by max
+
+/*!
+ * \brief Check if the edge intersects the plane
+ * \param[in] nDim - Number of dimensions of the particular problem.
+ * \param[in] p0 - Point defining the plane.
+ * \param[in] n - Plane normal vector.
+ * \param[in] p1,p2 - Points defining the edge
+ * \return Returns <code>TRUE</code> if the edge intersect the plane, <code>FALSE</code> it doesn't.
+ */
+template <class T, class Int>
+inline bool IntersectEdge(Int nDim, const T* p0, const T* n, const T* p1, const T* p2) {
+  T d = -DotProduct(nDim, n, p0);
+  auto a = DotProduct(nDim, n, p1) + d;
+  auto b = DotProduct(nDim, n, p2) + d;
+  if (a * b <= 0 && (a != 0 || b != 0))
+    return true;
+  else
+    return false;
+}
+
+/*!
+ * \brief Check if a point is inside a polygon
+ * \param[in] nDim - Number of dimensions of the particular problem.
+ * \param[in] vector - Vector to normalize.
+ */
+template <class T, class Int>
+inline void NormalizeVector(Int nDim, T* vector) {
+  T norm = Norm(nDim, vector);
+  for (Int i = 0; i < nDim; i++) vector[i] /= norm;
+}
+
+/*!
+ * \brief Check if a point is inside a polygon
+ * \param[in] nDim - Number of dimensions of the particular problem.
+ * \param[in] pVert - Point defining the polygon.
+ * \param[in] p0 - Point to test
+ * \param[in] nVert - Number of points that form the polygon.
+ * \return Returns TRUE if the edge intersect the plane, FALSE it doesn't.
+ */
+template <class Mat, class T, class Int>
+inline bool PointInConvexPolygon(Int nDim, const Mat& pVert, const T* p0, int nVert) {
+  unsigned short i = 0, j = 1;
+  unsigned short idxPoint1 = 0, idxPoint2 = 1;
+  unsigned short nIntersections = 0;
+  unsigned short proj_index = 0;
+  T max_proj = 0;
+
+  /* Check which of the x,y,z planes is the most parallel to the polygon */
+
+  if (nDim == 3) {
+    T plane_norm[3];
+    TriangleNormal(pVert, plane_norm);
+    NormalizeVector(3, plane_norm);
+
+    for (unsigned short iDim = 0; iDim < nDim; iDim++) {
+      if (abs(plane_norm[iDim]) > max_proj) {
+        proj_index = iDim;
+        max_proj = abs(plane_norm[iDim]);
+      }
+    }
+
+    switch (proj_index) {
+      case 0:
+        i = 1;
+        j = 2;
+        break;
+      case 1:
+        i = 2;
+        j = 0;
+        break;
+      default:
+        i = 0;
+        j = 1;
+        break;
+    }
+  }
+
+  /* Loop across the polygon edges and check if the ray intersect a vertex */
+
+  for (unsigned short iVert = 1; iVert < nVert + 1; iVert++) {
+    idxPoint2 = iVert % nVert;
+
+    if (((p0[j] < pVert[idxPoint1][j]) != (p0[j] < pVert[idxPoint2][j])) &&
+        (p0[i] < pVert[idxPoint1][i] + ((p0[j] - pVert[idxPoint1][j]) / (pVert[idxPoint2][j] - pVert[idxPoint1][j])) *
+                                           (pVert[idxPoint2][i] - pVert[idxPoint1][i]))) {
+      nIntersections++;
+    }
+    idxPoint1 = idxPoint2;
+  }
+
+  return nIntersections % 2 == 1;
+}
+
+// end added by max
 /// @}
 }  // namespace GeometryToolbox

Common/src/CConfig.cpp

@@ -570,6 +570,18 @@ void CConfig::addActDiskBemOption(const string& name,
   option_map.insert(pair<string, COptionBase *>(name, val));
 }
 
+// // added by max
+// void CConfig::addVgOption(const string& name, unsigned short& nVgs,
+//                           su2double***& Vg_Coordinates, su2double**& Vg_SurfaceNormalDirection,
+//                           su2double**& Vg_SurfaceTangentialDirection, su2double**& Vg_SurfaceCrossFlowDirection,su2double*& Vg_SurfaceArea,ENUM_VG_MODEL& bayModel) {
+//   assert(option_map.find(name) == option_map.end());
+//   all_options.insert(pair<string, bool>(name, true));
+//   COptionBase* val = new COptionVGmodel(name, nVgs, Vg_Coordinates, Vg_SurfaceNormalDirection,
+//                                         Vg_SurfaceTangentialDirection, Vg_SurfaceCrossFlowDirection,Vg_SurfaceArea,bayModel);
+//   option_map.insert(pair<string, COptionBase*>(name, val));
+// }
+// // end added by max
+
 void CConfig::addWallFunctionOption(const string &name, unsigned short &list_size, string* &string_field,
                                     WALL_FUNCTIONS* &val_Kind_WF, unsigned short** &val_IntInfo_WF,
                                     su2double** &val_DoubleInfo_WF) {
@@ -2961,6 +2973,20 @@ void CConfig::SetConfig_Options() {
   /*!\brief ROM_SAVE_FREQ \n DESCRIPTION: How often to save snapshots for unsteady problems.*/
   addUnsignedShortOption("ROM_SAVE_FREQ", rom_save_freq, 1);
 
+//Added by Max
+
+  /*!\brief VG_CONST \n DESCRIPTION: Calibration constant for VG model.*/
+  addEnumOption("VG_MODEL", vg_bay,VgModel_Map, ENUM_VG_MODEL::NONE);
+
+  /*!\brief VG_CONST \n DESCRIPTION: Calibration constant for VG model.*/
+  addDoubleOption("VG_CONST", vg_constant, 10);
+
+  /*!\brief VG_CONFIG \n DESCRIPTION: VG configuration file name*/
+  addStringOption("VG_CONFIG", vg_filename, " ");
+  // addVgOption("VG_CONFIG",nVgs,Vg_Coordinates,Vg_SurfaceNormalDirection,Vg_SurfaceTangentialDirection,Vg_SurfaceCrossFlowDirection,Vg_SurfaceArea,vg_bay);
+
+  //End Max
+
   /* END_CONFIG_OPTIONS */
 
 }
@@ -8220,6 +8246,29 @@ CConfig::~CConfig() {
 
   delete [] nBlades;
   delete [] FreeStreamTurboNormal;
+  //Added by max
+
+  /*--- Free variables used for the VG model ---*/
+
+  for(unsigned short iVG=0;iVG<nVgs;iVG++){
+    for(unsigned short iPoint=0;iPoint<nPointsVG;iPoint++){
+      delete [] Vg_Coordinates[iVG][iPoint];
+    }
+    delete [] Vg_Coordinates[iVG];
+    delete [] Vg_SurfaceNormalDirection[iVG];
+    delete [] Vg_SurfaceTangentialDirection[iVG];
+    delete [] Vg_SurfaceCrossFlowDirection[iVG];
+    delete [] Vg_StreamwiseDirection[iVG];
+  }
+  delete [] Vg_Coordinates;
+  delete [] Vg_SurfaceNormalDirection;
+  delete [] Vg_SurfaceTangentialDirection;
+  delete [] Vg_SurfaceCrossFlowDirection;
+  delete [] Vg_StreamwiseDirection;
+  delete [] Vg_SurfaceArea;
+  delete [] Vg_Angle;
+
+//End added by max
 }
 
 string CConfig::GetFilename(string filename, const string& ext, int timeIter) const {