CFD Online Discussion Forums

CFD Online Discussion Forums (http://www.cfd-online.com/Forums/)
-   SU2 Shape Design (http://www.cfd-online.com/Forums/su2-shape-design/)
-   -   How does SU2 calculate of_gradient.plt? (http://www.cfd-online.com/Forums/su2-shape-design/120491-how-does-su2-calculate-of_gradient-plt.html)

robyTKD July 8, 2013 09:27

How does SU2 calculate of_gradient.plt?
 
1 Attachment(s)
Hi developers,

I don't understand how SU2 evaluates objective functions gradient. I thought it simply evaluates shape sensitivity at each position of design variable and imposes this value as \delta_n of Hicks-Henne bump functions, but in SU2_GPC I found these lines:

Code:

                /*--- Continuous adjoint gradient computation ---*/
                if (rank == MASTER_NODE)
                        cout << "Evaluate functional gradient using the continuous adjoint strategy." << endl;
               
    /*--- Load the delta change in the design variable (finite difference step).
    Note that this assumes DV_Value_New = finite_diff_step and DV_Value_Old = 0.0
    in the config file. ---*/
                delta_eps = config->GetDV_Value_New(iDV);
    my_Gradient = 0.0; Gradient = 0.0;
     
      /*--- Reset update points ---*/
      for (iPoint = 0; iPoint < boundary->GetnPoint(); iPoint++)
        UpdatePoint[iPoint] = true;
     
      for (iMarker = 0; iMarker < config->GetnMarker_All(); iMarker++) {
                                if (config->GetMarker_All_Moving(iMarker) == YES) {
                                        for (iVertex = 0; iVertex < boundary->nVertex[iMarker]; iVertex++) {
                                               
                                                iPoint = boundary->vertex[iMarker][iVertex]->GetNode();
                                                if ((iPoint < boundary->GetnPointDomain()) && UpdatePoint[iPoint]) {
                                                       
                                                        Normal = boundary->vertex[iMarker][iVertex]->GetNormal();
                                                        VarCoord = boundary->vertex[iMarker][iVertex]->GetVarCoord();
                                                        Sensitivity = boundary->vertex[iMarker][iVertex]->GetAuxVar();
                                                       
                                                        dS = 0.0;
                                                        for (iDim = 0; iDim < boundary->GetnDim(); iDim++) {
                                                                dS += Normal[iDim]*Normal[iDim];
                                                                deps[iDim] = VarCoord[iDim] / delta_eps;
                                                        }
                                                        dS = sqrt(dS);
                                                       
                                                        dalpha_deps = 0.0;
                                                        for (iDim = 0; iDim < boundary->GetnDim(); iDim++) {
                                                                dalpha[iDim] = Normal[iDim] / dS;
                                                                dalpha_deps -= dalpha[iDim]*deps[iDim];
                                                        }
                                                       
                                                        my_Gradient += Sensitivity*dalpha_deps;
                                                        UpdatePoint[iPoint] = false;
                                                }
                                        }
                                }                               
    }

Does this imply that the deformation d \epsilon, deps in the code, is projected along the surface normal and then multiplied by Sensitivity? Why does this operation is needed since shape sensitivity is a gradient expressing the maximum change in the objective function due to a normal deformation?

In the picture attached below you find shape sensitivity with DRAG as objective function in blue, of_gradient in red. I don't understand why gradient evaluation doesn't follow shape sensitivity.

Cheers,
Roberto

rktchip July 25, 2013 13:03

hi roberto,
the adjoint approach implemented in SU2 solves for the sensitivity of a chosen objective to perturbations of the surface in the local normal direction. this must be chain ruled with the sensitivity of the surface to changes in the chosen design parameterization (ie hicks-henne bump function). to find this sensitivity SU2 uses a finite difference approximation, which is what the code snippet you quoted is doing. the size of the step used by SU2_GPC is chosen by the config option DV_VALUE_NEW. in previous studies we've seen that the accuracy of the overall design gradient is insensitive to the size of this step.

the plot you show is showing two different types of sensitivities. the solid line is showing the surface sensitivity (the first one i mentioned), and the x-axis is displacement tangent along the surface. the points are showing the overall design gradient, and the x-axis is the design variable index
-trent

Bortolazzi August 21, 2013 12:52

Hi developers,

Also concerning the gradients, I have seen that the subroutine that computes VarCoord (
grid_movement_structure.cpp >> CSurfaceMovement::SetHicksHenne
) evaluates a variation of the node's coordinates as it follows:


double Ampl_old = config->GetDV_Value_Old(iDV);
double Ampl_new = config->GetDV_Value_New(iDV);
double Ampl = Ampl_new - Ampl_old;

[…]

ek = log10(0.5)/log10(xk);
fk = pow( sin( PI_NUMBER * pow(Coord[0],ek) ) , t2);
/*--- Upper and lower surface ---*/
if (( upper) && (Normal[1] > 0)) { VarCoord[1] = Ampl*fk; }
if ((!upper) && (Normal[1] < 0)) { VarCoord[1] = -Ampl*fk; }

Which means that VarCoord is a variation of the coordinates due to a variation ∆δi of the design variable (∆δi=δi new δi old).

Yet, when computing the gradients (
SU2_GPC.cpp) , the variable deps is evaluated like this:
delta_eps = config->GetDV_Value_New(iDV);
[…]
deps[iDim] = VarCoord[iDim] / delta_eps;
}
dS = sqrt(dS);
dalpha_deps = 0.0;
for (iDim = 0; iDim < boundary->GetnDim(); iDim++) {
dalpha[iDim] = Normal[iDim] / dS;
dalpha_deps -= dalpha[iDim]*deps[iDim];
}
my_Gradient += Sensitivity*dalpha_deps;

That is,
deps[1] = ∆y/δinew = (δi new δi old)*fk / δinew
where fk is the kth bump function.
I didn’t understand the meaning of this step. I was expecting to evaluate deps by doing ∆y/(δi new δi old) instead of doing ∆y/δi new (in order to get the sensitivity of the node’s coordinates w.r.t. the design variable δi).
Is there a reason to do it like this?

Thanks in advance.

Cheers,

Andre

Bortolazzi August 22, 2013 05:15

Never mind, this comment in line 184 of SU2_GPC.ccp explains everything:

/*--- Load the delta change in the design variable (finite difference step).
Note that this assumes DV_Value_New = finite_diff_step and DV_Value_Old = 0.0
in the config file. ---*/

Best regards,

Andre

fpalacios August 26, 2013 16:22

Please note that we have removed the DV_Value_New and DV_Value_Old from the current developer's version. Currently, DV_Value is the only parameter.

Best,
Francisco


Quote:

Originally Posted by Bortolazzi (Post 447376)
Never mind, this comment in line 184 of SU2_GPC.ccp explains everything:

/*--- Load the delta change in the design variable (finite difference step).
Note that this assumes DV_Value_New = finite_diff_step and DV_Value_Old = 0.0
in the config file. ---*/

Best regards,

Andre



All times are GMT -4. The time now is 14:46.