diff --git a/Common/include/CConfig.hpp b/Common/include/CConfig.hpp index 7405a527eac..8d5e4f37789 100644 --- a/Common/include/CConfig.hpp +++ b/Common/include/CConfig.hpp @@ -472,7 +472,7 @@ class CConfig { string CustomObjFunc; /*!< \brief User-defined objective function. */ string CustomOutputs; /*!< \brief User-defined functions for outputs. */ unsigned short nDV, /*!< \brief Number of design variables. */ - nObj, nObjW; /*! \brief Number of objective functions. */ + nObj, nObjW; /*!< \brief Number of objective functions. */ unsigned short* nDV_Value; /*!< \brief Number of values for each design variable (might be different than 1 if we allow arbitrary movement). */ unsigned short nFFDBox; /*!< \brief Number of ffd boxes. */ unsigned short nTurboMachineryKind; /*!< \brief Number turbomachinery types specified. */ @@ -489,20 +489,14 @@ class CConfig { string *FFDTag; /*!< \brief Parameters of the design variable. */ string *TagFFDBox; /*!< \brief Tag of the FFD box. */ unsigned short GeometryMode; /*!< \brief Geometry mode (analysis or gradient computation). */ - unsigned short MGCycle; /*!< \brief Kind of multigrid cycle. */ unsigned short FinestMesh; /*!< \brief Finest mesh for the full multigrid approach. */ unsigned short nFFD_Fix_IDir, nFFD_Fix_JDir, nFFD_Fix_KDir; /*!< \brief Number of planes fixed in the FFD. */ - unsigned short nMG_PreSmooth, /*!< \brief Number of MG pre-smooth parameters found in config file. */ - nMG_PostSmooth, /*!< \brief Number of MG post-smooth parameters found in config file. */ - nMG_CorrecSmooth; /*!< \brief Number of MG correct-smooth parameters found in config file. */ short *FFD_Fix_IDir, *FFD_Fix_JDir, *FFD_Fix_KDir; /*!< \brief Exact sections. */ - unsigned short *MG_PreSmooth, /*!< \brief Multigrid Pre smoothing. */ - *MG_PostSmooth, /*!< \brief Multigrid Post smoothing. */ - *MG_CorrecSmooth; /*!< \brief Multigrid Jacobi implicit smoothing of the correction. */ su2double *LocationStations; /*!< \brief Airfoil sections in wing slicing subroutine. */ + MG_CYCLE Kind_MGCycle; /*!< \brief Kind of multigrid cycle. */ ENUM_MULTIZONE Kind_MZSolver; /*!< \brief Kind of multizone solver. */ INC_DENSITYMODEL Kind_DensityModel; /*!< \brief Kind of the density model for incompressible flows. */ CHT_COUPLING Kind_CHT_Coupling; /*!< \brief Kind of coupling method used at CHT interfaces. */ @@ -1132,6 +1126,10 @@ class CConfig { unsigned long rampMUSCLCoeff[3]; /*!< \brief ramp MUSCL value coefficients for the COption class. */ } RampMUSCLParam; su2double rampMUSCLValue; /*!< \brief Current value of the MUSCL ramp */ + CMGOptions MGOptions; + /*--- Multigrid options ---*/ + unsigned short nMG_PreSmooth_p{0}, nMG_PostSmooth_p{0}, nMG_CorrecSmooth_p{0}; + unsigned short *MG_PreSmooth_p{nullptr}, *MG_PostSmooth_p{nullptr}, *MG_CorrecSmooth_p{nullptr}; ENUM_STREAMWISE_PERIODIC Kind_Streamwise_Periodic; /*!< \brief Kind of Streamwise periodic flow (pressure drop or massflow) */ bool Streamwise_Periodic_Temperature; /*!< \brief Use real periodicity for Energy equation or otherwise outlet source term. */ @@ -2908,7 +2906,7 @@ class CConfig { */ void SetMGLevels(unsigned short val_nMGLevels) { nMGLevels = val_nMGLevels; - if (MGCycle == FULLMG_CYCLE) { + if (Kind_MGCycle == MG_CYCLE::FULL) { SetFinestMesh(val_nMGLevels); } } @@ -2925,7 +2923,7 @@ class CConfig { * \note This variable is used in a recursive way to perform the different kind of cycles * \return 0 or 1 depending of we are dealing with a V or W cycle. */ - unsigned short GetMGCycle(void) const { return MGCycle; } + MG_CYCLE GetMGCycle(void) const { return Kind_MGCycle; } /*! * \brief Get the king of evaluation in the geometrical module. @@ -3847,34 +3845,9 @@ class CConfig { su2double GetNacelleLocation(unsigned short val_index) const { return nacelle_location[val_index]; } /*! - * \brief Get the number of pre-smoothings in a multigrid strategy. - * \param[in] val_mesh - Index of the grid. - * \return Number of smoothing iterations. + * \brief Get the multigrid options struct. */ - unsigned short GetMG_PreSmooth(unsigned short val_mesh) const { - if (nMG_PreSmooth == 0) return 1; - return MG_PreSmooth[val_mesh]; - } - - /*! - * \brief Get the number of post-smoothings in a multigrid strategy. - * \param[in] val_mesh - Index of the grid. - * \return Number of smoothing iterations. - */ - unsigned short GetMG_PostSmooth(unsigned short val_mesh) const { - if (nMG_PostSmooth == 0) return 0; - return MG_PostSmooth[val_mesh]; - } - - /*! - * \brief Get the number of implicit Jacobi smoothings of the correction in a multigrid strategy. - * \param[in] val_mesh - Index of the grid. - * \return Number of implicit smoothing iterations. - */ - unsigned short GetMG_CorrecSmooth(unsigned short val_mesh) const { - if (nMG_CorrecSmooth == 0) return 0; - return MG_CorrecSmooth[val_mesh]; - } + const CMGOptions& GetMGOptions() const { return MGOptions; } /*! * \brief plane of the FFD (I axis) that should be fixed. @@ -6833,12 +6806,24 @@ class CConfig { */ su2double GetDamp_Res_Restric(void) const { return Damp_Res_Restric; } + /*! + * \brief Set the damping factor for the residual restriction (used by adaptive MG damping). + * \param[in] val - New damping factor value. + */ + void SetDamp_Res_Restric(su2double val) { Damp_Res_Restric = val; } + /*! * \brief Value of the damping factor for the correction prolongation. * \return Value of the damping factor. */ su2double GetDamp_Correc_Prolong(void) const { return Damp_Correc_Prolong; } + /*! + * \brief Set the damping factor for the correction prolongation (used by adaptive MG damping). + * \param[in] val - New damping factor value. + */ + void SetDamp_Correc_Prolong(su2double val) { Damp_Correc_Prolong = val; } + /*! * \brief Value of the position of the Near Field (y coordinate for 2D, and z coordinate for 3D). * \return Value of the Near Field position. diff --git a/Common/include/geometry/CGeometry.hpp b/Common/include/geometry/CGeometry.hpp index 563674def66..62600b08958 100644 --- a/Common/include/geometry/CGeometry.hpp +++ b/Common/include/geometry/CGeometry.hpp @@ -811,10 +811,13 @@ class CGeometry { inline virtual void MatchActuator_Disk(const CConfig* config) {} /*! - * \brief A virtual member. + * \brief Match periodic boundary points using coordinate-based matching. + * \details Gathers coordinates from all ranks via MPI, applies the rotation/translation + * for the periodic pair, and finds the nearest neighbor. Works on both fine and coarse grids. * \param[in] config - Definition of the particular problem. + * \param[in] val_periodic - Index of the periodic marker pair. */ - inline virtual void MatchPeriodic(const CConfig* config, unsigned short val_periodic) {} + virtual void MatchPeriodic(const CConfig* config, unsigned short val_periodic); /*! * \brief A virtual member. @@ -1609,12 +1612,6 @@ class CGeometry { return AverageGridVel[val_marker][val_span]; } - /*! - * \brief A virtual member. - * \param config - Config - */ - inline virtual void Check_Periodicity(CConfig* config) {} - /*! * \brief Get the value of the customized temperature at a specified vertex on a specified marker. * \param[in] val_marker - Marker value diff --git a/Common/include/geometry/CMultiGridGeometry.hpp b/Common/include/geometry/CMultiGridGeometry.hpp index f6036be227f..f155ec7c2c8 100644 --- a/Common/include/geometry/CMultiGridGeometry.hpp +++ b/Common/include/geometry/CMultiGridGeometry.hpp @@ -29,6 +29,8 @@ #include "CGeometry.hpp" +class CMultiGridQueue; + /*! * \class CMultiGridGeometry * \brief Class for defining the multigrid geometry, the main dedicated part is the @@ -75,6 +77,16 @@ class CMultiGridGeometry final : public CGeometry { */ su2double ComputeLocalCurvature(const CGeometry* fine_grid, unsigned long iPoint, unsigned short iMarker) const; + /*! + * \brief Agglomerate high-aspect-ratio interior cells along implicit lines from wall vertices. + * \param[in,out] Index_CoarseCV - Current coarse CV index, incremented as new coarse CVs are created. + * \param[in] fine_grid - Fine grid geometry. + * \param[in] config - Configuration. + * \param[in,out] MGQueue_InnerCV - Queue for domain agglomeration; processed points are removed. + */ + void AgglomerateImplicitLines(unsigned long& Index_CoarseCV, const CGeometry* fine_grid, const CConfig* config, + CMultiGridQueue& MGQueue_InnerCV); + public: /*--- This is to suppress Woverloaded-virtual, omitting it has no negative impact. ---*/ using CGeometry::SetBoundControlVolume; @@ -143,13 +155,6 @@ class CMultiGridGeometry final : public CGeometry { */ void MatchActuator_Disk(const CConfig* config) override; - /*! - * \brief Mach the periodic boundary conditions. - * \param[in] config - Definition of the particular problem. - * \param[in] val_periodic - Index of the first periodic face in a pair. - */ - void MatchPeriodic(const CConfig* config, unsigned short val_periodic) override; - /*! * \brief Set a representative wall normal heat flux of the agglomerated control volume on a particular boundary * marker. \param[in] fine_grid - Geometrical definition of the problem. \param[in] val_marker - Index of the boundary diff --git a/Common/include/geometry/CPhysicalGeometry.hpp b/Common/include/geometry/CPhysicalGeometry.hpp index be0863584d4..89176d99603 100644 --- a/Common/include/geometry/CPhysicalGeometry.hpp +++ b/Common/include/geometry/CPhysicalGeometry.hpp @@ -438,13 +438,6 @@ class CPhysicalGeometry final : public CGeometry { */ void MatchActuator_Disk(const CConfig* config) override; - /*! - * \brief Mach the periodic boundary conditions. - * \param[in] config - Definition of the particular problem. - * \param[in] val_periodic - Index of the first periodic face in a pair. - */ - void MatchPeriodic(const CConfig* config, unsigned short val_periodic) override; - /*! * \brief Set boundary vertex structure of the control volume. * \param[in] config - Definition of the particular problem. @@ -779,12 +772,6 @@ class CPhysicalGeometry final : public CGeometry { Sensitivity(iPoint, iDim) = val; } - /*! - * \brief Check the mesh for periodicity and deactivate multigrid if periodicity is found. - * \param[in] config - Definition of the particular problem. - */ - void Check_Periodicity(CConfig* config) override; - /*! * \brief Compute an ADT including the coordinates of all viscous markers * \param[in] config - Definition of the particular problem. diff --git a/Common/include/linear_algebra/CSysSolve.hpp b/Common/include/linear_algebra/CSysSolve.hpp index 611223b657b..11623f7bdb2 100644 --- a/Common/include/linear_algebra/CSysSolve.hpp +++ b/Common/include/linear_algebra/CSysSolve.hpp @@ -196,7 +196,7 @@ class CSysSolve { * vector is kept in nrm0 and updated after operating with each vector * */ - void ModGramSchmidt(bool shared_hsbg, int i, su2matrix& Hsbg, std::vector& w) const; + bool ModGramSchmidt(bool shared_hsbg, int i, su2matrix& Hsbg, std::vector& w) const; /*! * \brief writes header information for a CSysSolve residual history diff --git a/Common/include/option_structure.hpp b/Common/include/option_structure.hpp index 1361a12072d..b3d2478cf5f 100644 --- a/Common/include/option_structure.hpp +++ b/Common/include/option_structure.hpp @@ -1101,6 +1101,21 @@ inline SST_ParsedOptions ParseSSTOptions(const SST_OPTIONS *SST_Options, unsigne return SSTParsedOptions; } +/*! + * \brief Structure containing multigrid options. + */ +struct CMGOptions { + su2double MG_Smooth_Res_Threshold{0.0}; /*!< \brief RMS reduction threshold for MG smoothing early exit. */ + su2double MG_Smooth_Coeff{0.0}; /*!< \brief Jacobi smoother coefficient for coarse-grid correction. */ + unsigned long MG_Min_MeshSize{0}; /*!< \brief Minimum CVs on coarsest MG level. */ + std::vector MG_PreSmooth; /*!< \brief Multigrid pre-smoothing iterations per level. */ + std::vector MG_PostSmooth; /*!< \brief Multigrid post-smoothing iterations per level. */ + std::vector MG_CorrecSmooth; /*!< \brief Multigrid Jacobi correction-smoothing per level. */ + bool MG_Smooth_EarlyExit{false}; /*!< \brief Enable early exit for MG smoothing iterations. */ + bool MG_Smooth_Output{false}; /*!< \brief Output compact per-cycle smoothing summary. */ + bool MG_Implicit_Lines{false}; /*!< \brief Enable implicit-lines agglomeration from walls. */ +}; + /*! * \brief SST rough-wall boundary conditions Options */ @@ -2281,17 +2296,17 @@ static const MapType Jump_Map = { /*! * \brief Type of multigrid cycle */ -enum MG_CYCLE { - V_CYCLE = 0, /*!< \brief V cycle. */ - W_CYCLE = 1, /*!< \brief W cycle. */ - FULLMG_CYCLE = 2 /*!< \brief FullMG cycle. */ +enum class MG_CYCLE { + V, /*!< \brief V-cycle multigrid solver. */ + W, /*!< \brief W-cycle multigrid solver. */ + FULL, /*!< \brief Full multigrid (FMG) solver. */ }; + static const MapType MG_Cycle_Map = { - MakePair("V_CYCLE", V_CYCLE) - MakePair("W_CYCLE", W_CYCLE) - MakePair("FULLMG_CYCLE", FULLMG_CYCLE) + MakePair("V_CYCLE", MG_CYCLE::V) + MakePair("W_CYCLE", MG_CYCLE::W) + MakePair("FULLMG_CYCLE", MG_CYCLE::FULL) }; - /*! * \brief Types of design parameterizations */ diff --git a/Common/src/CConfig.cpp b/Common/src/CConfig.cpp index 79fe6d6aab1..65a84ed437d 100644 --- a/Common/src/CConfig.cpp +++ b/Common/src/CConfig.cpp @@ -993,9 +993,6 @@ void CConfig::SetPointersNull() { TimeIntegrationADER_DG = nullptr; WeightsIntegrationADER_DG = nullptr; RK_Alpha_Step = nullptr; - MG_CorrecSmooth = nullptr; - MG_PreSmooth = nullptr; - MG_PostSmooth = nullptr; Int_Coeffs = nullptr; Kind_Inc_Inlet = nullptr; @@ -1973,17 +1970,29 @@ void CConfig::SetConfig_Options() { /*!\brief MGLEVEL\n DESCRIPTION: Multi-grid Levels. DEFAULT: 0 \ingroup Config*/ addUnsignedShortOption("MGLEVEL", nMGLevels, 0); /*!\brief MGCYCLE\n DESCRIPTION: Multi-grid cycle. OPTIONS: See \link MG_Cycle_Map \endlink. Defualt V_CYCLE \ingroup Config*/ - addEnumOption("MGCYCLE", MGCycle, MG_Cycle_Map, V_CYCLE); + addEnumOption("MGCYCLE", Kind_MGCycle, MG_Cycle_Map, MG_CYCLE::V); /*!\brief MG_PRE_SMOOTH\n DESCRIPTION: Multi-grid pre-smoothing level \ingroup Config*/ - addUShortListOption("MG_PRE_SMOOTH", nMG_PreSmooth, MG_PreSmooth); + addUShortListOption("MG_PRE_SMOOTH", nMG_PreSmooth_p, MG_PreSmooth_p); /*!\brief MG_POST_SMOOTH\n DESCRIPTION: Multi-grid post-smoothing level \ingroup Config*/ - addUShortListOption("MG_POST_SMOOTH", nMG_PostSmooth, MG_PostSmooth); + addUShortListOption("MG_POST_SMOOTH", nMG_PostSmooth_p, MG_PostSmooth_p); /*!\brief MG_CORRECTION_SMOOTH\n DESCRIPTION: Jacobi implicit smoothing of the correction \ingroup Config*/ - addUShortListOption("MG_CORRECTION_SMOOTH", nMG_CorrecSmooth, MG_CorrecSmooth); + addUShortListOption("MG_CORRECTION_SMOOTH", nMG_CorrecSmooth_p, MG_CorrecSmooth_p); /*!\brief MG_DAMP_RESTRICTION\n DESCRIPTION: Damping factor for the residual restriction. DEFAULT: 0.75 \ingroup Config*/ - addDoubleOption("MG_DAMP_RESTRICTION", Damp_Res_Restric, 0.75); + addDoubleOption("MG_DAMP_RESTRICTION", Damp_Res_Restric, 0.5); /*!\brief MG_DAMP_PROLONGATION\n DESCRIPTION: Damping factor for the correction prolongation. DEFAULT 0.75 \ingroup Config*/ - addDoubleOption("MG_DAMP_PROLONGATION", Damp_Correc_Prolong, 0.75); + addDoubleOption("MG_DAMP_PROLONGATION", Damp_Correc_Prolong, 0.5); + /*!\brief MG_SMOOTH_EARLY_EXIT\n DESCRIPTION: Enable early exit for MG smoothing when RMS drops below threshold. DEFAULT: NO \ingroup Config*/ + addBoolOption("MG_SMOOTH_EARLY_EXIT", MGOptions.MG_Smooth_EarlyExit, true); + /*!\brief MG_SMOOTH_RES_THRESHOLD\n DESCRIPTION: Smoothing stops when current_rms < threshold * initial_rms. DEFAULT: 0.1 \ingroup Config*/ + addDoubleOption("MG_SMOOTH_RES_THRESHOLD", MGOptions.MG_Smooth_Res_Threshold, 0.5); + /*!\brief MG_SMOOTH_OUTPUT\n DESCRIPTION: Print compact per-cycle smoothing iteration summary. DEFAULT: NO \ingroup Config*/ + addBoolOption("MG_SMOOTH_OUTPUT", MGOptions.MG_Smooth_Output, false); + /*!\brief MG_SMOOTH_COEFF\n DESCRIPTION: Smoothing coefficient for the correction prolongation Jacobi smoother. DEFAULT: 1.25 \ingroup Config*/ + addDoubleOption("MG_SMOOTH_COEFF", MGOptions.MG_Smooth_Coeff, 1.25); + /*!\brief MG_MIN_MESHSIZE\n DESCRIPTION: Minimum number of CVs on the coarsest multigrid level. Levels that would produce fewer CVs are not created. DEFAULT: 50 \ingroup Config*/ + addUnsignedLongOption("MG_MIN_MESHSIZE", MGOptions.MG_Min_MeshSize, 500); + /*!\brief MG_IMPLICIT_LINES\n DESCRIPTION: Enable agglomeration along implicit lines from wall seeds. DEFAULT: NO \ingroup Config*/ + addBoolOption("MG_IMPLICIT_LINES", MGOptions.MG_Implicit_Lines, false); /*!\par CONFIG_CATEGORY: Spatial Discretization \ingroup Config*/ /*--- Options related to the spatial discretization ---*/ @@ -4692,7 +4701,7 @@ void CConfig::SetPostprocessing(SU2_COMPONENT val_software, unsigned short val_i } FinestMesh = MESH_0; - if (MGCycle == FULLMG_CYCLE) FinestMesh = nMGLevels; + if (Kind_MGCycle == MG_CYCLE::FULL) FinestMesh = nMGLevels; if ((Kind_Solver == MAIN_SOLVER::NAVIER_STOKES) && (Kind_Turb_Model != TURB_MODEL::NONE)) @@ -4713,128 +4722,36 @@ void CConfig::SetPostprocessing(SU2_COMPONENT val_software, unsigned short val_i Kappa_2nd_AdjFlow = jst_adj_coeff[0]; Kappa_4th_AdjFlow = jst_adj_coeff[1]; - /*--- Make the MG_PreSmooth, MG_PostSmooth, and MG_CorrecSmooth - arrays consistent with nMGLevels ---*/ + /*--- Fill MG smooth vectors to size nMGLevels+1. + Use parsed values (truncating or extending by repeat) or defaults if not set. ---*/ - auto * tmp_smooth = new unsigned short[nMGLevels+1]; - - if ((nMG_PreSmooth != nMGLevels+1) && (nMG_PreSmooth != 0)) { - if (nMG_PreSmooth > nMGLevels+1) { - - /*--- Truncate by removing unnecessary elements at the end ---*/ - - for (unsigned int i = 0; i <= nMGLevels; i++) - tmp_smooth[i] = MG_PreSmooth[i]; - delete [] MG_PreSmooth; - MG_PreSmooth=nullptr; - } - else { - - /*--- Add additional elements equal to last element ---*/ - - for (unsigned int i = 0; i < nMG_PreSmooth; i++) - tmp_smooth[i] = MG_PreSmooth[i]; - for (unsigned int i = nMG_PreSmooth; i <= nMGLevels; i++) - tmp_smooth[i] = MG_PreSmooth[nMG_PreSmooth-1]; - delete [] MG_PreSmooth; - MG_PreSmooth=nullptr; - } - - nMG_PreSmooth = nMGLevels+1; - MG_PreSmooth = new unsigned short[nMG_PreSmooth]; - for (unsigned int i = 0; i < nMG_PreSmooth; i++) - MG_PreSmooth[i] = tmp_smooth[i]; - } - if ((nMGLevels != 0) && (nMG_PreSmooth == 0)) { - delete [] MG_PreSmooth; - nMG_PreSmooth = nMGLevels+1; - MG_PreSmooth = new unsigned short[nMG_PreSmooth]; - for (unsigned int i = 0; i < nMG_PreSmooth; i++) - MG_PreSmooth[i] = i+1; - } - - if ((nMG_PostSmooth != nMGLevels+1) && (nMG_PostSmooth != 0)) { - if (nMG_PostSmooth > nMGLevels+1) { - - /*--- Truncate by removing unnecessary elements at the end ---*/ - - for (unsigned int i = 0; i <= nMGLevels; i++) - tmp_smooth[i] = MG_PostSmooth[i]; - delete [] MG_PostSmooth; - MG_PostSmooth=nullptr; - } - else { - - /*--- Add additional elements equal to last element ---*/ - - for (unsigned int i = 0; i < nMG_PostSmooth; i++) - tmp_smooth[i] = MG_PostSmooth[i]; - for (unsigned int i = nMG_PostSmooth; i <= nMGLevels; i++) - tmp_smooth[i] = MG_PostSmooth[nMG_PostSmooth-1]; - delete [] MG_PostSmooth; - MG_PostSmooth=nullptr; - } - - nMG_PostSmooth = nMGLevels+1; - MG_PostSmooth = new unsigned short[nMG_PostSmooth]; - for (unsigned int i = 0; i < nMG_PostSmooth; i++) - MG_PostSmooth[i] = tmp_smooth[i]; - - } - - if ((nMGLevels != 0) && (nMG_PostSmooth == 0)) { - delete [] MG_PostSmooth; - nMG_PostSmooth = nMGLevels+1; - MG_PostSmooth = new unsigned short[nMG_PostSmooth]; - for (unsigned int i = 0; i < nMG_PostSmooth; i++) - MG_PostSmooth[i] = 0; - } - - if ((nMG_CorrecSmooth != nMGLevels+1) && (nMG_CorrecSmooth != 0)) { - if (nMG_CorrecSmooth > nMGLevels+1) { - - /*--- Truncate by removing unnecessary elements at the end ---*/ - - for (unsigned int i = 0; i <= nMGLevels; i++) - tmp_smooth[i] = MG_CorrecSmooth[i]; - delete [] MG_CorrecSmooth; - MG_CorrecSmooth = nullptr; - } - else { - - /*--- Add additional elements equal to last element ---*/ - - for (unsigned int i = 0; i < nMG_CorrecSmooth; i++) - tmp_smooth[i] = MG_CorrecSmooth[i]; - for (unsigned int i = nMG_CorrecSmooth; i <= nMGLevels; i++) - tmp_smooth[i] = MG_CorrecSmooth[nMG_CorrecSmooth-1]; - delete [] MG_CorrecSmooth; - MG_CorrecSmooth = nullptr; - } - nMG_CorrecSmooth = nMGLevels+1; - MG_CorrecSmooth = new unsigned short[nMG_CorrecSmooth]; - for (unsigned int i = 0; i < nMG_CorrecSmooth; i++) - MG_CorrecSmooth[i] = tmp_smooth[i]; - } + { + auto fillSmooth = [&](unsigned short n, unsigned short* buf, + std::vector& vec, auto getDefault) { + const unsigned short nNew = nMGLevels + 1; + vec.resize(nNew); + if (n != 0) + for (unsigned short i = 0; i < nNew; i++) vec[i] = (i < n) ? buf[i] : buf[n - 1]; + else + for (unsigned short i = 0; i < nNew; i++) vec[i] = getDefault(i); + }; - if ((nMGLevels != 0) && (nMG_CorrecSmooth == 0)) { - delete [] MG_CorrecSmooth; - nMG_CorrecSmooth = nMGLevels+1; - MG_CorrecSmooth = new unsigned short[nMG_CorrecSmooth]; - for (unsigned int i = 0; i < nMG_CorrecSmooth; i++) - MG_CorrecSmooth[i] = 0; + fillSmooth(nMG_PreSmooth_p, MG_PreSmooth_p, MGOptions.MG_PreSmooth, + [](unsigned short i) { return static_cast(i + 1); }); + fillSmooth(nMG_PostSmooth_p, MG_PostSmooth_p, MGOptions.MG_PostSmooth, + [](unsigned short ) { return (unsigned short)0; }); + fillSmooth(nMG_CorrecSmooth_p, MG_CorrecSmooth_p, MGOptions.MG_CorrecSmooth, + [](unsigned short ) { return (unsigned short)0; }); } /*--- Override MG Smooth parameters ---*/ - if (nMG_PreSmooth != 0) MG_PreSmooth[MESH_0] = 1; - if (nMG_PostSmooth != 0) { - MG_PostSmooth[MESH_0] = 0; - MG_PostSmooth[nMGLevels] = 0; - } - if (nMG_CorrecSmooth != 0) MG_CorrecSmooth[nMGLevels] = 0; + MGOptions.MG_PreSmooth[MESH_0] = 1; + MGOptions.MG_PostSmooth[MESH_0] = 0; + MGOptions.MG_PostSmooth[nMGLevels] = 0; + MGOptions.MG_CorrecSmooth[nMGLevels] = 0; - if (Restart) MGCycle = V_CYCLE; + if (Restart) Kind_MGCycle = MG_CYCLE::V; if (ContinuousAdjoint) { if (Kind_Solver == MAIN_SOLVER::EULER) Kind_Solver = MAIN_SOLVER::ADJ_EULER; @@ -5154,8 +5071,6 @@ void CConfig::SetPostprocessing(SU2_COMPONENT val_software, unsigned short val_i } #endif - delete [] tmp_smooth; - /*--- Make sure that implicit time integration is disabled for the FEM fluid solver (numerics). ---*/ if ((Kind_Solver == MAIN_SOLVER::FEM_EULER) || @@ -7466,9 +7381,9 @@ void CConfig::SetOutput(SU2_COMPONENT val_software, unsigned short val_izone) { if (nMGLevels !=0) { - if (MGCycle == V_CYCLE) cout << "V Multigrid Cycle, with " << nMGLevels << " multigrid levels."<< endl; - if (MGCycle == W_CYCLE) cout << "W Multigrid Cycle, with " << nMGLevels << " multigrid levels."<< endl; - if (MGCycle == FULLMG_CYCLE) cout << "Full Multigrid Cycle, with " << nMGLevels << " multigrid levels."<< endl; + if (Kind_MGCycle == MG_CYCLE::V) cout << "V Multigrid Cycle, with " << nMGLevels << " multigrid levels."<< endl; + if (Kind_MGCycle == MG_CYCLE::W) cout << "W Multigrid Cycle, with " << nMGLevels << " multigrid levels."<< endl; + if (Kind_MGCycle == MG_CYCLE::FULL) cout << "Full Multigrid Cycle, with " << nMGLevels << " multigrid levels."<< endl; cout << "Damping factor for the residual restriction: " << Damp_Res_Restric <<"."<< endl; cout << "Damping factor for the correction prolongation: " << Damp_Correc_Prolong <<"."<< endl; @@ -7492,7 +7407,7 @@ void CConfig::SetOutput(SU2_COMPONENT val_software, unsigned short val_izone) { MGTable.SetAlign(PrintingToolbox::CTablePrinter::RIGHT); MGTable.PrintHeader(); for (unsigned short iLevel = 0; iLevel < nMGLevels+1; iLevel++) { - MGTable << iLevel << MG_PreSmooth[iLevel] << MG_PostSmooth[iLevel] << MG_CorrecSmooth[iLevel]; + MGTable << iLevel << MGOptions.MG_PreSmooth[iLevel] << MGOptions.MG_PostSmooth[iLevel] << MGOptions.MG_CorrecSmooth[iLevel]; } MGTable.PrintFooter(); } diff --git a/Common/src/geometry/CGeometry.cpp b/Common/src/geometry/CGeometry.cpp index 770c68f6066..2b8dfe3c636 100644 --- a/Common/src/geometry/CGeometry.cpp +++ b/Common/src/geometry/CGeometry.cpp @@ -768,6 +768,330 @@ void CGeometry::CompleteComms(CGeometry* geometry, const CConfig* config, MPI_QU #endif } +void CGeometry::MatchPeriodic(const CConfig* config, unsigned short val_periodic) { + unsigned short iMarker, iDim, jMarker, pMarker = 0; + unsigned short iPeriodic, nPeriodic; + + unsigned long iVertex, iPoint, iPointGlobal, index; + unsigned long jVertex, jVertex_, jPoint, jPointGlobal; + unsigned long pVertex = 0, pPoint = 0, pPointGlobal = 0; + unsigned long nLocalVertex_Periodic = 0, MaxLocalVertex_Periodic = 0; + unsigned long nPointMatch = 0; + + int iProcessor, pProcessor = 0, nProcessor = size; + + bool isBadMatch = false; + + string Marker_Tag; + + su2double Coord_j[3], dist, mindist, maxdist_local, maxdist_global; + const su2double *center, *angles, *trans; + su2double translation[3] = {0.0, 0.0, 0.0}, dx, dy, dz; + su2double rotMatrix[3][3] = {{1.0, 0.0, 0.0}, {0.0, 1.0, 0.0}, {0.0, 0.0, 1.0}}; + su2double rotCoord[3] = {0.0, 0.0, 0.0}; + + bool pointOnAxis = false; + bool chkSamePoint = false; + su2double distToAxis = 0.0; + + /*--- Tolerance for distance-based match to report warning. ---*/ + + su2double epsilon = 1e-6; + + /*--- Evaluate the number of periodic boundary conditions ---*/ + + nPeriodic = config->GetnMarker_Periodic(); + + /*--- Send an initial message to the console. ---*/ + + if (rank == MASTER_NODE) { + cout << "Matching the periodic boundary points for marker pair "; + cout << val_periodic << "." << endl; + } + + /*--- Compute the total number of vertices that sit on a periodic + boundary on our local rank. We only include our "owned" nodes. ---*/ + + nLocalVertex_Periodic = 0; + for (iMarker = 0; iMarker < config->GetnMarker_All(); iMarker++) { + if (config->GetMarker_All_KindBC(iMarker) == PERIODIC_BOUNDARY) { + iPeriodic = config->GetMarker_All_PerBound(iMarker); + if ((iPeriodic == val_periodic) || (iPeriodic == val_periodic + nPeriodic / 2)) { + for (iVertex = 0; iVertex < GetnVertex(iMarker); iVertex++) { + iPoint = vertex[iMarker][iVertex]->GetNode(); + if (nodes->GetDomain(iPoint)) nLocalVertex_Periodic++; + } + } + } + } + + /*--- Communicate our local periodic point count globally + and receive the counts of periodic points from all other ranks.---*/ + + auto* Buffer_Send_nVertex = new unsigned long[1]; + auto* Buffer_Recv_nVertex = new unsigned long[nProcessor]; + + Buffer_Send_nVertex[0] = nLocalVertex_Periodic; + + /*--- Copy our own count in serial or use collective comms with MPI. ---*/ + + SU2_MPI::Allreduce(&nLocalVertex_Periodic, &MaxLocalVertex_Periodic, 1, MPI_UNSIGNED_LONG, MPI_MAX, + SU2_MPI::GetComm()); + SU2_MPI::Allgather(Buffer_Send_nVertex, 1, MPI_UNSIGNED_LONG, Buffer_Recv_nVertex, 1, MPI_UNSIGNED_LONG, + SU2_MPI::GetComm()); + + /*--- Prepare buffers to send the information for each + periodic point to all ranks so that we can match pairs. ---*/ + + auto* Buffer_Send_Coord = new su2double[MaxLocalVertex_Periodic * nDim]; + auto* Buffer_Send_Point = new unsigned long[MaxLocalVertex_Periodic]; + auto* Buffer_Send_GlobalIndex = new unsigned long[MaxLocalVertex_Periodic]; + auto* Buffer_Send_Vertex = new unsigned long[MaxLocalVertex_Periodic]; + auto* Buffer_Send_Marker = new unsigned long[MaxLocalVertex_Periodic]; + + auto* Buffer_Recv_Coord = new su2double[nProcessor * MaxLocalVertex_Periodic * nDim]; + auto* Buffer_Recv_Point = new unsigned long[nProcessor * MaxLocalVertex_Periodic]; + auto* Buffer_Recv_GlobalIndex = new unsigned long[nProcessor * MaxLocalVertex_Periodic]; + auto* Buffer_Recv_Vertex = new unsigned long[nProcessor * MaxLocalVertex_Periodic]; + auto* Buffer_Recv_Marker = new unsigned long[nProcessor * MaxLocalVertex_Periodic]; + + unsigned long nBuffer_Coord = MaxLocalVertex_Periodic * nDim; + unsigned long nBuffer_Point = MaxLocalVertex_Periodic; + unsigned long nBuffer_GlobalIndex = MaxLocalVertex_Periodic; + unsigned long nBuffer_Vertex = MaxLocalVertex_Periodic; + unsigned long nBuffer_Marker = MaxLocalVertex_Periodic; + + for (iVertex = 0; iVertex < MaxLocalVertex_Periodic; iVertex++) { + Buffer_Send_Point[iVertex] = 0; + Buffer_Send_GlobalIndex[iVertex] = 0; + Buffer_Send_Vertex[iVertex] = 0; + Buffer_Send_Marker[iVertex] = 0; + for (iDim = 0; iDim < nDim; iDim++) Buffer_Send_Coord[iVertex * nDim + iDim] = 0.0; + } + + /*--- Store the local index, global index, local boundary index, + marker index, and point coordinates in the buffers for sending. + Note again that this is only for the current pair of periodic + markers and for only the "owned" points on each rank. ---*/ + + nLocalVertex_Periodic = 0; + for (iMarker = 0; iMarker < config->GetnMarker_All(); iMarker++) { + if (config->GetMarker_All_KindBC(iMarker) == PERIODIC_BOUNDARY) { + iPeriodic = config->GetMarker_All_PerBound(iMarker); + if ((iPeriodic == val_periodic) || (iPeriodic == val_periodic + nPeriodic / 2)) { + for (iVertex = 0; iVertex < GetnVertex(iMarker); iVertex++) { + iPoint = vertex[iMarker][iVertex]->GetNode(); + iPointGlobal = nodes->GetGlobalIndex(iPoint); + if (nodes->GetDomain(iPoint)) { + Buffer_Send_Point[nLocalVertex_Periodic] = iPoint; + Buffer_Send_GlobalIndex[nLocalVertex_Periodic] = iPointGlobal; + Buffer_Send_Vertex[nLocalVertex_Periodic] = iVertex; + Buffer_Send_Marker[nLocalVertex_Periodic] = iMarker; + for (iDim = 0; iDim < nDim; iDim++) + Buffer_Send_Coord[nLocalVertex_Periodic * nDim + iDim] = nodes->GetCoord(iPoint, iDim); + nLocalVertex_Periodic++; + } + } + } + } + } + + /*--- Gather the data for all points on each rank with MPI. ---*/ + + SU2_MPI::Allgather(Buffer_Send_Coord, nBuffer_Coord, MPI_DOUBLE, Buffer_Recv_Coord, nBuffer_Coord, MPI_DOUBLE, + SU2_MPI::GetComm()); + SU2_MPI::Allgather(Buffer_Send_Point, nBuffer_Point, MPI_UNSIGNED_LONG, Buffer_Recv_Point, nBuffer_Point, + MPI_UNSIGNED_LONG, SU2_MPI::GetComm()); + SU2_MPI::Allgather(Buffer_Send_GlobalIndex, nBuffer_GlobalIndex, MPI_UNSIGNED_LONG, Buffer_Recv_GlobalIndex, + nBuffer_GlobalIndex, MPI_UNSIGNED_LONG, SU2_MPI::GetComm()); + SU2_MPI::Allgather(Buffer_Send_Vertex, nBuffer_Vertex, MPI_UNSIGNED_LONG, Buffer_Recv_Vertex, nBuffer_Vertex, + MPI_UNSIGNED_LONG, SU2_MPI::GetComm()); + SU2_MPI::Allgather(Buffer_Send_Marker, nBuffer_Marker, MPI_UNSIGNED_LONG, Buffer_Recv_Marker, nBuffer_Marker, + MPI_UNSIGNED_LONG, SU2_MPI::GetComm()); + + /*--- Now that all ranks have the data for all periodic points for + this pair of periodic markers, we match the individual points + based on the translation / rotation specified for the marker pair. ---*/ + + maxdist_local = 0.0; + for (iMarker = 0; iMarker < config->GetnMarker_All(); iMarker++) { + if (config->GetMarker_All_KindBC(iMarker) == PERIODIC_BOUNDARY) { + iPeriodic = config->GetMarker_All_PerBound(iMarker); + if ((iPeriodic == val_periodic) || (iPeriodic == val_periodic + nPeriodic / 2)) { + /*--- Retrieve the supplied periodic information. ---*/ + + Marker_Tag = config->GetMarker_All_TagBound(iMarker); + center = config->GetPeriodicRotCenter(Marker_Tag); + angles = config->GetPeriodicRotAngles(Marker_Tag); + trans = config->GetPeriodicTranslation(Marker_Tag); + + /*--- Store (center+trans) as it is constant and will be added. ---*/ + + translation[0] = center[0] + trans[0]; + translation[1] = center[1] + trans[1]; + translation[2] = center[2] + trans[2]; + + /*--- Store angles separately for clarity. Compute sines/cosines. ---*/ + + const su2double Theta = angles[0]; + const su2double Phi = angles[1]; + const su2double Psi = angles[2]; + const su2double cosTheta = cos(Theta), sinTheta = sin(Theta); + const su2double cosPhi = cos(Phi), sinPhi = sin(Phi); + const su2double cosPsi = cos(Psi), sinPsi = sin(Psi); + + /*--- Compute the rotation matrix. Note that the implicit + ordering is rotation about the x-axis, y-axis, then z-axis. ---*/ + + rotMatrix[0][0] = cosPhi * cosPsi; + rotMatrix[1][0] = cosPhi * sinPsi; + rotMatrix[2][0] = -sinPhi; + + rotMatrix[0][1] = sinTheta * sinPhi * cosPsi - cosTheta * sinPsi; + rotMatrix[1][1] = sinTheta * sinPhi * sinPsi + cosTheta * cosPsi; + rotMatrix[2][1] = sinTheta * cosPhi; + + rotMatrix[0][2] = cosTheta * sinPhi * cosPsi + sinTheta * sinPsi; + rotMatrix[1][2] = cosTheta * sinPhi * sinPsi - sinTheta * cosPsi; + rotMatrix[2][2] = cosTheta * cosPhi; + + /*--- Loop over each point on the periodic marker that this rank + holds locally and find the matching point from the donor marker. ---*/ + + for (iVertex = 0; iVertex < nVertex[iMarker]; iVertex++) { + iPoint = vertex[iMarker][iVertex]->GetNode(); + iPointGlobal = nodes->GetGlobalIndex(iPoint); + + if (nodes->GetDomain(iPoint)) { + /*--- Coordinates of the current boundary point ---*/ + + const su2double* Coord_i = nodes->GetCoord(iPoint); + + /*--- Get the position vector from rotation center to point. ---*/ + + dx = Coord_i[0] - center[0]; + dy = Coord_i[1] - center[1]; + dz = su2double(0.0); + if (nDim == 3) dz = Coord_i[2] - center[2]; + + /*--- Compute transformed point coordinates. ---*/ + + rotCoord[0] = rotMatrix[0][0] * dx + rotMatrix[0][1] * dy + rotMatrix[0][2] * dz + translation[0]; + rotCoord[1] = rotMatrix[1][0] * dx + rotMatrix[1][1] * dy + rotMatrix[1][2] * dz + translation[1]; + rotCoord[2] = rotMatrix[2][0] * dx + rotMatrix[2][1] * dy + rotMatrix[2][2] * dz + translation[2]; + + /*--- Check if the point lies on the axis of rotation. ---*/ + + pointOnAxis = false; + distToAxis = 0.0; + for (iDim = 0; iDim < nDim; iDim++) + distToAxis += (rotCoord[iDim] - Coord_i[iDim]) * (rotCoord[iDim] - Coord_i[iDim]); + distToAxis = sqrt(distToAxis); + + if (distToAxis < epsilon) pointOnAxis = true; + + /*--- Initialize the distance to a large value. ---*/ + + mindist = 1E6; + pProcessor = 0; + pPoint = 0; + + /*--- Loop over all of the periodic data that was gathered from + all ranks in order to find the matching periodic point. ---*/ + + for (iProcessor = 0; iProcessor < nProcessor; iProcessor++) + for (jVertex = 0; jVertex < Buffer_Recv_nVertex[iProcessor]; jVertex++) { + index = iProcessor * MaxLocalVertex_Periodic + jVertex; + + jPoint = Buffer_Recv_Point[index]; + jPointGlobal = Buffer_Recv_GlobalIndex[index]; + jVertex_ = Buffer_Recv_Vertex[index]; + jMarker = Buffer_Recv_Marker[index]; + + /*--- Avoid matching the point to itself. Use local point + index + processor rather than global index, because global + indices are not set on coarse multigrid levels. ---*/ + + if ((iProcessor != rank || jPoint != iPoint) || (pointOnAxis)) { + dist = 0.0; + for (iDim = 0; iDim < nDim; iDim++) { + Coord_j[iDim] = Buffer_Recv_Coord[index * nDim + iDim]; + dist += pow(Coord_j[iDim] - rotCoord[iDim], 2.0); + } + dist = sqrt(dist); + + chkSamePoint = (((dist < mindist) && (iProcessor != rank)) || + ((dist < mindist) && (iProcessor == rank) && (jPoint != iPoint))); + + if (chkSamePoint || ((dist < mindist) && (pointOnAxis))) { + mindist = dist; + pProcessor = iProcessor; + pPoint = jPoint; + pPointGlobal = jPointGlobal; + pVertex = jVertex_; + pMarker = jMarker; + } + } + } + + /*--- Store the data for the best match found. ---*/ + + vertex[iMarker][iVertex]->SetDonorPoint(pPoint, pPointGlobal, pVertex, pMarker, pProcessor); + maxdist_local = max(maxdist_local, mindist); + nPointMatch++; + + if (mindist > epsilon) { + cout.precision(10); + cout << endl; + cout << " Bad match for point " << iPointGlobal << ".\tNearest"; + cout << " donor distance: " << scientific << mindist << "."; + maxdist_local = min(maxdist_local, 0.0); + isBadMatch = true; + } + } + } + } + } + } + + /*--- Communicate the final count of matched points and max distance. ---*/ + + unsigned long nPointMatch_Local = nPointMatch; + SU2_MPI::Reduce(&nPointMatch_Local, &nPointMatch, 1, MPI_UNSIGNED_LONG, MPI_SUM, MASTER_NODE, SU2_MPI::GetComm()); + SU2_MPI::Reduce(&maxdist_local, &maxdist_global, 1, MPI_DOUBLE, MPI_MAX, MASTER_NODE, SU2_MPI::GetComm()); + + if (rank == MASTER_NODE) { + if (nPointMatch > 0) { + cout << " Matched " << nPointMatch << " points with a max distance of: "; + cout << maxdist_global << "." << endl; + } else { + cout << " No matching points for periodic marker pair "; + cout << val_periodic << " in current zone." << endl; + } + + if (isBadMatch) { + cout << endl; + cout << "\n !!! Warning !!!" << endl; + cout << "Bad matches found. Computation will continue, but be cautious.\n"; + } + } + + /*--- Free local memory for communications. ---*/ + + delete[] Buffer_Send_Coord; + delete[] Buffer_Send_Point; + delete[] Buffer_Recv_Coord; + delete[] Buffer_Recv_Point; + delete[] Buffer_Send_nVertex; + delete[] Buffer_Recv_nVertex; + delete[] Buffer_Send_GlobalIndex; + delete[] Buffer_Send_Vertex; + delete[] Buffer_Send_Marker; + delete[] Buffer_Recv_GlobalIndex; + delete[] Buffer_Recv_Vertex; + delete[] Buffer_Recv_Marker; +} + void CGeometry::PreprocessPeriodicComms(CGeometry* geometry, CConfig* config) { /*--- We start with the send and receive lists already available in the form of stored periodic point-donor pairs. We will loop through diff --git a/Common/src/geometry/CMultiGridGeometry.cpp b/Common/src/geometry/CMultiGridGeometry.cpp index 6887a452155..37601860cac 100644 --- a/Common/src/geometry/CMultiGridGeometry.cpp +++ b/Common/src/geometry/CMultiGridGeometry.cpp @@ -90,6 +90,9 @@ CMultiGridGeometry::CMultiGridGeometry(CGeometry* fine_grid, CConfig* config, un /*--- STEP 1: The first step is the boundary agglomeration. ---*/ for (auto iMarker = 0u; iMarker < fine_grid->GetnMarker(); iMarker++) { + /*--- Skip periodic boundaries: do not agglomerate on periodic markers. ---*/ + if (config->GetMarker_All_KindBC(iMarker) == PERIODIC_BOUNDARY) continue; + for (auto iVertex = 0ul; iVertex < fine_grid->GetnVertex(iMarker); iVertex++) { const auto iPoint = fine_grid->vertex[iMarker][iVertex]->GetNode(); @@ -308,6 +311,11 @@ CMultiGridGeometry::CMultiGridGeometry(CGeometry* fine_grid, CConfig* config, un } } + /*--- Agglomerate high-aspect-ratio interior nodes along implicit lines from walls. ---*/ + if (config->GetMGOptions().MG_Implicit_Lines) { + AgglomerateImplicitLines(Index_CoarseCV, fine_grid, config, MGQueue_InnerCV); + } + /*--- STEP 2: Agglomerate the domain points. ---*/ auto iteration = 0ul; @@ -659,10 +667,12 @@ CMultiGridGeometry::CMultiGridGeometry(CGeometry* fine_grid, CConfig* config, un } const su2double ratio = su2double(Global_nPointFine) / su2double(Global_nPointCoarse); - cout << "********** ratio = " << ratio << endl; - // lower value leads to more levels being accepted. - if (((nDim == 2) && (ratio < 1.5)) || ((nDim == 3) && (ratio < 1.5))) { + if (Global_nPointCoarse < config->GetMGOptions().MG_Min_MeshSize) { + if (rank == MASTER_NODE) + cout << "MG level " << iMesh << " has only " << Global_nPointCoarse + << " CVs (< MG_MIN_MESHSIZE=" << config->GetMGOptions().MG_Min_MeshSize << "). Reducing MG levels to " + << iMesh - 1 << "." << endl; config->SetMGLevels(iMesh - 1); } else if (rank == MASTER_NODE) { PrintingToolbox::CTablePrinter MGTable(&std::cout); @@ -985,29 +995,6 @@ void CMultiGridGeometry::MatchActuator_Disk(const CConfig* config) { } } -void CMultiGridGeometry::MatchPeriodic(const CConfig* config, unsigned short val_periodic) { - int iProcessor = rank; - - /*--- Evaluate the number of periodic boundary conditions ---*/ - - auto nPeriodic = config->GetnMarker_Periodic(); - - for (auto iMarker = 0u; iMarker < config->GetnMarker_All(); iMarker++) { - if (config->GetMarker_All_KindBC(iMarker) == PERIODIC_BOUNDARY) { - auto iPeriodic = config->GetMarker_All_PerBound(iMarker); - if ((iPeriodic == val_periodic) || (iPeriodic == val_periodic + nPeriodic / 2)) { - for (auto iVertex = 0u; iVertex < nVertex[iMarker]; iVertex++) { - auto iPoint = vertex[iMarker][iVertex]->GetNode(); - if (nodes->GetDomain(iPoint)) { - vertex[iMarker][iVertex]->SetDonorPoint(iPoint, nodes->GetGlobalIndex(iPoint), iVertex, iMarker, - iProcessor); - } - } - } - } - } -} - void CMultiGridGeometry::SetControlVolume(const CGeometry* fine_grid, unsigned short action) { BEGIN_SU2_OMP_SAFE_GLOBAL_ACCESS { /*--- Compute the area of the coarse volume ---*/ @@ -1289,3 +1276,229 @@ su2double CMultiGridGeometry::ComputeLocalCurvature(const CGeometry* fine_grid, return max_angle; } + +void CMultiGridGeometry::AgglomerateImplicitLines(unsigned long& Index_CoarseCV, const CGeometry* fine_grid, + const CConfig* config, CMultiGridQueue& MGQueue_InnerCV) { + /*--- Parameters ---*/ + const su2double ANGLE_THRESHOLD_DEG = 20.0; /*!< Stop line if direction deviates more than this. */ + constexpr unsigned long MAX_LINE_LENGTH = 20; /*!< Max nodes on implicit line (including wall). */ + const su2double cos_threshold = cos(ANGLE_THRESHOLD_DEG * PI_NUMBER / 180.0); + + const unsigned long nPointFine = fine_grid->GetnPoint(); + + /*--- Collect implicit lines starting at wall vertices. + * Each line: [wall_node, interior_1, interior_2, ...]. + * The wall node (index 0) is already agglomerated by boundary agglomeration; + * only interior nodes (index >= 1) are paired into coarse CVs. ---*/ + vector> lines; + + for (auto iMarker = 0u; iMarker < fine_grid->GetnMarker(); iMarker++) { + /*--- Skip non-physical markers ---*/ + if (config->GetMarker_All_KindBC(iMarker) == SEND_RECEIVE || + config->GetMarker_All_KindBC(iMarker) == INTERNAL_BOUNDARY || + config->GetMarker_All_KindBC(iMarker) == NEARFIELD_BOUNDARY) + continue; + + for (auto iVertex = 0ul; iVertex < fine_grid->GetnVertex(iMarker); iVertex++) { + const auto iPoint = fine_grid->vertex[iMarker][iVertex]->GetNode(); + + /*--- Get vertex normal to seed the line direction ---*/ + const long ChildVertex = fine_grid->nodes->GetVertex(iPoint, iMarker); + if (ChildVertex == -1) continue; + su2double Normal[MAXNDIM] = {0.0}; + fine_grid->vertex[iMarker][ChildVertex]->GetNormal(Normal); + + /*--- Normalize the direction ---*/ + su2double prev_dir[MAXNDIM] = {0.0}; + su2double norm_prev = 0.0; + for (unsigned short d = 0; d < nDim; ++d) { + prev_dir[d] = Normal[d]; + norm_prev += Normal[d] * Normal[d]; + } + if (norm_prev <= 0.0) continue; + norm_prev = sqrt(norm_prev); + for (unsigned short d = 0; d < nDim; ++d) prev_dir[d] /= norm_prev; + + /*--- Build the implicit line by following the best-aligned interior neighbor ---*/ + vector L; + L.push_back(iPoint); + auto current = iPoint; + + while (L.size() < MAX_LINE_LENGTH) { + su2double best_dot = -2.0; + unsigned long best_neighbor = ULONG_MAX; + + for (auto jPoint : fine_grid->nodes->GetPoints(current)) { + if (jPoint == current) continue; + if (!fine_grid->nodes->GetDomain(jPoint)) continue; + if (fine_grid->nodes->GetBoundary(jPoint)) continue; + if (fine_grid->nodes->GetAgglomerate(jPoint)) continue; + + /*--- Compute normalized direction to candidate ---*/ + su2double vec[MAXNDIM] = {0.0}; + GeometryToolbox::Distance(nDim, fine_grid->nodes->GetCoord(jPoint), fine_grid->nodes->GetCoord(current), vec); + const su2double len = GeometryToolbox::Norm(nDim, vec); + if (len <= 0.0) continue; + for (unsigned short d = 0; d < nDim; ++d) vec[d] /= len; + + /*--- Alignment with previous direction ---*/ + const su2double dot = GeometryToolbox::DotProduct(nDim, vec, prev_dir); + if (dot > best_dot) { + best_dot = dot; + best_neighbor = jPoint; + } + } + + if (best_neighbor == ULONG_MAX || best_dot < cos_threshold) break; + + L.push_back(best_neighbor); + + /*--- Update direction for next step ---*/ + GeometryToolbox::Distance(nDim, fine_grid->nodes->GetCoord(best_neighbor), fine_grid->nodes->GetCoord(current), + prev_dir); + const su2double len = GeometryToolbox::Norm(nDim, prev_dir); + if (len <= 0.0) break; + for (unsigned short d = 0; d < nDim; ++d) prev_dir[d] /= len; + + current = best_neighbor; + } + + /*--- Accept only lines with at least 2 interior nodes (length >= 3 including wall) ---*/ + if (L.size() >= 3) { + lines.push_back(std::move(L)); + } + } + } + + if (lines.empty()) return; + + if (rank == MASTER_NODE) { + cout << "Implicit line agglomeration: detected " << lines.size() << " lines." << endl; + } + + /*--- Advancing-front greedy pairing with cross-line merging. + * For each pair stage k, process interior positions (1+2k, 1+2k+1). + * When two lines share the same wall-node parent CV, merge their pairs + * into a single 4-child coarse CV. Otherwise create 2-child coarse CVs. ---*/ + vector reserved(nPointFine, 0); + unsigned pair_idx = 0; + + while (true) { + bool any_work = false; + + /*--- Build map: wall parent CV -> list of line indices ---*/ + unordered_map> parent_to_lines; + parent_to_lines.reserve(lines.size()); + for (unsigned long li = 0; li < lines.size(); ++li) { + const auto& L = lines[li]; + if (L.empty()) continue; + const auto idx2 = 1 + 2 * pair_idx + 1; + if (L.size() <= idx2) continue; // no pair at this stage + const auto pW = fine_grid->nodes->GetParent_CV(L[0]); + parent_to_lines[pW].push_back(li); + } + + vector line_processed(lines.size(), 0); + + /*--- A) Cross-line merges: parents with multiple lines ---*/ + for (auto& [parent, line_ids] : parent_to_lines) { + if (line_ids.size() < 2) continue; + + for (size_t k = 0; k + 1 < line_ids.size(); k += 2) { + const auto li1 = line_ids[k]; + const auto li2 = line_ids[k + 1]; + if (line_processed[li1] || line_processed[li2]) continue; + + const auto& L1 = lines[li1]; + const auto& L2 = lines[li2]; + const auto idx1 = 1 + 2 * pair_idx; + const auto idx2 = idx1 + 1; + if (L1.size() <= idx2 || L2.size() <= idx2) continue; + + const auto a = L1[idx1], b = L1[idx2]; + const auto c = L2[idx1], d = L2[idx2]; + + /*--- Skip if any node is already claimed ---*/ + if (fine_grid->nodes->GetAgglomerate(a) || fine_grid->nodes->GetAgglomerate(b) || + fine_grid->nodes->GetAgglomerate(c) || fine_grid->nodes->GetAgglomerate(d)) + continue; + if (reserved[a] || reserved[b] || reserved[c] || reserved[d]) continue; + + /*--- Geometrical quality check ---*/ + if (!GeometricalCheck(a, fine_grid, config) || !GeometricalCheck(b, fine_grid, config) || + !GeometricalCheck(c, fine_grid, config) || !GeometricalCheck(d, fine_grid, config)) + continue; + + /*--- Guard against duplicate indices ---*/ + if (a == b || a == c || a == d || b == c || b == d || c == d) { + for (auto other_li : line_ids) line_processed[other_li] = 1; + continue; + } + + /*--- Create 4-child coarse CV ---*/ + fine_grid->nodes->SetParent_CV(a, Index_CoarseCV); + nodes->SetChildren_CV(Index_CoarseCV, 0, a); + fine_grid->nodes->SetParent_CV(b, Index_CoarseCV); + nodes->SetChildren_CV(Index_CoarseCV, 1, b); + fine_grid->nodes->SetParent_CV(c, Index_CoarseCV); + nodes->SetChildren_CV(Index_CoarseCV, 2, c); + fine_grid->nodes->SetParent_CV(d, Index_CoarseCV); + nodes->SetChildren_CV(Index_CoarseCV, 3, d); + nodes->SetnChildren_CV(Index_CoarseCV, 4); + + reserved[a] = reserved[b] = reserved[c] = reserved[d] = 1; + MGQueue_InnerCV.RemoveCV(a); + MGQueue_InnerCV.RemoveCV(b); + MGQueue_InnerCV.RemoveCV(c); + MGQueue_InnerCV.RemoveCV(d); + + Index_CoarseCV++; + line_processed[li1] = line_processed[li2] = 1; + for (auto other_li : line_ids) + if (other_li != li1 && other_li != li2) line_processed[other_li] = 1; + any_work = true; + } + } + + /*--- B) Single-line 2-child merges for remaining lines ---*/ + for (unsigned long li = 0; li < lines.size(); ++li) { + if (line_processed[li]) continue; + const auto& L = lines[li]; + const auto idx1 = 1 + 2 * pair_idx; + const auto idx2 = idx1 + 1; + if (L.size() <= idx2) continue; + + const auto a = L[idx1], b = L[idx2]; + if (fine_grid->nodes->GetAgglomerate(a) || fine_grid->nodes->GetAgglomerate(b)) continue; + if (reserved[a] || reserved[b]) continue; + if (!GeometricalCheck(a, fine_grid, config) || !GeometricalCheck(b, fine_grid, config)) continue; + + /*--- Create 2-child coarse CV ---*/ + fine_grid->nodes->SetParent_CV(a, Index_CoarseCV); + nodes->SetChildren_CV(Index_CoarseCV, 0, a); + fine_grid->nodes->SetParent_CV(b, Index_CoarseCV); + nodes->SetChildren_CV(Index_CoarseCV, 1, b); + nodes->SetnChildren_CV(Index_CoarseCV, 2); + + reserved[a] = reserved[b] = 1; + MGQueue_InnerCV.RemoveCV(a); + MGQueue_InnerCV.RemoveCV(b); + + Index_CoarseCV++; + any_work = true; + } + + pair_idx++; + if (!any_work) break; + + /*--- Check if any line still has pairs at the next stage ---*/ + bool any_more = false; + for (const auto& L : lines) { + if (L.size() > 1 + 2 * pair_idx + 1) { + any_more = true; + break; + } + } + if (!any_more) break; + } +} diff --git a/Common/src/geometry/CPhysicalGeometry.cpp b/Common/src/geometry/CPhysicalGeometry.cpp index db711b9f85a..8ed3f5c6103 100644 --- a/Common/src/geometry/CPhysicalGeometry.cpp +++ b/Common/src/geometry/CPhysicalGeometry.cpp @@ -6592,382 +6592,6 @@ void CPhysicalGeometry::MatchActuator_Disk(const CConfig* config) { } } -void CPhysicalGeometry::MatchPeriodic(const CConfig* config, unsigned short val_periodic) { - unsigned short iMarker, iDim, jMarker, pMarker = 0; - unsigned short iPeriodic, nPeriodic; - - unsigned long iVertex, iPoint, iPointGlobal, index; - unsigned long jVertex, jVertex_, jPoint, jPointGlobal; - unsigned long pVertex = 0, pPoint = 0, pPointGlobal = 0; - unsigned long nLocalVertex_Periodic = 0, MaxLocalVertex_Periodic = 0; - unsigned long nPointMatch = 0; - - int iProcessor, pProcessor = 0, nProcessor = size; - - bool isBadMatch = false; - - string Marker_Tag; - - su2double *Coord_i, Coord_j[3], dist, mindist, maxdist_local, maxdist_global; - const su2double *center, *angles, *trans; - su2double translation[3] = {0.0, 0.0, 0.0}, dx, dy, dz; - su2double rotMatrix[3][3] = {{1.0, 0.0, 0.0}, {0.0, 1.0, 0.0}, {0.0, 0.0, 1.0}}; - su2double Theta, Phi, Psi, cosTheta, sinTheta, cosPhi, sinPhi, cosPsi, sinPsi; - su2double rotCoord[3] = {0.0, 0.0, 0.0}; - - bool pointOnAxis = false; - - bool chkSamePoint = false; - - su2double distToAxis = 0.0; - - /*--- Tolerance for distance-based match to report warning. ---*/ - - su2double epsilon = 1e-6; - - /*--- Evaluate the number of periodic boundary conditions ---*/ - - nPeriodic = config->GetnMarker_Periodic(); - - /*--- Send an initial message to the console. ---*/ - - if (rank == MASTER_NODE) { - cout << "Matching the periodic boundary points for marker pair "; - cout << val_periodic << "." << endl; - } - - /*--- Compute the total number of vertices that sit on a periodic - boundary on our local rank. We only include our "owned" nodes. ---*/ - - nLocalVertex_Periodic = 0; - for (iMarker = 0; iMarker < config->GetnMarker_All(); iMarker++) { - if (config->GetMarker_All_KindBC(iMarker) == PERIODIC_BOUNDARY) { - iPeriodic = config->GetMarker_All_PerBound(iMarker); - if ((iPeriodic == val_periodic) || (iPeriodic == val_periodic + nPeriodic / 2)) { - for (iVertex = 0; iVertex < GetnVertex(iMarker); iVertex++) { - iPoint = vertex[iMarker][iVertex]->GetNode(); - if (nodes->GetDomain(iPoint)) nLocalVertex_Periodic++; - } - } - } - } - - /*--- Communicate our local periodic point count globally - and receive the counts of periodic points from all other ranks.---*/ - - auto* Buffer_Send_nVertex = new unsigned long[1]; - auto* Buffer_Recv_nVertex = new unsigned long[nProcessor]; - - Buffer_Send_nVertex[0] = nLocalVertex_Periodic; - - /*--- Copy our own count in serial or use collective comms with MPI. ---*/ - - SU2_MPI::Allreduce(&nLocalVertex_Periodic, &MaxLocalVertex_Periodic, 1, MPI_UNSIGNED_LONG, MPI_MAX, - SU2_MPI::GetComm()); - SU2_MPI::Allgather(Buffer_Send_nVertex, 1, MPI_UNSIGNED_LONG, Buffer_Recv_nVertex, 1, MPI_UNSIGNED_LONG, - SU2_MPI::GetComm()); - - /*--- Prepare buffers to send the information for each - periodic point to all ranks so that we can match pairs. ---*/ - - auto* Buffer_Send_Coord = new su2double[MaxLocalVertex_Periodic * nDim]; - auto* Buffer_Send_Point = new unsigned long[MaxLocalVertex_Periodic]; - auto* Buffer_Send_GlobalIndex = new unsigned long[MaxLocalVertex_Periodic]; - auto* Buffer_Send_Vertex = new unsigned long[MaxLocalVertex_Periodic]; - auto* Buffer_Send_Marker = new unsigned long[MaxLocalVertex_Periodic]; - - auto* Buffer_Recv_Coord = new su2double[nProcessor * MaxLocalVertex_Periodic * nDim]; - auto* Buffer_Recv_Point = new unsigned long[nProcessor * MaxLocalVertex_Periodic]; - auto* Buffer_Recv_GlobalIndex = new unsigned long[nProcessor * MaxLocalVertex_Periodic]; - auto* Buffer_Recv_Vertex = new unsigned long[nProcessor * MaxLocalVertex_Periodic]; - auto* Buffer_Recv_Marker = new unsigned long[nProcessor * MaxLocalVertex_Periodic]; - - unsigned long nBuffer_Coord = MaxLocalVertex_Periodic * nDim; - unsigned long nBuffer_Point = MaxLocalVertex_Periodic; - unsigned long nBuffer_GlobalIndex = MaxLocalVertex_Periodic; - unsigned long nBuffer_Vertex = MaxLocalVertex_Periodic; - unsigned long nBuffer_Marker = MaxLocalVertex_Periodic; - - for (iVertex = 0; iVertex < MaxLocalVertex_Periodic; iVertex++) { - Buffer_Send_Point[iVertex] = 0; - Buffer_Send_GlobalIndex[iVertex] = 0; - Buffer_Send_Vertex[iVertex] = 0; - Buffer_Send_Marker[iVertex] = 0; - for (iDim = 0; iDim < nDim; iDim++) Buffer_Send_Coord[iVertex * nDim + iDim] = 0.0; - } - - /*--- Store the local index, global index, local boundary index, - marker index, and point coordinates in the buffers for sending. - Note again that this is only for the current pair of periodic - markers and for only the "owned" points on each rank. ---*/ - - nLocalVertex_Periodic = 0; - for (iMarker = 0; iMarker < config->GetnMarker_All(); iMarker++) { - if (config->GetMarker_All_KindBC(iMarker) == PERIODIC_BOUNDARY) { - iPeriodic = config->GetMarker_All_PerBound(iMarker); - if ((iPeriodic == val_periodic) || (iPeriodic == val_periodic + nPeriodic / 2)) { - for (iVertex = 0; iVertex < GetnVertex(iMarker); iVertex++) { - iPoint = vertex[iMarker][iVertex]->GetNode(); - iPointGlobal = nodes->GetGlobalIndex(iPoint); - if (nodes->GetDomain(iPoint)) { - Buffer_Send_Point[nLocalVertex_Periodic] = iPoint; - Buffer_Send_GlobalIndex[nLocalVertex_Periodic] = iPointGlobal; - Buffer_Send_Vertex[nLocalVertex_Periodic] = iVertex; - Buffer_Send_Marker[nLocalVertex_Periodic] = iMarker; - for (iDim = 0; iDim < nDim; iDim++) - Buffer_Send_Coord[nLocalVertex_Periodic * nDim + iDim] = nodes->GetCoord(iPoint, iDim); - nLocalVertex_Periodic++; - } - } - } - } - } - - /*--- Copy our own data in serial or use collective comms to gather - the data for all points on each rank with MPI. Note that, since the - periodic point count should be small relative to the volume grid - and we are only storing one periodic marker pair at a time, - repeating the data for each pair on all ranks should be manageable. ---*/ - - SU2_MPI::Allgather(Buffer_Send_Coord, nBuffer_Coord, MPI_DOUBLE, Buffer_Recv_Coord, nBuffer_Coord, MPI_DOUBLE, - SU2_MPI::GetComm()); - SU2_MPI::Allgather(Buffer_Send_Point, nBuffer_Point, MPI_UNSIGNED_LONG, Buffer_Recv_Point, nBuffer_Point, - MPI_UNSIGNED_LONG, SU2_MPI::GetComm()); - SU2_MPI::Allgather(Buffer_Send_GlobalIndex, nBuffer_GlobalIndex, MPI_UNSIGNED_LONG, Buffer_Recv_GlobalIndex, - nBuffer_GlobalIndex, MPI_UNSIGNED_LONG, SU2_MPI::GetComm()); - SU2_MPI::Allgather(Buffer_Send_Vertex, nBuffer_Vertex, MPI_UNSIGNED_LONG, Buffer_Recv_Vertex, nBuffer_Vertex, - MPI_UNSIGNED_LONG, SU2_MPI::GetComm()); - SU2_MPI::Allgather(Buffer_Send_Marker, nBuffer_Marker, MPI_UNSIGNED_LONG, Buffer_Recv_Marker, nBuffer_Marker, - MPI_UNSIGNED_LONG, SU2_MPI::GetComm()); - - /*--- Now that all ranks have the data for all periodic points for - this pair of periodic markers, we match the individual points - based on the translation / rotation specified for the marker pair. ---*/ - - maxdist_local = 0.0; - for (iMarker = 0; iMarker < config->GetnMarker_All(); iMarker++) { - if (config->GetMarker_All_KindBC(iMarker) == PERIODIC_BOUNDARY) { - iPeriodic = config->GetMarker_All_PerBound(iMarker); - if ((iPeriodic == val_periodic) || (iPeriodic == val_periodic + nPeriodic / 2)) { - /*--- Retrieve the supplied periodic information. ---*/ - - Marker_Tag = config->GetMarker_All_TagBound(iMarker); - center = config->GetPeriodicRotCenter(Marker_Tag); - angles = config->GetPeriodicRotAngles(Marker_Tag); - trans = config->GetPeriodicTranslation(Marker_Tag); - - /*--- Store (center+trans) as it is constant and will be added. ---*/ - - translation[0] = center[0] + trans[0]; - translation[1] = center[1] + trans[1]; - translation[2] = center[2] + trans[2]; - - /*--- Store angles separately for clarity. Compute sines/cosines. ---*/ - - Theta = angles[0]; - Phi = angles[1]; - Psi = angles[2]; - cosTheta = cos(Theta); - cosPhi = cos(Phi); - cosPsi = cos(Psi); - sinTheta = sin(Theta); - sinPhi = sin(Phi); - sinPsi = sin(Psi); - - /*--- Compute the rotation matrix. Note that the implicit - ordering is rotation about the x-axis, y-axis, then z-axis. ---*/ - - rotMatrix[0][0] = cosPhi * cosPsi; - rotMatrix[1][0] = cosPhi * sinPsi; - rotMatrix[2][0] = -sinPhi; - - rotMatrix[0][1] = sinTheta * sinPhi * cosPsi - cosTheta * sinPsi; - rotMatrix[1][1] = sinTheta * sinPhi * sinPsi + cosTheta * cosPsi; - rotMatrix[2][1] = sinTheta * cosPhi; - - rotMatrix[0][2] = cosTheta * sinPhi * cosPsi + sinTheta * sinPsi; - rotMatrix[1][2] = cosTheta * sinPhi * sinPsi - sinTheta * cosPsi; - rotMatrix[2][2] = cosTheta * cosPhi; - - /*--- Loop over each point on the periodic marker that this rank - holds locally and find the matching point from the donor marker. ---*/ - - for (iVertex = 0; iVertex < nVertex[iMarker]; iVertex++) { - /*--- Local and global index for the owned periodic point. ---*/ - - iPoint = vertex[iMarker][iVertex]->GetNode(); - iPointGlobal = nodes->GetGlobalIndex(iPoint); - - /*--- If this is not a ghost, find the periodic match. ---*/ - - if (nodes->GetDomain(iPoint)) { - /*--- Coordinates of the current boundary point ---*/ - - Coord_i = nodes->GetCoord(iPoint); - - /*--- Get the position vector from rotation center to point. ---*/ - - dx = Coord_i[0] - center[0]; - dy = Coord_i[1] - center[1]; - if (nDim == 3) - dz = Coord_i[2] - center[2]; - else - dz = 0.0; - - /*--- Compute transformed point coordinates. ---*/ - - rotCoord[0] = (rotMatrix[0][0] * dx + rotMatrix[0][1] * dy + rotMatrix[0][2] * dz + translation[0]); - - rotCoord[1] = (rotMatrix[1][0] * dx + rotMatrix[1][1] * dy + rotMatrix[1][2] * dz + translation[1]); - - rotCoord[2] = (rotMatrix[2][0] * dx + rotMatrix[2][1] * dy + rotMatrix[2][2] * dz + translation[2]); - - /*--- Check if the point lies on the axis of rotation. If it does, - the rotated coordinate and the original coordinate are the same. ---*/ - - pointOnAxis = false; - distToAxis = 0.0; - for (iDim = 0; iDim < nDim; iDim++) - distToAxis = (rotCoord[iDim] - Coord_i[iDim]) * (rotCoord[iDim] - Coord_i[iDim]); - distToAxis = sqrt(distToAxis); - - if (distToAxis < epsilon) pointOnAxis = true; - - /*--- Our search is based on the minimum distance, so we - initialize the distance to a large value. ---*/ - - mindist = 1E6; - pProcessor = 0; - pPoint = 0; - - /*--- Loop over all of the periodic data that was gathered from - all ranks in order to find the matching periodic point. ---*/ - - for (iProcessor = 0; iProcessor < nProcessor; iProcessor++) - for (jVertex = 0; jVertex < Buffer_Recv_nVertex[iProcessor]; jVertex++) { - /*--- Store the loop index more easily. ---*/ - - index = iProcessor * MaxLocalVertex_Periodic + jVertex; - - /*--- For each candidate, we have the local and global index, - along with the boundary vertex and marker index. ---*/ - - jPoint = Buffer_Recv_Point[index]; - jPointGlobal = Buffer_Recv_GlobalIndex[index]; - jVertex_ = Buffer_Recv_Vertex[index]; - jMarker = Buffer_Recv_Marker[index]; - - /*--- The gathered data will also include the current - "owned" periodic point that we are matching, so first make - sure that we avoid the original point by checking that the - global index values are not the same. ---*/ - - if ((jPointGlobal != iPointGlobal) || (pointOnAxis)) { - /*--- Compute the distance between the candidate periodic - point and the transformed coordinates of the owned point. ---*/ - - dist = 0.0; - for (iDim = 0; iDim < nDim; iDim++) { - Coord_j[iDim] = Buffer_Recv_Coord[index * nDim + iDim]; - dist += pow(Coord_j[iDim] - rotCoord[iDim], 2.0); - } - dist = sqrt(dist); - - /*--- Compare the distance against the existing minimum - and also perform checks just to be sure that this is an - independent periodic point (even if on the same rank), - unless it lies on the axis of rotation. ---*/ - - chkSamePoint = false; - chkSamePoint = (((dist < mindist) && (iProcessor != rank)) || - ((dist < mindist) && (iProcessor == rank) && (jPoint != iPoint))); - - if (chkSamePoint || ((dist < mindist) && (pointOnAxis))) { - /*--- We have found an intermediate match. Store the - data for this point before continuing the search. ---*/ - - mindist = dist; - pProcessor = iProcessor; - pPoint = jPoint; - pPointGlobal = jPointGlobal; - pVertex = jVertex_; - pMarker = jMarker; - } - } - } - - /*--- Store the data for the best match found for the - owned periodic point. ---*/ - - vertex[iMarker][iVertex]->SetDonorPoint(pPoint, pPointGlobal, pVertex, pMarker, pProcessor); - maxdist_local = max(maxdist_local, mindist); - nPointMatch++; - - /*--- If the distance to the closest point is larger than our - tolerance, then throw a warning for this point. ---*/ - - if (mindist > epsilon) { - cout.precision(10); - cout << endl; - cout << " Bad match for point " << iPointGlobal << ".\tNearest"; - cout << " donor distance: " << scientific << mindist << "."; - maxdist_local = min(maxdist_local, 0.0); - isBadMatch = true; - } - } - } - } - } - } - - /*--- Communicate the final count of number of matched points - for the periodic boundary pair and the max distance for all - pairs of points. ---*/ - - unsigned long nPointMatch_Local = nPointMatch; - SU2_MPI::Reduce(&nPointMatch_Local, &nPointMatch, 1, MPI_UNSIGNED_LONG, MPI_SUM, MASTER_NODE, SU2_MPI::GetComm()); - SU2_MPI::Reduce(&maxdist_local, &maxdist_global, 1, MPI_DOUBLE, MPI_MAX, MASTER_NODE, SU2_MPI::GetComm()); - - /*--- Output some information about the matching process. ---*/ - - if (rank == MASTER_NODE) { - if (nPointMatch > 0) { - cout << " Matched " << nPointMatch << " points with a max distance of: "; - cout << maxdist_global << "." << endl; - } else { - cout << " No matching points for periodic marker pair "; - cout << val_periodic << " in current zone." << endl; - } - - /*--- Print final warning when finding bad matches. ---*/ - - if (isBadMatch) { - cout << endl; - cout << "\n !!! Warning !!!" << endl; - cout << "Bad matches found. Computation will continue, but be cautious.\n"; - } - } - - /*--- Free local memory for communications. ---*/ - - delete[] Buffer_Send_Coord; - delete[] Buffer_Send_Point; - - delete[] Buffer_Recv_Coord; - delete[] Buffer_Recv_Point; - - delete[] Buffer_Send_nVertex; - delete[] Buffer_Recv_nVertex; - - delete[] Buffer_Send_GlobalIndex; - delete[] Buffer_Send_Vertex; - delete[] Buffer_Send_Marker; - - delete[] Buffer_Recv_GlobalIndex; - delete[] Buffer_Recv_Vertex; - delete[] Buffer_Recv_Marker; -} - void CPhysicalGeometry::FindUniqueNode_PeriodicBound(const CConfig* config) { /*-------------------------------------------------------------------------------------------*/ /*--- Find reference node on the 'inlet' streamwise periodic marker for the computation ---*/ @@ -8844,16 +8468,6 @@ void CPhysicalGeometry::ReadUnorderedSensitivity(CConfig* config) { } } -void CPhysicalGeometry::Check_Periodicity(CConfig* config) { - /*--- Check for the presence of any periodic BCs and disable multigrid - for now if found. ---*/ - - if ((config->GetnMarker_Periodic() != 0) && (config->GetnMGLevels() > 0)) { - if (rank == MASTER_NODE) cout << "WARNING: Periodicity has been detected. Disabling multigrid. " << endl; - config->SetMGLevels(0); - } -} - su2double CPhysicalGeometry::Compute_MaxThickness(su2double* Plane_P0, su2double* Plane_Normal, CConfig* config, vector& Xcoord_Airfoil, vector& Ycoord_Airfoil, vector& Zcoord_Airfoil) { diff --git a/Common/src/linear_algebra/CSysSolve.cpp b/Common/src/linear_algebra/CSysSolve.cpp index ce454326546..178e2b3ba0d 100644 --- a/Common/src/linear_algebra/CSysSolve.cpp +++ b/Common/src/linear_algebra/CSysSolve.cpp @@ -178,7 +178,7 @@ void CSysSolve::SolveReduced(int n, const su2matrix& Hsb } template -void CSysSolve::ModGramSchmidt(bool shared_hsbg, int i, su2matrix& Hsbg, +bool CSysSolve::ModGramSchmidt(bool shared_hsbg, int i, su2matrix& Hsbg, vector>& w) const { const auto thread = omp_get_thread_num(); @@ -201,11 +201,13 @@ void CSysSolve::ModGramSchmidt(bool shared_hsbg, int i, su2matrix::ModGramSchmidt(bool shared_hsbg, int i, su2matrix @@ -543,13 +552,23 @@ unsigned long CSysSolve::FGMRES_LinSolver(const CSysVector::FGCRODR_LinSolverImpl(const CSysVector::max(); + /*--- Early-exit smoothing state (shared across OMP threads via master write + barrier). ---*/ + bool mg_early_exit_flag = false; /*!< \brief Shared flag for early exit across OMP threads. */ + passivedouble mg_initial_smooth_rms = 0.0; /*!< \brief Initial RMS before current smoothing phase. */ + passivedouble mg_last_smooth_rms = 0.0; /*!< \brief Last computed RMS; cached to avoid redundant Allreduce. */ + + /*--- Actual iteration counts per MG level, filled each cycle for the compact output summary. ---*/ + unsigned short lastPreSmoothIters[MAX_MG_LEVELS+1] = {}; + unsigned short lastPostSmoothIters[MAX_MG_LEVELS+1] = {}; + unsigned short lastCorrecSmoothIters[MAX_MG_LEVELS+1] = {}; + + /*--- Per-level residual progress flags: true if the final RMS after that phase was lower + * than the initial RMS. Used by the adaptive damping routines to distinguish + * "hit max iters but still converging" from "hit max iters and stagnated". ---*/ + bool lastPreSmoothProgress[MAX_MG_LEVELS+1] = {}; + bool lastPostSmoothProgress[MAX_MG_LEVELS+1] = {}; + bool lastCorrecSmoothProgress[MAX_MG_LEVELS+1] = {}; + + /*--- Per-level start/end RMS for the compact output summary. + * [0] = initial RMS before smoothing, [1] = final RMS after smoothing. + * Filled unconditionally (early-exit path and exhaustion path). + * Must be passivedouble: class members survive tape resets; su2double would + * carry stale AD indices referencing a cleared tape. ---*/ + passivedouble lastPreSmoothRMS[MAX_MG_LEVELS+1][2] = {}; + passivedouble lastPostSmoothRMS[MAX_MG_LEVELS+1][2] = {}; + passivedouble lastCorrecSmoothRMS[MAX_MG_LEVELS+1][2] = {}; + }; diff --git a/SU2_CFD/include/integration/ComputeLinSysResRMS.hpp b/SU2_CFD/include/integration/ComputeLinSysResRMS.hpp new file mode 100644 index 00000000000..9471557d402 --- /dev/null +++ b/SU2_CFD/include/integration/ComputeLinSysResRMS.hpp @@ -0,0 +1,63 @@ +/*! + * \file ComputeLinSysResRMS.hpp + * \brief Helper to compute the global RMS of LinSysRes across all variables and domain points. + * \author Nijso Beishuizen + * \version 8.4.0 "Harrier" + * + * SU2 Project Website: https://su2code.github.io + * + * The SU2 Project is maintained by the SU2 Foundation + * (http://su2foundation.org) + * + * Copyright 2012-2026, SU2 Contributors (cf. AUTHORS.md) + * + * SU2 is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * SU2 is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with SU2. If not, see . + */ + +#pragma once +#include "../../include/solvers/CSolver.hpp" +#include "../../../Common/include/parallelization/omp_structure.hpp" +#include + +/*! + * \brief Compute the global (MPI-reduced) RMS of LinSysRes over all variables and domain points. + * + * \note Thread-safety: This function MUST be called by ALL threads in the current + * OpenMP parallel region, because squaredNorm() uses parallel for + barriers + * internally. Do NOT call from inside BEGIN_SU2_OMP_SAFE_GLOBAL_ACCESS. + * The return value is correct only on the master thread (thread 0). + * + * \param[in] solver - Solver whose LinSysRes is evaluated. + * \return Global RMS value (valid on master thread; other threads return 0). + */ +inline passivedouble ComputeLinSysResRMS(const CSolver* solver) { + + /*--- squaredNorm() -> dot() uses OMP parallel for + barriers internally, + * so all threads must participate. ---*/ + const su2double sqNorm = solver->LinSysRes.squaredNorm(); + + /*--- The MPI reduction for nElmDomain must be single-threaded. ---*/ + passivedouble result = 0.0; + BEGIN_SU2_OMP_SAFE_GLOBAL_ACCESS + { + unsigned long nElmDomain = solver->LinSysRes.GetNElmDomain(); + unsigned long globalNElmDomain = 0; + SU2_MPI::Allreduce(&nElmDomain, &globalNElmDomain, 1, MPI_UNSIGNED_LONG, MPI_SUM, SU2_MPI::GetComm()); + if (globalNElmDomain > 0) + result = std::sqrt(SU2_TYPE::GetValue(sqNorm) / static_cast(globalNElmDomain)); + } + END_SU2_OMP_SAFE_GLOBAL_ACCESS + + return result; +} diff --git a/SU2_CFD/src/drivers/CDriver.cpp b/SU2_CFD/src/drivers/CDriver.cpp index 45042a022b1..c3620a54899 100644 --- a/SU2_CFD/src/drivers/CDriver.cpp +++ b/SU2_CFD/src/drivers/CDriver.cpp @@ -795,11 +795,6 @@ void CDriver::InitializeGeometryFVM(CConfig *config, CGeometry **&geometry) { geometry[MESH_0]->ComputeSurfaceAreaCfgFile(config); - /*--- Check for periodicity and disable MG if necessary. ---*/ - - if (rank == MASTER_NODE) cout << "Checking for periodicity." << endl; - geometry[MESH_0]->Check_Periodicity(config); - /*--- Compute mesh quality statistics on the fine grid. ---*/ if (!fea) { diff --git a/SU2_CFD/src/integration/CIntegration.cpp b/SU2_CFD/src/integration/CIntegration.cpp index edb4248d8c1..b3cfdfbfb0b 100644 --- a/SU2_CFD/src/integration/CIntegration.cpp +++ b/SU2_CFD/src/integration/CIntegration.cpp @@ -81,16 +81,17 @@ void CIntegration::Space_Integration(CGeometry *geometry, solver_container[MainSolver]->BC_Fluid_Interface(geometry, solver_container, conv_bound_numerics, visc_bound_numerics, config); - /*--- Compute Fourier Transformations for markers where NRBC_BOUNDARY is applied---*/ + /*--- Compute Fourier Transformations for markers where NRBC_BOUNDARY is applied. + Turbomachinery span-wise data structures are only initialized on the fine grid. ---*/ - if (config->GetBoolGiles() && config->GetSpatialFourier()){ + if (iMesh == MESH_0 && config->GetBoolGiles() && config->GetSpatialFourier()){ solver_container[MainSolver]->PreprocessBC_Giles(geometry, config, conv_bound_numerics, INFLOW); solver_container[MainSolver]->PreprocessBC_Giles(geometry, config, conv_bound_numerics, OUTFLOW); } BEGIN_SU2_OMP_SAFE_GLOBAL_ACCESS { - if (config->GetBoolTurbomachinery()){ + if (iMesh == MESH_0 && config->GetBoolTurbomachinery()){ /*--- Average quantities at the inflow and outflow boundaries ---*/ solver_container[MainSolver]->TurboAverageProcess(solver_container, geometry,config,INFLOW); solver_container[MainSolver]->TurboAverageProcess(solver_container, geometry, config, OUTFLOW); @@ -128,10 +129,14 @@ void CIntegration::Space_Integration(CGeometry *geometry, solver_container[MainSolver]->BC_Supersonic_Outlet(geometry, solver_container, conv_bound_numerics, visc_bound_numerics, config, iMarker); break; case GILES_BOUNDARY: - solver_container[MainSolver]->BC_Giles(geometry, solver_container, conv_bound_numerics, visc_bound_numerics, config, iMarker); + /*--- Giles BC uses turbo geometry data only available on the fine grid. ---*/ + if (iMesh == MESH_0) { + solver_container[MainSolver]->BC_Giles(geometry, solver_container, conv_bound_numerics, visc_bound_numerics, config, iMarker); + } break; case RIEMANN_BOUNDARY: - if (config->GetBoolTurbomachinery()){ + /*--- TurboRiemann uses turbo geometry data only available on the fine grid. ---*/ + if (config->GetBoolTurbomachinery() && iMesh == MESH_0){ solver_container[MainSolver]->BC_TurboRiemann(geometry, solver_container, conv_bound_numerics, visc_bound_numerics, config, iMarker); } else{ diff --git a/SU2_CFD/src/integration/CMultiGridIntegration.cpp b/SU2_CFD/src/integration/CMultiGridIntegration.cpp index 93960cd58f6..d721e74c0e7 100644 --- a/SU2_CFD/src/integration/CMultiGridIntegration.cpp +++ b/SU2_CFD/src/integration/CMultiGridIntegration.cpp @@ -25,13 +25,92 @@ * License along with SU2. If not, see . */ +#include "../../include/integration/ComputeLinSysResRMS.hpp" #include "../../include/integration/CMultiGridIntegration.hpp" #include "../../../Common/include/parallelization/omp_structure.hpp" +#include "../../../Common/include/toolboxes/printing_toolbox.hpp" + +/*!\cond PRIVATE Helper: shared logic for adapting a single MG damping factor. + * Inputs: + * performed[] - actual iteration counts per level from this cycle + * progress[] - whether residuals decreased per level + * getConfigured - returns the per-level configured maximum + * levelStart/End - level range to inspect + * getCurrent - returns the current damping factor from config + * setPersist - persists the updated factor back to config + \endcond */ +template +static void adaptMGDampingFactor(const unsigned short* performed, + const bool* progress, + GetCfg getConfigured, + unsigned short levelStart, unsigned short levelEnd, + GetCur getCurrent, SetPersist setPersist) { + int local_any_stagnant = 0; /*--- hit max iters AND residuals did not decrease: scale down. ---*/ + int local_all_early = 1; /*--- all levels exited before max iters: scale up. ---*/ + int local_inspected = 0; + + for (unsigned short lvl = levelStart; lvl <= levelEnd; ++lvl) { + const unsigned short configured = getConfigured(lvl); + if (configured == 0) continue; + ++local_inspected; + const bool hit_max = (performed[lvl] >= configured); + /*--- Scale-down signal: hit the cap AND residuals did not improve. + * Hitting the cap while still converging is not stagnation; no reduction needed. ---*/ + if (hit_max && !progress[lvl]) local_any_stagnant = 1; + /*--- Scale-up signal: requires early exit on every level. + * Making progress at max iters is good, but the damping is already doing useful work; + * do not increase it further until the smoother actually exits early. ---*/ + if (hit_max) local_all_early = 0; + } + if (local_inspected == 0) return; + + /*--- performed[] and progress[] are derived from MPI-reduced ComputeLinSysResRMS values, + * so local_any_stagnant and local_all_early are already identical on every rank. ---*/ + const su2double SCALE_DOWN = 0.99; + const su2double SCALE_UP = 1.01; + const su2double CLAMP_MIN = 0.1; + const su2double CLAMP_MAX = 0.95; + + su2double factor = getCurrent(); + if (local_any_stagnant) factor *= SCALE_DOWN; + else if (local_all_early) factor *= SCALE_UP; + /*--- else: hit max iters but still converging, or mixed — hold factor. ---*/ + factor = max(CLAMP_MIN, min(CLAMP_MAX, factor)); + setPersist(factor); +} -passivedouble CMultiGridIntegration::computeMultigridCFL(CConfig* config, CSolver* solver_coarse, CGeometry* geometry_coarse, - unsigned short iMesh, passivedouble CFL_fine, passivedouble CFL_coarse_current) { +void CMultiGridIntegration::adaptRestrictionDamping(CConfig* config) { + const auto& mgOpts = config->GetMGOptions(); + const unsigned short nMGLevels = config->GetnMGLevels(); + adaptMGDampingFactor( + lastPreSmoothIters, + lastPreSmoothProgress, + [&mgOpts](unsigned short lvl){ return mgOpts.MG_PreSmooth[lvl]; }, + /*levelStart=*/1, nMGLevels, + [config](){ return config->GetDamp_Res_Restric(); }, + [config](su2double v){ config->SetDamp_Res_Restric(v); }); +} + +void CMultiGridIntegration::adaptProlongationDamping(CConfig* config) { + /*--- Post-smoothing directly measures whether the corrected fine-grid solution + * is well-behaved after prolongation. If it exits early, increase damping. + * If it stagnates at max iters, decrease damping. ---*/ + const auto& mgOpts = config->GetMGOptions(); + const unsigned short nMGLevels = config->GetnMGLevels(); + if (nMGLevels == 0) return; + adaptMGDampingFactor( + lastPostSmoothIters, + lastPostSmoothProgress, + [&mgOpts](unsigned short lvl){ return mgOpts.MG_PostSmooth[lvl]; }, + /*levelStart=*/0, static_cast(nMGLevels - 1), + [config](){ return config->GetDamp_Correc_Prolong(); }, + [config](su2double v){ config->SetDamp_Correc_Prolong(v); }); +} + +passivedouble CMultiGridIntegration::computeMultigridCFL(CConfig* config, unsigned short iMesh, + passivedouble CFL_fine, passivedouble CFL_coarse_current, + passivedouble rms_res_coarse) { - /*--- Must be called from a single-thread context (e.g. inside BEGIN_SU2_OMP_SAFE_GLOBAL_ACCESS). ---*/ const bool wasActive = AD::BeginPassive(); passivedouble current_coeff = CFL_coarse_current / CFL_fine; @@ -41,116 +120,105 @@ passivedouble CMultiGridIntegration::computeMultigridCFL(CConfig* config, CSolve passivedouble CFL_coarse_new = CFL_coarse_current; // Default: keep current value - { - /*--- Get global iteration count first ---*/ - unsigned long current_iter; - if (config->GetTime_Domain()) - current_iter = config->GetTimeIter(); - else - current_iter = config->GetInnerIter(); - - /*--- Reset state at the beginning of a new solve (iter 0 or 1) ---*/ - /*--- This ensures deterministic behavior across multiple runs ---*/ - if (current_iter <= 1 && last_reset_iter != current_iter) { - for (int i = 0; i < MAX_MG_LEVELS; i++) { - current_avg[i] = 0.0; - prev_avg[i] = 0.0; - last_res[i] = 0.0; - last_was_increase[i] = false; - oscillation_count[i] = 0; - last_check_iter[i] = 0; - last_update_iter[i] = 0; - } - last_reset_iter = current_iter; - } - - unsigned short lvl = min(iMesh, (unsigned short)(MAX_MG_LEVELS - 1)); - unsigned long iter = current_iter; - - /*--- Get sum of all RMS residuals for all variables (local to this rank) ---*/ - su2double rms_res_coarse_local = 0.0; - for (unsigned short iVar = 0; iVar < solver_coarse->GetnVar(); iVar++) { - rms_res_coarse_local += SU2_TYPE::GetValue(solver_coarse->GetRes_RMS(iVar)); + /*--- Get global iteration count first ---*/ + unsigned long current_iter; + if (config->GetTime_Domain()) + current_iter = config->GetTimeIter(); + else + current_iter = config->GetInnerIter(); + + /*--- Reset state at the beginning of a new solve (iter 0 or 1) ---*/ + /*--- This ensures deterministic behavior across multiple runs ---*/ + if (current_iter <= 1 && last_reset_iter != current_iter) { + for (int i = 0; i < MAX_MG_LEVELS; i++) { + current_avg[i] = 0.0; + prev_avg[i] = 0.0; + last_res[i] = 0.0; + last_was_increase[i] = false; + oscillation_count[i] = 0; + last_check_iter[i] = 0; + last_update_iter[i] = 0; } + last_reset_iter = current_iter; + } - /*--- MPI synchronization: ensure all ranks use the same global residual value. ---*/ - /*--- Always reduce across ranks so all subsequent CFL logic is deterministic. ---*/ - su2double rms_global_sum = 0.0; - SU2_MPI::Allreduce(&rms_res_coarse_local, &rms_global_sum, 1, MPI_DOUBLE, MPI_SUM, SU2_MPI::GetComm()); - passivedouble rms_res_coarse = SU2_TYPE::GetValue(rms_global_sum) / static_cast(SU2_MPI::GetSize()); - - /*--- Flip-flop detection: detect oscillating residuals (once per outer iteration) ---*/ - bool oscillation_detected = false; - if (iter != last_check_iter[lvl]) { - last_check_iter[lvl] = iter; - - if (last_res[lvl] > EPS) { - bool current_is_increase = (rms_res_coarse > last_res[lvl]); - if (current_is_increase != last_was_increase[lvl]) { - /*--- Direction changed, increment oscillation counter ---*/ - oscillation_count[lvl]++; - if (oscillation_count[lvl] >= 4) { - /*--- Detected 4 consecutive direction changes = oscillation ---*/ - oscillation_detected = true; - oscillation_count[lvl] = 0; // Reset counter after detecting - } - } else { - /*--- Same direction, reset counter ---*/ - oscillation_count[lvl] = 0; + unsigned short lvl = min(iMesh, (unsigned short)(MAX_MG_LEVELS - 1)); + unsigned long iter = current_iter; + + /*--- rms_res_coarse is passed in (from lastPreSmoothRMS, already MPI-reduced). ---*/ + + /*--- Flip-flop detection: detect oscillating residuals (once per outer iteration) ---*/ + bool oscillation_detected = false; + if (iter != last_check_iter[lvl]) { + last_check_iter[lvl] = iter; + + if (last_res[lvl] > EPS) { + bool current_is_increase = (rms_res_coarse > last_res[lvl]); + if (current_is_increase != last_was_increase[lvl]) { + /*--- Direction changed, increment oscillation counter ---*/ + oscillation_count[lvl]++; + if (oscillation_count[lvl] >= 4) { + /*--- Detected 4 consecutive direction changes = oscillation ---*/ + oscillation_detected = true; + oscillation_count[lvl] = 0; // Reset counter after detecting } - last_was_increase[lvl] = current_is_increase; + } else { + /*--- Same direction, reset counter ---*/ + oscillation_count[lvl] = 0; } - last_res[lvl] = rms_res_coarse; + last_was_increase[lvl] = current_is_increase; } + last_res[lvl] = rms_res_coarse; + } - /*--- Update exponential moving average ---*/ - if (current_avg[lvl] < EPS) { - current_avg[lvl] = rms_res_coarse; // Initialize with first value - } else { - current_avg[lvl] = (current_avg[lvl] * (AVG_WINDOW - 1) + rms_res_coarse) / AVG_WINDOW; - } + /*--- Update exponential moving average ---*/ + if (current_avg[lvl] < EPS) { + current_avg[lvl] = rms_res_coarse; // Initialize with first value + } else { + current_avg[lvl] = (current_avg[lvl] * (AVG_WINDOW - 1) + rms_res_coarse) / AVG_WINDOW; + } - /*--- Check if we should compare and adapt CFL ---*/ - passivedouble new_coeff = current_coeff; - const passivedouble MIN_REDUCTION_FACTOR = 0.98; // Require at least 2% reduction - const int UPDATE_INTERVAL = 5; // Update reference every N iterations + /*--- Check if we should compare and adapt CFL ---*/ + passivedouble new_coeff = current_coeff; + const passivedouble MIN_REDUCTION_FACTOR = 0.98; // Require at least 2% reduction + const int UPDATE_INTERVAL = 5; // Update reference every N iterations - /*--- Initialize prev_avg on first use ---*/ - if (prev_avg[lvl] < EPS) { - prev_avg[lvl] = current_avg[lvl]; - } + /*--- Initialize prev_avg on first use ---*/ + if (prev_avg[lvl] < EPS) { + prev_avg[lvl] = current_avg[lvl]; + } - /*--- Periodically update prev_avg to allow ratio to reflect accumulated decrease ---*/ - bool should_update = (iter - last_update_iter[lvl] >= UPDATE_INTERVAL); - - /*--- Asymmetric adaptation for robustness ---*/ - if (prev_avg[lvl] > EPS) { - passivedouble ratio = current_avg[lvl] / prev_avg[lvl]; - bool sufficient_decrease = (ratio < MIN_REDUCTION_FACTOR); - bool increasing_trend = (ratio >= 1.0); - - if (increasing_trend) { - /*--- Residual increasing: reduce CFL immediately for robustness ---*/ - new_coeff = current_coeff * 0.90; - /*--- Update reference since we're reacting immediately ---*/ - prev_avg[lvl] = current_avg[lvl]; - last_update_iter[lvl] = iter; - } else if (sufficient_decrease && should_update) { - /*--- Residual decreasing sufficiently: increase CFL ---*/ - new_coeff = current_coeff * 1.05; - /*--- Update reference only when we actually increase CFL ---*/ - prev_avg[lvl] = current_avg[lvl]; - last_update_iter[lvl] = iter; - } - } + /*--- Periodically update prev_avg to allow ratio to reflect accumulated decrease ---*/ + bool should_update = (iter - last_update_iter[lvl] >= UPDATE_INTERVAL); + + /*--- Asymmetric adaptation for robustness ---*/ + if (prev_avg[lvl] > EPS) { + passivedouble ratio = current_avg[lvl] / prev_avg[lvl]; + bool sufficient_decrease = (ratio < MIN_REDUCTION_FACTOR); + bool increasing_trend = (ratio >= 1.0); - /*--- CFL reduction for oscillation detection ---*/ - if (oscillation_detected) { - new_coeff = current_coeff * 0.75; - /*--- Update reference after oscillation response ---*/ + if (increasing_trend) { + /*--- Residual increasing: reduce CFL immediately for robustness ---*/ + new_coeff = current_coeff * 0.90; + /*--- Update reference since we're reacting immediately ---*/ + prev_avg[lvl] = current_avg[lvl]; + last_update_iter[lvl] = iter; + } else if (sufficient_decrease && should_update) { + /*--- Residual decreasing sufficiently: increase CFL ---*/ + new_coeff = current_coeff * 1.05; + /*--- Update reference only when we actually increase CFL ---*/ prev_avg[lvl] = current_avg[lvl]; last_update_iter[lvl] = iter; } + } + + /*--- CFL reduction for oscillation detection ---*/ + if (oscillation_detected) { + new_coeff = current_coeff * 0.75; + /*--- Update reference after oscillation response ---*/ + prev_avg[lvl] = current_avg[lvl]; + last_update_iter[lvl] = iter; + } /*--- Clamp coefficient between 0.5 and 1.0 ---*/ new_coeff = max(0.5, min(1.0, new_coeff)); @@ -159,7 +227,6 @@ passivedouble CMultiGridIntegration::computeMultigridCFL(CConfig* config, CSolve CFL_coarse_new = max(0.5 * CFL_fine, min(CFL_fine, CFL_fine * new_coeff)); config->SetCFL(iMesh+1, CFL_coarse_new); - } AD::EndPassive(wasActive); return CFL_coarse_new; @@ -208,10 +275,10 @@ void CMultiGridIntegration::MultiGrid_Iteration(CGeometry ****geometry, su2double monitor = 1.0; bool FullMG = false; - unsigned short RecursiveParam = config[iZone]->GetMGCycle(); + unsigned short RecursiveParam = static_cast(config[iZone]->GetMGCycle()); - if (config[iZone]->GetMGCycle() == FULLMG_CYCLE) { - RecursiveParam = V_CYCLE; + if (config[iZone]->GetMGCycle() == MG_CYCLE::FULL) { + RecursiveParam = static_cast(MG_CYCLE::V); FullMG = true; } @@ -219,8 +286,32 @@ void CMultiGridIntegration::MultiGrid_Iteration(CGeometry ****geometry, unsigned short FinestMesh = config[iZone]->GetFinestMesh(); - /// TODO: This was always false. - const bool Convergence_FullMG = false; + /*--- Initialize per-level smoothing iteration counters to the configured maximum. + * If early exit never fires, the output will show actual == max. ---*/ + BEGIN_SU2_OMP_SAFE_GLOBAL_ACCESS + { + const unsigned short nMGLevels = config[iZone]->GetnMGLevels(); + const auto& mgOpts = config[iZone]->GetMGOptions(); + for (unsigned short i = 0; i <= nMGLevels; ++i) { + lastPreSmoothIters[i] = mgOpts.MG_PreSmooth[i]; + lastPostSmoothIters[i] = mgOpts.MG_PostSmooth[i]; + lastCorrecSmoothIters[i] = mgOpts.MG_CorrecSmooth[i]; + lastPreSmoothProgress[i] = false; + lastPostSmoothProgress[i] = false; + lastCorrecSmoothProgress[i] = false; + lastPreSmoothRMS[i][0] = lastPreSmoothRMS[i][1] = 0.0; + lastPostSmoothRMS[i][0] = lastPostSmoothRMS[i][1] = 0.0; + lastCorrecSmoothRMS[i][0] = lastCorrecSmoothRMS[i][1] = 0.0; + } + } + END_SU2_OMP_SAFE_GLOBAL_ACCESS + + /*--- Full MG: advance to the next finer grid after a fixed number of + * outer iterations on the current coarsest active level. + * We use 100 iterations per level (nMGLevels levels total) ---*/ + const bool Convergence_FullMG = + FullMG && (FinestMesh != MESH_0) && + (config[iZone]->GetInnerIter() % 100 == 99); if (!config[iZone]->GetRestart() && FullMG && direct && ( Convergence_FullMG && (FinestMesh != MESH_0 ))) { @@ -243,6 +334,30 @@ void CMultiGridIntegration::MultiGrid_Iteration(CGeometry ****geometry, MultiGrid_Cycle(geometry, solver_container, numerics_container, config, FinestMesh, RecursiveParam, RunTime_EqSystem, iZone, iInst); + /*--- Adapt coarse-grid CFL once per cycle using smoothing residuals gathered during the cycle. + * lastPreSmoothRMS[iMesh+1][1] is the final RMS after pre-smoothing at the coarse level ---*/ + const unsigned short nMGLevels = config[iZone]->GetnMGLevels(); + BEGIN_SU2_OMP_SAFE_GLOBAL_ACCESS + { + for (unsigned short iMesh = FinestMesh; iMesh < nMGLevels; ++iMesh) { + const passivedouble CFL_fine_p = SU2_TYPE::GetValue(config[iZone]->GetCFL(iMesh)); + const passivedouble CFL_coarse_p = SU2_TYPE::GetValue(config[iZone]->GetCFL(iMesh+1)); + computeMultigridCFL(config[iZone], iMesh, CFL_fine_p, CFL_coarse_p, + lastPreSmoothRMS[iMesh+1][1]); + } + } + END_SU2_OMP_SAFE_GLOBAL_ACCESS + + /*--- Propagate the updated coarse-grid CFL to every coarse-grid point (all threads). ---*/ + for (unsigned short iMesh = FinestMesh; iMesh < nMGLevels; ++iMesh) { + const passivedouble CFL_coarse_new = SU2_TYPE::GetValue(config[iZone]->GetCFL(iMesh+1)); + CGeometry* geo_c = geometry[iZone][iInst][iMesh+1]; + CSolver* sol_c = solver_container[iZone][iInst][iMesh+1][Solver_Position]; + SU2_OMP_FOR_STAT(roundUpDiv(geo_c->GetnPoint(), omp_get_num_threads())) + for (auto iPoint = 0ul; iPoint < geo_c->GetnPoint(); iPoint++) + sol_c->GetNodes()->SetLocalCFL(iPoint, CFL_coarse_new); + END_SU2_OMP_FOR + } /*--- Computes primitive variables and gradients in the finest mesh (useful for the next solver (turbulence) and output ---*/ @@ -257,6 +372,72 @@ void CMultiGridIntegration::MultiGrid_Iteration(CGeometry ****geometry, numerics_container[iZone][iInst], config[iZone], FinestMesh, RunTime_EqSystem, &monitor); + /*--- Adapt restriction damping based on coarse-level pre-smoothing workload from this cycle. + * Only effective when MG_SMOOTH_EARLY_EXIT= YES (otherwise all levels always run to completion + * and the signal would always point to "scale down"). ---*/ + const auto& mgOptsZone = config[iZone]->GetMGOptions(); + if (mgOptsZone.MG_Smooth_EarlyExit) { + BEGIN_SU2_OMP_SAFE_GLOBAL_ACCESS + { + adaptRestrictionDamping(config[iZone]); + adaptProlongationDamping(config[iZone]); + } + END_SU2_OMP_SAFE_GLOBAL_ACCESS + } + + /*--- Print compact smoothing summary when MG_SMOOTH_OUTPUT= YES. ---*/ + if (mgOptsZone.MG_Smooth_Output) { + BEGIN_SU2_OMP_SAFE_GLOBAL_ACCESS + { + if (SU2_MPI::GetRank() == MASTER_NODE) { + + /*--- Helper: format one cell as "act/max [init->final]". ---*/ + auto cellStr = [](unsigned short act, unsigned short mx, + su2double rms0, su2double rms1) -> std::string { + std::ostringstream ss; + ss << act << "/" << mx << " [" + << std::scientific << std::setprecision(2) + << rms0 << "->" << rms1 << "]"; + return ss.str(); + }; + + PrintingToolbox::CTablePrinter table(&std::cout); + table.AddColumn("Smoother", 13); + for (unsigned short i = 0; i <= nMGLevels; ++i) + table.AddColumn("Level " + std::to_string(i), 26); + table.PrintHeader(); + + /*--- Pre-smooth: defined on all levels 0..nMGLevels. ---*/ + table << "Pre-smooth"; + for (unsigned short i = 0; i <= nMGLevels; ++i) + table << cellStr(lastPreSmoothIters[i], mgOptsZone.MG_PreSmooth[i], + lastPreSmoothRMS[i][0], lastPreSmoothRMS[i][1]); + + /*--- Post-smooth: defined on levels 0..nMGLevels-1; coarsest has none. ---*/ + table << "Post-smooth"; + for (unsigned short i = 0; i < nMGLevels; ++i) + table << cellStr(lastPostSmoothIters[i], mgOptsZone.MG_PostSmooth[i], + lastPostSmoothRMS[i][0], lastPostSmoothRMS[i][1]); + table << "-"; + + /*--- Corr.-smooth: defined on levels 0..nMGLevels-1; coarsest has none. ---*/ + table << "Corr-smooth"; + for (unsigned short i = 0; i < nMGLevels; ++i) + table << cellStr(lastCorrecSmoothIters[i], mgOptsZone.MG_CorrecSmooth[i], + lastCorrecSmoothRMS[i][0], lastCorrecSmoothRMS[i][1]); + table << "-"; + + table.PrintFooter(); + + cout << std::fixed << std::setprecision(4) + << "Damping [restrict | prolong] : " << config[iZone]->GetDamp_Res_Restric() + << " | " << config[iZone]->GetDamp_Correc_Prolong() << "\n" + << std::defaultfloat << std::setprecision(6); + } + } + END_SU2_OMP_SAFE_GLOBAL_ACCESS + } + } END_SU2_OMP_PARALLEL @@ -348,33 +529,14 @@ void CMultiGridIntegration::MultiGrid_Cycle(CGeometry ****geometry, MultiGrid_Cycle(geometry, solver_container, numerics_container, config_container, iMesh+1, nextRecurseParam, RunTime_EqSystem, iZone, iInst); - } /*--- Compute prolongated solution, and smooth the correction $u^(new)_k = u_k + Smooth(I^k_(k+1)(u_(k+1)-I^(k+1)_k u_k))$ ---*/ GetProlongated_Correction(RunTime_EqSystem, solver_fine, solver_coarse, geometry_fine, geometry_coarse, config); - /*--- Compute adaptive CFL for coarse grid (master only, with barriers for synchronization) ---*/ - BEGIN_SU2_OMP_SAFE_GLOBAL_ACCESS - { - passivedouble CFL_fine_passive = SU2_TYPE::GetValue(config->GetCFL(iMesh)); - passivedouble CFL_coarse_current_passive = SU2_TYPE::GetValue(config->GetCFL(iMesh+1)); - computeMultigridCFL(config, solver_coarse, geometry_coarse, iMesh, CFL_fine_passive, CFL_coarse_current_passive); - } - END_SU2_OMP_SAFE_GLOBAL_ACCESS - - /*--- All threads read the CFL updated by master (safe after trailing barrier above) ---*/ - const passivedouble CFL_coarse_new = SU2_TYPE::GetValue(config->GetCFL(iMesh+1)); - - /*--- Update LocalCFL at each coarse grid point ---*/ - SU2_OMP_FOR_STAT(roundUpDiv(geometry_coarse->GetnPoint(), omp_get_num_threads())) - for (auto iPoint = 0ul; iPoint < geometry_coarse->GetnPoint(); iPoint++) { - solver_coarse->GetNodes()->SetLocalCFL(iPoint, CFL_coarse_new); - } - END_SU2_OMP_FOR - - SmoothProlongated_Correction(RunTime_EqSystem, solver_fine, geometry_fine, config->GetMG_CorrecSmooth(iMesh), 1.25, config); + const auto& mgOpts = config->GetMGOptions(); + SmoothProlongated_Correction(RunTime_EqSystem, solver_fine, geometry_fine, mgOpts.MG_CorrecSmooth[iMesh], mgOpts.MG_Smooth_Coeff, config, iMesh); SetProlongated_Correction(solver_fine, geometry_fine, config, iMesh); @@ -399,11 +561,14 @@ void CMultiGridIntegration::PreSmoothing(unsigned short RunTime_EqSystem, unsigned short iZone, unsigned short iRKLimit) { + const auto& mgOpts = config->GetMGOptions(); const bool classical_rk4 = (config->GetKind_TimeIntScheme() == CLASSICAL_RK4_EXPLICIT); - const unsigned short nPreSmooth = config->GetMG_PreSmooth(iMesh); + const unsigned short nPreSmooth = mgOpts.MG_PreSmooth[iMesh]; const unsigned long timeIter = config->GetTimeIter(); + const bool early_exit = mgOpts.MG_Smooth_EarlyExit && (nPreSmooth > 1); - /*--- Do a presmoothing on the grid iMesh to be restricted to the grid iMesh+1 ---*/ + /*--- Reset the shared early-exit flag (master only). ---*/ + SU2_OMP_SAFE_GLOBAL_ACCESS(mg_early_exit_flag = false;) for (unsigned short iPreSmooth = 0; iPreSmooth < nPreSmooth; iPreSmooth++) { /*--- Time and space integration ---*/ @@ -425,13 +590,59 @@ void CMultiGridIntegration::PreSmoothing(unsigned short RunTime_EqSystem, /*--- Space integration ---*/ Space_Integration(geometry_fine, solver_container_fine, numerics_fine, config, iMesh, iRKStep, RunTime_EqSystem); + /*--- Capture initial RMS after the very first residual evaluation. + * This is the earliest point where LinSysRes = R(u_current) (not stale). + * ComputeLinSysResRMS must be called by all threads (uses parallel dot). ---*/ + if (iPreSmooth == 0 && iRKStep == 0) { + const passivedouble initial_rms = ComputeLinSysResRMS(solver_fine); + BEGIN_SU2_OMP_SAFE_GLOBAL_ACCESS + { + lastPreSmoothRMS[iMesh][0] = initial_rms; + if (early_exit) mg_initial_smooth_rms = initial_rms; + } + END_SU2_OMP_SAFE_GLOBAL_ACCESS + } + /*--- Time integration, update solution using the old solution plus the solution increment ---*/ Time_Integration(geometry_fine, solver_container_fine, config, iRKStep, RunTime_EqSystem); /*--- Send-Receive boundary conditions, and postprocessing ---*/ solver_fine->Postprocessing(geometry_fine, solver_container_fine, config, iMesh); } + + /*--- Early exit: check if RMS has dropped sufficiently. + * ComputeLinSysResRMS must be called by all threads. + * only master uses the result inside the safe block. ---*/ + if (early_exit) { + const passivedouble current_rms = ComputeLinSysResRMS(solver_fine); + BEGIN_SU2_OMP_SAFE_GLOBAL_ACCESS + { + mg_last_smooth_rms = current_rms; + if (mg_last_smooth_rms < mgOpts.MG_Smooth_Res_Threshold * mg_initial_smooth_rms) { + lastPreSmoothIters[iMesh] = iPreSmooth + 1; + mg_early_exit_flag = true; + } + } + END_SU2_OMP_SAFE_GLOBAL_ACCESS + if (mg_early_exit_flag) break; + } } + + /*--- Record final RMS and progress flag. + * In the early-exit path mg_last_smooth_rms already holds the current value; + * in the normal path we compute it once here. + * The condition is the same for all threads so they all agree on whether to call. ---*/ + passivedouble final_pre_rms = mg_last_smooth_rms; + if (!(early_exit && mg_early_exit_flag)) + final_pre_rms = ComputeLinSysResRMS(solver_fine); + BEGIN_SU2_OMP_SAFE_GLOBAL_ACCESS + { + mg_last_smooth_rms = final_pre_rms; + lastPreSmoothRMS[iMesh][1] = final_pre_rms; + lastPreSmoothProgress[iMesh] = mg_early_exit_flag || + (final_pre_rms < lastPreSmoothRMS[iMesh][0]); + } + END_SU2_OMP_SAFE_GLOBAL_ACCESS } @@ -444,9 +655,14 @@ void CMultiGridIntegration::PostSmoothing(unsigned short RunTime_EqSystem, unsigned short iMesh, unsigned short iRKLimit) { + const auto& mgOpts = config->GetMGOptions(); const bool classical_rk4 = (config->GetKind_TimeIntScheme() == CLASSICAL_RK4_EXPLICIT); - const unsigned short nPostSmooth = config->GetMG_PostSmooth(iMesh); + const unsigned short nPostSmooth = mgOpts.MG_PostSmooth[iMesh]; const unsigned long timeIter = config->GetTimeIter(); + const bool early_exit = mgOpts.MG_Smooth_EarlyExit && (nPostSmooth > 1); + + /*--- Reset the shared early-exit flag (master only). ---*/ + SU2_OMP_SAFE_GLOBAL_ACCESS(mg_early_exit_flag = false;) /*--- Do a postsmoothing on the grid iMesh after prolongation from the grid iMesh+1 ---*/ for (unsigned short iPostSmooth = 0; iPostSmooth < nPostSmooth; iPostSmooth++) { @@ -459,12 +675,26 @@ void CMultiGridIntegration::PostSmoothing(unsigned short RunTime_EqSystem, solver_fine->Set_OldSolution(); if (classical_rk4) solver_fine->Set_NewSolution(); - solver_fine->SetTime_Step(geometry_fine, solver_container_fine, config, iMesh, timeIter); + solver_fine->SetTime_Step(geometry_fine, solver_container_fine, config, iMesh, timeIter); } /*--- Space integration ---*/ Space_Integration(geometry_fine, solver_container_fine, numerics_fine, config, iMesh, iRKStep, RunTime_EqSystem); + /*--- Capture initial RMS after the very first residual evaluation. + * Before this point, LinSysRes held the smoothed correction (from SmoothProlongated_Correction), + * NOT the spatial residual R(u). This is the first valid R(u) after applying the correction. + * ComputeLinSysResRMS must be called by all threads (uses parallel dot). ---*/ + if (iPostSmooth == 0 && iRKStep == 0) { + const passivedouble initial_rms = ComputeLinSysResRMS(solver_fine); + BEGIN_SU2_OMP_SAFE_GLOBAL_ACCESS + { + lastPostSmoothRMS[iMesh][0] = initial_rms; + if (early_exit) mg_initial_smooth_rms = initial_rms; + } + END_SU2_OMP_SAFE_GLOBAL_ACCESS + } + /*--- Time integration, update solution using the old solution plus the solution increment ---*/ Time_Integration(geometry_fine, solver_container_fine, config, iRKStep, RunTime_EqSystem); @@ -472,7 +702,38 @@ void CMultiGridIntegration::PostSmoothing(unsigned short RunTime_EqSystem, solver_fine->Postprocessing(geometry_fine, solver_container_fine, config, iMesh); } + + /*--- Early exit: check if RMS has dropped sufficiently. + * ComputeLinSysResRMS must be called by all threads (uses parallel dot). ---*/ + if (early_exit) { + const passivedouble current_rms = ComputeLinSysResRMS(solver_fine); + BEGIN_SU2_OMP_SAFE_GLOBAL_ACCESS + { + mg_last_smooth_rms = current_rms; + if (mg_last_smooth_rms < mgOpts.MG_Smooth_Res_Threshold * mg_initial_smooth_rms) { + lastPostSmoothIters[iMesh] = iPostSmooth + 1; + mg_early_exit_flag = true; + } + } + END_SU2_OMP_SAFE_GLOBAL_ACCESS + if (mg_early_exit_flag) break; + } + } + + /*--- Record final RMS after post-smoothing. + * In the early-exit path mg_last_smooth_rms is already current; otherwise compute once. + * The condition is the same for all threads so they all agree on whether to call. ---*/ + passivedouble final_post_rms = mg_last_smooth_rms; + if (!(early_exit && mg_early_exit_flag)) + final_post_rms = ComputeLinSysResRMS(solver_fine); + BEGIN_SU2_OMP_SAFE_GLOBAL_ACCESS + { + mg_last_smooth_rms = final_post_rms; + lastPostSmoothRMS[iMesh][1] = final_post_rms; + lastPostSmoothProgress[iMesh] = mg_early_exit_flag || + (final_post_rms < lastPostSmoothRMS[iMesh][0]); } + END_SU2_OMP_SAFE_GLOBAL_ACCESS } @@ -527,7 +788,7 @@ void CMultiGridIntegration::GetProlongated_Correction(unsigned short RunTime_EqS for (auto iVertex = 0ul; iVertex < geo_coarse->nVertex[iMarker]; iVertex++) { auto Point_Coarse = geo_coarse->vertex[iMarker][iVertex]->GetNode(); - /*--- For dirichlet boundary condtions, set the correction to zero. + /*--- For dirichlet boundary conditions, set the correction to zero. Note that Solution_Old stores the correction not the actual value ---*/ su2double zero[3] = {0.0}; @@ -555,7 +816,8 @@ void CMultiGridIntegration::GetProlongated_Correction(unsigned short RunTime_EqS } void CMultiGridIntegration::SmoothProlongated_Correction(unsigned short RunTime_EqSystem, CSolver *solver, CGeometry *geometry, - unsigned short val_nSmooth, su2double val_smooth_coeff, CConfig *config) { + unsigned short val_nSmooth, su2double val_smooth_coeff, CConfig *config, + unsigned short iMesh) { /*--- Check if there is work to do. ---*/ if (val_nSmooth == 0) return; @@ -571,7 +833,15 @@ void CMultiGridIntegration::SmoothProlongated_Correction(unsigned short RunTime_ } END_SU2_OMP_FOR - /*--- Jacobi iterations. ---*/ + /*--- Record initial correction norm for debugging output. + * ComputeLinSysResRMS must be called by all threads (uses parallel dot). ---*/ + { + const passivedouble initial_corr_rms = ComputeLinSysResRMS(solver); + SU2_OMP_SAFE_GLOBAL_ACCESS(lastCorrecSmoothRMS[iMesh][0] = initial_corr_rms;) + } + + /*--- Jacobi iterations (no early exit — Jacobi targets high-frequency modes, + * so the global RMS is not a meaningful convergence indicator). ---*/ for (auto iSmooth = 0u; iSmooth < val_nSmooth; iSmooth++) { @@ -625,6 +895,11 @@ void CMultiGridIntegration::SmoothProlongated_Correction(unsigned short RunTime_ } + /*--- Record final correction norm for debugging output. + * ComputeLinSysResRMS must be called by all threads (uses parallel dot). ---*/ + const passivedouble final_corr_rms = ComputeLinSysResRMS(solver); + SU2_OMP_SAFE_GLOBAL_ACCESS(lastCorrecSmoothRMS[iMesh][1] = final_corr_rms;) + } void CMultiGridIntegration::SetProlongated_Correction(CSolver *sol_fine, CGeometry *geo_fine, @@ -632,7 +907,15 @@ void CMultiGridIntegration::SetProlongated_Correction(CSolver *sol_fine, CGeomet su2double *Solution_Fine, *Residual_Fine; const unsigned short nVar = sol_fine->GetnVar(); - const su2double factor = config->GetDamp_Correc_Prolong(); + + /*--- Level-dependent damping: coarser prolongations produce noisier corrections + * due to larger cell-size jumps, so we reduce the factor progressively. + * iMesh=0: factor = base_damp * 1.0 (finest grid, full correction) + * iMesh=1: factor = base_damp * 0.75 + * iMesh=2: factor = base_damp * 0.5625, etc. ---*/ + const su2double base_damp = config->GetDamp_Correc_Prolong(); + const su2double level_factor = pow(0.75, static_cast(iMesh)); + const su2double factor = base_damp * level_factor; SU2_OMP_FOR_STAT(roundUpDiv(geo_fine->GetnPointDomain(), omp_get_num_threads())) for (auto Point_Fine = 0ul; Point_Fine < geo_fine->GetnPointDomain(); Point_Fine++) { @@ -675,7 +958,7 @@ void CMultiGridIntegration::SetForcing_Term(CSolver *sol_fine, CSolver *sol_coar const su2double *Residual_Fine; const unsigned short nVar = sol_coarse->GetnVar(); - su2double factor = config->GetDamp_Res_Restric(); + const su2double factor = config->GetDamp_Res_Restric(); auto *Residual = new su2double[nVar]; @@ -689,7 +972,7 @@ void CMultiGridIntegration::SetForcing_Term(CSolver *sol_fine, CSolver *sol_coar auto Point_Fine = geo_coarse->nodes->GetChildren_CV(Point_Coarse, iChildren); Residual_Fine = sol_fine->LinSysRes.GetBlock(Point_Fine); for (auto iVar = 0u; iVar < nVar; iVar++) - Residual[iVar] += factor*Residual_Fine[iVar]; + Residual[iVar] += factor * Residual_Fine[iVar]; } sol_coarse->GetNodes()->AddRes_TruncError(Point_Coarse, Residual); } @@ -835,8 +1118,9 @@ void CMultiGridIntegration::NonDimensional_Parameters(CGeometry **geometry, CSol solver_container[FinestMesh][FLOW_SOL]->Momentum_Forces(geometry[FinestMesh], config); solver_container[FinestMesh][FLOW_SOL]->Friction_Forces(geometry[FinestMesh], config); - /*--- Calculate the turbo performance ---*/ - if (config->GetBoolTurbomachinery()){ + /*--- Calculate the turbo performance (only on the fine grid; turbo + * geometry data is only available on MESH_0). ---*/ + if (config->GetBoolTurbomachinery() && FinestMesh == MESH_0){ /*--- Average quantities at the inflow and outflow boundaries ---*/ diff --git a/SU2_CFD/src/solvers/CIncNSSolver.cpp b/SU2_CFD/src/solvers/CIncNSSolver.cpp index 182fb133bb9..dc02968fda4 100644 --- a/SU2_CFD/src/solvers/CIncNSSolver.cpp +++ b/SU2_CFD/src/solvers/CIncNSSolver.cpp @@ -108,8 +108,6 @@ void CIncNSSolver::Preprocessing(CGeometry *geometry, CSolver **solver_container if (wall_functions) { SU2_OMP_SAFE_GLOBAL_ACCESS(SetTau_Wall_WF(geometry, solver_container, config);) - // nijso: we have to set this as well?? - // seteddyviscfirstpoint } /*--- Compute recovered pressure and temperature for streamwise periodic flow ---*/ diff --git a/SU2_CFD/src/solvers/CSpeciesSolver.cpp b/SU2_CFD/src/solvers/CSpeciesSolver.cpp index 8966ca3da31..2857bdc7fd5 100644 --- a/SU2_CFD/src/solvers/CSpeciesSolver.cpp +++ b/SU2_CFD/src/solvers/CSpeciesSolver.cpp @@ -113,7 +113,7 @@ void CSpeciesSolver::Initialize(CGeometry* geometry, CConfig* config, unsigned s AllocVectorOfMatrices( nVertex, nVar,CustomBoundaryScalar); - if (iMesh == MESH_0 || config->GetMGCycle() == FULLMG_CYCLE) { + if (iMesh == MESH_0 || config->GetMGCycle() == MG_CYCLE::FULL) { /*--- Define some auxiliary vector related with the residual ---*/ diff --git a/SU2_CFD/src/solvers/CTurbSASolver.cpp b/SU2_CFD/src/solvers/CTurbSASolver.cpp index 00d3009faa7..23237370762 100644 --- a/SU2_CFD/src/solvers/CTurbSASolver.cpp +++ b/SU2_CFD/src/solvers/CTurbSASolver.cpp @@ -56,7 +56,7 @@ CTurbSASolver::CTurbSASolver(CGeometry *geometry, CConfig *config, unsigned shor /*--- Single grid simulation ---*/ - if (iMesh == MESH_0 || config->GetMGCycle() == FULLMG_CYCLE) { + if (iMesh == MESH_0 || config->GetMGCycle() == MG_CYCLE::FULL) { /*--- Define some auxiliar vector related with the residual ---*/ diff --git a/SU2_CFD/src/solvers/CTurbSSTSolver.cpp b/SU2_CFD/src/solvers/CTurbSSTSolver.cpp index e5e845abf7a..7cd7c250521 100644 --- a/SU2_CFD/src/solvers/CTurbSSTSolver.cpp +++ b/SU2_CFD/src/solvers/CTurbSSTSolver.cpp @@ -58,7 +58,7 @@ CTurbSSTSolver::CTurbSSTSolver(CGeometry *geometry, CConfig *config, unsigned sh /*--- Single grid simulation ---*/ - if (iMesh == MESH_0 || config->GetMGCycle() == FULLMG_CYCLE) { + if (iMesh == MESH_0 || config->GetMGCycle() == MG_CYCLE::FULL) { /*--- Define some auxiliary vector related with the residual ---*/ diff --git a/SU2_CFD/src/solvers/CTurbSolver.cpp b/SU2_CFD/src/solvers/CTurbSolver.cpp index 609bc3daaee..121c004c104 100644 --- a/SU2_CFD/src/solvers/CTurbSolver.cpp +++ b/SU2_CFD/src/solvers/CTurbSolver.cpp @@ -191,6 +191,36 @@ void CTurbSolver::LoadRestart(CGeometry** geometry, CSolver*** solver, CConfig* false); solver[iMesh][TURB_SOL]->Postprocessing(geometry[iMesh], solver[iMesh], config, iMesh); } + + /*--- Overwrite coarse-level eddy viscosity to ensure restart reproducibility. ---*/ + SU2_OMP_FOR_STAT(roundUpDiv(geometry[iMesh]->GetnPointDomain(), omp_get_num_threads())) + for (auto iPoint = 0ul; iPoint < geometry[iMesh]->GetnPointDomain(); iPoint++) { + su2double Area_Parent = geometry[iMesh]->nodes->GetVolume(iPoint); + su2double EddyVisc = 0.0; + for (auto iChildren = 0u; iChildren < geometry[iMesh]->nodes->GetnChildren_CV(iPoint); iChildren++) { + auto Point_Fine = geometry[iMesh]->nodes->GetChildren_CV(iPoint, iChildren); + su2double Area_Children = geometry[iMesh - 1]->nodes->GetVolume(Point_Fine); + EddyVisc += solver[iMesh - 1][TURB_SOL]->GetNodes()->GetmuT(Point_Fine) * Area_Children / Area_Parent; + } + solver[iMesh][TURB_SOL]->GetNodes()->SetmuT(iPoint, EddyVisc); + } + END_SU2_OMP_FOR + + /*--- Zero eddy viscosity at viscous walls. ---*/ + for (auto iMarker = 0u; iMarker < config->GetnMarker_All(); iMarker++) { + if (config->GetViscous_Wall(iMarker)) { + SU2_OMP_FOR_STAT(32) + for (auto iVertex = 0ul; iVertex < geometry[iMesh]->nVertex[iMarker]; iVertex++) { + auto Point_Coarse = geometry[iMesh]->vertex[iMarker][iVertex]->GetNode(); + solver[iMesh][TURB_SOL]->GetNodes()->SetmuT(Point_Coarse, 0.0); + } + END_SU2_OMP_FOR + } + } + + /*--- Communicate the restricted eddy viscosity. ---*/ + solver[iMesh][TURB_SOL]->InitiateComms(geometry[iMesh], config, MPI_QUANTITIES::SOLUTION_EDDY); + solver[iMesh][TURB_SOL]->CompleteComms(geometry[iMesh], config, MPI_QUANTITIES::SOLUTION_EDDY); } /*--- Go back to single threaded execution. ---*/ diff --git a/SU2_CFD/src/variables/CAdjEulerVariable.cpp b/SU2_CFD/src/variables/CAdjEulerVariable.cpp index b2ac36a5b8b..67a33bbe18b 100644 --- a/SU2_CFD/src/variables/CAdjEulerVariable.cpp +++ b/SU2_CFD/src/variables/CAdjEulerVariable.cpp @@ -40,7 +40,7 @@ CAdjEulerVariable::CAdjEulerVariable(su2double psirho, const su2double *phi, su2 /*--- Only for residual smoothing (multigrid) ---*/ for (unsigned long iMesh = 0; iMesh <= config->GetnMGLevels(); iMesh++) { - if (config->GetMG_CorrecSmooth(iMesh) > 0) { + if (config->GetMGOptions().MG_CorrecSmooth[iMesh] > 0) { Residual_Sum.resize(nPoint,nVar); Residual_Old.resize(nPoint,nVar); break; diff --git a/SU2_CFD/src/variables/CFlowVariable.cpp b/SU2_CFD/src/variables/CFlowVariable.cpp index 422118245f9..06f90656450 100644 --- a/SU2_CFD/src/variables/CFlowVariable.cpp +++ b/SU2_CFD/src/variables/CFlowVariable.cpp @@ -39,7 +39,7 @@ CFlowVariable::CFlowVariable(unsigned long npoint, unsigned long ndim, unsigned Res_TruncError.resize(nPoint, nVar) = su2double(0.0); for (unsigned long iMesh = 0; iMesh <= config->GetnMGLevels(); iMesh++) { - if (config->GetMG_CorrecSmooth(iMesh) > 0) { + if (config->GetMGOptions().MG_CorrecSmooth[iMesh] > 0) { Residual_Sum.resize(nPoint, nVar); Residual_Old.resize(nPoint, nVar); break; diff --git a/SU2_CFD/src/variables/CHeatVariable.cpp b/SU2_CFD/src/variables/CHeatVariable.cpp index cc41d69b25b..ae2b294d38a 100644 --- a/SU2_CFD/src/variables/CHeatVariable.cpp +++ b/SU2_CFD/src/variables/CHeatVariable.cpp @@ -45,7 +45,7 @@ CHeatVariable::CHeatVariable(su2double heat, unsigned long npoint, unsigned long /*--- Only for residual smoothing (multigrid) ---*/ for (unsigned long iMesh = 0; iMesh <= config->GetnMGLevels(); iMesh++) { - if (config->GetMG_CorrecSmooth(iMesh) > 0) { + if (config->GetMGOptions().MG_CorrecSmooth[iMesh] > 0) { Residual_Sum.resize(nPoint, nVar); Residual_Old.resize(nPoint, nVar); break; diff --git a/TestCases/cont_adj_euler/naca0012/inv_NACA0012.cfg b/TestCases/cont_adj_euler/naca0012/inv_NACA0012.cfg index a4aa2b72898..bc5ee7bb83c 100644 --- a/TestCases/cont_adj_euler/naca0012/inv_NACA0012.cfg +++ b/TestCases/cont_adj_euler/naca0012/inv_NACA0012.cfg @@ -53,19 +53,19 @@ ITER= 150 % LINEAR_SOLVER= FGMRES LINEAR_SOLVER_PREC= LU_SGS -LINEAR_SOLVER_ERROR= 1E-6 -LINEAR_SOLVER_ITER= 5 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 LINEAR_SOLVER_ILU_FILL_IN= 0 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % MGLEVEL= 2 MGCYCLE= W_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 2, 2 ) -MG_POST_SMOOTH= ( 1, 1, 1, 1 ) +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) -MG_DAMP_RESTRICTION= 1.0 -MG_DAMP_PROLONGATION= 1.0 +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/cont_adj_euler/naca0012/of_grad_cd_disc.dat.ref b/TestCases/cont_adj_euler/naca0012/of_grad_cd_disc.dat.ref index 9a1f6b7d1e7..f7e509e5e3c 100644 --- a/TestCases/cont_adj_euler/naca0012/of_grad_cd_disc.dat.ref +++ b/TestCases/cont_adj_euler/naca0012/of_grad_cd_disc.dat.ref @@ -1,39 +1,39 @@ VARIABLES="VARIABLE" , "GRADIENT" , "FINDIFF_STEP" - 0 , 17852.4 , 0.001 - 1 , 17762.2 , 0.001 - 2 , 13023.3 , 0.001 - 3 , 7235.23 , 0.001 - 4 , 2025.24 , 0.001 - 5 , -2173.83 , 0.001 - 6 , -5516.67 , 0.001 - 7 , -8317.99 , 0.001 - 8 , -10814.3 , 0.001 - 9 , -13092.8 , 0.001 - 10 , -15126.6 , 0.001 - 11 , -16823.4 , 0.001 - 12 , -17994.0 , 0.001 - 13 , -18196.9 , 0.001 - 14 , -16453.7 , 0.001 - 15 , -10589.4 , 0.001 - 16 , 4413.36 , 0.001 - 17 , 30522.9 , 0.001 - 18 , 5834.86 , 0.001 - 19 , -18131.9 , 0.001 - 20 , -21995.1 , 0.001 - 21 , -20862.7 , 0.001 - 22 , -18622.4 , 0.001 - 23 , -18164.8 , 0.001 - 24 , -20842.9 , 0.001 - 25 , -26432.9 , 0.001 - 26 , -33388.6 , 0.001 - 27 , -39214.0 , 0.001 - 28 , -40910.6 , 0.001 - 29 , -35624.7 , 0.001 - 30 , -21761.1 , 0.001 - 31 , -718.652 , 0.001 - 32 , 21422.9 , 0.001 - 33 , 34942.8 , 0.001 - 34 , 34300.9 , 0.001 - 35 , 28342.4 , 0.001 - 36 , 23237.9 , 0.001 - 37 , -20230.5 , 0.001 + 0 , -7747.74 , 0.001 + 1 , -10948.1 , 0.001 + 2 , -8280.46 , 0.001 + 3 , -3802.21 , 0.001 + 4 , 658.085 , 0.001 + 5 , 4392.72 , 0.001 + 6 , 7268.92 , 0.001 + 7 , 9422.0 , 0.001 + 8 , 11077.6 , 0.001 + 9 , 12447.2 , 0.001 + 10 , 13660.8 , 0.001 + 11 , 14713.0 , 0.001 + 12 , 15397.1 , 0.001 + 13 , 15179.4 , 0.001 + 14 , 12887.9 , 0.001 + 15 , 5922.05 , 0.001 + 16 , -11571.8 , 0.001 + 17 , -51702.7 , 0.001 + 18 , -126889.0 , 0.001 + 19 , -21493.4 , 0.001 + 20 , -22571.2 , 0.001 + 21 , -16492.2 , 0.001 + 22 , -10533.8 , 0.001 + 23 , -6901.19 , 0.001 + 24 , -5763.06 , 0.001 + 25 , -6449.91 , 0.001 + 26 , -8061.2 , 0.001 + 27 , -9790.18 , 0.001 + 28 , -11077.2 , 0.001 + 29 , -11650.8 , 0.001 + 30 , -11500.7 , 0.001 + 31 , -10793.0 , 0.001 + 32 , -9652.1 , 0.001 + 33 , -7555.2 , 0.001 + 34 , -2031.11 , 0.001 + 35 , 12735.8 , 0.001 + 36 , 43905.7 , 0.001 + 37 , 85428.3 , 0.001 diff --git a/TestCases/cont_adj_euler/naca0012/of_grad_directdiff.dat.ref b/TestCases/cont_adj_euler/naca0012/of_grad_directdiff.dat.ref index 366ba74b704..0218e98d316 100644 --- a/TestCases/cont_adj_euler/naca0012/of_grad_directdiff.dat.ref +++ b/TestCases/cont_adj_euler/naca0012/of_grad_directdiff.dat.ref @@ -1,4 +1,4 @@ VARIABLES="VARIABLE" , "DRAG" , "EFFICIENCY" , "FORCE_X" , "FORCE_Y" , "FORCE_Z" , "LIFT" , "MOMENT_X" , "MOMENT_Y" , "MOMENT_Z" , "SIDEFORCE" - 0 , 0.1875371398 , -46.4529905 , 0.2229292755 , -1.619952826 , 0.0 , -1.624430497 , 0.0 , 0.0 , 0.9817393925 , 0.0 - 1 , 0.2883063943 , -65.16223458 , 0.3360834125 , -2.186444684 , 0.0 , -2.193255991 , 0.0 , 0.0 , 0.9308579056 , 0.0 - 2 , 0.4016718294 , -81.51255705 , 0.4583979297 , -2.595338639 , 0.0 , -2.604720916 , 0.0 , 0.0 , 0.6566891255 , 0.0 + 0 , 0.05240962543 , -27.33945591 , 0.08647516198 , -1.560629715 , 0.0 , -1.562144773 , 0.0 , 0.0 , 0.8858124377 , 0.0 + 1 , 0.2008795877 , -41.40890891 , 0.2463424389 , -2.081341632 , 0.0 , -2.086220261 , 0.0 , 0.0 , 0.737429107 , 0.0 + 2 , 0.371975273 , -55.04424867 , 0.4271103196 , -2.522745633 , 0.0 , -2.531462651 , 0.0 , 0.0 , 0.4069664819 , 0.0 diff --git a/TestCases/cont_adj_euler/wedge/inv_wedge_ROE.cfg b/TestCases/cont_adj_euler/wedge/inv_wedge_ROE.cfg index 22ef8c5a87c..08ab48f4f13 100644 --- a/TestCases/cont_adj_euler/wedge/inv_wedge_ROE.cfg +++ b/TestCases/cont_adj_euler/wedge/inv_wedge_ROE.cfg @@ -49,18 +49,18 @@ CFL_ADAPT_PARAM= ( 1.5, 0.5, 1.0, 100.0 ) RK_ALPHA_COEFF= ( 0.66667, 0.66667, 1.000000 ) ITER=100 LINEAR_SOLVER= BCGSTAB -LINEAR_SOLVER_ERROR= 1E-6 -LINEAR_SOLVER_ITER= 5 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % -MGLEVEL= 2 +MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 0.8 -MG_DAMP_PROLONGATION= 0.8 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/cont_adj_euler/wedge/inv_wedge_ROE_multiobj.cfg b/TestCases/cont_adj_euler/wedge/inv_wedge_ROE_multiobj.cfg index 2e862e21b08..c204b340550 100644 --- a/TestCases/cont_adj_euler/wedge/inv_wedge_ROE_multiobj.cfg +++ b/TestCases/cont_adj_euler/wedge/inv_wedge_ROE_multiobj.cfg @@ -51,20 +51,20 @@ CFL_ADAPT_PARAM= ( 1.5, 0.5, 1.0, 100.0 ) RK_ALPHA_COEFF= ( 0.66667, 0.66667, 1.000000 ) ITER=1000 LINEAR_SOLVER= BCGSTAB -LINEAR_SOLVER_ERROR= 1E-6 -LINEAR_SOLVER_ITER= 5 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 LINEAR_SOLVER_PREC= ILU LINEAR_SOLVER_ILU_FILL_IN= 0 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % -MGLEVEL= 2 +MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 0.8 -MG_DAMP_PROLONGATION= 0.8 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/cont_adj_euler/wedge/of_grad_combo.dat.ref b/TestCases/cont_adj_euler/wedge/of_grad_combo.dat.ref index c861e4fbd81..88d7794ce03 100644 --- a/TestCases/cont_adj_euler/wedge/of_grad_combo.dat.ref +++ b/TestCases/cont_adj_euler/wedge/of_grad_combo.dat.ref @@ -1,5 +1,5 @@ VARIABLES="VARIABLE" , "GRADIENT" , "FINDIFF_STEP" - 0 , 0.00763648 , 0.0001 - 1 , 0.00504898 , 0.0001 - 2 , 0.00249639 , 0.0001 - 3 , 0.000890798 , 0.0001 + 0 , 0.00701137 , 0.0001 + 1 , 0.00485473 , 0.0001 + 2 , 0.00244467 , 0.0001 + 3 , 0.000872557 , 0.0001 diff --git a/TestCases/cont_adj_navierstokes/cylinder/lam_cylinder.cfg b/TestCases/cont_adj_navierstokes/cylinder/lam_cylinder.cfg index d3713299855..e247fa9f375 100644 --- a/TestCases/cont_adj_navierstokes/cylinder/lam_cylinder.cfg +++ b/TestCases/cont_adj_navierstokes/cylinder/lam_cylinder.cfg @@ -44,27 +44,27 @@ MARKER_MONITORING= ( cylinder ) % NUM_METHOD_GRAD= WEIGHTED_LEAST_SQUARES OBJECTIVE_FUNCTION= DRAG -CFL_NUMBER= 5.0 +CFL_NUMBER= 10.0 CFL_ADAPT= NO CFL_ADAPT_PARAM= ( 1.5, 0.5, 1.0, 100.0 ) RK_ALPHA_COEFF= ( 0.66667, 0.66667, 1.000000 ) -ITER= 150 +ITER= 1000 % ------------------------ LINEAR SOLVER DEFINITION ---------------------------% % LINEAR_SOLVER= BCGSTAB -LINEAR_SOLVER_ERROR= 1E-8 -LINEAR_SOLVER_ITER= 2 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % -MGLEVEL= 1 +MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 0.8 -MG_DAMP_PROLONGATION= 0.8 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/cont_adj_rans/oneram6/turb_ONERAM6.cfg b/TestCases/cont_adj_rans/oneram6/turb_ONERAM6.cfg index b651703583a..16c80e3534d 100644 --- a/TestCases/cont_adj_rans/oneram6/turb_ONERAM6.cfg +++ b/TestCases/cont_adj_rans/oneram6/turb_ONERAM6.cfg @@ -54,18 +54,18 @@ EXT_ITER= 10 % LINEAR_SOLVER= FGMRES LINEAR_SOLVER_PREC= LU_SGS -LINEAR_SOLVER_ERROR= 1E-5 -LINEAR_SOLVER_ITER= 10 +LINEAR_SOLVER_ERROR= 1E-3 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % -MGLEVEL= 2 +MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 0.7 -MG_DAMP_PROLONGATION= 0.7 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/cont_adj_rans/rae2822/turb_SA_RAE2822.cfg b/TestCases/cont_adj_rans/rae2822/turb_SA_RAE2822.cfg index 6a9d3c21d92..e5a16f081b6 100644 --- a/TestCases/cont_adj_rans/rae2822/turb_SA_RAE2822.cfg +++ b/TestCases/cont_adj_rans/rae2822/turb_SA_RAE2822.cfg @@ -48,18 +48,18 @@ CFL_ADAPT= NO CFL_ADAPT_PARAM= ( 1.5, 0.5, 1.0, 100.0 ) ITER= 150 LINEAR_SOLVER= BCGSTAB -LINEAR_SOLVER_ERROR= 1E-6 -LINEAR_SOLVER_ITER= 2 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 0.95 -MG_DAMP_PROLONGATION= 0.95 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/disc_adj_euler/arina2k/Arina2KRS.cfg b/TestCases/disc_adj_euler/arina2k/Arina2KRS.cfg index be55f7956df..8c4a46b2682 100644 --- a/TestCases/disc_adj_euler/arina2k/Arina2KRS.cfg +++ b/TestCases/disc_adj_euler/arina2k/Arina2KRS.cfg @@ -102,18 +102,18 @@ JST_SENSOR_COEFF= ( 0.5, 0.02 ) LINEAR_SOLVER= FGMRES LINEAR_SOLVER_PREC= LU_SGS LINEAR_SOLVER_ILU_FILL_IN= 0 -LINEAR_SOLVER_ERROR= 1E-4 -LINEAR_SOLVER_ITER= 20 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % -MGLEVEL= 2 +MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 0.75 -MG_DAMP_PROLONGATION= 0.75 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/disc_adj_euler/naca0012_pitching/inv_NACA0012_pitching.cfg b/TestCases/disc_adj_euler/naca0012_pitching/inv_NACA0012_pitching.cfg index df699f72301..84bd700d982 100644 --- a/TestCases/disc_adj_euler/naca0012_pitching/inv_NACA0012_pitching.cfg +++ b/TestCases/disc_adj_euler/naca0012_pitching/inv_NACA0012_pitching.cfg @@ -67,18 +67,18 @@ RK_ALPHA_COEFF= ( 0.66667, 0.66667, 1.000000 ) % LINEAR_SOLVER= FGMRES LINEAR_SOLVER_PREC= ILU -LINEAR_SOLVER_ERROR= 1E-4 -LINEAR_SOLVER_ITER= 2 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % -MGLEVEL= 2 +MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 1.0 -MG_DAMP_PROLONGATION= 1.0 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % --------------------- FLOW NUMERICAL METHOD DEFINITION ----------------------% % diff --git a/TestCases/disc_adj_euler/naca0012_pitching_def/inv_NACA0012_pitching_deform.cfg b/TestCases/disc_adj_euler/naca0012_pitching_def/inv_NACA0012_pitching_deform.cfg index 02e9e6fd019..3df91b6f367 100644 --- a/TestCases/disc_adj_euler/naca0012_pitching_def/inv_NACA0012_pitching_deform.cfg +++ b/TestCases/disc_adj_euler/naca0012_pitching_def/inv_NACA0012_pitching_deform.cfg @@ -51,17 +51,17 @@ RK_ALPHA_COEFF= ( 0.66667, 0.66667, 1.000000 ) % ------------------------ LINEAR SOLVER DEFINITION ---------------------------% LINEAR_SOLVER= FGMRES LINEAR_SOLVER_PREC= ILU -LINEAR_SOLVER_ERROR= 1E-4 -LINEAR_SOLVER_ITER= 2 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% -MGLEVEL= 2 +MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 1.0 -MG_DAMP_PROLONGATION= 1.0 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % --------------------- FLOW NUMERICAL METHOD DEFINITION ----------------------% CONV_NUM_METHOD_FLOW= JST @@ -71,7 +71,7 @@ TIME_DISCRE_FLOW= EULER_IMPLICIT % ---------------- ADJOINT-FLOW NUMERICAL METHOD DEFINITION -------------------% OBJECTIVE_FUNCTION= EFFICIENCY -OPT_OBJECTIVE= EFFICIENCY * 1.0 +OPT_OBJECTIVE= EFFICIENCY * 1.0 CONV_NUM_METHOD_ADJFLOW= JST SLOPE_LIMITER_ADJFLOW= VENKATAKRISHNAN ADJ_JST_SENSOR_COEFF= ( 0.0, 0.02 ) @@ -89,7 +89,7 @@ FFD_CONTINUITY= 2ND_DERIVATIVE % ----------------------- DESIGN VARIABLE PARAMETERS --------------------------% DV_KIND= FFD_CONTROL_POINT, FFD_CONTROL_POINT, FFD_CONTROL_POINT, FFD_CONTROL_POINT, FFD_CONTROL_POINT, FFD_CONTROL_POINT, FFD_CONTROL_POINT, FFD_CONTROL_POINT, FFD_CONTROL_POINT, FFD_CONTROL_POINT, FFD_CONTROL_POINT, FFD_CONTROL_POINT, FFD_CONTROL_POINT, FFD_CONTROL_POINT, FFD_CONTROL_POINT, FFD_CONTROL_POINT, FFD_CONTROL_POINT, FFD_CONTROL_POINT, FFD_CONTROL_POINT, FFD_CONTROL_POINT, FFD_CONTROL_POINT, FFD_CONTROL_POINT DV_MARKER= ( airfoil ) -DV_PARAM= ( airfoil_box, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 2.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 3.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 4.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 5.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 6.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 7.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 8.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 9.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 10.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 2.0, 1.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 3.0, 1.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 4.0, 1.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 5.0, 1.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 6.0, 1.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 7.0, 1.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 8.0, 1.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 9.0, 1.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 10.0, 1.0, 0.0, 0.0, 1.0, 0.0) +DV_PARAM= ( airfoil_box, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 2.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 3.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 4.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 5.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 6.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 7.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 8.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 9.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 10.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 2.0, 1.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 3.0, 1.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 4.0, 1.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 5.0, 1.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 6.0, 1.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 7.0, 1.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 8.0, 1.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 9.0, 1.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 10.0, 1.0, 0.0, 0.0, 1.0, 0.0) DV_VALUE= 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001 % ------------------------ GRID DEFORMATION PARAMETERS ------------------------% diff --git a/TestCases/disc_adj_euler/naca0012_pitching_def/inv_NACA0012_pitching_deform_ad.cfg b/TestCases/disc_adj_euler/naca0012_pitching_def/inv_NACA0012_pitching_deform_ad.cfg index 775a824e134..2a377323c52 100644 --- a/TestCases/disc_adj_euler/naca0012_pitching_def/inv_NACA0012_pitching_deform_ad.cfg +++ b/TestCases/disc_adj_euler/naca0012_pitching_def/inv_NACA0012_pitching_deform_ad.cfg @@ -51,17 +51,17 @@ RK_ALPHA_COEFF= ( 0.66667, 0.66667, 1.000000 ) % ------------------------ LINEAR SOLVER DEFINITION ---------------------------% LINEAR_SOLVER= FGMRES LINEAR_SOLVER_PREC= ILU -LINEAR_SOLVER_ERROR= 1E-4 -LINEAR_SOLVER_ITER= 2 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% -MGLEVEL= 2 +MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 1.0 -MG_DAMP_PROLONGATION= 1.0 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % --------------------- FLOW NUMERICAL METHOD DEFINITION ----------------------% CONV_NUM_METHOD_FLOW= JST @@ -71,7 +71,7 @@ TIME_DISCRE_FLOW= EULER_IMPLICIT % ---------------- ADJOINT-FLOW NUMERICAL METHOD DEFINITION -------------------% OBJECTIVE_FUNCTION= EFFICIENCY -OPT_OBJECTIVE= EFFICIENCY * 1.0 +OPT_OBJECTIVE= EFFICIENCY * 1.0 CONV_NUM_METHOD_ADJFLOW= JST SLOPE_LIMITER_ADJFLOW= VENKATAKRISHNAN ADJ_JST_SENSOR_COEFF= ( 0.0, 0.02 ) @@ -89,7 +89,7 @@ FFD_CONTINUITY= 2ND_DERIVATIVE % ----------------------- DESIGN VARIABLE PARAMETERS --------------------------% DV_KIND= FFD_CONTROL_POINT, FFD_CONTROL_POINT, FFD_CONTROL_POINT, FFD_CONTROL_POINT, FFD_CONTROL_POINT, FFD_CONTROL_POINT, FFD_CONTROL_POINT, FFD_CONTROL_POINT, FFD_CONTROL_POINT, FFD_CONTROL_POINT, FFD_CONTROL_POINT, FFD_CONTROL_POINT, FFD_CONTROL_POINT, FFD_CONTROL_POINT, FFD_CONTROL_POINT, FFD_CONTROL_POINT, FFD_CONTROL_POINT, FFD_CONTROL_POINT, FFD_CONTROL_POINT, FFD_CONTROL_POINT, FFD_CONTROL_POINT, FFD_CONTROL_POINT DV_MARKER= ( airfoil ) -DV_PARAM= ( airfoil_box, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 2.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 3.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 4.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 5.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 6.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 7.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 8.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 9.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 10.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 2.0, 1.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 3.0, 1.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 4.0, 1.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 5.0, 1.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 6.0, 1.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 7.0, 1.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 8.0, 1.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 9.0, 1.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 10.0, 1.0, 0.0, 0.0, 1.0, 0.0) +DV_PARAM= ( airfoil_box, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 2.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 3.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 4.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 5.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 6.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 7.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 8.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 9.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 10.0, 0.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 2.0, 1.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 3.0, 1.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 4.0, 1.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 5.0, 1.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 6.0, 1.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 7.0, 1.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 8.0, 1.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 9.0, 1.0, 0.0, 0.0, 1.0, 0.0) ; ( airfoil_box, 10.0, 1.0, 0.0, 0.0, 1.0, 0.0) DV_VALUE= 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001 % ------------------------ GRID DEFORMATION PARAMETERS ------------------------% diff --git a/TestCases/disc_adj_turbomachinery/transonic_stator_2D/transonic_stator.cfg b/TestCases/disc_adj_turbomachinery/transonic_stator_2D/transonic_stator.cfg index ed7563e8543..2278d0ca393 100644 --- a/TestCases/disc_adj_turbomachinery/transonic_stator_2D/transonic_stator.cfg +++ b/TestCases/disc_adj_turbomachinery/transonic_stator_2D/transonic_stator.cfg @@ -92,7 +92,7 @@ MARKER_ANALYZE= (outflow, inflow) % ------------- COMMON PARAMETERS DEFINING THE NUMERICAL METHOD ---------------% % NUM_METHOD_GRAD= WEIGHTED_LEAST_SQUARES -CFL_NUMBER= 40.0 +CFL_NUMBER= 50.0 CFL_ADAPT= NO CFL_ADAPT_PARAM= ( 1.3, 1.2, 1.0, 10.0) @@ -100,13 +100,18 @@ CFL_ADAPT_PARAM= ( 1.3, 1.2, 1.0, 10.0) % LINEAR_SOLVER= FGMRES LINEAR_SOLVER_PREC= LU_SGS -LINEAR_SOLVER_ERROR= 1E-4 -LINEAR_SOLVER_ITER= 5 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % -% ----------- NOT WORKING WITH PERIODIC BOUNDARY CONDITIONS !!!!! -------------% -% +MGLEVEL= 1 +MGCYCLE= V_CYCLE +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % ----------------------- SLOPE LIMITER DEFINITION ----------------------------% % @@ -116,7 +121,7 @@ LIMITER_ITER= 999999 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % CONV_NUM_METHOD_FLOW= ROE -MUSCL_FLOW= YES +MUSCL_FLOW= NO SLOPE_LIMITER_FLOW= VENKATAKRISHNAN ENTROPY_FIX_COEFF= 0.03 JST_SENSOR_COEFF= ( 0.5, 0.02 ) diff --git a/TestCases/euler/CRM/inv_CRM_JST.cfg b/TestCases/euler/CRM/inv_CRM_JST.cfg index 60083baeb8a..3245925c773 100644 --- a/TestCases/euler/CRM/inv_CRM_JST.cfg +++ b/TestCases/euler/CRM/inv_CRM_JST.cfg @@ -49,18 +49,18 @@ CFL_ADAPT_PARAM= ( 1.5, 0.5, 1.0, 100.0 ) RK_ALPHA_COEFF= ( 0.66667, 0.66667, 1.000000 ) EXT_ITER= 99999 LINEAR_SOLVER= FGMRES -LINEAR_SOLVER_ERROR= 1E-6 -LINEAR_SOLVER_ITER= 5 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % -MGLEVEL= 2 +MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 0.9 -MG_DAMP_PROLONGATION= 0.9 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/euler/biparabolic/BIPARABOLIC.cfg b/TestCases/euler/biparabolic/BIPARABOLIC.cfg index 8bd845b430e..e3e381dccd0 100644 --- a/TestCases/euler/biparabolic/BIPARABOLIC.cfg +++ b/TestCases/euler/biparabolic/BIPARABOLIC.cfg @@ -56,11 +56,11 @@ EXT_ITER= 99999999 % MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 0.95 -MG_DAMP_PROLONGATION= 0.95 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/euler/channel/inv_channel.cfg b/TestCases/euler/channel/inv_channel.cfg index cfac9e17d95..a73818a9d89 100644 --- a/TestCases/euler/channel/inv_channel.cfg +++ b/TestCases/euler/channel/inv_channel.cfg @@ -57,18 +57,18 @@ EXT_ITER= 999999 % LINEAR_SOLVER= FGMRES LINEAR_SOLVER_PREC= LU_SGS -LINEAR_SOLVER_ERROR= 1E-4 -LINEAR_SOLVER_ITER= 10 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 0.9 -MG_DAMP_PROLONGATION= 0.9 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/euler/naca0012/inv_NACA0012_Roe.cfg b/TestCases/euler/naca0012/inv_NACA0012_Roe.cfg index 63932da5629..3639613c54e 100644 --- a/TestCases/euler/naca0012/inv_NACA0012_Roe.cfg +++ b/TestCases/euler/naca0012/inv_NACA0012_Roe.cfg @@ -41,14 +41,14 @@ MARKER_MONITORING= ( airfoil ) % ------------- COMMON PARAMETERS TO DEFINE THE NUMERICAL METHOD --------------% % NUM_METHOD_GRAD= WEIGHTED_LEAST_SQUARES -CFL_NUMBER= 20.0 +CFL_NUMBER= 30.0 CFL_ADAPT= NO CFL_ADAPT_PARAM= ( 1.5, 0.5, 1.0, 100.0 ) RK_ALPHA_COEFF= ( 0.66667, 0.66667, 1.000000 ) ITER= 1000 LINEAR_SOLVER= BCGSTAB -LINEAR_SOLVER_ERROR= 1E-6 -LINEAR_SOLVER_ITER= 5 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % diff --git a/TestCases/euler/wedge/inv_wedge_HLLC.cfg b/TestCases/euler/wedge/inv_wedge_HLLC.cfg index 5c86e82487b..4af702aab8d 100644 --- a/TestCases/euler/wedge/inv_wedge_HLLC.cfg +++ b/TestCases/euler/wedge/inv_wedge_HLLC.cfg @@ -42,24 +42,24 @@ MARKER_MONITORING= ( upper, lower ) % ------------- COMMON PARAMETERS DEFINING THE NUMERICAL METHOD ---------------% % NUM_METHOD_GRAD= WEIGHTED_LEAST_SQUARES -CFL_NUMBER= 4.0 +CFL_NUMBER= 100.0 CFL_ADAPT= NO CFL_ADAPT_PARAM= ( 1.5, 0.5, 1.0, 100.0 ) RK_ALPHA_COEFF= ( 0.66667, 0.66667, 1.000000 ) ITER= 11000 LINEAR_SOLVER= BCGSTAB -LINEAR_SOLVER_ERROR= 1E-6 -LINEAR_SOLVER_ITER= 5 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % -MGLEVEL= 2 +MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 0.8 -MG_DAMP_PROLONGATION= 0.8 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/fea_fsi/Airfoil_RBF/configFlow.cfg b/TestCases/fea_fsi/Airfoil_RBF/configFlow.cfg index 3011b3a22ad..79481394470 100644 --- a/TestCases/fea_fsi/Airfoil_RBF/configFlow.cfg +++ b/TestCases/fea_fsi/Airfoil_RBF/configFlow.cfg @@ -77,13 +77,13 @@ NUM_METHOD_GRAD= GREEN_GAUSS CFL_NUMBER= 10.0 % % Multigrid ------------------------------------------------------------ % -MGLEVEL= 1 +MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 0.75 -MG_DAMP_PROLONGATION= 0.75 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % % Grid deformation ----------------------------------------------------- % DEFORM_MESH= YES diff --git a/TestCases/fixed_cl/naca0012/inv_NACA0012.cfg b/TestCases/fixed_cl/naca0012/inv_NACA0012.cfg index d089c8622c8..d797f2e5d5f 100644 --- a/TestCases/fixed_cl/naca0012/inv_NACA0012.cfg +++ b/TestCases/fixed_cl/naca0012/inv_NACA0012.cfg @@ -62,18 +62,18 @@ ITER= 1000 % LINEAR_SOLVER= FGMRES LINEAR_SOLVER_PREC= LU_SGS -LINEAR_SOLVER_ERROR= 1E-6 -LINEAR_SOLVER_ITER= 2 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 1.0 -MG_DAMP_PROLONGATION= 1.0 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/fixed_cl/naca0012/inv_NACA0012_ContAdj.cfg b/TestCases/fixed_cl/naca0012/inv_NACA0012_ContAdj.cfg index e803c70bf49..c7db611e3d6 100644 --- a/TestCases/fixed_cl/naca0012/inv_NACA0012_ContAdj.cfg +++ b/TestCases/fixed_cl/naca0012/inv_NACA0012_ContAdj.cfg @@ -63,18 +63,18 @@ ITER= 500 % LINEAR_SOLVER= FGMRES LINEAR_SOLVER_PREC= LU_SGS -LINEAR_SOLVER_ERROR= 1E-6 -LINEAR_SOLVER_ITER= 2 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 1.0 -MG_DAMP_PROLONGATION= 1.0 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/gust/inv_gust_NACA0012.cfg b/TestCases/gust/inv_gust_NACA0012.cfg index 1d73d400535..e4b596afbdb 100644 --- a/TestCases/gust/inv_gust_NACA0012.cfg +++ b/TestCases/gust/inv_gust_NACA0012.cfg @@ -72,7 +72,7 @@ MARKER_MONITORING = ( airfoil ) % ------------- COMMON PARAMETERS DEFINING THE NUMERICAL METHOD ---------------% % NUM_METHOD_GRAD= GREEN_GAUSS -CFL_NUMBER= 10.0 +CFL_NUMBER= 100.0 % ----------------------- SLOPE LIMITER DEFINITION ----------------------------% % @@ -86,16 +86,16 @@ SENS_REMOVE_SHARP= NO % LINEAR_SOLVER= FGMRES LINEAR_SOLVER_PREC= LU_SGS -LINEAR_SOLVER_ERROR= 1E-4 -LINEAR_SOLVER_ITER= 2 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % MGLEVEL= 3 MGCYCLE= W_CYCLE MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) +MG_POST_SMOOTH= ( 1, 1, 1, 1 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) MG_DAMP_RESTRICTION= 0.75 MG_DAMP_PROLONGATION= 0.75 diff --git a/TestCases/hybrid_regression.py b/TestCases/hybrid_regression.py index 378cf419ff4..b8e39bc9fba 100644 --- a/TestCases/hybrid_regression.py +++ b/TestCases/hybrid_regression.py @@ -51,7 +51,7 @@ def main(): channel.cfg_dir = "euler/channel" channel.cfg_file = "inv_channel_RK.cfg" channel.test_iter = 20 - channel.test_vals = [-2.356739, 3.185311, 0.135404, 0.143482] + channel.test_vals = [-2.318252, 3.226111, 0.133426, 0.150359] test_list.append(channel) # NACA0012 @@ -59,7 +59,7 @@ def main(): naca0012.cfg_dir = "euler/naca0012" naca0012.cfg_file = "inv_NACA0012_Roe.cfg" naca0012.test_iter = 20 - naca0012.test_vals = [-4.968156, -4.396643, 0.331958, 0.023010] + naca0012.test_vals = [-4.252415, -3.789971, 0.306821, 0.024573] test_list.append(naca0012) # Supersonic wedge @@ -67,7 +67,7 @@ def main(): wedge.cfg_dir = "euler/wedge" wedge.cfg_file = "inv_wedge_HLLC.cfg" wedge.test_iter = 20 - wedge.test_vals = [-1.301825, 4.369535, -0.236575, 0.041741] + wedge.test_vals = [-3.587150, 2.136260, -0.249533, 0.043953] test_list.append(wedge) # ONERA M6 Wing @@ -83,7 +83,7 @@ def main(): fixedCL_naca0012.cfg_dir = "fixed_cl/naca0012" fixedCL_naca0012.cfg_file = "inv_NACA0012.cfg" fixedCL_naca0012.test_iter = 10 - fixedCL_naca0012.test_vals = [-3.786753, 1.752735, 0.301271, 0.019497] + fixedCL_naca0012.test_vals = [-3.936884, 1.574653, 0.300864, 0.019462] test_list.append(fixedCL_naca0012) # HYPERSONIC FLOW PAST BLUNT BODY @@ -103,7 +103,7 @@ def main(): flatplate.cfg_dir = "navierstokes/flatplate" flatplate.cfg_file = "lam_flatplate.cfg" flatplate.test_iter = 100 - flatplate.test_vals = [-7.466885, -1.982938, 0.001084, 0.036236, 2.361500, -2.325300, 0.000000, 0.000000] + flatplate.test_vals = [-6.382489, -0.905413, 0.001313, 0.025294, 2.361500, -2.336200, 0.000000, 0.000000] test_list.append(flatplate) # Laminar cylinder (steady) @@ -111,7 +111,7 @@ def main(): cylinder.cfg_dir = "navierstokes/cylinder" cylinder.cfg_file = "lam_cylinder.cfg" cylinder.test_iter = 25 - cylinder.test_vals = [-8.433648, -2.945868, -0.009392, 1.603197, 0.000000] + cylinder.test_vals = [-8.460419, -2.972300, 0.271000, 1.701198, 0.000000] test_list.append(cylinder) # Laminar cylinder (low Mach correction) @@ -119,7 +119,7 @@ def main(): cylinder_lowmach.cfg_dir = "navierstokes/cylinder" cylinder_lowmach.cfg_file = "cylinder_lowmach.cfg" cylinder_lowmach.test_iter = 25 - cylinder_lowmach.test_vals = [-6.412671, -0.950845, 0.039507, -134.197077, 0.000000] + cylinder_lowmach.test_vals = [-6.629113, -1.167336, -0.016421, -73.160843, 0.000000] cylinder_lowmach.test_vals_aarch64 = [-6.830996, -1.368850, -0.143956, 73.963354, 0] test_list.append(cylinder_lowmach) @@ -136,7 +136,7 @@ def main(): poiseuille_profile.cfg_dir = "navierstokes/poiseuille" poiseuille_profile.cfg_file = "profile_poiseuille.cfg" poiseuille_profile.test_iter = 10 - poiseuille_profile.test_vals = [-12.012575, -7.696236, -0.000000, 2.089953] + poiseuille_profile.test_vals = [-12.005215, -7.539613, -0.000000, 2.089953] poiseuille_profile.test_vals_aarch64 = [-12.009012, -7.262530, -0.000000, 2.089953] test_list.append(poiseuille_profile) @@ -157,7 +157,7 @@ def main(): rae2822_sa.cfg_dir = "rans/rae2822" rae2822_sa.cfg_file = "turb_SA_RAE2822.cfg" rae2822_sa.test_iter = 20 - rae2822_sa.test_vals = [-1.846052, -5.109587, 0.571411, 0.040773, 0.000000] + rae2822_sa.test_vals = [-2.169314, -5.450577, 0.293838, 0.104752, 0.000000] test_list.append(rae2822_sa) # RAE2822 SST @@ -165,7 +165,7 @@ def main(): rae2822_sst.cfg_dir = "rans/rae2822" rae2822_sst.cfg_file = "turb_SST_RAE2822.cfg" rae2822_sst.test_iter = 20 - rae2822_sst.test_vals = [-0.509927, 5.868873, 0.580652, 0.014294, 0.000000] + rae2822_sst.test_vals = [-1.028401, 5.875380, 0.279522, 0.093893, 0.000000] test_list.append(rae2822_sst) # RAE2822 SST_SUST @@ -173,7 +173,7 @@ def main(): rae2822_sst_sust.cfg_dir = "rans/rae2822" rae2822_sst_sust.cfg_file = "turb_SST_SUST_RAE2822.cfg" rae2822_sst_sust.test_iter = 20 - rae2822_sst_sust.test_vals = [-2.446013, 5.868873, 0.580652, 0.014294] + rae2822_sst_sust.test_vals = [-2.540329, 5.875369, 0.279522, 0.093893] test_list.append(rae2822_sst_sust) # Flat plate @@ -181,7 +181,7 @@ def main(): turb_flatplate.cfg_dir = "rans/flatplate" turb_flatplate.cfg_file = "turb_SA_flatplate.cfg" turb_flatplate.test_iter = 20 - turb_flatplate.test_vals = [-4.075879, -6.829935, -0.200296, 0.022692] + turb_flatplate.test_vals = [-4.938980, -7.469368, -0.187651, 0.015894] test_list.append(turb_flatplate) # ONERA M6 Wing @@ -266,7 +266,7 @@ def main(): turb_naca0012_sst_restart_mg.cfg_file = "turb_NACA0012_sst_multigrid_restart.cfg" turb_naca0012_sst_restart_mg.test_iter = 20 turb_naca0012_sst_restart_mg.ntest_vals = 5 - turb_naca0012_sst_restart_mg.test_vals = [-6.613316, -5.057159, 0.830274, -0.008869, 0.077835] + turb_naca0012_sst_restart_mg.test_vals = [-6.538814, -5.057150, 0.830240, -0.008813, 0.078177] test_list.append(turb_naca0012_sst_restart_mg) ############################# @@ -347,7 +347,7 @@ def main(): inc_euler_naca0012.cfg_dir = "incomp_euler/naca0012" inc_euler_naca0012.cfg_file = "incomp_NACA0012.cfg" inc_euler_naca0012.test_iter = 20 - inc_euler_naca0012.test_vals = [-7.118160, -6.555943, 0.531994, 0.008466] + inc_euler_naca0012.test_vals = [-5.737092, -4.868827, 0.512333, 0.009264] test_list.append(inc_euler_naca0012) # C-D nozzle with pressure inlet and mass flow outlet @@ -355,7 +355,7 @@ def main(): inc_nozzle.cfg_dir = "incomp_euler/nozzle" inc_nozzle.cfg_file = "inv_nozzle.cfg" inc_nozzle.test_iter = 20 - inc_nozzle.test_vals = [-4.177986, -3.716749, 0.151721, 0.152945] + inc_nozzle.test_vals = [-5.362338, -4.748247, -0.017498, 0.115865] test_list.append(inc_nozzle) ############################# @@ -367,7 +367,7 @@ def main(): inc_lam_cylinder.cfg_dir = "incomp_navierstokes/cylinder" inc_lam_cylinder.cfg_file = "incomp_cylinder.cfg" inc_lam_cylinder.test_iter = 10 - inc_lam_cylinder.test_vals = [-4.059218, -3.311865, 0.006311, 6.172389] + inc_lam_cylinder.test_vals = [-4.168263, -3.611146, 0.013547, 4.538946] test_list.append(inc_lam_cylinder) # Buoyancy-driven cavity @@ -432,7 +432,7 @@ def main(): cavity.cfg_dir = "moving_wall/cavity" cavity.cfg_file = "lam_cavity.cfg" cavity.test_iter = 25 - cavity.test_vals = [-5.515304, -0.049093, -0.114942, -7.135967] + cavity.test_vals = [-7.325788, -1.861524, 1.097830, 1.028368] test_list.append(cavity) # Spinning cylinder @@ -440,7 +440,7 @@ def main(): spinning_cylinder.cfg_dir = "moving_wall/spinning_cylinder" spinning_cylinder.cfg_file = "spinning_cylinder.cfg" spinning_cylinder.test_iter = 25 - spinning_cylinder.test_vals = [-7.756180, -2.301600, 1.422425, 1.431645] + spinning_cylinder.test_vals = [-7.881383, -2.419298, 1.535192, 1.450905] spinning_cylinder.test_vals_aarch64 = [-8.008023, -2.611064, 1.497308, 1.487483] test_list.append(spinning_cylinder) @@ -462,7 +462,7 @@ def main(): sine_gust.cfg_dir = "gust" sine_gust.cfg_file = "inv_gust_NACA0012.cfg" sine_gust.test_iter = 5 - sine_gust.test_vals = [-1.977498, 3.481817, -0.010140, -0.007833] + sine_gust.test_vals = [-1.977498, 3.481817, -0.009878, -0.005086] sine_gust.unsteady = True test_list.append(sine_gust) @@ -471,7 +471,7 @@ def main(): cosine_gust.cfg_dir = "gust" cosine_gust.cfg_file = "cosine_gust_zdir.cfg" cosine_gust.test_iter = 79 - cosine_gust.test_vals = [-2.418805, 0.001919, -0.001262, 0.000418, -0.000592] + cosine_gust.test_vals = [-2.418805, 0.001521, -0.001239, 0.000394, -0.000593] cosine_gust.unsteady = True cosine_gust.enabled_with_tsan = False test_list.append(cosine_gust) @@ -491,7 +491,7 @@ def main(): aeroelastic.cfg_dir = "aeroelastic" aeroelastic.cfg_file = "aeroelastic_NACA64A010.cfg" aeroelastic.test_iter = 2 - aeroelastic.test_vals = [0.075093, 0.027559, -0.001640, -0.000129] + aeroelastic.test_vals = [0.073776, 0.027464, -0.001638, -0.000129] aeroelastic.test_vals_aarch64 = [0.074170, 0.027590, -0.001579, -0.000160] aeroelastic.unsteady = True aeroelastic.enabled_on_cpu_arch = ["x86_64"] # Requires AVX-capable architecture @@ -521,7 +521,7 @@ def main(): unst_deforming_naca0012.cfg_dir = "disc_adj_euler/naca0012_pitching_def" unst_deforming_naca0012.cfg_file = "inv_NACA0012_pitching_deform.cfg" unst_deforming_naca0012.test_iter = 5 - unst_deforming_naca0012.test_vals = [-3.665129, -3.793418, -3.716491, -3.148323] + unst_deforming_naca0012.test_vals = [-3.665243, -3.794042, -3.716822, -3.148495] unst_deforming_naca0012.unsteady = True unst_deforming_naca0012.enabled_with_tsan = False test_list.append(unst_deforming_naca0012) @@ -535,16 +535,16 @@ def main(): edge_VW.cfg_dir = "nicf/edge" edge_VW.cfg_file = "edge_VW.cfg" edge_VW.test_iter = 40 - edge_VW.test_vals = [-2.013020, 4.187730, -0.000009, 0.000000] + edge_VW.test_vals = [-8.895442, -2.694280, -0.000009, 0.000000] test_list.append(edge_VW) # Rarefaction shock wave edge_PPR edge_PPR = TestCase('edge_PPR') edge_PPR.cfg_dir = "nicf/edge" edge_PPR.cfg_file = "edge_PPR.cfg" - edge_PPR.test_iter = 40 - edge_PPR.test_vals = [-7.126741, -0.965306, -0.000034, 0.000000] - edge_PPR.test_vals_aarch64 = [-7.139211, -0.980821, -0.000034, 0.000000] + edge_PPR.test_iter = 20 + edge_PPR.test_vals = [-10.590427, -4.427866, -0.000034, 0.000000] + edge_PPR.test_vals_aarch64 = [ -7.139211, -0.980821, -0.000034, 0.000000] test_list.append(edge_PPR) ###################################### @@ -656,7 +656,7 @@ def main(): bars_SST_2D.cfg_dir = "sliding_interface/bars_SST_2D" bars_SST_2D.cfg_file = "bars.cfg" bars_SST_2D.test_iter = 13 - bars_SST_2D.test_vals = [13.000000, -0.623154, -1.660901] + bars_SST_2D.test_vals = [13.000000, -0.473801, -1.563681] bars_SST_2D.multizone = True test_list.append(bars_SST_2D) diff --git a/TestCases/hybrid_regression_AD.py b/TestCases/hybrid_regression_AD.py index 7a6abd83c22..63fd98baf12 100644 --- a/TestCases/hybrid_regression_AD.py +++ b/TestCases/hybrid_regression_AD.py @@ -66,7 +66,7 @@ def main(): discadj_arina2k.cfg_dir = "disc_adj_euler/arina2k" discadj_arina2k.cfg_file = "Arina2KRS.cfg" discadj_arina2k.test_iter = 20 - discadj_arina2k.test_vals = [-3.229402, -3.466984, 0.043984, 0.000000] + discadj_arina2k.test_vals = [-2.928012, -3.351754, 0.073361, 0.000000] test_list.append(discadj_arina2k) #################################### @@ -99,7 +99,7 @@ def main(): discadj_incomp_NACA0012.cfg_dir = "disc_adj_incomp_euler/naca0012" discadj_incomp_NACA0012.cfg_file = "incomp_NACA0012_disc.cfg" discadj_incomp_NACA0012.test_iter = 20 - discadj_incomp_NACA0012.test_vals = [20.000000, -3.977753, -2.562520, 0.000000] + discadj_incomp_NACA0012.test_vals = [20.000000, -3.338267, -2.490046, 0.000000] test_list.append(discadj_incomp_NACA0012) ##################################### @@ -187,7 +187,7 @@ def main(): discadj_pitchingNACA0012.cfg_dir = "disc_adj_euler/naca0012_pitching" discadj_pitchingNACA0012.cfg_file = "inv_NACA0012_pitching.cfg" discadj_pitchingNACA0012.test_iter = 4 - discadj_pitchingNACA0012.test_vals = [-1.224189, -1.654687, -0.004097, -0.000003] + discadj_pitchingNACA0012.test_vals = [-1.124927, -1.586220, -0.006032, 0.000009] discadj_pitchingNACA0012.tol = 0.01 discadj_pitchingNACA0012.unsteady = True discadj_pitchingNACA0012.enabled_with_tsan = False diff --git a/TestCases/incomp_euler/naca0012/incomp_NACA0012.cfg b/TestCases/incomp_euler/naca0012/incomp_NACA0012.cfg index a8bf56c8d2b..0daddefc19a 100644 --- a/TestCases/incomp_euler/naca0012/incomp_NACA0012.cfg +++ b/TestCases/incomp_euler/naca0012/incomp_NACA0012.cfg @@ -49,15 +49,23 @@ CFL_ADAPT_PARAM= ( 1.5, 0.5, 1.0, 100.0 ) RK_ALPHA_COEFF= ( 0.66667, 0.66667, 1.000000 ) ITER= 9999 +% ------------------------ LINEAR SOLVER DEFINITION ---------------------------% +% +LINEAR_SOLVER= FGMRES +LINEAR_SOLVER_PREC= ILU +LINEAR_SOLVER_ILU_FILL_IN= 0 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 + % -------------------------- MULTIGRID PARAMETERS -----------------------------% % MGLEVEL= 3 MGCYCLE= W_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 1, 1, 1, 1 ) +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) -MG_DAMP_RESTRICTION= 0.9 -MG_DAMP_PROLONGATION= 0.9 +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/incomp_euler/nozzle/inv_nozzle.cfg b/TestCases/incomp_euler/nozzle/inv_nozzle.cfg index 1205675bb95..b4521656a3e 100644 --- a/TestCases/incomp_euler/nozzle/inv_nozzle.cfg +++ b/TestCases/incomp_euler/nozzle/inv_nozzle.cfg @@ -53,18 +53,18 @@ CFL_NUMBER= 500 LINEAR_SOLVER= FGMRES LINEAR_SOLVER_PREC= ILU LINEAR_SOLVER_ILU_FILL_IN= 0 -LINEAR_SOLVER_ERROR= 1E-15 -LINEAR_SOLVER_ITER= 5 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % MGLEVEL= 3 MGCYCLE= W_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 1, 1, 1, 0 ) -MG_CORRECTION_SMOOTH= ( 1, 1, 1, 0 ) -MG_DAMP_RESTRICTION= 0.95 -MG_DAMP_PROLONGATION= 0.95 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % ----------- SLOPE LIMITER AND DISSIPATION SENSOR DEFINITION -----------------% % diff --git a/TestCases/incomp_navierstokes/cylinder/incomp_cylinder.cfg b/TestCases/incomp_navierstokes/cylinder/incomp_cylinder.cfg index 8283abd2531..badb9cdd0fa 100644 --- a/TestCases/incomp_navierstokes/cylinder/incomp_cylinder.cfg +++ b/TestCases/incomp_navierstokes/cylinder/incomp_cylinder.cfg @@ -44,7 +44,7 @@ MARKER_MONITORING= ( cylinder ) % ------------- COMMON PARAMETERS DEFINING THE NUMERICAL METHOD ---------------% % NUM_METHOD_GRAD= GREEN_GAUSS -CFL_NUMBER= 10.0 +CFL_NUMBER= 100.0 CFL_ADAPT= NO CFL_ADAPT_PARAM= ( 1.5, 0.5, 1.0, 100.0 ) RK_ALPHA_COEFF= ( 0.66667, 0.66667, 1.000000 ) @@ -55,11 +55,11 @@ VENKAT_LIMITER_COEFF= 0.01 % MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 1, 1, 1, 1 ) +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) -MG_DAMP_RESTRICTION= 0.75 -MG_DAMP_PROLONGATION= 0.75 +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/incomp_navierstokes/sphere/sphere.cfg b/TestCases/incomp_navierstokes/sphere/sphere.cfg index e558dc3c3df..0c37afb1873 100644 --- a/TestCases/incomp_navierstokes/sphere/sphere.cfg +++ b/TestCases/incomp_navierstokes/sphere/sphere.cfg @@ -50,8 +50,8 @@ MARKER_MONITORING= ( wall ) % ------------- COMMON PARAMETERS DEFINING THE NUMERICAL METHOD ---------------% % -NUM_METHOD_GRAD= GREEN_GAUSS -CFL_NUMBER= 10.0 +NUM_METHOD_GRAD= GREEN_GAUSS +CFL_NUMBER= 100.0 CFL_ADAPT= NO ITER=50000 VENKAT_LIMITER_COEFF= 0.01 @@ -60,18 +60,18 @@ VENKAT_LIMITER_COEFF= 0.01 % LINEAR_SOLVER= FGMRES LINEAR_SOLVER_PREC= ILU -LINEAR_SOLVER_ERROR= 1E-05 -LINEAR_SOLVER_ITER= 5 +LINEAR_SOLVER_ERROR= 1E-01 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % -MGLEVEL= 1 +MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 1, 1, 1, 1 ) +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) -MG_DAMP_RESTRICTION= 0.6 -MG_DAMP_PROLONGATION= 0.6 +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/moving_wall/cavity/lam_cavity.cfg b/TestCases/moving_wall/cavity/lam_cavity.cfg index 9f70ebd2257..3f838cc3892 100644 --- a/TestCases/moving_wall/cavity/lam_cavity.cfg +++ b/TestCases/moving_wall/cavity/lam_cavity.cfg @@ -49,7 +49,7 @@ MARKER_MONITORING= ( upper, left, right, lower ) % ------------- COMMON PARAMETERS DEFINING THE NUMERICAL METHOD ---------------% % NUM_METHOD_GRAD= WEIGHTED_LEAST_SQUARES -CFL_NUMBER= 2.0 +CFL_NUMBER= 100 CFL_ADAPT= NO CFL_ADAPT_PARAM= ( 1.5, 0.5, 1.0, 100.0 ) ITER= 99999 @@ -58,18 +58,18 @@ ITER= 99999 % LINEAR_SOLVER= FGMRES LINEAR_SOLVER_PREC= LU_SGS -LINEAR_SOLVER_ERROR= 1E-6 -LINEAR_SOLVER_ITER= 5 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % MGLEVEL= 2 MGCYCLE= W_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 0.9 -MG_DAMP_PROLONGATION= 0.9 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 1, 1, 1, 1 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % @@ -103,4 +103,4 @@ GRAD_OBJFUNC_FILENAME= of_grad SURFACE_FILENAME= surface_flow SURFACE_ADJ_FILENAME= surface_adjoint OUTPUT_WRT_FREQ= 250 -SCREEN_OUTPUT= (INNER_ITER, RMS_DENSITY, RMS_ENERGY, LIFT, DRAG) \ No newline at end of file +SCREEN_OUTPUT= (INNER_ITER, RMS_DENSITY, RMS_ENERGY, LIFT, DRAG) diff --git a/TestCases/moving_wall/spinning_cylinder/spinning_cylinder.cfg b/TestCases/moving_wall/spinning_cylinder/spinning_cylinder.cfg index 921f445e012..8f282ed5b16 100644 --- a/TestCases/moving_wall/spinning_cylinder/spinning_cylinder.cfg +++ b/TestCases/moving_wall/spinning_cylinder/spinning_cylinder.cfg @@ -30,7 +30,7 @@ REYNOLDS_LENGTH= 1.0 SURFACE_MOVEMENT= MOVING_WALL MACH_MOTION= 0.1 MARKER_MOVING= ( cylinder ) -SURFACE_MOTION_ORIGIN= 0.5 0.0 0.0 +SURFACE_MOTION_ORIGIN= 0.5 0.0 0.0 SURFACE_ROTATION_RATE = 0.0 0.0 -199.0738 % ---------------------- REFERENCE VALUE DEFINITION ---------------------------% @@ -67,16 +67,16 @@ SENS_REMOVE_SHARP= NO % LINEAR_SOLVER= FGMRES LINEAR_SOLVER_PREC= LU_SGS -LINEAR_SOLVER_ERROR= 1E-4 -LINEAR_SOLVER_ITER= 5 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 1, 1, 1 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) MG_DAMP_RESTRICTION= 0.5 MG_DAMP_PROLONGATION= 0.5 diff --git a/TestCases/multiple_ffd/naca0012/inv_NACA0012_ffd.cfg b/TestCases/multiple_ffd/naca0012/inv_NACA0012_ffd.cfg index ecf2a35c387..df6d8152c6c 100644 --- a/TestCases/multiple_ffd/naca0012/inv_NACA0012_ffd.cfg +++ b/TestCases/multiple_ffd/naca0012/inv_NACA0012_ffd.cfg @@ -55,18 +55,18 @@ ITER= 10 % LINEAR_SOLVER= FGMRES LINEAR_SOLVER_PREC= ILU -LINEAR_SOLVER_ERROR= 1E-4 -LINEAR_SOLVER_ITER= 10 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % -MGLEVEL= 2 +MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 1.0 -MG_DAMP_PROLONGATION= 1.0 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % --------------------- FLOW NUMERICAL METHOD DEFINITION ----------------------% % @@ -130,7 +130,7 @@ MESH_FORMAT= SU2 MESH_OUT_FILENAME= mesh_out SOLUTION_FILENAME= solution_flow SOLUTION_ADJ_FILENAME= solution_adj -TABULAR_FORMAT= TECPLOT +TABULAR_FORMAT= TECPLOT CONV_FILENAME= history RESTART_FILENAME= restart_flow RESTART_ADJ_FILENAME= restart_adj diff --git a/TestCases/multiple_ffd/naca0012/of_grad_cd.dat.ref b/TestCases/multiple_ffd/naca0012/of_grad_cd.dat.ref index dcfbdc3dc26..8ab0b5b0fe7 100644 --- a/TestCases/multiple_ffd/naca0012/of_grad_cd.dat.ref +++ b/TestCases/multiple_ffd/naca0012/of_grad_cd.dat.ref @@ -1,3 +1,3 @@ VARIABLES="VARIABLE" , "GRADIENT" , "FINDIFF_STEP" - 0 , 0.0640697 , 0.001 - 1 , -0.117493 , 0.001 + 0 , 0.0456482 , 0.001 + 1 , -0.0881187 , 0.001 diff --git a/TestCases/multiple_ffd/naca0012/of_grad_directdiff.dat.ref b/TestCases/multiple_ffd/naca0012/of_grad_directdiff.dat.ref index d09e8e3fb04..9365cd9cd74 100644 --- a/TestCases/multiple_ffd/naca0012/of_grad_directdiff.dat.ref +++ b/TestCases/multiple_ffd/naca0012/of_grad_directdiff.dat.ref @@ -1,3 +1,3 @@ VARIABLES="VARIABLE" , "DRAG" , "EFFICIENCY" , "FORCE_X" , "FORCE_Y" , "FORCE_Z" , "LIFT" , "MOMENT_X" , "MOMENT_Y" , "MOMENT_Z" , "SIDEFORCE" - 0 , 0.06254154103 , 0.1373280567 , 0.06005900872 , 0.1144550943 , 0.0 , 0.1131176767 , 0.0 , 0.0 , 0.01961712845 , 0.0 - 1 , -0.1126451148 , 6.126522734 , -0.1183006714 , 0.2579616726 , 0.0 , 0.2604810003 , 0.0 , 0.0 , 0.04918121089 , 0.0 + 0 , 0.04734305575 , -0.4824482295 , 0.04752721691 , -0.00792353334 , 0.0 , -0.008958448527 , 0.0 , 0.0 , 0.02636591979 , 0.0 + 1 , -0.09189465405 , 0.6527341405 , -0.09165316206 , -0.01206987592 , 0.0 , -0.01006760043 , 0.0 , 0.0 , 0.06097366677 , 0.0 diff --git a/TestCases/navierstokes/cylinder/cylinder_lowmach.cfg b/TestCases/navierstokes/cylinder/cylinder_lowmach.cfg index 7a282c5fee8..03125dc00c9 100644 --- a/TestCases/navierstokes/cylinder/cylinder_lowmach.cfg +++ b/TestCases/navierstokes/cylinder/cylinder_lowmach.cfg @@ -52,18 +52,18 @@ ITER= 99999 % LINEAR_SOLVER= FGMRES LINEAR_SOLVER_PREC= LU_SGS -LINEAR_SOLVER_ERROR= 1E-4 -LINEAR_SOLVER_ITER= 5 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % -MGLEVEL= 2 +MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 0.8 -MG_DAMP_PROLONGATION= 0.8 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/navierstokes/cylinder/lam_cylinder.cfg b/TestCases/navierstokes/cylinder/lam_cylinder.cfg index 17d3d8c567b..140957069af 100644 --- a/TestCases/navierstokes/cylinder/lam_cylinder.cfg +++ b/TestCases/navierstokes/cylinder/lam_cylinder.cfg @@ -52,18 +52,18 @@ ITER= 99999 % LINEAR_SOLVER= FGMRES LINEAR_SOLVER_PREC= LU_SGS -LINEAR_SOLVER_ERROR= 1E-4 -LINEAR_SOLVER_ITER= 5 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % -MGLEVEL= 2 +MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 0.8 -MG_DAMP_PROLONGATION= 0.8 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/navierstokes/flatplate/lam_flatplate.cfg b/TestCases/navierstokes/flatplate/lam_flatplate.cfg index 949fcc0df28..a1b95f54aab 100644 --- a/TestCases/navierstokes/flatplate/lam_flatplate.cfg +++ b/TestCases/navierstokes/flatplate/lam_flatplate.cfg @@ -53,18 +53,18 @@ CFL_ADAPT= NO % LINEAR_SOLVER= FGMRES LINEAR_SOLVER_PREC= LU_SGS -LINEAR_SOLVER_ERROR= 0.05 +LINEAR_SOLVER_ERROR= 1.0E-01 LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 0 ) -MG_POST_SMOOTH= ( 1, 1, 1, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 0.8 -MG_DAMP_PROLONGATION= 0.8 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/navierstokes/naca0012/lam_NACA0012.cfg b/TestCases/navierstokes/naca0012/lam_NACA0012.cfg index 6c1c5b79037..217add418fd 100644 --- a/TestCases/navierstokes/naca0012/lam_NACA0012.cfg +++ b/TestCases/navierstokes/naca0012/lam_NACA0012.cfg @@ -10,7 +10,7 @@ %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % ------------- DIRECT, ADJOINT, AND LINEARIZED PROBLEM DEFINITION ------------% -% +% SOLVER= NAVIER_STOKES KIND_TURB_MODEL= NONE MATH_PROBLEM= DIRECT @@ -48,18 +48,18 @@ CFL_ADAPT_PARAM= ( 1.5, 0.5, 1.0, 100.0 ) RK_ALPHA_COEFF= ( 0.66667, 0.66667, 1.000000 ) EXT_ITER= 99999 LINEAR_SOLVER= FGMRES -LINEAR_SOLVER_ERROR= 1E-4 -LINEAR_SOLVER_ITER= 5 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % -MGLEVEL= 2 +MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 2, 2 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 0.85 -MG_DAMP_PROLONGATION= 0.85 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/navierstokes/poiseuille/profile_poiseuille.cfg b/TestCases/navierstokes/poiseuille/profile_poiseuille.cfg index 917a53b98d2..62cb94bb143 100644 --- a/TestCases/navierstokes/poiseuille/profile_poiseuille.cfg +++ b/TestCases/navierstokes/poiseuille/profile_poiseuille.cfg @@ -79,18 +79,18 @@ ITER= 99999 % LINEAR_SOLVER= FGMRES LINEAR_SOLVER_PREC= LU_SGS -LINEAR_SOLVER_ERROR= 1E-4 -LINEAR_SOLVER_ITER= 5 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 1, 1, 1 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 0.8 -MG_DAMP_PROLONGATION= 0.8 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/nicf/LS89/turb_SA_PR.cfg b/TestCases/nicf/LS89/turb_SA_PR.cfg index 1e6ba192fc3..35703485f50 100644 --- a/TestCases/nicf/LS89/turb_SA_PR.cfg +++ b/TestCases/nicf/LS89/turb_SA_PR.cfg @@ -78,18 +78,18 @@ CFL_ADAPT= NO CFL_ADAPT_PARAM= ( 1.5, 0.5, 1.0, 100.0 ) ITER= 5000 LINEAR_SOLVER= FGMRES -LINEAR_SOLVER_ERROR= 1E-4 -LINEAR_SOLVER_ITER= 20 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 0.75 -MG_DAMP_PROLONGATION= 0.75 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/nicf/edge/edge_PPR.cfg b/TestCases/nicf/edge/edge_PPR.cfg index 7effeebc613..a757641e6a1 100644 --- a/TestCases/nicf/edge/edge_PPR.cfg +++ b/TestCases/nicf/edge/edge_PPR.cfg @@ -50,7 +50,7 @@ MARKER_MONITORING= ( WALL1 ) % ------------- COMMON PARAMETERS DEFINING THE NUMERICAL METHOD ---------------% % NUM_METHOD_GRAD= GREEN_GAUSS -CFL_NUMBER= 2.5 +CFL_NUMBER= 100 CFL_ADAPT= YES CFL_ADAPT_PARAM= ( 0.9, 1.1, 1.0, 200.0 ) RK_ALPHA_COEFF= ( 0.66667, 0.66667, 1.000000 ) @@ -60,16 +60,16 @@ ITER= 51 % LINEAR_SOLVER= FGMRES LINEAR_SOLVER_PREC= LU_SGS -LINEAR_SOLVER_ERROR= 1E-4 -LINEAR_SOLVER_ITER= 10 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % MGLEVEL= 3 MGCYCLE= W_CYCLE MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) +MG_POST_SMOOTH= ( 1, 1, 1, 1 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) MG_DAMP_RESTRICTION= 0.9 MG_DAMP_PROLONGATION= 0.9 diff --git a/TestCases/nicf/edge/edge_VW.cfg b/TestCases/nicf/edge/edge_VW.cfg index 8d6eb4a13f1..bf6d02e44d2 100644 --- a/TestCases/nicf/edge/edge_VW.cfg +++ b/TestCases/nicf/edge/edge_VW.cfg @@ -51,7 +51,7 @@ MARKER_MONITORING= ( WALL1 ) % ------------- COMMON PARAMETERS DEFINING THE NUMERICAL METHOD ---------------% % NUM_METHOD_GRAD= GREEN_GAUSS -CFL_NUMBER= 2.0 +CFL_NUMBER= 100 CFL_ADAPT= YES CFL_ADAPT_PARAM= ( 0.9, 1.1, 1.0, 200.0 ) RK_ALPHA_COEFF= ( 0.66667, 0.66667, 1.000000 ) @@ -61,18 +61,18 @@ ITER= 500 % LINEAR_SOLVER= FGMRES LINEAR_SOLVER_PREC= LU_SGS -LINEAR_SOLVER_ERROR= 1E-4 -LINEAR_SOLVER_ITER= 10 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % MGLEVEL= 3 MGCYCLE= W_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) MG_POST_SMOOTH= ( 1, 1, 1, 1 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 0.85 -MG_DAMP_PROLONGATION= 0.85 +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/optimization_euler/multiobjective_wedge/inv_wedge_ROE_2surf_1obj.cfg b/TestCases/optimization_euler/multiobjective_wedge/inv_wedge_ROE_2surf_1obj.cfg index 62728da55a6..d30538b6cdd 100644 --- a/TestCases/optimization_euler/multiobjective_wedge/inv_wedge_ROE_2surf_1obj.cfg +++ b/TestCases/optimization_euler/multiobjective_wedge/inv_wedge_ROE_2surf_1obj.cfg @@ -51,20 +51,20 @@ CFL_ADAPT_PARAM= ( 1.5, 0.5, 1.0, 100.0 ) RK_ALPHA_COEFF= ( 0.66667, 0.66667, 1.000000 ) ITER=1 LINEAR_SOLVER= BCGSTAB -LINEAR_SOLVER_ERROR= 1E-6 -LINEAR_SOLVER_ITER= 5 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 LINEAR_SOLVER_PREC= ILU LINEAR_SOLVER_ILU_FILL_IN= 0 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % -MGLEVEL= 2 +MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 0.8 -MG_DAMP_PROLONGATION= 0.8 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/optimization_euler/multiobjective_wedge/inv_wedge_ROE_multiobj.cfg b/TestCases/optimization_euler/multiobjective_wedge/inv_wedge_ROE_multiobj.cfg index 435729bcf38..9720823cc3c 100644 --- a/TestCases/optimization_euler/multiobjective_wedge/inv_wedge_ROE_multiobj.cfg +++ b/TestCases/optimization_euler/multiobjective_wedge/inv_wedge_ROE_multiobj.cfg @@ -52,8 +52,8 @@ CFL_ADAPT_PARAM= ( 0.1, 2.0, 1.0, 100.0 ) RK_ALPHA_COEFF= ( 0.66667, 0.66667, 1.000000 ) ITER=1 LINEAR_SOLVER= BCGSTAB -LINEAR_SOLVER_ERROR= 1E-6 -LINEAR_SOLVER_ITER= 5 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 LINEAR_SOLVER_PREC= ILU LINEAR_SOLVER_ILU_FILL_IN= 0 @@ -61,13 +61,13 @@ LINEAR_SOLVER_ILU_FILL_IN= 0 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % -MGLEVEL= 2 +MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 0.8 -MG_DAMP_PROLONGATION= 0.8 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/optimization_euler/multiobjective_wedge/inv_wedge_ROE_multiobj_1surf.cfg b/TestCases/optimization_euler/multiobjective_wedge/inv_wedge_ROE_multiobj_1surf.cfg index 5e9d114473d..229c1c99488 100644 --- a/TestCases/optimization_euler/multiobjective_wedge/inv_wedge_ROE_multiobj_1surf.cfg +++ b/TestCases/optimization_euler/multiobjective_wedge/inv_wedge_ROE_multiobj_1surf.cfg @@ -52,20 +52,20 @@ CFL_ADAPT_PARAM= ( 1.5, 0.5, 1.0, 100.0 ) RK_ALPHA_COEFF= ( 0.66667, 0.66667, 1.000000 ) ITER=1 LINEAR_SOLVER= BCGSTAB -LINEAR_SOLVER_ERROR= 1E-6 -LINEAR_SOLVER_ITER= 5 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 LINEAR_SOLVER_PREC= ILU LINEAR_SOLVER_ILU_FILL_IN= 0 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % -MGLEVEL= 2 +MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 0.8 -MG_DAMP_PROLONGATION= 0.8 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/optimization_euler/multiobjective_wedge/inv_wedge_ROE_multiobj_combo.cfg b/TestCases/optimization_euler/multiobjective_wedge/inv_wedge_ROE_multiobj_combo.cfg index 0f62bc8e531..3bd6868099d 100644 --- a/TestCases/optimization_euler/multiobjective_wedge/inv_wedge_ROE_multiobj_combo.cfg +++ b/TestCases/optimization_euler/multiobjective_wedge/inv_wedge_ROE_multiobj_combo.cfg @@ -54,20 +54,20 @@ CFL_ADAPT_PARAM= ( 0.1, 2.0, 1.0, 100.0 ) RK_ALPHA_COEFF= ( 0.66667, 0.66667, 1.000000 ) ITER=1 LINEAR_SOLVER= BCGSTAB -LINEAR_SOLVER_ERROR= 1E-6 -LINEAR_SOLVER_ITER= 5 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 LINEAR_SOLVER_PREC= ILU LINEAR_SOLVER_ILU_FILL_IN= 0 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % -MGLEVEL= 2 +MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 0.8 -MG_DAMP_PROLONGATION= 0.8 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/optimization_euler/pitching_oneram6/pitching_ONERAM6.cfg b/TestCases/optimization_euler/pitching_oneram6/pitching_ONERAM6.cfg index e5a07599481..149ecaecf91 100644 --- a/TestCases/optimization_euler/pitching_oneram6/pitching_ONERAM6.cfg +++ b/TestCases/optimization_euler/pitching_oneram6/pitching_ONERAM6.cfg @@ -74,18 +74,18 @@ CFL_ADAPT_PARAM= ( 1.5, 0.5, 1.0, 100.0 ) RK_ALPHA_COEFF= ( 0.66667, 0.66667, 1.000000 ) ITER= 99999 LINEAR_SOLVER= FGMRES -LINEAR_SOLVER_ERROR= 1E-6 -LINEAR_SOLVER_ITER= 5 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % -MGLEVEL= 2 +MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 0.9 -MG_DAMP_PROLONGATION= 0.9 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/optimization_euler/steady_naca0012/inv_NACA0012_adv.cfg b/TestCases/optimization_euler/steady_naca0012/inv_NACA0012_adv.cfg index 5931802d7c0..6adf74ba02e 100644 --- a/TestCases/optimization_euler/steady_naca0012/inv_NACA0012_adv.cfg +++ b/TestCases/optimization_euler/steady_naca0012/inv_NACA0012_adv.cfg @@ -55,18 +55,18 @@ ITER= 250 % LINEAR_SOLVER= FGMRES LINEAR_SOLVER_PREC= LU_SGS -LINEAR_SOLVER_ERROR= 1E-4 -LINEAR_SOLVER_ITER= 10 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % -MGLEVEL= 2 +MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 1.0 -MG_DAMP_PROLONGATION= 1.0 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % --------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/optimization_euler/steady_naca0012/inv_NACA0012_basic.cfg b/TestCases/optimization_euler/steady_naca0012/inv_NACA0012_basic.cfg index c5514bff6f7..616ccf3f3b8 100644 --- a/TestCases/optimization_euler/steady_naca0012/inv_NACA0012_basic.cfg +++ b/TestCases/optimization_euler/steady_naca0012/inv_NACA0012_basic.cfg @@ -53,18 +53,18 @@ ITER= 1000 % LINEAR_SOLVER= FGMRES LINEAR_SOLVER_PREC= ILU -LINEAR_SOLVER_ERROR= 1E-4 -LINEAR_SOLVER_ITER= 2 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % -MGLEVEL= 2 +MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 1.0 -MG_DAMP_PROLONGATION= 1.0 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % --------------------- FLOW NUMERICAL METHOD DEFINITION ----------------------% % diff --git a/TestCases/optimization_rans/steady_oneram6/turb_ONERAM6.cfg b/TestCases/optimization_rans/steady_oneram6/turb_ONERAM6.cfg index 448fc73964d..f1af0039769 100644 --- a/TestCases/optimization_rans/steady_oneram6/turb_ONERAM6.cfg +++ b/TestCases/optimization_rans/steady_oneram6/turb_ONERAM6.cfg @@ -54,18 +54,18 @@ EXT_ITER= 10000 % LINEAR_SOLVER= FGMRES LINEAR_SOLVER_PREC= LU_SGS -LINEAR_SOLVER_ERROR= 1E-5 -LINEAR_SOLVER_ITER= 2 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % -MGLEVEL= 2 +MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 0.7 -MG_DAMP_PROLONGATION= 0.7 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/optimization_rans/steady_rae2822/turb_SA_RAE2822.cfg b/TestCases/optimization_rans/steady_rae2822/turb_SA_RAE2822.cfg index 191e7219f51..19d1737885f 100644 --- a/TestCases/optimization_rans/steady_rae2822/turb_SA_RAE2822.cfg +++ b/TestCases/optimization_rans/steady_rae2822/turb_SA_RAE2822.cfg @@ -47,18 +47,18 @@ CFL_ADAPT= NO CFL_ADAPT_PARAM= ( 1.5, 0.5, 1.0, 100.0 ) ITER= 10000 LINEAR_SOLVER= FGMRES -LINEAR_SOLVER_ERROR= 1E-6 -LINEAR_SOLVER_ITER= 5 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % -MGLEVEL= 2 +MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 0.95 -MG_DAMP_PROLONGATION= 0.95 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/parallel_regression.py b/TestCases/parallel_regression.py index 2925725d1eb..c729da516de 100755 --- a/TestCases/parallel_regression.py +++ b/TestCases/parallel_regression.py @@ -220,7 +220,7 @@ def main(): channel.cfg_dir = "euler/channel" channel.cfg_file = "inv_channel_RK.cfg" channel.test_iter = 20 - channel.test_vals = [-2.343552, 3.197189, 0.123534, 0.148052] + channel.test_vals = [-2.305051, 3.237256, 0.125006, 0.154077] test_list.append(channel) # NACA0012 @@ -228,7 +228,7 @@ def main(): naca0012.cfg_dir = "euler/naca0012" naca0012.cfg_file = "inv_NACA0012_Roe.cfg" naca0012.test_iter = 20 - naca0012.test_vals = [-4.877597, -4.355615, 0.331699, 0.022976] + naca0012.test_vals = [-4.314738, -3.845428, 0.307738, 0.024670] test_list.append(naca0012) # Supersonic wedge @@ -236,7 +236,7 @@ def main(): wedge.cfg_dir = "euler/wedge" wedge.cfg_file = "inv_wedge_HLLC.cfg" wedge.test_iter = 20 - wedge.test_vals = [-1.296189, 4.375714, -0.235637, 0.041589] + wedge.test_vals = [-3.573085, 2.150321, -0.249533, 0.043953] test_list.append(wedge) # ONERA M6 Wing @@ -244,7 +244,7 @@ def main(): oneram6.cfg_dir = "euler/oneram6" oneram6.cfg_file = "inv_ONERAM6.cfg" oneram6.test_iter = 10 - oneram6.test_vals = [-11.457168, -10.921423, 0.280800, 0.008623] + oneram6.test_vals = [-11.525271, -10.995902, 0.280800, 0.008623] oneram6.timeout = 3200 test_list.append(oneram6) @@ -253,7 +253,7 @@ def main(): fixedCL_naca0012.cfg_dir = "fixed_cl/naca0012" fixedCL_naca0012.cfg_file = "inv_NACA0012.cfg" fixedCL_naca0012.test_iter = 10 - fixedCL_naca0012.test_vals = [-3.802419, 1.735767, 0.301252, 0.019495] + fixedCL_naca0012.test_vals = [-3.919916, 1.592064, 0.300852, 0.019461] test_list.append(fixedCL_naca0012) # Polar sweep of the inviscid NACA0012 @@ -262,7 +262,7 @@ def main(): polar_naca0012.cfg_file = "inv_NACA0012.cfg" polar_naca0012.polar = True polar_naca0012.test_iter = 10 - polar_naca0012.test_vals = [-1.107467, 4.365654, 0.006796, 0.025216] + polar_naca0012.test_vals = [-1.206973, 4.234604, 0.013410, 0.073285] polar_naca0012.test_vals_aarch64 = [-1.083394, 4.386134, 0.001588, 0.033513] polar_naca0012.command = TestCase.Command(exec = "compute_polar.py", param = "-i 11") # flaky test on arm64 @@ -319,7 +319,7 @@ def main(): flatplate.cfg_dir = "navierstokes/flatplate" flatplate.cfg_file = "lam_flatplate.cfg" flatplate.test_iter = 100 - flatplate.test_vals = [-7.436411, -1.956557, 0.001084, 0.036232, 2.361500, -2.325300, 0.000000, 0.000000] + flatplate.test_vals = [-6.397042, -0.919335, 0.001321, 0.025064, 2.361500, -2.336500, 0.000000, 0.000000] test_list.append(flatplate) # Custom objective function @@ -344,7 +344,7 @@ def main(): cylinder.cfg_dir = "navierstokes/cylinder" cylinder.cfg_file = "lam_cylinder.cfg" cylinder.test_iter = 25 - cylinder.test_vals = [-8.486555, -2.997719, -0.006044, 1.601479, 0.000000] + cylinder.test_vals = [-8.529918, -3.059339, 0.189560, 1.746170, 0.000000] test_list.append(cylinder) # Laminar cylinder (low Mach correction) @@ -352,7 +352,7 @@ def main(): cylinder_lowmach.cfg_dir = "navierstokes/cylinder" cylinder_lowmach.cfg_file = "cylinder_lowmach.cfg" cylinder_lowmach.test_iter = 25 - cylinder_lowmach.test_vals = [-6.388898, -0.927029, -0.590968, -132.145318, 0.000000] + cylinder_lowmach.test_vals = [-6.603373, -1.141590, -0.715787, -63.545748, 0.000000] test_list.append(cylinder_lowmach) # 2D Poiseuille flow (body force driven with periodic inlet / outlet) @@ -369,7 +369,7 @@ def main(): poiseuille_profile.cfg_dir = "navierstokes/poiseuille" poiseuille_profile.cfg_file = "profile_poiseuille.cfg" poiseuille_profile.test_iter = 10 - poiseuille_profile.test_vals = [-12.011765, -7.670052, -0.000000, 2.089953] + poiseuille_profile.test_vals = [-12.004334, -7.534404, -0.000000, 2.089953] poiseuille_profile.test_vals_aarch64 = [-12.007498, -7.226926, -0.000000, 2.089953] test_list.append(poiseuille_profile) @@ -382,7 +382,7 @@ def main(): rae2822_sa.cfg_dir = "rans/rae2822" rae2822_sa.cfg_file = "turb_SA_RAE2822.cfg" rae2822_sa.test_iter = 20 - rae2822_sa.test_vals = [-1.850422, -5.131788, 0.571589, 0.042386, 0.000000] + rae2822_sa.test_vals = [-2.172705, -5.465982, 0.292927, 0.103369, 0.000000] test_list.append(rae2822_sa) # RAE2822 SST @@ -390,7 +390,7 @@ def main(): rae2822_sst.cfg_dir = "rans/rae2822" rae2822_sst.cfg_file = "turb_SST_RAE2822.cfg" rae2822_sst.test_iter = 20 - rae2822_sst.test_vals = [-0.509872, 5.867970, 0.575399, 0.016441, 0.000000] + rae2822_sst.test_vals = [-1.035662, 5.868036, 0.283073, 0.094756, 0.000000] test_list.append(rae2822_sst) # RAE2822 SST_SUST @@ -398,7 +398,7 @@ def main(): rae2822_sst_sust.cfg_dir = "rans/rae2822" rae2822_sst_sust.cfg_file = "turb_SST_SUST_RAE2822.cfg" rae2822_sst_sust.test_iter = 20 - rae2822_sst_sust.test_vals = [-2.464677, 5.867970, 0.575399, 0.016441] + rae2822_sst_sust.test_vals = [-2.542992, 5.868021, 0.283073, 0.094756] test_list.append(rae2822_sst_sust) # Flat plate @@ -406,7 +406,7 @@ def main(): turb_flatplate.cfg_dir = "rans/flatplate" turb_flatplate.cfg_file = "turb_SA_flatplate.cfg" turb_flatplate.test_iter = 20 - turb_flatplate.test_vals = [-3.944613, -6.827069, -0.192592, 0.023549] + turb_flatplate.test_vals = [-4.879863, -7.464877, -0.187760, 0.016260] test_list.append(turb_flatplate) # Flat plate (compressible) with species inlet @@ -414,7 +414,7 @@ def main(): turb_flatplate_species.cfg_dir = "rans/flatplate" turb_flatplate_species.cfg_file = "turb_SA_flatplate_species.cfg" turb_flatplate_species.test_iter = 20 - turb_flatplate_species.test_vals = [-3.901196, -1.030304, -1.390862, 1.596603, -3.294825, 9.000000, -6.033863, 5.000000, -6.604787, 10.000000, -5.749978, 0.999917, 0.999917] + turb_flatplate_species.test_vals = [-4.548766, -1.476908, -1.980237, 0.937064, -3.573976, 3.000000, -0.475230, 2.000000, -1.511528, 3.000000, -0.699313, 0.999900, 0.999900] test_list.append(turb_flatplate_species) # Flat plate SST compressibility correction Wilcox @@ -586,7 +586,7 @@ def main(): turb_naca0012_sst_restart_mg.cfg_file = "turb_NACA0012_sst_multigrid_restart.cfg" turb_naca0012_sst_restart_mg.test_iter = 20 turb_naca0012_sst_restart_mg.ntest_vals = 5 - turb_naca0012_sst_restart_mg.test_vals = [-6.605858, -5.057159, 0.830274, -0.008419, 0.077910] + turb_naca0012_sst_restart_mg.test_vals = [-6.538846, -5.057149, 0.830238, -0.008740, 0.078171] turb_naca0012_sst_restart_mg.timeout = 3200 turb_naca0012_sst_restart_mg.tol = 0.000001 test_list.append(turb_naca0012_sst_restart_mg) @@ -600,7 +600,7 @@ def main(): inc_euler_naca0012.cfg_dir = "incomp_euler/naca0012" inc_euler_naca0012.cfg_file = "incomp_NACA0012.cfg" inc_euler_naca0012.test_iter = 20 - inc_euler_naca0012.test_vals = [-7.155691, -6.591881, 0.531999, 0.008466] + inc_euler_naca0012.test_vals = [-5.984413, -5.104039, 0.523625, 0.008885] test_list.append(inc_euler_naca0012) # C-D nozzle with pressure inlet and mass flow outlet @@ -608,7 +608,7 @@ def main(): inc_nozzle.cfg_dir = "incomp_euler/nozzle" inc_nozzle.cfg_file = "inv_nozzle.cfg" inc_nozzle.test_iter = 20 - inc_nozzle.test_vals = [-4.867594, -4.435604, -0.006083, 0.131415] + inc_nozzle.test_vals = [-5.594509, -4.878247, 0.005147, 0.139611] test_list.append(inc_nozzle) # Laminar wall mounted cylinder, Euler walls, cylinder wall diagonally split @@ -628,7 +628,7 @@ def main(): inc_lam_cylinder.cfg_dir = "incomp_navierstokes/cylinder" inc_lam_cylinder.cfg_file = "incomp_cylinder.cfg" inc_lam_cylinder.test_iter = 10 - inc_lam_cylinder.test_vals = [-3.959383, -3.272502, -0.087725, 6.769520] + inc_lam_cylinder.test_vals = [-4.157264, -3.589125, -0.018681, 4.659302] test_list.append(inc_lam_cylinder) # Laminar sphere, Re=1. Last column: Cd=24/Re @@ -636,7 +636,7 @@ def main(): inc_lam_sphere.cfg_dir = "incomp_navierstokes/sphere" inc_lam_sphere.cfg_file = "sphere.cfg" inc_lam_sphere.test_iter = 5 - inc_lam_sphere.test_vals = [-8.377082, -9.393391, 0.121003, 25.782686] + inc_lam_sphere.test_vals = [-8.166398, -8.947226, 0.121003, 25.782690] test_list.append(inc_lam_sphere) # Buoyancy-driven cavity @@ -774,7 +774,7 @@ def main(): turbmod_sa_bsl_rae2822.cfg_dir = "turbulence_models/sa/rae2822" turbmod_sa_bsl_rae2822.cfg_file = "turb_SA_BSL_RAE2822.cfg" turbmod_sa_bsl_rae2822.test_iter = 20 - turbmod_sa_bsl_rae2822.test_vals = [-1.850422, 0.801378, 0.576701, -5.131788, 0.571589, 0.042386] + turbmod_sa_bsl_rae2822.test_vals = [-2.610446, 0.335724, -0.118510, -5.463071, 0.765741, 0.028251] test_list.append(turbmod_sa_bsl_rae2822) # SA Negative @@ -791,7 +791,7 @@ def main(): turbmod_sa_comp_rae2822.cfg_dir = "turbulence_models/sa/rae2822" turbmod_sa_comp_rae2822.cfg_file = "turb_SA_COMP_RAE2822.cfg" turbmod_sa_comp_rae2822.test_iter = 20 - turbmod_sa_comp_rae2822.test_vals = [-1.850425, 0.801375, 0.576699, -5.131880, 0.571592, 0.042388] + turbmod_sa_comp_rae2822.test_vals = [-2.610449, 0.335720, -0.118515, -5.468848, 0.765768, 0.028257] test_list.append(turbmod_sa_comp_rae2822) # SA Edwards @@ -799,7 +799,7 @@ def main(): turbmod_sa_edw_rae2822.cfg_dir = "turbulence_models/sa/rae2822" turbmod_sa_edw_rae2822.cfg_file = "turb_SA_EDW_RAE2822.cfg" turbmod_sa_edw_rae2822.test_iter = 20 - turbmod_sa_edw_rae2822.test_vals = [-1.850407, 0.801397, 0.576716, -5.168509, 0.571594, 0.042384] + turbmod_sa_edw_rae2822.test_vals = [-2.609968, 0.336105, -0.118179, -6.022707, 0.765928, 0.028192] test_list.append(turbmod_sa_edw_rae2822) # SA Compressibility and Edwards @@ -807,7 +807,7 @@ def main(): turbmod_sa_comp_edw_rae2822.cfg_dir = "turbulence_models/sa/rae2822" turbmod_sa_comp_edw_rae2822.cfg_file = "turb_SA_COMP_EDW_RAE2822.cfg" turbmod_sa_comp_edw_rae2822.test_iter = 20 - turbmod_sa_comp_edw_rae2822.test_vals = [-1.850411, 0.801392, 0.576713, -5.168535, 0.571597, 0.042387] + turbmod_sa_comp_edw_rae2822.test_vals = [-2.610041, 0.336057, -0.118225, -6.023847, 0.765944, 0.028196] test_list.append(turbmod_sa_comp_edw_rae2822) # SA QCR @@ -815,7 +815,7 @@ def main(): turbmod_sa_qcr_rae2822.cfg_dir = "turbulence_models/sa/rae2822" turbmod_sa_qcr_rae2822.cfg_file = "turb_SA_QCR_RAE2822.cfg" turbmod_sa_qcr_rae2822.test_iter = 20 - turbmod_sa_qcr_rae2822.test_vals = [-1.848614, 0.801975, 0.578549, -5.131053, 0.571093, 0.042439] + turbmod_sa_qcr_rae2822.test_vals = [-2.320855, 0.512787, 0.108026, -5.449178, 0.770698, 0.026693] test_list.append(turbmod_sa_qcr_rae2822) ############################ @@ -839,7 +839,7 @@ def main(): contadj_naca0012.cfg_dir = "cont_adj_euler/naca0012" contadj_naca0012.cfg_file = "inv_NACA0012.cfg" contadj_naca0012.test_iter = 5 - contadj_naca0012.test_vals = [-9.583496, -15.034977, -0.726250, 0.020280] + contadj_naca0012.test_vals = [-9.520784, -15.101278, -0.726250, 0.020280] contadj_naca0012.test_vals_aarch64 = [-9.662546, -14.998818, -0.726250, 0.020280] test_list.append(contadj_naca0012) @@ -848,7 +848,7 @@ def main(): contadj_oneram6.cfg_dir = "cont_adj_euler/oneram6" contadj_oneram6.cfg_file = "inv_ONERAM6.cfg" contadj_oneram6.test_iter = 10 - contadj_oneram6.test_vals = [-11.981260, -12.515067, -1.086100, 0.007556] + contadj_oneram6.test_vals = [-12.069374, -12.632463, -1.086100, 0.007556] test_list.append(contadj_oneram6) # Inviscid WEDGE: tests averaged outflow total pressure adjoint @@ -864,7 +864,7 @@ def main(): contadj_fixed_CL_naca0012.cfg_dir = "fixed_cl/naca0012" contadj_fixed_CL_naca0012.cfg_file = "inv_NACA0012_ContAdj.cfg" contadj_fixed_CL_naca0012.test_iter = 100 - contadj_fixed_CL_naca0012.test_vals = [0.838756, -4.799730, -0.372690, -0.000630] + contadj_fixed_CL_naca0012.test_vals = [1.154889, -4.342907, -0.075177, -0.007496] test_list.append(contadj_fixed_CL_naca0012) ################################### @@ -876,7 +876,7 @@ def main(): contadj_ns_cylinder.cfg_dir = "cont_adj_navierstokes/cylinder" contadj_ns_cylinder.cfg_file = "lam_cylinder.cfg" contadj_ns_cylinder.test_iter = 20 - contadj_ns_cylinder.test_vals = [-3.600450, -9.041799, 2.056700, -0.000000] + contadj_ns_cylinder.test_vals = [-3.589714, -9.027143, 2.056700, -0.000000] test_list.append(contadj_ns_cylinder) # Adjoint laminar naca0012 subsonic @@ -920,7 +920,7 @@ def main(): contadj_rans_rae2822.cfg_dir = "cont_adj_rans/rae2822" contadj_rans_rae2822.cfg_file = "turb_SA_RAE2822.cfg" contadj_rans_rae2822.test_iter = 20 - contadj_rans_rae2822.test_vals = [-5.385804, -10.889762, -0.212470, 0.005448] + contadj_rans_rae2822.test_vals = [-5.399633, -10.904666, -0.212470, 0.005448] test_list.append(contadj_rans_rae2822) ############################# @@ -1000,7 +1000,7 @@ def main(): rot_naca0012.cfg_dir = "rotating/naca0012" rot_naca0012.cfg_file = "rot_NACA0012.cfg" rot_naca0012.test_iter = 25 - rot_naca0012.test_vals = [-1.412607, 4.090722, -0.021973, 0.057457] + rot_naca0012.test_vals = [-1.302487, 4.220598, -0.002152, 0.124241] test_list.append(rot_naca0012) # Lid-driven cavity @@ -1008,7 +1008,7 @@ def main(): cavity.cfg_dir = "moving_wall/cavity" cavity.cfg_file = "lam_cavity.cfg" cavity.test_iter = 25 - cavity.test_vals = [-5.450215, 0.015635, 0.011950, -9.224629] + cavity.test_vals = [-8.194578, -2.735580, 0.005612, -0.019805] test_list.append(cavity) # Spinning cylinder @@ -1016,7 +1016,7 @@ def main(): spinning_cylinder.cfg_dir = "moving_wall/spinning_cylinder" spinning_cylinder.cfg_file = "spinning_cylinder.cfg" spinning_cylinder.test_iter = 25 - spinning_cylinder.test_vals = [-7.707122, -2.253704, 1.633997, 1.546081] + spinning_cylinder.test_vals = [-7.716789, -2.257294, 2.054821, 1.660858] test_list.append(spinning_cylinder) ###################################### @@ -1037,7 +1037,7 @@ def main(): sine_gust.cfg_dir = "gust" sine_gust.cfg_file = "inv_gust_NACA0012.cfg" sine_gust.test_iter = 5 - sine_gust.test_vals = [-1.977498, 3.481817, -0.010227, -0.007902] + sine_gust.test_vals = [-1.977498, 3.481817, -0.010372, -0.005217] sine_gust.unsteady = True test_list.append(sine_gust) @@ -1046,7 +1046,7 @@ def main(): aeroelastic.cfg_dir = "aeroelastic" aeroelastic.cfg_file = "aeroelastic_NACA64A010.cfg" aeroelastic.test_iter = 2 - aeroelastic.test_vals = [0.075680, 0.027563, -0.001642, -0.000127] + aeroelastic.test_vals = [0.073686, 0.027423, -0.001644, -0.000125] aeroelastic.unsteady = True test_list.append(aeroelastic) @@ -1085,16 +1085,16 @@ def main(): edge_VW = TestCase('edge_VW') edge_VW.cfg_dir = "nicf/edge" edge_VW.cfg_file = "edge_VW.cfg" - edge_VW.test_iter = 50 - edge_VW.test_vals = [-2.386376, 3.814463, -0.000009, 0.000000] + edge_VW.test_iter = 25 + edge_VW.test_vals = [-3.178712, 3.023048, -0.000009, 0.000000] test_list.append(edge_VW) # Rarefaction shock wave edge_PPR edge_PPR = TestCase('edge_PPR') edge_PPR.cfg_dir = "nicf/edge" edge_PPR.cfg_file = "edge_PPR.cfg" - edge_PPR.test_iter = 50 - edge_PPR.test_vals = [-12.063410, -5.872787, -0.000034, 0.000000] + edge_PPR.test_iter = 25 + edge_PPR.test_vals = [-9.020461, -2.870274, -0.000034, 0.000000] test_list.append(edge_PPR) # Rarefaction Q1D nozzle, include CoolProp fluid model @@ -1241,7 +1241,7 @@ def main(): bars_SST_2D.cfg_dir = "sliding_interface/bars_SST_2D" bars_SST_2D.cfg_file = "bars.cfg" bars_SST_2D.test_iter = 13 - bars_SST_2D.test_vals = [13.000000, -0.623154, -1.660901] + bars_SST_2D.test_vals = [13.000000, -0.472766, -1.559919] bars_SST_2D.multizone = True test_list.append(bars_SST_2D) @@ -1322,7 +1322,7 @@ def main(): nonlinear_plane_stress.cfg_dir = "fea_fsi/VonMissesVerif" nonlinear_plane_stress.cfg_file = "nonlinear_plane_stress_2d.cfg" nonlinear_plane_stress.test_iter = 19 - nonlinear_plane_stress.test_vals = [-7.433449, -3.355607, -13.983863, 162480, 43, -4.070373] + nonlinear_plane_stress.test_vals = [-7.433449, -3.355607, -13.983863, 162480.000000, 43.000000, -4.070373] test_list.append(nonlinear_plane_stress) # Dynamic beam, 2d @@ -1449,7 +1449,7 @@ def main(): pywrapper_naca0012.cfg_dir = "euler/naca0012" pywrapper_naca0012.cfg_file = "inv_NACA0012_Roe.cfg" pywrapper_naca0012.test_iter = 80 - pywrapper_naca0012.test_vals = [-9.980225, -9.402767, 0.335769, 0.023275] + pywrapper_naca0012.test_vals = [-7.755848, -7.082517, 0.335769, 0.023275] pywrapper_naca0012.command = TestCase.Command("mpirun -np 2", "SU2_CFD.py", "--parallel -f") test_list.append(pywrapper_naca0012) @@ -1479,7 +1479,7 @@ def main(): pywrapper_aeroelastic.cfg_dir = "aeroelastic" pywrapper_aeroelastic.cfg_file = "aeroelastic_NACA64A010.cfg" pywrapper_aeroelastic.test_iter = 2 - pywrapper_aeroelastic.test_vals = [0.075680, 0.027563, -0.001642, -0.000127] + pywrapper_aeroelastic.test_vals = [0.073686, 0.027423, -0.001644, -0.000125] pywrapper_aeroelastic.command = TestCase.Command("mpirun -np 2", "SU2_CFD.py", "--parallel -f") pywrapper_aeroelastic.unsteady = True test_list.append(pywrapper_aeroelastic) @@ -1520,7 +1520,7 @@ def main(): pywrapper_unsteadyCHT.cfg_dir = "py_wrapper/flatPlate_unsteady_CHT" pywrapper_unsteadyCHT.cfg_file = "unsteady_CHT_FlatPlate_Conf.cfg" pywrapper_unsteadyCHT.test_iter = 5 - pywrapper_unsteadyCHT.test_vals = [-1.614167, 2.260123, -0.002469, 0.100260] + pywrapper_unsteadyCHT.test_vals = [-1.614168, 2.259984, -0.005601, 0.129785] pywrapper_unsteadyCHT.command = TestCase.Command("mpirun -np 2", "python", "launch_unsteady_CHT_FlatPlate.py --parallel -f") pywrapper_unsteadyCHT.unsteady = True test_list.append(pywrapper_unsteadyCHT) diff --git a/TestCases/parallel_regression_AD.py b/TestCases/parallel_regression_AD.py index 5a6bbef85a6..9e4863cc42b 100644 --- a/TestCases/parallel_regression_AD.py +++ b/TestCases/parallel_regression_AD.py @@ -63,7 +63,7 @@ def main(): discadj_arina2k.cfg_dir = "disc_adj_euler/arina2k" discadj_arina2k.cfg_file = "Arina2KRS.cfg" discadj_arina2k.test_iter = 20 - discadj_arina2k.test_vals = [-3.259547, -3.544519, 0.044517, 0.000000] + discadj_arina2k.test_vals = [-2.931649, -3.356322, 0.073332, 0.000000] test_list.append(discadj_arina2k) # Equivalent area NACA64-206 @@ -104,7 +104,7 @@ def main(): discadj_incomp_NACA0012.cfg_dir = "disc_adj_incomp_euler/naca0012" discadj_incomp_NACA0012.cfg_file = "incomp_NACA0012_disc.cfg" discadj_incomp_NACA0012.test_iter = 20 - discadj_incomp_NACA0012.test_vals = [20.000000, -3.949889, -2.567232, 0.000000] + discadj_incomp_NACA0012.test_vals = [20.000000, -3.319959, -2.489110, 0.000000] test_list.append(discadj_incomp_NACA0012) ##################################### @@ -217,7 +217,7 @@ def main(): discadj_pitchingNACA0012.cfg_dir = "disc_adj_euler/naca0012_pitching" discadj_pitchingNACA0012.cfg_file = "inv_NACA0012_pitching.cfg" discadj_pitchingNACA0012.test_iter = 4 - discadj_pitchingNACA0012.test_vals = [-1.226498, -1.653107, -0.003489, -0.000000] + discadj_pitchingNACA0012.test_vals = [-1.126077, -1.582787, -0.005904, 0.000009] discadj_pitchingNACA0012.tol = 0.01 discadj_pitchingNACA0012.unsteady = True test_list.append(discadj_pitchingNACA0012) @@ -231,7 +231,7 @@ def main(): discadj_trans_stator.cfg_dir = "disc_adj_turbomachinery/transonic_stator_2D" discadj_trans_stator.cfg_file = "transonic_stator.cfg" discadj_trans_stator.test_iter = 79 - discadj_trans_stator.test_vals = [79.000000, 0.697136, 0.459036, 0.536525, -0.995531] + discadj_trans_stator.test_vals = [79.000000, 2.599437, 2.336310, 2.141020, 0.786888] discadj_trans_stator.test_vals_aarch64 = [79.000000, 0.696755, 0.485950, 0.569475, -0.990065] test_list.append(discadj_trans_stator) diff --git a/TestCases/py_wrapper/custom_inlet/lam_flatplate.cfg b/TestCases/py_wrapper/custom_inlet/lam_flatplate.cfg index bc9ea1fc61f..3660dd1d6e1 100644 --- a/TestCases/py_wrapper/custom_inlet/lam_flatplate.cfg +++ b/TestCases/py_wrapper/custom_inlet/lam_flatplate.cfg @@ -60,10 +60,11 @@ CFL_NUMBER= 1e3 CFL_ADAPT= NO TIME_DISCRE_FLOW= EULER_IMPLICIT % -MGLEVEL= 2 +MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 1, 1 ) -MG_POST_SMOOTH= ( 0, 0, 0 ) +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) MG_DAMP_RESTRICTION= 0.5 MG_DAMP_PROLONGATION= 0.5 @@ -71,8 +72,8 @@ MG_DAMP_PROLONGATION= 0.5 % LINEAR_SOLVER= FGMRES LINEAR_SOLVER_PREC= ILU -LINEAR_SOLVER_ERROR= 0.2 -LINEAR_SOLVER_ITER= 5 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/py_wrapper/rotating_cylinder/spinning_cylinder.cfg b/TestCases/py_wrapper/rotating_cylinder/spinning_cylinder.cfg index 5e2bcaa0692..73c0fe931be 100644 --- a/TestCases/py_wrapper/rotating_cylinder/spinning_cylinder.cfg +++ b/TestCases/py_wrapper/rotating_cylinder/spinning_cylinder.cfg @@ -30,7 +30,7 @@ REYNOLDS_LENGTH= 1.0 SURFACE_MOVEMENT= MOVING_WALL MACH_MOTION= 0.1 MARKER_MOVING= ( cylinder ) -SURFACE_MOTION_ORIGIN= 0.5 0.0 0.0 +SURFACE_MOTION_ORIGIN= 0.5 0.0 0.0 SURFACE_ROTATION_RATE = 0.0 0.0 -199.0738 % ---------------------- REFERENCE VALUE DEFINITION ---------------------------% @@ -67,16 +67,16 @@ SENS_REMOVE_SHARP= NO % LINEAR_SOLVER= FGMRES LINEAR_SOLVER_PREC= LU_SGS -LINEAR_SOLVER_ERROR= 1E-4 -LINEAR_SOLVER_ITER= 5 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 1, 1, 1 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) MG_DAMP_RESTRICTION= 0.5 MG_DAMP_PROLONGATION= 0.5 diff --git a/TestCases/py_wrapper/translating_NACA0012/config.cfg b/TestCases/py_wrapper/translating_NACA0012/config.cfg index 3deaf8fc1b6..adfce41ed71 100644 --- a/TestCases/py_wrapper/translating_NACA0012/config.cfg +++ b/TestCases/py_wrapper/translating_NACA0012/config.cfg @@ -9,12 +9,12 @@ RESTART_SOL= NO % % We are translating the domain instead of having farfield velocity. % 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 +% 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 +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 @@ -55,17 +55,17 @@ CFL_ADAPT= NO % MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 0.7 -MG_DAMP_PROLONGATION= 0.7 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % LINEAR_SOLVER= FGMRES LINEAR_SOLVER_PREC= LU_SGS -LINEAR_SOLVER_ERROR= 0.1 -LINEAR_SOLVER_ITER= 5 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % CONVERGENCE PARAMETERS % diff --git a/TestCases/py_wrapper/translating_NACA0012/forces_0.csv.ref b/TestCases/py_wrapper/translating_NACA0012/forces_0.csv.ref index d715ec6cdcc..782f0d2d806 100644 --- a/TestCases/py_wrapper/translating_NACA0012/forces_0.csv.ref +++ b/TestCases/py_wrapper/translating_NACA0012/forces_0.csv.ref @@ -1,200 +1,200 @@ -199, -0.86, -0.00, 0.00 -0, -2.65, 18.23, 0.00 -1, -3.76, 25.89, 0.00 -2, -4.65, 32.09, 0.00 -3, -5.46, 37.74, 0.00 -4, -6.13, 42.56, 0.00 -5, -6.71, 46.69, 0.00 -6, -7.16, 50.07, 0.00 -7, -7.53, 52.90, 0.00 -8, -7.76, 54.82, 0.00 -9, -7.90, 56.13, 0.00 -10, -7.93, 56.70, 0.00 -11, -7.90, 56.91, 0.00 -12, -7.75, 56.22, 0.00 -13, -7.57, 55.39, 0.00 -14, -7.26, 53.59, 0.00 -15, -6.89, 51.30, 0.00 -16, -6.44, 48.47, 0.00 -17, -5.99, 45.51, 0.00 -18, -5.40, 41.51, 0.00 -19, -4.79, 37.20, 0.00 -20, -4.13, 32.43, 0.00 -21, -3.45, 27.41, 0.00 -22, -2.67, 21.54, 0.00 -23, -1.89, 15.41, 0.00 -24, -1.09, 9.05, 0.00 -25, -0.31, 2.56, 0.00 -26, 0.57, -4.88, 0.00 -27, 1.43, -12.39, 0.00 -28, 2.29, -20.08, 0.00 -29, 3.06, -27.24, 0.00 -30, 3.89, -35.25, 0.00 -31, 4.75, -43.77, 0.00 -32, 5.63, -52.86, 0.00 -33, 6.43, -61.46, 0.00 -34, 7.32, -71.39, 0.00 -35, 8.22, -81.78, 0.00 -36, 9.08, -92.31, 0.00 -37, 9.89, -102.78, 0.00 -38, 10.69, -113.72, 0.00 -39, 11.47, -125.13, 0.00 -40, 12.18, -136.48, 0.00 -41, 12.94, -149.09, 0.00 -42, 13.63, -161.87, 0.00 -43, 14.33, -175.75, 0.00 -44, 14.84, -188.45, 0.00 -45, 15.37, -202.73, 0.00 -46, 15.64, -214.91, 0.00 -47, 16.02, -230.07, 0.00 -48, 16.07, -242.38, 0.00 -49, 16.04, -255.31, 0.00 -50, 15.75, -266.07, 0.00 -51, 15.41, -278.35, 0.00 -52, 14.99, -291.85, 0.00 -53, 14.69, -311.51, 0.00 -54, 14.03, -328.05, 0.00 -55, 13.22, -346.63, 0.00 -56, 11.58, -347.88, 0.00 -57, 9.48, -336.06, 0.00 -58, 7.63, -333.70, 0.00 -59, 6.69, -387.45, 0.00 -60, 5.25, -460.90, 0.00 -61, 2.49, -475.82, 0.00 -62, -0.58, -468.44, 0.00 -63, -3.64, -454.65, 0.00 -64, -6.73, -444.52, 0.00 -65, -9.62, -425.48, 0.00 -66, -12.57, -412.95, 0.00 -67, -15.42, -398.58, 0.00 -68, -18.20, -384.41, 0.00 -69, -20.74, -367.51, 0.00 -70, -23.30, -352.80, 0.00 -71, -25.57, -335.76, 0.00 -72, -27.15, -312.68, 0.00 -73, -28.23, -287.64, 0.00 -74, -30.47, -276.68, 0.00 -75, -32.56, -264.93, 0.00 -76, -32.95, -241.41, 0.00 -77, -33.96, -224.77, 0.00 -78, -35.35, -211.94, 0.00 -79, -35.57, -193.60, 0.00 -80, -33.74, -166.92, 0.00 -81, -37.96, -170.78, 0.00 -82, -35.41, -144.86, 0.00 -83, -35.53, -132.10, 0.00 -84, -30.07, -101.42, 0.00 -85, -26.51, -80.93, 0.00 -86, -20.60, -56.73, 0.00 -87, -16.53, -40.87, 0.00 -88, -10.32, -22.78, 0.00 -89, -1.78, -3.49, 0.00 -90, 5.56, 9.54, 0.00 -91, 13.08, 19.45, 0.00 -92, 20.82, 26.37, 0.00 -93, 41.34, 43.59, 0.00 -94, 56.70, 48.17, 0.00 -95, 86.67, 56.45, 0.00 -96, 94.24, 43.20, 0.00 -97, 124.52, 33.70, 0.00 -98, 95.89, 12.87, 0.00 -99, 56.96, -0.00, 0.00 -100, 87.55, -11.75, 0.00 -101, 76.99, -20.84, 0.00 -102, 46.64, -21.38, 0.00 -103, 27.47, -17.89, 0.00 -104, 9.68, -8.22, 0.00 -105, -19.36, 20.42, 0.00 -106, -24.54, 31.07, 0.00 -107, -36.12, 53.70, 0.00 -108, -39.92, 68.49, 0.00 -109, -46.04, 90.04, 0.00 -110, -50.48, 111.42, 0.00 -111, -53.58, 132.47, 0.00 -112, -55.98, 154.13, 0.00 -113, -58.11, 177.39, 0.00 -114, -61.20, 206.40, 0.00 -115, -62.47, 232.26, 0.00 -116, -62.39, 255.28, 0.00 -117, -62.07, 279.29, 0.00 -118, -61.73, 305.38, 0.00 -119, -60.90, 331.50, 0.00 -120, -59.52, 356.86, 0.00 -121, -57.20, 378.58, 0.00 -122, -54.90, 402.16, 0.00 -123, -52.07, 423.70, 0.00 -124, -49.20, 446.69, 0.00 -125, -45.88, 467.53, 0.00 -126, -42.63, 490.92, 0.00 -127, -39.04, 512.69, 0.00 -128, -35.26, 534.03, 0.00 -129, -31.36, 555.63, 0.00 -130, -27.27, 576.05, 0.00 -131, -23.01, 594.86, 0.00 -132, -18.68, 613.47, 0.00 -133, -14.28, 631.83, 0.00 -134, -9.82, 648.99, 0.00 -135, -5.33, 665.19, 0.00 -136, -0.84, 680.91, 0.00 -137, 3.65, 697.90, 0.00 -138, 8.11, 711.95, 0.00 -139, 12.54, 725.96, 0.00 -140, 16.89, 738.46, 0.00 -141, 21.14, 749.55, 0.00 -142, 25.30, 759.68, 0.00 -143, 29.32, 768.68, 0.00 -144, 33.23, 776.92, 0.00 -145, 37.07, 785.93, 0.00 -146, 40.69, 791.99, 0.00 -147, 44.12, 796.75, 0.00 -148, 47.39, 800.59, 0.00 -149, 50.60, 805.39, 0.00 -150, 53.53, 807.33, 0.00 -151, 56.24, 807.80, 0.00 -152, 58.72, 806.69, 0.00 -153, 61.82, 815.20, 0.00 -154, 64.19, 815.25, 0.00 -155, 67.21, 824.40, 0.00 -156, 71.43, 848.24, 0.00 -157, 39.92, 460.00, 0.00 -158, 4.29, 48.09, 0.00 -159, 17.77, 193.92, 0.00 -160, 21.23, 225.97, 0.00 -161, 10.74, 111.65, 0.00 -162, 9.33, 94.79, 0.00 -163, 6.98, 69.42, 0.00 -164, 6.08, 59.32, 0.00 -165, 4.35, 41.60, 0.00 -166, 3.64, 34.13, 0.00 -167, 2.62, 24.13, 0.00 -168, 1.95, 17.64, 0.00 -169, 1.16, 10.32, 0.00 -170, 0.46, 4.05, 0.00 -171, -0.36, -3.14, 0.00 -172, -1.08, -9.18, 0.00 -173, -1.74, -14.63, 0.00 -174, -2.38, -19.72, 0.00 -175, -3.04, -24.84, 0.00 -176, -3.71, -29.86, 0.00 -177, -4.30, -34.19, 0.00 -178, -4.90, -38.47, 0.00 -179, -5.43, -42.17, 0.00 -180, -5.99, -46.01, 0.00 -181, -6.42, -48.81, 0.00 -182, -6.86, -51.59, 0.00 -183, -7.19, -53.60, 0.00 -184, -7.54, -55.68, 0.00 -185, -7.71, -56.39, 0.00 -186, -7.94, -57.63, 0.00 -187, -7.98, -57.50, 0.00 -188, -8.00, -57.19, 0.00 -189, -7.94, -56.41, 0.00 -190, -7.77, -54.88, 0.00 -191, -7.47, -52.50, 0.00 -192, -7.09, -49.57, 0.00 -193, -6.59, -45.88, 0.00 -194, -6.01, -41.72, 0.00 -195, -5.29, -36.63, 0.00 -196, -4.48, -30.94, 0.00 -197, -3.58, -24.65, 0.00 -198, -2.49, -17.12, 0.00 +199, -0.88, -0.00, 0.00 +0, -2.74, 18.87, 0.00 +1, -4.00, 27.56, 0.00 +2, -4.94, 34.10, 0.00 +3, -5.93, 41.01, 0.00 +4, -6.68, 46.33, 0.00 +5, -7.33, 51.03, 0.00 +6, -7.86, 54.95, 0.00 +7, -8.30, 58.28, 0.00 +8, -8.60, 60.75, 0.00 +9, -8.85, 62.89, 0.00 +10, -8.96, 64.06, 0.00 +11, -9.01, 64.88, 0.00 +12, -8.93, 64.80, 0.00 +13, -8.77, 64.14, 0.00 +14, -8.51, 62.83, 0.00 +15, -8.19, 61.03, 0.00 +16, -7.81, 58.73, 0.00 +17, -7.52, 57.17, 0.00 +18, -6.97, 53.51, 0.00 +19, -6.23, 48.37, 0.00 +20, -5.59, 43.91, 0.00 +21, -4.89, 38.89, 0.00 +22, -4.16, 33.52, 0.00 +23, -3.27, 26.73, 0.00 +24, -2.44, 20.19, 0.00 +25, -1.23, 10.28, 0.00 +26, -0.37, 3.17, 0.00 +27, 0.97, -8.37, 0.00 +28, 1.86, -16.27, 0.00 +29, 3.20, -28.55, 0.00 +30, 3.94, -35.67, 0.00 +31, 5.22, -48.09, 0.00 +32, 6.02, -56.52, 0.00 +33, 7.59, -72.59, 0.00 +34, 8.24, -80.30, 0.00 +35, 9.39, -93.40, 0.00 +36, 9.92, -100.86, 0.00 +37, 10.54, -109.58, 0.00 +38, 11.01, -117.21, 0.00 +39, 10.95, -119.48, 0.00 +40, 11.48, -128.65, 0.00 +41, 10.97, -126.35, 0.00 +42, 11.91, -141.43, 0.00 +43, 12.30, -150.90, 0.00 +44, 13.37, -169.77, 0.00 +45, 14.68, -193.53, 0.00 +46, 15.80, -217.03, 0.00 +47, 19.25, -276.51, 0.00 +48, 19.53, -294.59, 0.00 +49, 22.26, -354.30, 0.00 +50, 20.96, -354.19, 0.00 +51, 20.16, -364.14, 0.00 +52, 18.40, -358.18, 0.00 +53, 16.69, -353.80, 0.00 +54, 15.07, -352.32, 0.00 +55, 12.98, -340.39, 0.00 +56, 11.19, -336.20, 0.00 +57, 8.60, -304.96, 0.00 +58, 7.16, -313.01, 0.00 +59, 6.01, -347.70, 0.00 +60, 4.70, -412.79, 0.00 +61, 2.33, -445.52, 0.00 +62, -0.55, -443.29, 0.00 +63, -3.42, -427.14, 0.00 +64, -6.31, -417.03, 0.00 +65, -8.94, -395.68, 0.00 +66, -11.64, -382.49, 0.00 +67, -14.13, -365.39, 0.00 +68, -16.51, -348.88, 0.00 +69, -18.69, -331.14, 0.00 +70, -20.72, -313.74, 0.00 +71, -22.32, -293.09, 0.00 +72, -23.72, -273.12, 0.00 +73, -24.63, -251.02, 0.00 +74, -25.83, -234.51, 0.00 +75, -26.33, -214.23, 0.00 +76, -26.92, -197.22, 0.00 +77, -26.80, -177.38, 0.00 +78, -26.94, -161.54, 0.00 +79, -26.13, -142.24, 0.00 +80, -25.19, -124.64, 0.00 +81, -22.82, -102.67, 0.00 +82, -21.57, -88.23, 0.00 +83, -19.26, -71.61, 0.00 +84, -17.97, -60.61, 0.00 +85, -15.93, -48.61, 0.00 +86, -12.97, -35.71, 0.00 +87, -8.42, -20.82, 0.00 +88, -5.98, -13.21, 0.00 +89, -8.03, -15.71, 0.00 +90, 4.80, 8.23, 0.00 +91, 4.36, 6.47, 0.00 +92, 11.84, 14.99, 0.00 +93, 0.32, 0.34, 0.00 +94, 11.38, 9.67, 0.00 +95, 45.23, 29.46, 0.00 +96, 48.26, 22.12, 0.00 +97, -197.68, -53.50, 0.00 +98, -125.90, -16.89, 0.00 +99, 14.92, -0.00, 0.00 +100, 79.73, -10.70, 0.00 +101, 186.44, -50.46, 0.00 +102, 187.22, -85.81, 0.00 +103, 135.06, -87.97, 0.00 +104, 119.91, -101.86, 0.00 +105, 79.10, -83.40, 0.00 +106, 59.63, -75.52, 0.00 +107, 30.90, -45.94, 0.00 +108, 22.56, -38.71, 0.00 +109, -4.56, 8.92, 0.00 +110, -9.71, 21.43, 0.00 +111, -21.99, 54.38, 0.00 +112, -24.51, 67.48, 0.00 +113, -34.81, 106.26, 0.00 +114, -39.06, 131.73, 0.00 +115, -43.87, 163.08, 0.00 +116, -44.80, 183.28, 0.00 +117, -47.81, 215.10, 0.00 +118, -48.21, 238.52, 0.00 +119, -49.89, 271.53, 0.00 +120, -49.93, 299.38, 0.00 +121, -49.00, 324.32, 0.00 +122, -47.34, 346.82, 0.00 +123, -45.93, 373.77, 0.00 +124, -43.73, 397.06, 0.00 +125, -41.62, 424.09, 0.00 +126, -38.87, 447.69, 0.00 +127, -36.04, 473.29, 0.00 +128, -32.71, 495.38, 0.00 +129, -29.18, 517.04, 0.00 +130, -25.50, 538.64, 0.00 +131, -21.67, 560.11, 0.00 +132, -17.65, 579.80, 0.00 +133, -13.60, 601.56, 0.00 +134, -9.38, 619.71, 0.00 +135, -5.13, 640.08, 0.00 +136, -0.81, 656.70, 0.00 +137, 3.53, 674.34, 0.00 +138, 7.85, 688.58, 0.00 +139, 12.18, 704.99, 0.00 +140, 16.41, 717.64, 0.00 +141, 20.57, 729.02, 0.00 +142, 24.63, 739.65, 0.00 +143, 28.56, 748.77, 0.00 +144, 32.40, 757.51, 0.00 +145, 36.12, 765.59, 0.00 +146, 39.66, 772.06, 0.00 +147, 43.13, 778.88, 0.00 +148, 46.36, 783.25, 0.00 +149, 49.60, 789.39, 0.00 +150, 52.48, 791.53, 0.00 +151, 55.47, 796.64, 0.00 +152, 57.83, 794.45, 0.00 +153, 57.34, 756.10, 0.00 +154, 59.99, 761.83, 0.00 +155, 69.07, 847.19, 0.00 +156, 69.33, 823.32, 0.00 +157, 53.10, 611.85, 0.00 +158, 40.29, 451.37, 0.00 +159, 43.59, 475.55, 0.00 +160, 49.17, 523.27, 0.00 +161, 18.54, 192.66, 0.00 +162, 14.94, 151.89, 0.00 +163, 8.48, 84.34, 0.00 +164, 7.58, 73.94, 0.00 +165, 3.72, 35.56, 0.00 +166, 2.83, 26.52, 0.00 +167, 1.26, 11.65, 0.00 +168, 0.55, 5.03, 0.00 +169, -0.64, -5.72, 0.00 +170, -1.47, -12.88, 0.00 +171, -2.41, -20.82, 0.00 +172, -3.12, -26.59, 0.00 +173, -3.82, -32.02, 0.00 +174, -4.48, -37.03, 0.00 +175, -5.61, -45.76, 0.00 +176, -6.31, -50.81, 0.00 +177, -6.84, -54.39, 0.00 +178, -7.42, -58.32, 0.00 +179, -7.79, -60.51, 0.00 +180, -8.26, -63.45, 0.00 +181, -8.73, -66.31, 0.00 +182, -9.08, -68.30, 0.00 +183, -9.46, -70.51, 0.00 +184, -9.69, -71.54, 0.00 +185, -9.74, -71.24, 0.00 +186, -9.78, -70.95, 0.00 +187, -9.85, -70.97, 0.00 +188, -9.79, -70.04, 0.00 +189, -9.43, -66.99, 0.00 +190, -9.12, -64.44, 0.00 +191, -8.61, -60.49, 0.00 +192, -8.09, -56.58, 0.00 +193, -7.41, -51.57, 0.00 +194, -6.72, -46.59, 0.00 +195, -5.79, -40.06, 0.00 +196, -4.88, -33.67, 0.00 +197, -3.73, -25.71, 0.00 +198, -2.60, -17.88, 0.00 diff --git a/TestCases/py_wrapper/updated_moving_frame_NACA12/config.cfg b/TestCases/py_wrapper/updated_moving_frame_NACA12/config.cfg index 5806f25e7d0..053828f96eb 100644 --- a/TestCases/py_wrapper/updated_moving_frame_NACA12/config.cfg +++ b/TestCases/py_wrapper/updated_moving_frame_NACA12/config.cfg @@ -9,7 +9,7 @@ RESTART_SOL= NO % % We are translating the domain instead of having farfield velocity. % 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 +% 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 @@ -50,13 +50,13 @@ VENKAT_LIMITER_COEFF= 0.1 % SOLUTION ACCELERATION % -CFL_NUMBER= 100 +CFL_NUMBER= 50 CFL_ADAPT= NO % MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 1, 1, 1, 1 ) +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) MG_DAMP_RESTRICTION= 0.5 MG_DAMP_PROLONGATION= 0.5 @@ -64,7 +64,7 @@ MG_DAMP_PROLONGATION= 0.5 LINEAR_SOLVER= FGMRES LINEAR_SOLVER_PREC= ILU LINEAR_SOLVER_ERROR= 0.1 -LINEAR_SOLVER_ITER= 10 +LINEAR_SOLVER_ITER= 3 % CONVERGENCE PARAMETERS % diff --git a/TestCases/py_wrapper/updated_moving_frame_NACA12/forces_0.csv.ref b/TestCases/py_wrapper/updated_moving_frame_NACA12/forces_0.csv.ref index 4e95fa24a0e..1e7ab436b72 100644 --- a/TestCases/py_wrapper/updated_moving_frame_NACA12/forces_0.csv.ref +++ b/TestCases/py_wrapper/updated_moving_frame_NACA12/forces_0.csv.ref @@ -1,200 +1,200 @@ -199, -0.86, -0.00, 0.00 -0, -2.63, 18.11, 0.00 -1, -3.63, 25.00, 0.00 -2, -4.49, 31.01, 0.00 -3, -5.27, 36.45, 0.00 -4, -5.94, 41.20, 0.00 -5, -6.49, 45.19, 0.00 -6, -6.94, 48.51, 0.00 -7, -7.30, 51.25, 0.00 -8, -7.53, 53.19, 0.00 -9, -7.69, 54.61, 0.00 -10, -7.73, 55.29, 0.00 -11, -7.72, 55.60, 0.00 -12, -7.59, 55.07, 0.00 -13, -7.40, 54.17, 0.00 -14, -7.11, 52.49, 0.00 -15, -6.79, 50.55, 0.00 -16, -6.37, 47.90, 0.00 -17, -5.91, 44.92, 0.00 -18, -5.36, 41.14, 0.00 -19, -4.80, 37.28, 0.00 -20, -4.15, 32.62, 0.00 -21, -3.50, 27.86, 0.00 -22, -2.78, 22.37, 0.00 -23, -2.06, 16.81, 0.00 -24, -1.27, 10.52, 0.00 -25, -0.50, 4.21, 0.00 -26, 0.33, -2.80, 0.00 -27, 1.15, -9.97, 0.00 -28, 2.04, -17.86, 0.00 -29, 2.85, -25.42, 0.00 -30, 3.69, -33.44, 0.00 -31, 4.48, -41.33, 0.00 -32, 5.36, -50.31, 0.00 -33, 6.18, -59.06, 0.00 -34, 7.05, -68.72, 0.00 -35, 7.84, -78.03, 0.00 -36, 8.69, -88.33, 0.00 -37, 9.43, -98.01, 0.00 -38, 10.23, -108.84, 0.00 -39, 10.92, -119.14, 0.00 -40, 11.63, -130.32, 0.00 -41, 12.28, -141.50, 0.00 -42, 12.91, -153.33, 0.00 -43, 13.43, -164.72, 0.00 -44, 13.81, -175.34, 0.00 -45, 14.01, -184.69, 0.00 -46, 14.17, -194.64, 0.00 -47, 14.35, -206.11, 0.00 -48, 14.35, -216.45, 0.00 -49, 14.66, -233.35, 0.00 -50, 14.44, -243.91, 0.00 -51, 13.23, -239.01, 0.00 -52, 9.28, -180.73, 0.00 -53, 10.93, -231.67, 0.00 -54, 22.42, -524.14, 0.00 -55, 23.41, -613.61, 0.00 -56, 19.80, -594.50, 0.00 -57, 16.27, -576.89, 0.00 -58, 13.02, -569.14, 0.00 -59, 9.66, -559.58, 0.00 -60, 6.26, -549.57, 0.00 -61, 2.81, -536.89, 0.00 -62, -0.65, -524.68, 0.00 -63, -4.08, -509.47, 0.00 -64, -7.50, -495.51, 0.00 -65, -10.82, -478.63, 0.00 -66, -14.09, -462.77, 0.00 -67, -17.20, -444.59, 0.00 -68, -20.22, -427.15, 0.00 -69, -22.98, -407.10, 0.00 -70, -25.67, -388.75, 0.00 -71, -27.98, -367.48, 0.00 -72, -30.23, -348.11, 0.00 -73, -31.93, -325.35, 0.00 -74, -33.71, -306.06, 0.00 -75, -34.92, -284.17, 0.00 -76, -36.03, -263.97, 0.00 -77, -36.59, -242.17, 0.00 -78, -37.19, -222.97, 0.00 -79, -36.76, -200.07, 0.00 -80, -36.54, -180.76, 0.00 -81, -35.69, -160.58, 0.00 -82, -34.73, -142.08, 0.00 -83, -32.59, -121.17, 0.00 -84, -30.29, -102.16, 0.00 -85, -26.60, -81.19, 0.00 -86, -22.96, -63.22, 0.00 -87, -15.77, -38.98, 0.00 -88, -10.68, -23.57, 0.00 -89, -2.62, -5.11, 0.00 -90, 2.96, 5.08, 0.00 -91, 10.30, 15.31, 0.00 -92, 19.77, 25.04, 0.00 -93, 17.81, 18.78, 0.00 -94, 23.65, 20.09, 0.00 -95, 12.09, 7.87, 0.00 -96, 11.10, 5.09, 0.00 -97, 33.12, 8.96, 0.00 -98, 30.07, 4.03, 0.00 -99, 6.42, -0.00, 0.00 -100, 26.15, -3.51, 0.00 -101, 36.45, -9.86, 0.00 -102, 30.00, -13.75, 0.00 -103, 31.67, -20.63, 0.00 -104, 13.92, -11.83, 0.00 -105, 11.86, -12.50, 0.00 -106, -3.05, 3.86, 0.00 -107, -9.48, 14.09, 0.00 -108, -15.43, 26.47, 0.00 -109, -23.77, 46.48, 0.00 -110, -29.37, 64.83, 0.00 -111, -36.14, 89.36, 0.00 -112, -39.14, 107.77, 0.00 -113, -43.76, 133.57, 0.00 -114, -46.73, 157.62, 0.00 -115, -48.66, 180.91, 0.00 -116, -49.42, 202.21, 0.00 -117, -50.43, 226.88, 0.00 -118, -50.47, 249.70, 0.00 -119, -50.38, 274.24, 0.00 -120, -49.39, 296.15, 0.00 -121, -48.36, 320.09, 0.00 -122, -46.69, 342.06, 0.00 -123, -44.98, 365.99, 0.00 -124, -42.69, 387.65, 0.00 -125, -40.38, 411.42, 0.00 -126, -37.70, 434.15, 0.00 -127, -34.80, 457.05, 0.00 -128, -31.59, 478.33, 0.00 -129, -28.21, 499.82, 0.00 -130, -24.60, 519.72, 0.00 -131, -20.90, 540.34, 0.00 -132, -17.01, 558.78, 0.00 -133, -13.08, 578.82, 0.00 -134, -9.02, 595.64, 0.00 -135, -4.92, 613.62, 0.00 -136, -0.78, 629.39, 0.00 -137, 3.38, 645.30, 0.00 -138, 7.51, 658.91, 0.00 -139, 11.63, 673.17, 0.00 -140, 15.67, 685.03, 0.00 -141, 19.64, 696.34, 0.00 -142, 23.51, 705.94, 0.00 -143, 27.29, 715.50, 0.00 -144, 30.93, 723.09, 0.00 -145, 34.51, 731.63, 0.00 -146, 37.87, 737.15, 0.00 -147, 41.12, 742.64, 0.00 -148, 44.13, 745.57, 0.00 -149, 47.11, 749.74, 0.00 -150, 49.67, 749.17, 0.00 -151, 52.81, 758.54, 0.00 -152, 56.11, 770.82, 0.00 -153, 31.65, 417.42, 0.00 -154, 3.15, 40.06, 0.00 -155, 10.66, 130.75, 0.00 -156, 12.98, 154.17, 0.00 -157, 9.56, 110.13, 0.00 -158, 8.57, 96.03, 0.00 -159, 7.81, 85.17, 0.00 -160, 7.42, 78.98, 0.00 -161, 6.93, 72.03, 0.00 -162, 6.41, 65.19, 0.00 -163, 5.87, 58.43, 0.00 -164, 5.27, 51.40, 0.00 -165, 4.67, 44.62, 0.00 -166, 3.99, 37.44, 0.00 -167, 3.31, 30.56, 0.00 -168, 2.58, 23.38, 0.00 -169, 1.85, 16.52, 0.00 -170, 1.09, 9.54, 0.00 -171, 0.38, 3.32, 0.00 -172, -0.36, -3.08, 0.00 -173, -1.06, -8.86, 0.00 -174, -1.80, -14.86, 0.00 -175, -2.49, -20.35, 0.00 -176, -3.20, -25.78, 0.00 -177, -3.83, -30.43, 0.00 -178, -4.46, -35.04, 0.00 -179, -5.01, -38.95, 0.00 -180, -5.56, -42.75, 0.00 -181, -6.03, -45.86, 0.00 -182, -6.49, -48.84, 0.00 -183, -6.85, -51.00, 0.00 -184, -7.19, -53.04, 0.00 -185, -7.40, -54.18, 0.00 -186, -7.60, -55.14, 0.00 -187, -7.66, -55.16, 0.00 -188, -7.69, -54.99, 0.00 -189, -7.63, -54.19, 0.00 -190, -7.48, -52.85, 0.00 -191, -7.21, -50.64, 0.00 -192, -6.86, -47.97, 0.00 -193, -6.39, -44.48, 0.00 -194, -5.85, -40.57, 0.00 -195, -5.16, -35.70, 0.00 -196, -4.39, -30.33, 0.00 -197, -3.53, -24.31, 0.00 -198, -2.53, -17.43, 0.00 +199, -0.92, -0.00, 0.00 +0, -2.82, 19.44, 0.00 +1, -3.96, 27.26, 0.00 +2, -4.94, 34.13, 0.00 +3, -5.83, 40.30, 0.00 +4, -6.56, 45.50, 0.00 +5, -7.20, 50.13, 0.00 +6, -7.69, 53.74, 0.00 +7, -8.11, 56.96, 0.00 +8, -8.36, 59.03, 0.00 +9, -8.58, 60.93, 0.00 +10, -8.62, 61.61, 0.00 +11, -8.64, 62.26, 0.00 +12, -8.50, 61.68, 0.00 +13, -8.38, 61.34, 0.00 +14, -8.07, 59.56, 0.00 +15, -7.78, 57.97, 0.00 +16, -7.34, 55.18, 0.00 +17, -6.93, 52.67, 0.00 +18, -6.35, 48.76, 0.00 +19, -5.80, 45.05, 0.00 +20, -5.13, 40.31, 0.00 +21, -4.50, 35.79, 0.00 +22, -3.74, 30.16, 0.00 +23, -2.98, 24.34, 0.00 +24, -2.17, 17.93, 0.00 +25, -1.32, 11.04, 0.00 +26, -0.49, 4.21, 0.00 +27, 0.41, -3.51, 0.00 +28, 1.27, -11.10, 0.00 +29, 2.10, -18.72, 0.00 +30, 2.92, -26.44, 0.00 +31, 3.77, -34.73, 0.00 +32, 4.60, -43.16, 0.00 +33, 5.42, -51.86, 0.00 +34, 6.20, -60.46, 0.00 +35, 6.96, -69.21, 0.00 +36, 7.70, -78.27, 0.00 +37, 8.36, -86.87, 0.00 +38, 9.02, -96.02, 0.00 +39, 9.56, -104.28, 0.00 +40, 10.12, -113.40, 0.00 +41, 10.55, -121.56, 0.00 +42, 10.95, -130.05, 0.00 +43, 11.05, -135.56, 0.00 +44, 11.34, -144.01, 0.00 +45, 11.40, -150.32, 0.00 +46, 11.65, -160.10, 0.00 +47, 12.24, -175.82, 0.00 +48, 11.59, -174.80, 0.00 +49, 10.49, -166.97, 0.00 +50, 8.68, -146.70, 0.00 +51, 4.59, -82.88, 0.00 +52, 7.31, -142.21, 0.00 +53, 21.25, -450.45, 0.00 +54, 25.14, -587.71, 0.00 +55, 21.48, -563.18, 0.00 +56, 17.96, -539.23, 0.00 +57, 15.76, -558.72, 0.00 +58, 12.71, -555.72, 0.00 +59, 9.40, -544.46, 0.00 +60, 6.08, -533.76, 0.00 +61, 2.72, -520.75, 0.00 +62, -0.63, -508.27, 0.00 +63, -3.95, -492.77, 0.00 +64, -7.24, -478.52, 0.00 +65, -10.39, -459.48, 0.00 +66, -13.50, -443.36, 0.00 +67, -16.41, -424.23, 0.00 +68, -19.24, -406.47, 0.00 +69, -21.77, -385.65, 0.00 +70, -24.22, -366.85, 0.00 +71, -26.21, -344.18, 0.00 +72, -28.12, -323.80, 0.00 +73, -29.28, -298.39, 0.00 +74, -30.70, -278.72, 0.00 +75, -31.20, -253.86, 0.00 +76, -31.79, -232.87, 0.00 +77, -31.78, -210.36, 0.00 +78, -31.81, -190.72, 0.00 +79, -29.96, -163.09, 0.00 +80, -28.81, -142.51, 0.00 +81, -25.70, -115.63, 0.00 +82, -23.36, -95.56, 0.00 +83, -17.92, -66.64, 0.00 +84, -15.19, -51.24, 0.00 +85, -4.65, -14.18, 0.00 +86, -0.26, -0.71, 0.00 +87, 9.41, 23.25, 0.00 +88, 14.47, 31.93, 0.00 +89, 23.43, 45.83, 0.00 +90, 37.69, 64.67, 0.00 +91, 42.67, 63.43, 0.00 +92, 56.09, 71.03, 0.00 +93, 53.23, 56.12, 0.00 +94, 77.35, 65.70, 0.00 +95, 42.42, 27.63, 0.00 +96, 10.74, 4.92, 0.00 +97, 47.56, 12.87, 0.00 +98, 75.03, 10.07, 0.00 +99, 0.36, -0.00, 0.00 +100, 97.48, -13.08, 0.00 +101, 172.16, -46.60, 0.00 +102, 148.56, -68.09, 0.00 +103, 130.04, -84.70, 0.00 +104, 110.88, -94.19, 0.00 +105, 98.92, -104.31, 0.00 +106, 84.16, -106.58, 0.00 +107, 53.49, -79.51, 0.00 +108, 45.94, -78.83, 0.00 +109, 17.03, -33.31, 0.00 +110, 11.56, -25.52, 0.00 +111, -7.53, 18.62, 0.00 +112, -14.11, 38.85, 0.00 +113, -26.43, 80.67, 0.00 +114, -31.15, 105.06, 0.00 +115, -36.24, 134.73, 0.00 +116, -38.44, 157.29, 0.00 +117, -41.50, 186.70, 0.00 +118, -42.29, 209.23, 0.00 +119, -43.71, 237.89, 0.00 +120, -43.36, 259.97, 0.00 +121, -43.38, 287.09, 0.00 +122, -42.21, 309.23, 0.00 +123, -41.30, 336.04, 0.00 +124, -39.47, 358.43, 0.00 +125, -37.83, 385.46, 0.00 +126, -35.45, 408.28, 0.00 +127, -32.92, 432.34, 0.00 +128, -29.95, 453.52, 0.00 +129, -26.87, 476.13, 0.00 +130, -23.51, 496.73, 0.00 +131, -20.04, 517.96, 0.00 +132, -16.35, 536.89, 0.00 +133, -12.60, 557.35, 0.00 +134, -8.70, 574.79, 0.00 +135, -4.75, 592.92, 0.00 +136, -0.75, 609.08, 0.00 +137, 3.27, 625.75, 0.00 +138, 7.29, 639.56, 0.00 +139, 11.30, 654.52, 0.00 +140, 15.25, 666.62, 0.00 +141, 19.14, 678.33, 0.00 +142, 22.92, 688.27, 0.00 +143, 26.63, 698.04, 0.00 +144, 30.19, 705.88, 0.00 +145, 33.68, 713.98, 0.00 +146, 36.96, 719.54, 0.00 +147, 40.03, 723.00, 0.00 +148, 42.96, 725.82, 0.00 +149, 45.50, 724.25, 0.00 +150, 48.43, 730.47, 0.00 +151, 51.10, 733.97, 0.00 +152, 53.48, 734.72, 0.00 +153, 39.59, 522.09, 0.00 +154, -0.60, -7.66, 0.00 +155, -3.05, -37.45, 0.00 +156, 5.42, 64.40, 0.00 +157, 6.68, 76.94, 0.00 +158, 6.61, 74.08, 0.00 +159, 5.30, 57.82, 0.00 +160, 5.37, 57.13, 0.00 +161, 4.93, 51.25, 0.00 +162, 4.64, 47.15, 0.00 +163, 4.21, 41.93, 0.00 +164, 3.81, 37.17, 0.00 +165, 3.32, 31.75, 0.00 +166, 2.81, 26.41, 0.00 +167, 2.22, 20.44, 0.00 +168, 1.62, 14.65, 0.00 +169, 0.93, 8.33, 0.00 +170, 0.25, 2.23, 0.00 +171, -0.51, -4.42, 0.00 +172, -1.24, -10.52, 0.00 +173, -1.95, -16.35, 0.00 +174, -2.66, -22.04, 0.00 +175, -3.38, -27.60, 0.00 +176, -4.10, -33.06, 0.00 +177, -4.70, -37.37, 0.00 +178, -5.35, -42.05, 0.00 +179, -5.86, -45.51, 0.00 +180, -6.43, -49.40, 0.00 +181, -6.84, -51.98, 0.00 +182, -7.31, -55.02, 0.00 +183, -7.65, -57.00, 0.00 +184, -8.01, -59.13, 0.00 +185, -8.18, -59.86, 0.00 +186, -8.41, -61.04, 0.00 +187, -8.44, -60.78, 0.00 +188, -8.49, -60.71, 0.00 +189, -8.38, -59.56, 0.00 +190, -8.23, -58.15, 0.00 +191, -7.93, -55.68, 0.00 +192, -7.56, -52.84, 0.00 +193, -7.02, -48.89, 0.00 +194, -6.43, -44.64, 0.00 +195, -5.67, -39.23, 0.00 +196, -4.82, -33.30, 0.00 +197, -3.83, -26.41, 0.00 +198, -2.73, -18.78, 0.00 diff --git a/TestCases/rans/flatplate/turb_SA_flatplate.cfg b/TestCases/rans/flatplate/turb_SA_flatplate.cfg index c90b5c2bef3..36d65f3b089 100644 --- a/TestCases/rans/flatplate/turb_SA_flatplate.cfg +++ b/TestCases/rans/flatplate/turb_SA_flatplate.cfg @@ -45,7 +45,7 @@ MARKER_MONITORING= ( wall ) % ------------- COMMON PARAMETERS DEFINING THE NUMERICAL METHOD ---------------% % NUM_METHOD_GRAD= GREEN_GAUSS -CFL_NUMBER= 10.0 +CFL_NUMBER= 100.0 CFL_ADAPT= NO CFL_ADAPT_PARAM= ( 1.5, 0.5, 1.0, 100.0 ) RK_ALPHA_COEFF= ( 0.66667, 0.66667, 1.000000 ) @@ -62,11 +62,11 @@ SENS_REMOVE_SHARP= NO % MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 2, 2, 2, 2) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 0.8 -MG_DAMP_PROLONGATION= 0.8 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/rans/flatplate/turb_SA_flatplate_species.cfg b/TestCases/rans/flatplate/turb_SA_flatplate_species.cfg index c364ddd07ac..d0bb2dfb7cd 100644 --- a/TestCases/rans/flatplate/turb_SA_flatplate_species.cfg +++ b/TestCases/rans/flatplate/turb_SA_flatplate_species.cfg @@ -42,7 +42,7 @@ MOLECULAR_WEIGHT= 28.960 SPECIFIC_HEAT_CP = 1009.39 % CONDUCTIVITY_MODEL= CONSTANT_CONDUCTIVITY -THERMAL_CONDUCTIVITY_CONSTANT= 0.0258 +THERMAL_CONDUCTIVITY_CONSTANT= 0.0258 % PRANDTL_LAM= 0.72 TURBULENT_CONDUCTIVITY_MODEL= CONSTANT_PRANDTL_TURB @@ -78,7 +78,7 @@ SPECIES_CLIPPING_MAX= 1.0 % ------------- COMMON PARAMETERS DEFINING THE NUMERICAL METHOD ---------------% % NUM_METHOD_GRAD= GREEN_GAUSS -CFL_NUMBER= 10.0 +CFL_NUMBER= 100.0 CFL_ADAPT= NO CFL_ADAPT_PARAM= ( 1.5, 0.5, 1.0, 100.0 ) RK_ALPHA_COEFF= ( 0.66667, 0.66667, 1.000000 ) @@ -90,15 +90,22 @@ ADJ_SHARP_LIMITER_COEFF= 3.0 REF_SHARP_EDGES= 3.0 SENS_REMOVE_SHARP= NO +% ------------------------ LINEAR SOLVER DEFINITION ---------------------------% +% +LINEAR_SOLVER= FGMRES +LINEAR_SOLVER_PREC= LU_SGS +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 + % -------------------------- MULTIGRID PARAMETERS -----------------------------% % MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 2, 2, 2, 2) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 0.8 -MG_DAMP_PROLONGATION= 0.8 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/rans/flatplate/turb_SST_flatplate.cfg b/TestCases/rans/flatplate/turb_SST_flatplate.cfg index 0e3ee25f4e0..61446ecab7f 100644 --- a/TestCases/rans/flatplate/turb_SST_flatplate.cfg +++ b/TestCases/rans/flatplate/turb_SST_flatplate.cfg @@ -62,11 +62,11 @@ SENS_REMOVE_SHARP= NO % MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 2, 2, 2, 2) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 0.8 -MG_DAMP_PROLONGATION= 0.8 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/rans/naca0012/turb_NACA0012_sst_multigrid_restart.cfg b/TestCases/rans/naca0012/turb_NACA0012_sst_multigrid_restart.cfg index 7e22bf6979c..cc0b2636381 100644 --- a/TestCases/rans/naca0012/turb_NACA0012_sst_multigrid_restart.cfg +++ b/TestCases/rans/naca0012/turb_NACA0012_sst_multigrid_restart.cfg @@ -86,18 +86,18 @@ SENS_REMOVE_SHARP= NO % LINEAR_SOLVER= FGMRES LINEAR_SOLVER_PREC= LU_SGS -LINEAR_SOLVER_ERROR= 1E-6 -LINEAR_SOLVER_ITER= 5 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 1, 1, 1 ) -MG_POST_SMOOTH= ( 1, 1, 1, 1 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 0.8 -MG_DAMP_PROLONGATION= 0.8 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/rans/rae2822/turb_SA_RAE2822.cfg b/TestCases/rans/rae2822/turb_SA_RAE2822.cfg index 68071ae47da..36146c4ac32 100644 --- a/TestCases/rans/rae2822/turb_SA_RAE2822.cfg +++ b/TestCases/rans/rae2822/turb_SA_RAE2822.cfg @@ -41,23 +41,23 @@ MARKER_MONITORING= ( AIRFOIL ) % ------------- COMMON PARAMETERS DEFINING THE NUMERICAL METHOD ---------------% % NUM_METHOD_GRAD= WEIGHTED_LEAST_SQUARES -CFL_NUMBER= 2.5 +CFL_NUMBER= 10.0 CFL_ADAPT= NO CFL_ADAPT_PARAM= ( 1.5, 0.5, 1.0, 100.0 ) ITER= 99999 LINEAR_SOLVER= BCGSTAB -LINEAR_SOLVER_ERROR= 1E-6 -LINEAR_SOLVER_ITER= 20 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % MGLEVEL= 3 MGCYCLE= W_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 0.95 -MG_DAMP_PROLONGATION= 0.95 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/rans/rae2822/turb_SST_RAE2822.cfg b/TestCases/rans/rae2822/turb_SST_RAE2822.cfg index 097ebd6c42e..5614fc349e4 100644 --- a/TestCases/rans/rae2822/turb_SST_RAE2822.cfg +++ b/TestCases/rans/rae2822/turb_SST_RAE2822.cfg @@ -44,24 +44,24 @@ MARKER_MONITORING= ( AIRFOIL ) % ------------- COMMON PARAMETERS DEFINING THE NUMERICAL METHOD ---------------% % NUM_METHOD_GRAD= WEIGHTED_LEAST_SQUARES -CFL_NUMBER= 2.5 +CFL_NUMBER= 10.0 CFL_ADAPT= NO CFL_ADAPT_PARAM= ( 1.5, 0.5, 1.0, 100.0 ) ITER= 99999 LINEAR_SOLVER= FGMRES LINEAR_SOLVER_PREC= LU_SGS -LINEAR_SOLVER_ERROR= 1E-6 -LINEAR_SOLVER_ITER= 2 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % MGLEVEL= 3 MGCYCLE= W_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 0.95 -MG_DAMP_PROLONGATION= 0.95 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/rans/rae2822/turb_SST_SUST_RAE2822.cfg b/TestCases/rans/rae2822/turb_SST_SUST_RAE2822.cfg index db88f0e394e..d89be651429 100644 --- a/TestCases/rans/rae2822/turb_SST_SUST_RAE2822.cfg +++ b/TestCases/rans/rae2822/turb_SST_SUST_RAE2822.cfg @@ -45,24 +45,24 @@ MARKER_MONITORING= ( AIRFOIL ) % ------------- COMMON PARAMETERS DEFINING THE NUMERICAL METHOD ---------------% % NUM_METHOD_GRAD= WEIGHTED_LEAST_SQUARES -CFL_NUMBER= 2.5 +CFL_NUMBER= 10.0 CFL_ADAPT= NO CFL_ADAPT_PARAM= ( 1.5, 0.5, 1.0, 100.0 ) ITER= 99999 LINEAR_SOLVER= FGMRES LINEAR_SOLVER_PREC= LU_SGS -LINEAR_SOLVER_ERROR= 1E-6 -LINEAR_SOLVER_ITER= 2 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % MGLEVEL= 3 MGCYCLE= W_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 0.95 -MG_DAMP_PROLONGATION= 0.95 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/rotating/naca0012/rot_NACA0012.cfg b/TestCases/rotating/naca0012/rot_NACA0012.cfg index fec91316e14..8bce2a0fb30 100644 --- a/TestCases/rotating/naca0012/rot_NACA0012.cfg +++ b/TestCases/rotating/naca0012/rot_NACA0012.cfg @@ -52,7 +52,7 @@ MARKER_DESIGNING = ( airfoil ) % ------------- COMMON PARAMETERS TO DEFINE THE NUMERICAL METHOD --------------% % NUM_METHOD_GRAD= WEIGHTED_LEAST_SQUARES -CFL_NUMBER= 5 +CFL_NUMBER= 2.0 CFL_ADAPT= NO CFL_ADAPT_PARAM= ( 1.5, 0.5, 1.0, 100.0 ) RK_ALPHA_COEFF= ( 0.66667, 0.66667, 1.000000 ) @@ -63,15 +63,15 @@ ITER= 9999 LINEAR_SOLVER= FGMRES LINEAR_SOLVER_PREC= LU_SGS LINEAR_SOLVER_ERROR= 1E-1 -LINEAR_SOLVER_ITER= 5 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % MGLEVEL= 3 -MGCYCLE= W_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) +MGCYCLE= V_CYCLE +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) MG_DAMP_RESTRICTION= 0.5 % lower damping, to keep from fast oscillations in residuals MG_DAMP_PROLONGATION= 0.5 diff --git a/TestCases/serial_regression.py b/TestCases/serial_regression.py index ca83cca21ef..9d7c6b857b1 100755 --- a/TestCases/serial_regression.py +++ b/TestCases/serial_regression.py @@ -93,7 +93,7 @@ def main(): channel.cfg_dir = "euler/channel" channel.cfg_file = "inv_channel_RK.cfg" channel.test_iter = 10 - channel.test_vals = [-2.244274, 3.300113, 0.075814, 0.159961] + channel.test_vals = [-2.215160, 3.327978, 0.064048, 0.163516] test_list.append(channel) # NACA0012 @@ -101,7 +101,7 @@ def main(): naca0012.cfg_dir = "euler/naca0012" naca0012.cfg_file = "inv_NACA0012_Roe.cfg" naca0012.test_iter = 20 - naca0012.test_vals = [-4.968082, -4.396602, 0.331959, 0.023010] + naca0012.test_vals = [-4.256408, -3.795038, 0.306510, 0.024657] test_list.append(naca0012) # Supersonic wedge @@ -109,7 +109,7 @@ def main(): wedge.cfg_dir = "euler/wedge" wedge.cfg_file = "inv_wedge_HLLC.cfg" wedge.test_iter = 20 - wedge.test_vals = [-1.301825, 4.369535, -0.236575, 0.041741] + wedge.test_vals = [-3.609826, 2.113544, -0.249533, 0.043953] test_list.append(wedge) # ONERA M6 Wing @@ -117,7 +117,7 @@ def main(): oneram6.cfg_dir = "euler/oneram6" oneram6.cfg_file = "inv_ONERAM6.cfg" oneram6.test_iter = 10 - oneram6.test_vals = [-11.428634, -10.889247, 0.280800, 0.008623] + oneram6.test_vals = [-11.512881, -10.980703, 0.280800, 0.008623] oneram6.timeout = 9600 test_list.append(oneram6) @@ -126,7 +126,7 @@ def main(): fixedCL_naca0012.cfg_dir = "fixed_cl/naca0012" fixedCL_naca0012.cfg_file = "inv_NACA0012.cfg" fixedCL_naca0012.test_iter = 10 - fixedCL_naca0012.test_vals = [-3.751251, 1.788794, 0.301332, 0.019499] + fixedCL_naca0012.test_vals = [-3.920501, 1.594999, 0.300907, 0.019465] test_list.append(fixedCL_naca0012) # Polar sweep of the inviscid NACA0012 @@ -135,7 +135,7 @@ def main(): polar_naca0012.cfg_file = "inv_NACA0012.cfg" polar_naca0012.polar = True polar_naca0012.test_iter = 10 - polar_naca0012.test_vals = [-1.119642, 4.342860, 0.002338, 0.020591] + polar_naca0012.test_vals = [-1.196985, 4.245790, 0.010492, 0.070124] polar_naca0012.test_vals_aarch64 = [-1.063447, 4.401847, 0.000291, 0.031696] polar_naca0012.command = TestCase.Command(exec = "compute_polar.py", param = "-n 1 -i 11") # flaky test on arm64 @@ -166,7 +166,7 @@ def main(): flatplate.cfg_dir = "navierstokes/flatplate" flatplate.cfg_file = "lam_flatplate.cfg" flatplate.test_iter = 20 - flatplate.test_vals = [-5.099346, 0.381614, 0.001277, 0.024994, 2.361500, -2.336500, 0.000000, 0.000000] + flatplate.test_vals = [-5.448267, 0.027571, 0.002633, 0.015619, 2.361200, -2.345600, 0.000000, 0.000000] test_list.append(flatplate) # Laminar cylinder (steady) @@ -174,7 +174,7 @@ def main(): cylinder.cfg_dir = "navierstokes/cylinder" cylinder.cfg_file = "lam_cylinder.cfg" cylinder.test_iter = 25 - cylinder.test_vals = [-8.631691, -3.138513, -0.003331, 1.602087, 0.000000] + cylinder.test_vals = [-8.503813, -3.012051, 0.260768, 1.697376, 0.000000] test_list.append(cylinder) # Laminar cylinder (low Mach correction) @@ -182,7 +182,7 @@ def main(): cylinder_lowmach.cfg_dir = "navierstokes/cylinder" cylinder_lowmach.cfg_file = "cylinder_lowmach.cfg" cylinder_lowmach.test_iter = 25 - cylinder_lowmach.test_vals = [-6.412653, -0.950827, 0.038557, -134.198785, 0.000000] + cylinder_lowmach.test_vals = [-6.604626, -1.142842, -0.080684, -80.137778, 0.000000] test_list.append(cylinder_lowmach) # 2D Poiseuille flow (body force driven with periodic inlet / outlet) @@ -190,7 +190,7 @@ def main(): poiseuille.cfg_dir = "navierstokes/poiseuille" poiseuille.cfg_file = "lam_poiseuille.cfg" poiseuille.test_iter = 10 - poiseuille.test_vals = [-5.050753, 0.648333, 0.012273, 13.643141, 0] + poiseuille.test_vals = [-5.050753, 0.648333, 0.012273, 13.643141, 0.000000] test_list.append(poiseuille) # 2D Poiseuille flow (inlet profile file) @@ -198,7 +198,7 @@ def main(): poiseuille_profile.cfg_dir = "navierstokes/poiseuille" poiseuille_profile.cfg_file = "profile_poiseuille.cfg" poiseuille_profile.test_iter = 10 - poiseuille_profile.test_vals = [-12.012556, -7.696221, -0.000000, 2.089953] + poiseuille_profile.test_vals = [-12.004412, -7.544478, -0.000000, 2.089953] poiseuille_profile.test_vals_aarch64 = [-12.009012, -7.262299, -0.000000, 2.089953] #last 4 columns test_list.append(poiseuille_profile) @@ -218,7 +218,7 @@ def main(): rae2822_sa.cfg_dir = "rans/rae2822" rae2822_sa.cfg_file = "turb_SA_RAE2822.cfg" rae2822_sa.test_iter = 20 - rae2822_sa.test_vals = [-1.846052, -5.109587, 0.571411, 0.040773, 0.000000] + rae2822_sa.test_vals = [-2.168944, -5.451519, 0.287676, 0.104861, 0.000000] test_list.append(rae2822_sa) # RAE2822 SST @@ -226,7 +226,7 @@ def main(): rae2822_sst.cfg_dir = "rans/rae2822" rae2822_sst.cfg_file = "turb_SST_RAE2822.cfg" rae2822_sst.test_iter = 20 - rae2822_sst.test_vals = [-0.509931, 5.862083, 0.583382, 0.013958, 0.000000] + rae2822_sst.test_vals = [-1.028398, 5.868068, 0.277703, 0.093381, 0.000000] test_list.append(rae2822_sst) # RAE2822 SST_SUST @@ -234,7 +234,7 @@ def main(): rae2822_sst_sust.cfg_dir = "rans/rae2822" rae2822_sst_sust.cfg_file = "turb_SST_SUST_RAE2822.cfg" rae2822_sst_sust.test_iter = 20 - rae2822_sst_sust.test_vals = [-2.446759, 5.862083, 0.583382, 0.013958] + rae2822_sst_sust.test_vals = [-2.536320, 5.868058, 0.277703, 0.093381] test_list.append(rae2822_sst_sust) # Flat plate @@ -242,7 +242,7 @@ def main(): turb_flatplate.cfg_dir = "rans/flatplate" turb_flatplate.cfg_file = "turb_SA_flatplate.cfg" turb_flatplate.test_iter = 20 - turb_flatplate.test_vals = [-4.075879, -6.829935, -0.200296, 0.022692] + turb_flatplate.test_vals = [-4.939159, -7.469363, -0.187651, 0.015894] test_list.append(turb_flatplate) # FLAT PLATE, WALL FUNCTIONS, COMPRESSIBLE SST @@ -359,7 +359,7 @@ def main(): turb_naca0012_sst_restart_mg.cfg_file = "turb_NACA0012_sst_multigrid_restart.cfg" turb_naca0012_sst_restart_mg.test_iter = 50 turb_naca0012_sst_restart_mg.ntest_vals = 5 - turb_naca0012_sst_restart_mg.test_vals = [-6.606238, -5.081439, 0.810958, -0.008789, 0.077730] + turb_naca0012_sst_restart_mg.test_vals = [-6.575448, -5.081421, 0.810883, -0.008836, 0.077960] turb_naca0012_sst_restart_mg.timeout = 3200 turb_naca0012_sst_restart_mg.tol = 0.000001 test_list.append(turb_naca0012_sst_restart_mg) @@ -380,7 +380,7 @@ def main(): inc_euler_naca0012.cfg_dir = "incomp_euler/naca0012" inc_euler_naca0012.cfg_file = "incomp_NACA0012.cfg" inc_euler_naca0012.test_iter = 20 - inc_euler_naca0012.test_vals = [-7.126959, -6.573716, 0.531996, 0.008466] + inc_euler_naca0012.test_vals = [-5.930469, -4.994452, 0.519589, 0.008977] test_list.append(inc_euler_naca0012) # C-D nozzle with pressure inlet and mass flow outlet @@ -388,7 +388,7 @@ def main(): inc_nozzle.cfg_dir = "incomp_euler/nozzle" inc_nozzle.cfg_file = "inv_nozzle.cfg" inc_nozzle.test_iter = 20 - inc_nozzle.test_vals = [-3.936023, -3.470470, -0.012281, 0.120981] + inc_nozzle.test_vals = [-5.550954, -4.854401, -0.027964, 0.120734] test_list.append(inc_nozzle) ############################# @@ -407,7 +407,7 @@ def main(): inc_lam_cylinder.cfg_dir = "incomp_navierstokes/cylinder" inc_lam_cylinder.cfg_file = "incomp_cylinder.cfg" inc_lam_cylinder.test_iter = 10 - inc_lam_cylinder.test_vals = [-4.059218, -3.311865, 0.006311, 6.172388] + inc_lam_cylinder.test_vals = [-4.168180, -3.611108, 0.007850, 4.539924] test_list.append(inc_lam_cylinder) # Buoyancy-driven cavity @@ -586,7 +586,7 @@ def main(): contadj_naca0012.cfg_dir = "cont_adj_euler/naca0012" contadj_naca0012.cfg_file = "inv_NACA0012.cfg" contadj_naca0012.test_iter = 5 - contadj_naca0012.test_vals = [-9.578867, -15.048458, -0.726250, 0.020280] + contadj_naca0012.test_vals = [-9.525042, -15.101716, -0.726250, 0.020280] contadj_naca0012.tol = 0.001 test_list.append(contadj_naca0012) @@ -595,7 +595,7 @@ def main(): contadj_oneram6.cfg_dir = "cont_adj_euler/oneram6" contadj_oneram6.cfg_file = "inv_ONERAM6.cfg" contadj_oneram6.test_iter = 10 - contadj_oneram6.test_vals = [-11.969828, -12.503366, -1.086100, 0.007556] + contadj_oneram6.test_vals = [-12.062243, -12.621811, -1.086100, 0.007556] test_list.append(contadj_oneram6) # Inviscid WEDGE: tests averaged outflow total pressure adjoint @@ -611,7 +611,7 @@ def main(): contadj_fixedCL_naca0012.cfg_dir = "fixed_cl/naca0012" contadj_fixedCL_naca0012.cfg_file = "inv_NACA0012_ContAdj.cfg" contadj_fixedCL_naca0012.test_iter = 100 - contadj_fixedCL_naca0012.test_vals = [0.887003, -4.740585, -0.358290, -0.000626] + contadj_fixedCL_naca0012.test_vals = [1.165313, -4.338177, -0.068991, -0.007568] test_list.append(contadj_fixedCL_naca0012) ################################### @@ -630,7 +630,7 @@ def main(): contadj_ns_cylinder.cfg_dir = "cont_adj_navierstokes/cylinder" contadj_ns_cylinder.cfg_file = "lam_cylinder.cfg" contadj_ns_cylinder.test_iter = 20 - contadj_ns_cylinder.test_vals = [-3.600653, -9.043319, 2.056700, -0.000000] + contadj_ns_cylinder.test_vals = [-3.606048, -9.050787, 2.056700, -0.000000] test_list.append(contadj_ns_cylinder) # Adjoint laminar naca0012 subsonic @@ -674,7 +674,7 @@ def main(): contadj_rans_rae2822.cfg_dir = "cont_adj_rans/rae2822" contadj_rans_rae2822.cfg_file = "turb_SA_RAE2822.cfg" contadj_rans_rae2822.test_iter = 20 - contadj_rans_rae2822.test_vals = [-5.387481, -10.891118, -0.212470, 0.005448] + contadj_rans_rae2822.test_vals = [-5.399739, -10.904778, -0.212470, 0.005448] test_list.append(contadj_rans_rae2822) ############################# @@ -752,7 +752,7 @@ def main(): rot_naca0012.cfg_dir = "rotating/naca0012" rot_naca0012.cfg_file = "rot_NACA0012.cfg" rot_naca0012.test_iter = 25 - rot_naca0012.test_vals = [-1.413477, 4.090702, -0.024889, 0.056654] + rot_naca0012.test_vals = [-1.313205, 4.208222, -0.001635, 0.121312] test_list.append(rot_naca0012) # Lid-driven cavity @@ -760,7 +760,7 @@ def main(): cavity.cfg_dir = "moving_wall/cavity" cavity.cfg_file = "lam_cavity.cfg" cavity.test_iter = 25 - cavity.test_vals = [-5.515303, -0.049093, -0.114925, -7.135945] + cavity.test_vals = [-8.327173, -2.944600, 0.017813, 0.009045] test_list.append(cavity) # Spinning cylinder @@ -768,7 +768,7 @@ def main(): spinning_cylinder.cfg_dir = "moving_wall/spinning_cylinder" spinning_cylinder.cfg_file = "spinning_cylinder.cfg" spinning_cylinder.test_iter = 25 - spinning_cylinder.test_vals = [-7.699257, -2.240779, 1.471969, 1.496512] + spinning_cylinder.test_vals = [-7.824549, -2.360413, 1.581109, 1.528894] test_list.append(spinning_cylinder) ###################################### @@ -789,7 +789,7 @@ def main(): sine_gust.cfg_dir = "gust" sine_gust.cfg_file = "inv_gust_NACA0012.cfg" sine_gust.test_iter = 5 - sine_gust.test_vals = [-1.977498, 3.481817, -0.010233, -0.007786] + sine_gust.test_vals = [-1.977498, 3.481817, -0.009957, -0.005021] sine_gust.unsteady = True test_list.append(sine_gust) @@ -798,7 +798,7 @@ def main(): aeroelastic.cfg_dir = "aeroelastic" aeroelastic.cfg_file = "aeroelastic_NACA64A010.cfg" aeroelastic.test_iter = 2 - aeroelastic.test_vals = [0.075274, 0.027537, -0.001640, -0.000129] + aeroelastic.test_vals = [0.073896, 0.027450, -0.001638, -0.000130] aeroelastic.unsteady = True test_list.append(aeroelastic) @@ -824,7 +824,7 @@ def main(): unst_pitching_naca64a010_rans.cfg_dir = "unsteady/pitching_naca64a010_rans" unst_pitching_naca64a010_rans.cfg_file = "turb_NACA64A010.cfg" unst_pitching_naca64a010_rans.test_iter = 2 - unst_pitching_naca64a010_rans.test_vals = [-1.299045, -3.951372, 0.010139, 0.008244] + unst_pitching_naca64a010_rans.test_vals = [-1.299045, -3.951413, 0.012821, 0.008239] unst_pitching_naca64a010_rans.unsteady = True test_list.append(unst_pitching_naca64a010_rans) # unsteady pitching NACA64A010, Euler @@ -832,7 +832,7 @@ def main(): unst_pitching_naca64a010_euler.cfg_dir = "unsteady/pitching_naca64a010_euler" unst_pitching_naca64a010_euler.cfg_file = "pitching_NACA64A010.cfg" unst_pitching_naca64a010_euler.test_iter = 2 - unst_pitching_naca64a010_euler.test_vals = [-1.186839, 4.280301, -0.038811, 0.000913] + unst_pitching_naca64a010_euler.test_vals = [-1.186839, 4.280301, -0.043557, 0.000935] unst_pitching_naca64a010_euler.unsteady = True test_list.append(unst_pitching_naca64a010_euler) # unsteady plunging NACA0012, Laminar NS @@ -840,7 +840,7 @@ def main(): unst_plunging_naca0012.cfg_dir = "unsteady/plunging_naca0012" unst_plunging_naca0012.cfg_file = "plunging_NACA0012.cfg" unst_plunging_naca0012.test_iter = 2 - unst_plunging_naca0012.test_vals = [-4.083462, 1.366757, -3.718481, -0.066605] + unst_plunging_naca0012.test_vals = [-4.083462, 1.366757, -6.820746, -0.081557] unst_plunging_naca0012.unsteady = True test_list.append(unst_plunging_naca0012) @@ -849,7 +849,7 @@ def main(): unst_deforming_naca0012.cfg_dir = "disc_adj_euler/naca0012_pitching_def" unst_deforming_naca0012.cfg_file = "inv_NACA0012_pitching_deform.cfg" unst_deforming_naca0012.test_iter = 5 - unst_deforming_naca0012.test_vals = [-3.665164, -3.793367, -3.716518, -3.148356] + unst_deforming_naca0012.test_vals = [-3.665254, -3.794011, -3.716829, -3.148509] unst_deforming_naca0012.unsteady = True test_list.append(unst_deforming_naca0012) @@ -862,7 +862,7 @@ def main(): ls89_sa.cfg_dir = "nicf/LS89" ls89_sa.cfg_file = "turb_SA_PR.cfg" ls89_sa.test_iter = 20 - ls89_sa.test_vals = [-5.050483, -13.371795, 0.174939, 0.430757] + ls89_sa.test_vals = [-5.241488, -13.580472, 0.188420, 0.414010] test_list.append(ls89_sa) # Rarefaction shock wave edge_VW @@ -870,7 +870,7 @@ def main(): edge_VW.cfg_dir = "nicf/edge" edge_VW.cfg_file = "edge_VW.cfg" edge_VW.test_iter = 20 - edge_VW.test_vals = [-0.577419, 5.624333, -0.016050, 0.000000] + edge_VW.test_vals = [-2.656646, 3.544572, -0.000020, 0.000000] test_list.append(edge_VW) # Rarefaction shock wave edge_PPR @@ -878,7 +878,7 @@ def main(): edge_PPR.cfg_dir = "nicf/edge" edge_PPR.cfg_file = "edge_PPR.cfg" edge_PPR.test_iter = 20 - edge_PPR.test_vals = [-1.542990, 4.650149, 0.001487, 0.000000] + edge_PPR.test_vals = [-12.154112, -5.995257, -0.000034, 0.000000] test_list.append(edge_PPR) @@ -1009,7 +1009,7 @@ def main(): bars_SST_2D.cfg_dir = "sliding_interface/bars_SST_2D" bars_SST_2D.cfg_file = "bars.cfg" bars_SST_2D.test_iter = 13 - bars_SST_2D.test_vals = [13.000000, -0.623154, -1.660901] + bars_SST_2D.test_vals = [13.000000, -0.473009, -1.562179] bars_SST_2D.multizone = True test_list.append(bars_SST_2D) @@ -1115,15 +1115,14 @@ def main(): airfoilRBF.cfg_dir = "fea_fsi/Airfoil_RBF" airfoilRBF.cfg_file = "config.cfg" airfoilRBF.test_iter = 1 - - airfoilRBF.test_vals = [1.000000, 0.112689, -3.382129] + airfoilRBF.test_vals = [1.000000, 0.184123, -3.375352] airfoilRBF.tol = 0.0001 airfoilRBF.multizone = True test_list.append(airfoilRBF) # ############################### # ### Radiative Heat Transfer ### - # ############################### + # ###############################] # Radiative heat transfer p1rad = TestCase('p1rad') @@ -1523,7 +1522,7 @@ def main(): opt_multiobj1surf_py.cfg_dir = "optimization_euler/multiobjective_wedge" opt_multiobj1surf_py.cfg_file = "inv_wedge_ROE_multiobj_1surf.cfg" opt_multiobj1surf_py.test_iter = 1 - opt_multiobj1surf_py.test_vals = [1.000000, 1.000000, 36.178490, 3.891506] + opt_multiobj1surf_py.test_vals = [1.000000, 1.000000, 36.699910, 5.780304] opt_multiobj1surf_py.command = TestCase.Command(exec = "shape_optimization.py", param = "-g CONTINUOUS_ADJOINT -f") opt_multiobj1surf_py.timeout = 1600 opt_multiobj1surf_py.tol = 0.00001 @@ -1536,7 +1535,7 @@ def main(): opt_2surf1obj_py.cfg_dir = "optimization_euler/multiobjective_wedge" opt_2surf1obj_py.cfg_file = "inv_wedge_ROE_2surf_1obj.cfg" opt_2surf1obj_py.test_iter = 1 - opt_2surf1obj_py.test_vals = [1.000000, 1.000000, 2.005074, 0.000323] + opt_2surf1obj_py.test_vals = [1.000000, 1.000000, 2.005030, 0.000476] opt_2surf1obj_py.command = TestCase.Command(exec = "shape_optimization.py", param = "-g CONTINUOUS_ADJOINT -f") opt_2surf1obj_py.timeout = 1600 opt_2surf1obj_py.tol = 0.00001 @@ -1553,7 +1552,7 @@ def main(): pywrapper_naca0012.cfg_dir = "euler/naca0012" pywrapper_naca0012.cfg_file = "inv_NACA0012_Roe.cfg" pywrapper_naca0012.test_iter = 20 - pywrapper_naca0012.test_vals = [-4.968082, -4.396602, 0.331959, 0.023010] + pywrapper_naca0012.test_vals = [-4.256408, -3.795038, 0.306510, 0.024657] pywrapper_naca0012.command = TestCase.Command(exec = "SU2_CFD.py", param = "-f") pywrapper_naca0012.timeout = 1600 pywrapper_naca0012.tol = 0.00001 @@ -1623,7 +1622,7 @@ def main(): pywrapper_unsteadyCHT.cfg_dir = "py_wrapper/flatPlate_unsteady_CHT" pywrapper_unsteadyCHT.cfg_file = "unsteady_CHT_FlatPlate_Conf.cfg" pywrapper_unsteadyCHT.test_iter = 5 - pywrapper_unsteadyCHT.test_vals = [-1.614167, 2.260153, -0.003880, 0.099289] + pywrapper_unsteadyCHT.test_vals = [-1.614168, 2.259972, 0.000757, 0.113614] pywrapper_unsteadyCHT.command = TestCase.Command(exec = "python", param = "launch_unsteady_CHT_FlatPlate.py -f") pywrapper_unsteadyCHT.timeout = 1600 pywrapper_unsteadyCHT.tol = 0.00001 @@ -1651,7 +1650,7 @@ def main(): pywrapper_custom_inlet.cfg_dir = "py_wrapper/custom_inlet" pywrapper_custom_inlet.cfg_file = "lam_flatplate.cfg" pywrapper_custom_inlet.test_iter = 20 - pywrapper_custom_inlet.test_vals = [-4.122866, -1.542850, -3.664440, 1.339854, -0.793567, 0.159301, -0.007466, 0.514290, -0.521750] + pywrapper_custom_inlet.test_vals = [-4.123921, -1.544230, -3.886906, 1.338713, -0.688132, 0.160844, -0.009845, 0.520880, -0.530730] pywrapper_custom_inlet.command = TestCase.Command(exec = "python", param = "run.py") pywrapper_custom_inlet.timeout = 1600 pywrapper_custom_inlet.tol = 0.0001 diff --git a/TestCases/serial_regression_AD.py b/TestCases/serial_regression_AD.py index 13b7984ab1d..f673baabd18 100644 --- a/TestCases/serial_regression_AD.py +++ b/TestCases/serial_regression_AD.py @@ -76,7 +76,7 @@ def main(): discadj_arina2k.cfg_dir = "disc_adj_euler/arina2k" discadj_arina2k.cfg_file = "Arina2KRS.cfg" discadj_arina2k.test_iter = 20 - discadj_arina2k.test_vals = [-3.229386, -3.466956, 0.043983, 0.000000] + discadj_arina2k.test_vals = [-2.928012, -3.351813, 0.073362, 0.000000] test_list.append(discadj_arina2k) ####################################################### @@ -108,7 +108,7 @@ def main(): discadj_incomp_NACA0012.cfg_dir = "disc_adj_incomp_euler/naca0012" discadj_incomp_NACA0012.cfg_file = "incomp_NACA0012_disc.cfg" discadj_incomp_NACA0012.test_iter = 20 - discadj_incomp_NACA0012.test_vals = [20.000000, -3.977751, -2.562520, 0.000000] + discadj_incomp_NACA0012.test_vals = [20.000000, -3.338269, -2.490047, 0.000000] test_list.append(discadj_incomp_NACA0012) ##################################### @@ -158,7 +158,7 @@ def main(): discadj_pitchingNACA0012.cfg_dir = "disc_adj_euler/naca0012_pitching" discadj_pitchingNACA0012.cfg_file = "inv_NACA0012_pitching.cfg" discadj_pitchingNACA0012.test_iter = 4 - discadj_pitchingNACA0012.test_vals = [-1.223517, -1.653450, -0.004178, -0.000004] + discadj_pitchingNACA0012.test_vals = [-1.130532, -1.575494, -0.005113, 0.000007] discadj_pitchingNACA0012.unsteady = True test_list.append(discadj_pitchingNACA0012) @@ -167,7 +167,7 @@ def main(): unst_deforming_naca0012.cfg_dir = "disc_adj_euler/naca0012_pitching_def" unst_deforming_naca0012.cfg_file = "inv_NACA0012_pitching_deform_ad.cfg" unst_deforming_naca0012.test_iter = 4 - unst_deforming_naca0012.test_vals = [-1.965747, -1.848881, 2961.700000, 0.000000] + unst_deforming_naca0012.test_vals = [-1.885032, -1.775564, 3994.600000, 0.000002] unst_deforming_naca0012.unsteady = True test_list.append(unst_deforming_naca0012) diff --git a/TestCases/sliding_interface/bars_SST_2D/bars.cfg b/TestCases/sliding_interface/bars_SST_2D/bars.cfg index c1eeb710783..2b2b569306f 100644 --- a/TestCases/sliding_interface/bars_SST_2D/bars.cfg +++ b/TestCases/sliding_interface/bars_SST_2D/bars.cfg @@ -87,17 +87,18 @@ CFL_ADAPT= NO CFL_ADAPT_PARAM= ( 1.5, 0.5, 0.3,20.0 ) LINEAR_SOLVER= FGMRES LINEAR_SOLVER_PREC= LU_SGS -LINEAR_SOLVER_ERROR= 1E-4 -LINEAR_SOLVER_ITER= 20 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % MGLEVEL= 3 -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 0.75 -MG_DAMP_PROLONGATION= 0.75 +MGCYCLE= V_CYCLE +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/turbulence_models/sa/rae2822/turb_SA_BSL_RAE2822.cfg b/TestCases/turbulence_models/sa/rae2822/turb_SA_BSL_RAE2822.cfg index 50604b60db7..cdc080aca0f 100644 --- a/TestCases/turbulence_models/sa/rae2822/turb_SA_BSL_RAE2822.cfg +++ b/TestCases/turbulence_models/sa/rae2822/turb_SA_BSL_RAE2822.cfg @@ -30,22 +30,22 @@ MARKER_MONITORING= ( AIRFOIL ) % ------------- COMMON PARAMETERS DEFINING THE NUMERICAL METHOD ---------------% % NUM_METHOD_GRAD= WEIGHTED_LEAST_SQUARES -CFL_NUMBER= 2.5 +CFL_NUMBER= 100 CFL_ADAPT= NO ITER= 99999 LINEAR_SOLVER= BCGSTAB -LINEAR_SOLVER_ERROR= 1E-6 -LINEAR_SOLVER_ITER= 20 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % MGLEVEL= 3 MGCYCLE= W_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 0.95 -MG_DAMP_PROLONGATION= 0.95 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/turbulence_models/sa/rae2822/turb_SA_COMP_EDW_RAE2822.cfg b/TestCases/turbulence_models/sa/rae2822/turb_SA_COMP_EDW_RAE2822.cfg index ba678723998..ff13edb7145 100644 --- a/TestCases/turbulence_models/sa/rae2822/turb_SA_COMP_EDW_RAE2822.cfg +++ b/TestCases/turbulence_models/sa/rae2822/turb_SA_COMP_EDW_RAE2822.cfg @@ -30,22 +30,22 @@ MARKER_MONITORING= ( AIRFOIL ) % ------------- COMMON PARAMETERS DEFINING THE NUMERICAL METHOD ---------------% % NUM_METHOD_GRAD= WEIGHTED_LEAST_SQUARES -CFL_NUMBER= 2.5 +CFL_NUMBER= 100.0 CFL_ADAPT= NO ITER= 99999 LINEAR_SOLVER= BCGSTAB -LINEAR_SOLVER_ERROR= 1E-6 -LINEAR_SOLVER_ITER= 20 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % MGLEVEL= 3 MGCYCLE= W_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 0.95 -MG_DAMP_PROLONGATION= 0.95 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/turbulence_models/sa/rae2822/turb_SA_COMP_RAE2822.cfg b/TestCases/turbulence_models/sa/rae2822/turb_SA_COMP_RAE2822.cfg index 8f783b5d7fc..70f6f0cf4aa 100644 --- a/TestCases/turbulence_models/sa/rae2822/turb_SA_COMP_RAE2822.cfg +++ b/TestCases/turbulence_models/sa/rae2822/turb_SA_COMP_RAE2822.cfg @@ -31,22 +31,22 @@ MARKER_MONITORING= ( AIRFOIL ) % ------------- COMMON PARAMETERS DEFINING THE NUMERICAL METHOD ---------------% % NUM_METHOD_GRAD= WEIGHTED_LEAST_SQUARES -CFL_NUMBER= 2.5 +CFL_NUMBER= 100.0 CFL_ADAPT= NO ITER= 99999 LINEAR_SOLVER= BCGSTAB -LINEAR_SOLVER_ERROR= 1E-6 -LINEAR_SOLVER_ITER= 20 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % MGLEVEL= 3 MGCYCLE= W_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 0.95 -MG_DAMP_PROLONGATION= 0.95 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/turbulence_models/sa/rae2822/turb_SA_EDW_RAE2822.cfg b/TestCases/turbulence_models/sa/rae2822/turb_SA_EDW_RAE2822.cfg index 3eefc408141..a4dc42ff4ee 100644 --- a/TestCases/turbulence_models/sa/rae2822/turb_SA_EDW_RAE2822.cfg +++ b/TestCases/turbulence_models/sa/rae2822/turb_SA_EDW_RAE2822.cfg @@ -31,22 +31,22 @@ MARKER_MONITORING= ( AIRFOIL ) % ------------- COMMON PARAMETERS DEFINING THE NUMERICAL METHOD ---------------% % NUM_METHOD_GRAD= WEIGHTED_LEAST_SQUARES -CFL_NUMBER= 2.5 +CFL_NUMBER= 100.0 CFL_ADAPT= NO ITER= 99999 LINEAR_SOLVER= BCGSTAB -LINEAR_SOLVER_ERROR= 1E-6 -LINEAR_SOLVER_ITER= 20 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % MGLEVEL= 3 MGCYCLE= W_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 0.95 -MG_DAMP_PROLONGATION= 0.95 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/TestCases/turbulence_models/sa/rae2822/turb_SA_QCR_RAE2822.cfg b/TestCases/turbulence_models/sa/rae2822/turb_SA_QCR_RAE2822.cfg index d038f5ff7e6..20d46b10b9b 100644 --- a/TestCases/turbulence_models/sa/rae2822/turb_SA_QCR_RAE2822.cfg +++ b/TestCases/turbulence_models/sa/rae2822/turb_SA_QCR_RAE2822.cfg @@ -31,22 +31,22 @@ MARKER_MONITORING= ( AIRFOIL ) % ------------- COMMON PARAMETERS DEFINING THE NUMERICAL METHOD ---------------% % NUM_METHOD_GRAD= WEIGHTED_LEAST_SQUARES -CFL_NUMBER= 2.5 +CFL_NUMBER= 100.0 CFL_ADAPT= NO ITER= 99999 LINEAR_SOLVER= BCGSTAB -LINEAR_SOLVER_ERROR= 1E-6 -LINEAR_SOLVER_ITER= 20 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % MGLEVEL= 3 MGCYCLE= W_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 0.95 -MG_DAMP_PROLONGATION= 0.95 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % @@ -61,7 +61,7 @@ TIME_DISCRE_TURB= EULER_IMPLICIT % --------------------------- CONVERGENCE PARAMETERS --------------------------% % -CONV_RESIDUAL_MINVAL= -8 +CONV_RESIDUAL_MINVAL= -10 CONV_STARTITER= 10 CONV_CAUCHY_ELEMS= 100 CONV_CAUCHY_EPS= 1E-6 diff --git a/TestCases/tutorials.py b/TestCases/tutorials.py index cf0968e2a9d..bef1f3c1fde 100644 --- a/TestCases/tutorials.py +++ b/TestCases/tutorials.py @@ -175,7 +175,7 @@ def main(): tutorial_inv_bump.cfg_dir = "../Tutorials/compressible_flow/Inviscid_Bump" tutorial_inv_bump.cfg_file = "inv_channel.cfg" tutorial_inv_bump.test_iter = 0 - tutorial_inv_bump.test_vals = [-1.437425, 4.075857, 0.060602, -0.001097] + tutorial_inv_bump.test_vals = [-1.437425, 4.075857, 0.043691, 0.034241] test_list.append(tutorial_inv_bump) # Inviscid Wedge @@ -183,7 +183,7 @@ def main(): tutorial_inv_wedge.cfg_dir = "../Tutorials/compressible_flow/Inviscid_Wedge" tutorial_inv_wedge.cfg_file = "inv_wedge_HLLC.cfg" tutorial_inv_wedge.test_iter = 0 - tutorial_inv_wedge.test_vals = [-0.481460, 5.253008, -0.290816, 0.051445] + tutorial_inv_wedge.test_vals = [-0.481460, 5.253008, -0.253048, 0.044501] tutorial_inv_wedge.no_restart = True test_list.append(tutorial_inv_wedge) @@ -192,7 +192,7 @@ def main(): tutorial_inv_onera.cfg_dir = "../Tutorials/compressible_flow/Inviscid_ONERAM6" tutorial_inv_onera.cfg_file = "inv_ONERAM6.cfg" tutorial_inv_onera.test_iter = 0 - tutorial_inv_onera.test_vals = [-5.204928, -4.597762, 0.262596, 0.084044] + tutorial_inv_onera.test_vals = [-5.204928, -4.597762, 0.255680, 0.087977] tutorial_inv_onera.no_restart = True test_list.append(tutorial_inv_onera) @@ -201,7 +201,7 @@ def main(): tutorial_lam_cylinder.cfg_dir = "../Tutorials/compressible_flow/Laminar_Cylinder" tutorial_lam_cylinder.cfg_file = "lam_cylinder.cfg" tutorial_lam_cylinder.test_iter = 0 - tutorial_lam_cylinder.test_vals = [-6.162141, -0.699617, -0.124663, 31.721714] + tutorial_lam_cylinder.test_vals = [-6.162141, -0.699617, -0.047729, 43.442977] tutorial_lam_cylinder.no_restart = True test_list.append(tutorial_lam_cylinder) @@ -323,7 +323,7 @@ def main(): tutorial_design_inv_naca0012.cfg_dir = "../Tutorials/design/Inviscid_2D_Unconstrained_NACA0012" tutorial_design_inv_naca0012.cfg_file = "inv_NACA0012_basic.cfg" tutorial_design_inv_naca0012.test_iter = 0 - tutorial_design_inv_naca0012.test_vals = [-3.585391, -2.989014, 0.165195, 0.238368] + tutorial_design_inv_naca0012.test_vals = [-3.585391, -2.989014, 0.164248, 0.228824] tutorial_design_inv_naca0012.no_restart = True test_list.append(tutorial_design_inv_naca0012) diff --git a/TestCases/unsteady/plunging_naca0012/plunging_NACA0012.cfg b/TestCases/unsteady/plunging_naca0012/plunging_NACA0012.cfg index b1ce80b506f..9ac2fbaaea3 100644 --- a/TestCases/unsteady/plunging_naca0012/plunging_NACA0012.cfg +++ b/TestCases/unsteady/plunging_naca0012/plunging_NACA0012.cfg @@ -76,18 +76,18 @@ SENS_REMOVE_SHARP= NO % LINEAR_SOLVER= FGMRES LINEAR_SOLVER_PREC= LU_SGS -LINEAR_SOLVER_ERROR= 1E-4 -LINEAR_SOLVER_ITER= 5 +LINEAR_SOLVER_ERROR= 1E-1 +LINEAR_SOLVER_ITER= 3 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % MGLEVEL= 3 MGCYCLE= V_CYCLE -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) -MG_POST_SMOOTH= ( 2, 2, 2, 2 ) -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) -MG_DAMP_RESTRICTION= 0.7 -MG_DAMP_PROLONGATION= 0.7 +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) +MG_DAMP_RESTRICTION= 0.5 +MG_DAMP_PROLONGATION= 0.5 % -------------------- FLOW NUMERICAL METHOD DEFINITION -----------------------% % diff --git a/config_template.cfg b/config_template.cfg index 47b1ee28375..ab8175bb680 100644 --- a/config_template.cfg +++ b/config_template.cfg @@ -1612,26 +1612,47 @@ LINEAR_SOLVER_SMOOTHER_RELAXATION= 1.0 % -------------------------- MULTIGRID PARAMETERS -----------------------------% % -% Multi-grid levels (0 = no multi-grid) +% Max. number of multi-grid levels (0 = no multi-grid) MGLEVEL= 0 % % Multi-grid cycle (V_CYCLE, W_CYCLE, FULLMG_CYCLE) MGCYCLE= V_CYCLE % -% Multi-grid pre-smoothing level -MG_PRE_SMOOTH= ( 1, 2, 3, 3 ) +% Max. iterations for multi-grid pre-smoothing level +MG_PRE_SMOOTH= ( 4, 4, 4, 4 ) % -% Multi-grid post-smoothing level -MG_POST_SMOOTH= ( 0, 0, 0, 0 ) +% Max. iterations for multi-grid post-smoothing level +MG_POST_SMOOTH= ( 4, 4, 4, 4 ) % % Jacobi implicit smoothing of the correction -MG_CORRECTION_SMOOTH= ( 0, 0, 0, 0 ) +MG_CORRECTION_SMOOTH= ( 1, 1, 1, 1 ) % % Damping factor for the residual restriction MG_DAMP_RESTRICTION= 0.75 % % Damping factor for the correction prolongation MG_DAMP_PROLONGATION= 0.75 +% +% Enable early exit from multigrid smoothing when the residual RMS drops +% below MG_SMOOTH_RES_THRESHOLD * initial_rms (NO, YES) +MG_SMOOTH_EARLY_EXIT= YES +% +% Relative RMS reduction threshold for the multigrid smoothing early exit. +% Smoothing stops when current_rms < threshold * initial_rms (default 0.5) +MG_SMOOTH_RES_THRESHOLD= 0.5 +% +% Smoothing coefficient for the Jacobi correction-prolongation smoother (default 1.25) +MG_SMOOTH_COEFF= 1.25 +% +% Print a compact per-cycle summary of smoothing iterations and residuals (NO, YES) +MG_SMOOTH_OUTPUT= NO +% +% Minimum number of control volumes on the coarsest multigrid level. +% Effectively limits the number of multigrid levels. +MG_MIN_MESHSIZE= 500 +% +% Enable agglomeration along implicit lines seeded from viscous walls (NO, YES) +MG_IMPLICIT_LINES= NO % -------------------------- MESH SMOOTHING -----------------------------% %