spelling

Author: ScSteffen

_tutorials/design_features/Unsteady_Shape_Opt_NACA0012.md

@@ -18,15 +18,17 @@ Consequently, the following capabilities of SU2 will be showcased in this tutori
 - Windowed sensitivity calculation
 - Unsteady adjoints
 - Unsteady Optimization
-- Code parallelism (optional)
+- Code parallelism 
 
-This tutorial uses the windowing techniques explained in [here](../Unsteady_NACA0012.md), to compute meaningful optimization objectives.
+This tutorial uses the windowing techniques explained in [here](../Unsteady_NACA0012), to compute meaningful optimization objectives.
  Hence it is recommended to read that tutorial first. 
 
 
 ## Resources ##
 
-The resources for this tutorial can be found in the [Unsteady_NACA0012](https://github.com/su2code/su2code.github.io/tree/master/Unsteady_Shape_Opt_NACA0012) directory in the [project website repository](https://github.com/su2code/su2code.github.io). 
+The resources for this tutorial can be found in the 
+[Unsteady_Shape_Opt_NACA0012](https://github.com/su2code/su2code.github.io/tree/master/Unsteady_Shape_Opt_NACA0012) directory 
+in the [project website repository](https://github.com/su2code/su2code.github.io). 
 
 You will need the configuration file ([unsteady_naca0012_opt.cfg](../../Unsteady_Shape_Opt_NACA0012/unsteady_naca0012_opt.cfg)) and 
 the mesh file ([unsteady_naca0012_FFD.su2](../../Unsteady_Shape_Opt_NACA0012/unsteady_naca0012_FFD.su2)).
@@ -58,20 +60,19 @@ This problem will solve the flow about the airfoil with these conditions:
 - Reynolds number = 1E6
 - Reynolds length = 1.0 m
 - Number of time iterations: 2200
-- Restart Iteration: 1100
 - Start of the windowed time-average: 1500
 
 These subsonic flow conditions will cause a detached flow about the airfoil, that exhibts a vortex street and is therefore periodic for the baseline geometry. 
 Depending on the windowing-function used to average the optimization objective, the flow about the optimized geometry will eventually be a steady state flow.
 
 We want to solve an optimization problem with a time dependent system output, e.g. Drag. A meaningful objective and constraint function is therefore a time average over a period. 
-The period average is approximated by a windowed time average over a finite time span $$M$$.
+The period average is approximated by a windowed time-average over a finite time-span $$M$$.
 
 $$ \frac{1}{M}\int_0^M w(t/M)C_D(\sigma, t) \mathcal{d}t,$$
 
 where $$C_D(\sigma, t) $$ denotes the drag coefficient. $$C_D(\sigma, t)$$ depends on time $$t$$ and the design parameters $$\sigma$$. The window-function is denoted by $$w$$.
-There are different windows available. Depending on their smoothness, they have different regularizing effects on the time average and its sensitivity and therefore, the windowed time
-average converges with different speed to the period average.
+There are different windows available. Depending on their smoothness, they have different regularizing effects on the time-average and 
+its sensitivity and therefore, the windowed time-average converges with different speed to the period-average.
 The following options are implemented:
 
 | Window | Convergence Order | Convergence Order (sensitivity) |
@@ -82,36 +83,40 @@ The following options are implemented:
 | `BUMP`| exponential | exponential |
 
 
-For each optimization run, we have to compute the sensitivity of above windowed time average, that reads
+For each optimization run, we have to compute the sensitivity of above windowed time-average, which reads
 
 $$ \frac{1}{M}\int_0^M w(t/M)\partial_\sigma C_D(\sigma, t) \mathcal{d}t.$$
 
-Figure 2 shows the time dependent drag and its sensitivity. As one can see,  the amplitude of the drag sensitivity grows faster than linear. This is the reason why Square-windowing
-is not a viable option for many application cases. 
+Figure 2 shows the time dependent drag and its sensitivity. As one can see,  the amplitude of the drag sensitivity grows faster than 
+linear. Roughly speaking, windowed time-average must converge faster than the amplitude of the oscillation grows to ensure convergence. 
+This is the reason why Square-windowing is not a viable option for many application cases. 
 
 ![Drag and Drag sensitivity](../../Unsteady_Shape_Opt_NACA0012/images/Optimiztation_Horizon.png)
 Figure (2): Instantaneous drag and drag sensitivity shown. The time frame to average the drag coefficient is in between iteration $$n_{tr} = 1500 $$ and $$N=2200$$.
 
 Using the midpoint rule for above integral, we arrive at the following constrained optimization problem
 
-$$ \min_{\sigma} \frac{1}{M} \sum_{n_{tr}}^{N} w\left(\frac{n-n_{tr}}{N-n_{tr}}\right)C_D(\sigma,n) $$
+$$ \min_{\sigma} \frac{1}{N-n_{tr}} \sum_{n_{tr}}^{N} w\left(\frac{n-n_{tr}}{N-n_{tr}}\right)C_D(\sigma,n) $$
+
 $$ s.t. \qquad R(u^n) = 0 \qquad \forall n=1,\dots,N $$
-$$ \qquad\qquad\frac{1}{M} \sum_{n_{tr}}^{N} w\left(\frac{n-n_{tr}}{N-n_{tr}}\right)C_L(\sigma,n) \geq c$$
+
+$$ \qquad\qquad\frac{1}{N-n_{tr}} \sum_{n_{tr}}^{N} w\left(\frac{n-n_{tr}}{N-n_{tr}}\right)C_L(\sigma,n) \geq c$$
 
 The optimization constraint is given by the windowed time-averaged lift, that should be greater than a specific value $$c$$. We choose arbitrarily as $$c=0.96$$, which is the windowed
-time-averaged lift of the baseline geometry.
+time-averaged lift of the baseline geometry. The time-span to average both lift and drag is given by $$M =N-n_{tr}$$.
 
 
 ### Configuration File Options ###
 
-To compute the unsteady shape-optimization, we set up the unsteady simulation according to our test case above. More information about unsteady simulations can be found [here](../Unsteady_NACA0012.md)
+To compute the unsteady shape-optimization, we set up the unsteady simulation according to our test case above. 
+More information about setting up unsteady simulations can be found [here](../Unsteady_NACA0012)
 
 ```
 % -------- UNSTEADY SIMULATION -----------------%
 %
 TIME_DOMAIN = YES
 %
-% Numerical Method for Unsteady simulation(NO, TIME_STEPPING, DUAL_TIME_STEPPING-1ST_ORDER, DUAL_TIME_STEPPING-2ND_ORDER, TIME_SPECTRAL)
+% Numerical Method for Unsteady simulation
 TIME_MARCHING= DUAL_TIME_STEPPING-2ND_ORDER
 %
 % Time Step for dual time stepping simulations (s)
@@ -144,7 +149,7 @@ it may happen that the adjoint inner iterator needs more iterations to reach a s
 correct sensitivity results. 
 
 Note, that the adjoint iterator runs backwards in time, i.e. it starts at iteration given by `UNST_ADJOINT_START_ITER` and ends at iteration 0.
-We set the start iter to the final iteration of the direct run, i.e. `UNST_ADJOINT_START_ITER = TIME_ITER = 2200`.
+We set the start iteration to the final iteration of the direct run, i.e. `UNST_ADJOINT_START_ITER = TIME_ITER = 2200`.
 The time to average the objective and constraint function is given by the option `ITER_AVERAGE_OBJ`. Here we set `ITER_AVERAGE_OBJ=TIME_ITER-WINDOW_START_ITER=700`.
 
 ```
@@ -198,10 +203,11 @@ With each design iteration, the direct and adjoint solutions are used to compute
 	ITER_AVERAGE_OBJ =  250
 	```
 	
-	Note, that this configuration will produce different designs. To best showcase the difference between the windowing function, the original configuration is recommended.
+	Note, that this configuration may produce different designs. To best showcase the difference between the windowing function, the original configuration is recommended.
     
 
  2. The python script will drive the optimization process by executing flow solutions, adjoint solutions, gradient projection, geometry evaluations, and mesh deformation in order to drive the design toward an optimum. The optimization process will cease when certain tolerances set within the SciPy optimizer are met.
+ 
  3. Solution files containing the flow and surface data will be written for each flow solution and adjoint solution and can be found in the DESIGNS directory that is created. The file named history_project.dat (or history_project.csv for ParaView) will contain the functional values of interest resulting from each evaluation during the optimization. The major iterations and function evaluations for the SLSQP optimizer will be written to the console during execution.