Merge branch 'develop' into feature_NEMO_newton

Author: WallyMaier

.github/workflows/release-management.yml

@@ -23,7 +23,7 @@ jobs:
           - os_bin: macos64-mpi
             flags: '-Dcustom-mpi=true --cross-file=/hostfiles/hostfile_darwin_mpi'
           - os_bin: linux64
-            flags: '-Dwith-mpi=disabled --cross-file=/hostfiles/hostfile_linux'
+            flags: '-Dwith-mpi=disabled -Dstatic-cgns-deps=true --cross-file=/hostfiles/hostfile_linux'
           - os_bin: linux64-mpi
             flags: '-Dcustom-mpi=true --cross-file=/hostfiles/hostfile_linux_mpi'
     runs-on: ubuntu-latest

Common/src/geometry/CGeometry.cpp

@@ -3510,14 +3510,16 @@ void CGeometry::SetRotationalVelocity(const CConfig *config, bool print) {
   unsigned long iPoint;
   unsigned short iDim;
 
-  su2double RotVel[3] = {0.0,0.0,0.0}, Distance[3] = {0.0,0.0,0.0},
-            Center[3] = {0.0,0.0,0.0}, Omega[3] = {0.0,0.0,0.0};
+  su2double GridVel[3] = {0.0,0.0,0.0}, Distance[3] = {0.0,0.0,0.0},
+            Center[3] = {0.0,0.0,0.0}, Omega[3] = {0.0,0.0,0.0},
+            xDot[3] = {0.0,0.0,0.0};
 
   /*--- Center of rotation & angular velocity vector from config ---*/
 
   for (iDim = 0; iDim < 3; iDim++) {
     Center[iDim] = config->GetMotion_Origin(iDim);
     Omega[iDim]  = config->GetRotation_Rate(iDim)/config->GetOmega_Ref();
+    xDot[iDim] = config->GetTranslation_Rate(iDim)/config->GetVelocity_Ref();
   }
 
   su2double L_Ref = config->GetLength_Ref();
@@ -3529,9 +3531,11 @@ void CGeometry::SetRotationalVelocity(const CConfig *config, bool print) {
     cout << ", " << Center[2] << " )\n";
     cout << " Angular velocity about x, y, z axes: ( " << Omega[0] << ", ";
     cout << Omega[1] << ", " << Omega[2] << " ) rad/s" << endl;
+    cout << " Translational velocity in x, y, z direction: ("
+         << xDot[0] << ", " << xDot[1] << ", " << xDot[2] << ")." << endl;
   }
 
-  /*--- Loop over all nodes and set the rotational velocity ---*/
+  /*--- Loop over all nodes and set the rotational and translational velocity ---*/
 
   for (iPoint = 0; iPoint < nPoint; iPoint++) {
 
@@ -3544,15 +3548,15 @@ void CGeometry::SetRotationalVelocity(const CConfig *config, bool print) {
     for (iDim = 0; iDim < nDim; iDim++)
       Distance[iDim] = (Coord[iDim]-Center[iDim])/L_Ref;
 
-    /*--- Calculate the angular velocity as omega X r ---*/
+    /*--- Calculate the angular velocity as omega X r and add translational velocity ---*/
 
-    RotVel[0] = Omega[1]*(Distance[2]) - Omega[2]*(Distance[1]);
-    RotVel[1] = Omega[2]*(Distance[0]) - Omega[0]*(Distance[2]);
-    RotVel[2] = Omega[0]*(Distance[1]) - Omega[1]*(Distance[0]);
+    GridVel[0] = Omega[1]*(Distance[2]) - Omega[2]*(Distance[1]) + xDot[0];
+    GridVel[1] = Omega[2]*(Distance[0]) - Omega[0]*(Distance[2]) + xDot[1];
+    GridVel[2] = Omega[0]*(Distance[1]) - Omega[1]*(Distance[0]) + xDot[2];
 
     /*--- Store the grid velocity at this node ---*/
 
-    nodes->SetGridVel(iPoint, RotVel);
+    nodes->SetGridVel(iPoint, GridVel);
 
   }
 

SU2_CFD/src/output/COutput.cpp

@@ -924,16 +924,16 @@ bool COutput::GetCauchyCorrectedTimeConvergence(const CConfig *config){
 }
 
 bool COutput::SetResult_Files(CGeometry *geometry, CConfig *config, CSolver** solver_container,
-                              unsigned long iter, bool force_writing){
+                              unsigned long iter, bool force_writing) {
 
-  bool isFileWrite=false;
-  unsigned short nVolumeFiles = config->GetnVolumeOutputFiles();
-  auto VolumeFiles = config->GetVolumeOutputFiles();
+  bool isFileWrite = false;
+  const auto nVolumeFiles = config->GetnVolumeOutputFiles();
+  const auto* VolumeFiles = config->GetVolumeOutputFiles();
 
   /*--- Check if the data sorters are allocated, if not, allocate them. --- */
   AllocateDataSorters(config, geometry);
 
-  for (unsigned short iFile = 0; iFile < nVolumeFiles; iFile++){
+  for (unsigned short iFile = 0; iFile < nVolumeFiles; iFile++) {
 
     /*--- Collect the volume data from the solvers.
      *  If time-domain is enabled, we also load the data although we don't output it,
@@ -947,7 +947,7 @@ bool COutput::SetResult_Files(CGeometry *geometry, CConfig *config, CSolver** so
 
     volumeDataSorter->SortOutputData();
 
-    if (rank == MASTER_NODE && !isFileWrite){
+    if (rank == MASTER_NODE && !isFileWrite) {
       fileWritingTable->SetAlign(PrintingToolbox::CTablePrinter::CENTER);
       fileWritingTable->PrintHeader();
       fileWritingTable->SetAlign(PrintingToolbox::CTablePrinter::LEFT);
@@ -958,18 +958,18 @@ bool COutput::SetResult_Files(CGeometry *geometry, CConfig *config, CSolver** so
 
     WriteToFile(config, geometry, VolumeFiles[iFile]);
 
-    if (rank == MASTER_NODE && !isFileWrite){
-      fileWritingTable->PrintFooter();
-      headerNeeded = true;
-    }
-
     /*--- Write any additonal files defined in the child class ----*/
 
     WriteAdditionalFiles(config, geometry, solver_container);
 
     isFileWrite = true;
   }
 
+  if (rank == MASTER_NODE && isFileWrite) {
+    fileWritingTable->PrintFooter();
+    headerNeeded = true;
+  }
+
   return isFileWrite;
 }
 
@@ -1006,90 +1006,83 @@ void COutput::PrintConvergenceSummary(){
 
 bool COutput::Convergence_Monitoring(CConfig *config, unsigned long Iteration) {
 
-  unsigned short iCounter;
-
   convergence = true;
 
-  for (unsigned short iField_Conv = 0; iField_Conv < convFields.size(); iField_Conv++){
+  for (auto iField_Conv = 0ul; iField_Conv < convFields.size(); iField_Conv++) {
 
-    bool fieldConverged = false;
+    const auto& convField = convFields[iField_Conv];
+    const auto it = historyOutput_Map.find(convField);
 
-    const string &convField = convFields[iField_Conv];
-    if (historyOutput_Map.count(convField) > 0){
-      su2double monitor = historyOutput_Map.at(convField).value;
+    if (it == historyOutput_Map.end()) continue;
 
-      /*--- Stop the simulation in case a nan appears, do not save the solution ---*/
-      if (std::isnan(SU2_TYPE::GetValue(monitor))) {
-        SU2_MPI::Error("SU2 has diverged (NaN detected).", CURRENT_FUNCTION);
-      }
+    const auto& field = it->second;
+    const su2double monitor = field.value;
 
-      /*--- Cauchy based convergence criteria ---*/
+    /*--- Stop the simulation in case a nan appears, do not save the solution. ---*/
+    if (std::isnan(SU2_TYPE::GetValue(monitor))) {
+      SU2_MPI::Error("SU2 has diverged (NaN detected).", CURRENT_FUNCTION);
+    }
 
-      if (historyOutput_Map.at(convField).fieldType == HistoryFieldType::COEFFICIENT) {
+    bool fieldConverged = false;
+
+    switch (field.fieldType) {
+
+      /*--- Cauchy based convergence criteria ---*/
+      case HistoryFieldType::COEFFICIENT: {
 
-        if (Iteration == 0){
-          for (iCounter = 0; iCounter < nCauchy_Elems; iCounter++){
+        if (Iteration == 0) {
+          for (auto iCounter = 0ul; iCounter < nCauchy_Elems; iCounter++) {
             cauchySerie[iField_Conv][iCounter] = 0.0;
           }
           newFunc[iField_Conv] = monitor;
         }
 
         oldFunc[iField_Conv] = newFunc[iField_Conv];
         newFunc[iField_Conv] = monitor;
-        cauchyFunc = fabs(newFunc[iField_Conv] - oldFunc[iField_Conv])/fabs(monitor);
+        /*--- Automatically modify the scaling factor of relative Cauchy convergence for 
+        * coefficients that are close to zero. Example: For the clean aircraft, the rolling 
+        * moment coefficient MOMENT_X is close to zero and thus will never reach a relative 
+        * cauchy convergence ->> dividing tiny numbers is not a good idea. Using absolute 
+        * cauchy convergence is more robust in this case. ---*/
+        cauchyFunc = fabs(newFunc[iField_Conv] - oldFunc[iField_Conv]) / fmax(fabs(monitor), 0.1);
 
         cauchySerie[iField_Conv][Iteration % nCauchy_Elems] = cauchyFunc;
         cauchyValue = 0.0;
-        for (iCounter = 0; iCounter < nCauchy_Elems; iCounter++)
+        for (auto iCounter = 0ul; iCounter < nCauchy_Elems; iCounter++)
           cauchyValue += cauchySerie[iField_Conv][iCounter];
 
         cauchyValue /= nCauchy_Elems;
 
-        if (cauchyValue >= cauchyEps) { fieldConverged = false;}
-        else { fieldConverged = true;}
-
         /*--- Start monitoring only if the current iteration
-         *  is larger than the number of cauchy elements and
-         * the number of start-up iterations --- */
-
-        if (Iteration < max(config->GetStartConv_Iter(), nCauchy_Elems)){
-          fieldConverged = false;
-        }
+         *    is larger than the number of cauchy elements. --- */
+        fieldConverged = (cauchyValue < cauchyEps) && (Iteration >= nCauchy_Elems);
 
+        if (Iteration == 0) cauchyValue = 1.0;
         SetHistoryOutputValue("CAUCHY_" + convField, cauchyValue);
 
-        if(Iteration == 0){
-          SetHistoryOutputValue("CAUCHY_" + convField, 1.0);
-        }
-      }
+      } break;
 
 
       /*--- Residual based convergence criteria ---*/
+      case HistoryFieldType::RESIDUAL:
+      case HistoryFieldType::AUTO_RESIDUAL:
 
-      if (historyOutput_Map.at(convField).fieldType == HistoryFieldType::RESIDUAL ||
-          historyOutput_Map.at(convField).fieldType == HistoryFieldType::AUTO_RESIDUAL) {
-
-        /*--- Check the convergence ---*/
-
-        if (Iteration != 0 && (monitor <= minLogResidual)) { fieldConverged = true;  }
-        else { fieldConverged = false; }
-
-      }
-
-      /*--- Do not apply any convergence criteria of the number
-     of iterations is less than a particular value ---*/
-
-      if (Iteration < config->GetStartConv_Iter()) {
-        fieldConverged = false;
-      }
+        fieldConverged = (Iteration != 0) && (monitor <= minLogResidual);
+        break;
 
-      convergence = fieldConverged && convergence;
+      default:
+        break;
     }
+
+    convergence = fieldConverged && convergence;
   }
 
-  if (convFields.empty()) convergence = false;
+  /*--- Do not apply any convergence criteria if the number
+   *    of iterations is less than a particular value. ---*/
+
+  if (convFields.empty() || Iteration < config->GetStartConv_Iter()) convergence = false;
 
-  /*--- Apply the same convergence criteria to all the processors ---*/
+  /*--- Apply the same convergence criteria to all processors. ---*/
 
   unsigned short local = convergence, global = 0;
   SU2_MPI::Allreduce(&local, &global, 1, MPI_UNSIGNED_SHORT, MPI_MAX, SU2_MPI::GetComm());

TestCases/py_wrapper/translating_NACA0012/config.cfg

@@ -8,9 +8,13 @@ RESTART_SOL= NO
 % FREE-STREAM DEFINITION
 %
 % We are translating the domain instead of having farfield velocity.
-GRID_MOVEMENT= STEADY_TRANSLATION
-MOTION_ORIGIN= ( 0.0, 0.0, 0.0 )
-TRANSLATION_RATE= ( -264.994, -5.78219, 0.0 )
+% Note: The rotating frame is intended for 3D cases. To use the feature in a 2D case,
+% care must be taken with respect to the axes, e.g. to obtain a pitching motion, a 
+% rotation about the z-axis can be used.
+GRID_MOVEMENT= ROTATING_FRAME
+MOTION_ORIGIN= 0.0, 0.0, 0.0
+ROTATION_RATE=  0.0, 0.0, 0.5 
+TRANSLATION_RATE= -264.994, -5.78219, 0.0 
 MACH_NUMBER= 0.0
 FREESTREAM_PRESSURE= 101325.0
 FREESTREAM_TEMPERATURE= 273.15
@@ -68,6 +72,6 @@ CONV_RESIDUAL_MINVAL= -9
 %
 MESH_FILENAME= ../../euler/naca0012/mesh_NACA0012_inv.su2
 MESH_FORMAT= SU2
-SCREEN_OUTPUT= (INNER_ITER, RMS_RES, LIFT, DRAG)
+SCREEN_OUTPUT= (INNER_ITER, RMS_RES, LIFT, DRAG, MOMENT_X, MOMENT_Y, MOMENT_Z)
 HISTORY_OUTPUT= (INNER_ITER, RMS_RES, AERO_COEFF)