def test_DLLM_valid_grad_TCl(self):
OC, wing_param = self.__init_wing_param()
x0 = wing_param.get_dv_array()
def f1(x):
wing_param.update_from_x_list(x)
DLLM = DLLMTargetCl('Simple', wing_param, OC)
DLLM.set_target_Cl(0.5)
DLLM.run_direct()
DLLM.run_post()
func = DLLM.get_F_list()
return func
def df1(x):
wing_param.update_from_x_list(x)
DLLM = DLLMTargetCl('Simple', wing_param, OC)
DLLM.set_target_Cl(0.5)
DLLM.run_direct()
DLLM.run_post()
DLLM.run_adjoint()
func_grad = array(DLLM.get_dF_list_dchi())
return func_grad
val_grad1 = FDValidGrad(2, f1, df1, fd_step=1.e-8)
ok1, df_fd1, df1 = val_grad1.compare(x0,
treshold=1.e-6,
split_out=True,
return_all=True)
assert (ok1)
def test_DLLM_valid_dpF_list_dpchi(self):
OC, wing_param = self.__init_wing_param()
DLLM = DLLMSolver('test', wing_param, OC)
print ''
DLLM.run_direct()
iAoA = DLLM.get_iAoA()
x0 = wing_param.get_dv_array()
def f2(x):
wing_param.update_from_x_list(x)
DLLM.set_wing_param(wing_param)
DLLM.comp_R(iAoA)
DLLM.set_direct_computed()
DLLM.run_post()
func = DLLM.get_F_list()
return func
def df2(x):
wing_param.update_from_x_list(x)
DLLM.set_wing_param(wing_param)
DLLM.comp_R(iAoA)
DLLM.set_direct_computed()
DLLM.run_post()
func_grad = DLLM.get_dpF_list_dpchi()
return func_grad
val_grad2 = FDValidGrad(2, f2, df2, fd_step=1.e-8)
ok2, df_fd2, df2 = val_grad2.compare(x0,
treshold=1.e-6,
split_out=True,
return_all=True)
assert (ok2)
def test_DLLM_valid_grad_TLift(self):
OC, wing_param = self.__init_wing_param()
x0 = wing_param.get_dv_array()
DLLM = DLLMTargetLift('Simple', wing_param, OC)
F_list_names = DLLM.get_DLLMPost().DEF_F_LIST_NAMES
F_list_names.remove('Lift')
def f2(x):
wing_param.update_from_x_list(x)
DLLM = DLLMTargetLift('Simple', wing_param, OC)
DLLM.set_target_Lift(769200.)
DLLM.set_F_list_names(F_list_names)
DLLM.run_direct()
DLLM.run_post()
func = DLLM.get_F_list()
return func
def df2(x):
wing_param.update_from_x_list(x)
DLLM = DLLMTargetLift('Simple', wing_param, OC)
DLLM.set_target_Lift(769200.)
DLLM.set_F_list_names(F_list_names)
DLLM.run_direct()
DLLM.run_post()
DLLM.run_adjoint()
func_grad = array(DLLM.get_dF_list_dchi())
return func_grad
val_grad2 = FDValidGrad(2, f2, df2, fd_step=1.e-8)
ok2, df_fd2, df2 = val_grad2.compare(x0,
treshold=1.e-6,
split_out=True,
return_all=True)
assert (ok2)
def test_DLLM_valid_dF_list_dchi(self):
OC, wing_param = self.__init_wing_param()
x0 = wing_param.get_dv_array()
def f4(x):
wing_param.update_from_x_list(x)
DLLM = DLLMSolver('test', wing_param, OC)
DLLM.run_direct()
DLLM.run_post()
func = DLLM.get_F_list()
return func
def df4(x):
wing_param.update_from_x_list(x)
DLLM = DLLMSolver('test', wing_param, OC)
DLLM.run_direct()
DLLM.run_post()
DLLM.run_adjoint()
func_grad = array(DLLM.get_dF_list_dchi())
return func_grad
val_grad4 = FDValidGrad(2, f4, df4, fd_step=1.e-8)
ok4, df_fd4, df4 = val_grad4.compare(x0,
treshold=1.e-6,
split_out=True,
return_all=True)
assert (ok4)
def test_DLLM_valid_dpF_list_dpW(self):
OC, wing_param = self.__init_wing_param()
DLLM = DLLMSolver('test', wing_param, OC)
print ''
DLLM.run_direct()
iAoA0 = DLLM.get_iAoA()
def f1(x):
DLLM.comp_R(x)
DLLM.set_direct_computed()
DLLM.run_post()
func = DLLM.get_F_list()
return func
def df1(x):
DLLM.comp_R(x)
DLLM.set_direct_computed()
DLLM.run_post()
func_grad = DLLM.get_dpF_list_dpW()
return func_grad
val_grad1 = FDValidGrad(2, f1, df1, fd_step=1.e-8)
ok1, df_fd1, df1 = val_grad1.compare(iAoA0,
treshold=1.e-6,
return_all=True)
assert (ok1)
def test_DLLM_valid_dpF_list_dpAoA(self):
OC, wing_param = self.__init_wing_param()
DLLM = DLLMSolver('test', wing_param, OC)
print ''
DLLM.run_direct()
iAoA = DLLM.get_iAoA()
AoA0 = OC.get_AoA_rad()
def f3(x):
OC.set_AoA_rad(x[0])
DLLM.comp_R(iAoA)
DLLM.set_direct_computed()
DLLM.run_post()
func = DLLM.get_F_list()
return func
def df3(x):
OC.set_AoA_rad(x[0])
DLLM.comp_R(iAoA)
DLLM.set_direct_computed()
DLLM.run_post()
func_grad = DLLM.get_dpF_list_dpAoA()
N = len(func_grad)
np_func_grad = zeros((N, 1))
np_func_grad[:, 0] = func_grad[:]
return np_func_grad
val_grad3 = FDValidGrad(2, f3, df3, fd_step=1.e-8)
ok3, df_fd3, df3 = val_grad3.compare([AoA0],
treshold=1.e-6,
split_out=True,
return_all=True)
assert (ok3)
def test_DLLM_valid_dpLoads_dpAoA(self):
OC, wing_param = self.__init_wing_param()
DLLM = DLLMSolver('test', wing_param, OC)
print ''
DLLM.run_direct()
iAoA0 = DLLM.get_iAoA()
AoA0 = OC.get_AoA_rad()
def f2(x):
OC.set_AoA_rad(x[0])
R = DLLM.comp_R(iAoA0)
Post = DLLM.get_DLLMPost()
func = Post.comp_Lift_distrib()
return func
def df2(x):
OC.set_AoA_rad(x[0])
R = DLLM.comp_R(iAoA0)
Post = DLLM.get_DLLMPost()
func_grad = Post.comp_dpLift_distrib_dpAoA()
N = len(func_grad)
np_func_grad = zeros((N, 1))
np_func_grad[:, 0] = func_grad[:]
return np_func_grad
val_grad2 = FDValidGrad(2, f2, df2, fd_step=1.e-8)
ok2, df_fd2, df2 = val_grad2.compare([AoA0],
treshold=1.e-5,
return_all=True)
assert (ok2)
def test_Wing_param_valid_grad_chords(self):
wing_param = self.__init_wing_param()
x0 = wing_param.get_dv_array()
def f2(x):
wing_param.update_from_x_list(x)
func = wing_param.get_chords()
return func
def df2(x):
wing_param.update_from_x_list(x)
func_grad = wing_param.get_chords_grad()
return func_grad
val_grad2 = FDValidGrad(2, f2, df2, fd_step=1.e-8)
ok2, df_fd2, df2 = val_grad2.compare(x0,
treshold=1.e-6,
return_all=True)
assert (ok2)
def test_Wing_param_valid_grad_XYZ(self):
wing_param = self.__init_wing_param()
x0 = wing_param.get_dv_array()
def f5(x):
wing_param.update_from_x_list(x)
func = wing_param.get_XYZ()
return func
def df5(x):
wing_param.update_from_x_list(x)
func_grad = wing_param.get_XYZ_grad()
return func_grad
val_grad5 = FDValidGrad(2, f5, df5, fd_step=1.e-8)
ok5, df_fd5, df5 = val_grad5.compare(x0,
treshold=1.e-6,
return_all=True)
assert (ok5)
def test_Wing_param_valid_grad_rel_thicks(self):
wing_param = self.__init_wing_param()
x0 = wing_param.get_dv_array()
def f3(x):
wing_param.update_from_x_list(x)
func = wing_param.get_rel_thicks()
return func
def df3(x):
wing_param.update_from_x_list(x)
func_grad = wing_param.get_rel_thicks_grad()
return func_grad
val_grad3 = FDValidGrad(2, f3, df3, fd_step=1.e-8)
ok3, df_fd3, df3 = val_grad3.compare(x0,
treshold=1.e-6,
return_all=True)
assert (ok3)
def test_Wing_param_valid_grad_twist(self):
wing_param = self.__init_wing_param()
x0 = wing_param.get_dv_array()
def f1(x):
wing_param.update_from_x_list(x)
func = wing_param.get_twist()
return func
def df1(x):
wing_param.update_from_x_list(x)
func_grad = wing_param.get_twist_grad()
return func_grad
val_grad1 = FDValidGrad(2, f1, df1, fd_step=1.e-8)
ok1, df_fd1, df1 = val_grad1.compare(x0,
treshold=1.e-6,
return_all=True)
assert (ok1)
def test_Wing_param_valid_grad_eta(self):
wing_param = self.__init_wing_param()
x0 = wing_param.get_dv_array()
def f4(x):
wing_param.update_from_x_list(x)
func = wing_param.get_eta()
return func
def df4(x):
wing_param.update_from_x_list(x)
func_grad = wing_param.get_eta_grad()
return func_grad
val_grad4 = FDValidGrad(2, f4, df4, fd_step=1.e-8)
ok4, df_fd4, df4 = val_grad4.compare(x0,
treshold=1.e-6,
return_all=True)
assert (ok4)
def test_DLLM_valid_dpR_dpthetaY(self):
OC,wing_param = self.__init_wing_param()
DLLM = DLLMSolver('test',wing_param,OC)
print ''
DLLM.run_direct()
iAoA=DLLM.get_iAoA()
thetaY0=wing_param.get_thetaY()
def f3(x):
wing_param.set_thetaY(x)
func=DLLM.comp_R(iAoA)
return func
def df3(x):
wing_param.set_thetaY(x)
func_grad=DLLM.comp_dpR_dpthetaY()
return func_grad
val_grad3=FDValidGrad(2,f3,df3,fd_step=1.e-8)
ok3,df_fd3,df3=val_grad3.compare(thetaY0,treshold=1.e-6,return_all=True)
assert(ok3)
def test_DLLM_valid_dpR_dpAoA(self):
OC,wing_param = self.__init_wing_param()
DLLM = DLLMSolver('test',wing_param,OC)
print ''
DLLM.run_direct()
iAoA = DLLM.get_iAoA()
AoA0=OC.get_AoA_rad()
def f4(x):
OC.set_AoA_rad(x[0])
func=DLLM.comp_R(iAoA)
return func
def df4(x):
OC.set_AoA_rad(x[0])
func_grad=DLLM.comp_dpR_dpAoA()
N=len(func_grad)
np_func_grad=zeros((N,1))
np_func_grad[:,0]=func_grad[:]
return np_func_grad
val_grad4=FDValidGrad(2,f4,df4,fd_step=1.e-8)
ok4,df_fd4,df4=val_grad4.compare([AoA0],treshold=1.e-6,return_all=True)
assert(ok4)
def test_DLLM_valid_dpLoads_dpiAoA(self):
OC, wing_param = self.__init_wing_param()
DLLM = DLLMSolver('test', wing_param, OC)
print ''
DLLM.run_direct()
iAoA0 = DLLM.get_iAoA()
def f1(x):
R = DLLM.comp_R(x)
Post = DLLM.get_DLLMPost()
func = Post.comp_Lift_distrib()
return func
def df1(x):
R = DLLM.comp_R(x)
Post = DLLM.get_DLLMPost()
func_grad = Post.comp_dpLift_distrib_dpiAoA()
return func_grad
val_grad1 = FDValidGrad(2, f1, df1, fd_step=1.e-8)
ok1, df_fd1, df1 = val_grad1.compare(iAoA0,
treshold=1.e-2,
return_all=True)
assert (ok1)
print 'dv_array=', x0
def f1(x):
wing_param.update_from_x_list(x)
func = wing_param.get_twist()
return func
def df1(x):
wing_param.update_from_x_list(x)
func_grad = wing_param.get_twist_grad()
return func_grad
val_grad1 = FDValidGrad(2, f1, df1, fd_step=1.e-8)
ok1, df_fd1, df1 = val_grad1.compare(x0, treshold=1.e-6, return_all=True)
def f2(x):
wing_param.update_from_x_list(x)
func = wing_param.get_chords()
return func
def df2(x):
wing_param.update_from_x_list(x)
func_grad = wing_param.get_chords_grad()
return func_grad
config_dict['Case.DLLM.relax_factor'] = 0.99
config_dict['Case.DLLM.stop_residual'] = 1e-9
config_dict['Case.DLLM.max_iterations'] = 100
list_log = glob('*.log')
for log in list_log:
os.remove(log)
MP = DLLMMP('Case')
MP.configure(config_dict)
MP.set_out_format('numpy')
MP.set_grad_format('numpy')
x0 = MP.get_x0()
val_grad = FDValidGrad(2, MP.run, MP.run_grad, fd_step=1.e-8)
ok, df_fd, df = val_grad.compare(x0,
treshold=1.e-6,
split_out=True,
return_all=True)
# for j in xrange(len(df[:,0])):
# fid=open('gradient_file'+str(j)+'.dat','w')
# for i in xrange(len(x0)):
# fid.write(str(i)+' '+str(df_fd[j,i])+' '+str(df[j,i])+'\n')
# fid.close()
print '\n****************************************************'
if ok:
print 'DLLMMP gradients are valid.'
else:
DLLM = DLLMSolver('Simple', wing_param, OC)
DLLM.run_direct()
iAoA0 = DLLM.get_iAoA()
AoA0 = OC.get_AoA_rad()
def f(x):
OC.set_AoA_rad(x[0])
func = DLLM.comp_R(iAoA0)
return func
def df(x):
OC.set_AoA_rad(x[0])
func_grad = DLLM.comp_dpR_dpAoA()
N = len(func_grad)
np_func_grad = numpy.zeros((N, 1))
np_func_grad[:, 0] = func_grad[:]
return np_func_grad
val_grad = FDValidGrad(2, f, df, fd_step=1.e-8)
ok, df_fd, df = val_grad.compare([AoA0], treshold=1.e-6, return_all=True)
print '\n****************************************************'
if ok:
print 'dpR_dpAoA is valid.'
else:
print '!!!! dpR_dpAoA is NOT valid !!!!'
print '****************************************************'
config_dict['cond1.DLLM.gamma_file_name'] = 'gamma.dat'
#config_dict['cond1.DLLM.F_list_names']=['Lift','Drag','Drag_Pressure','Drag_Friction','Cl', 'Cd', 'Cdp', 'Cdf', 'LoD']
#config_dict['cond1.DLLM.F_list_names']=['Lift','Drag','Drag_Pressure','Drag_Friction','LoD']
#config_dict['cond1.DLLM.target_Cl']=0.5
#config_dict['cond1.DLLM.target_Lift']=769200.
DLLMcond1 = DLLMWrapper('cond1')
DLLMcond1.configure(config_dict)
DLLMcond1.set_out_format('numpy')
DLLMcond1.set_grad_format('numpy')
x0 = DLLMcond1.get_x0()
print 'dv array shape', x0.shape
print 'dv_array=', x0
val_grad = FDValidGrad(2, DLLMcond1.run, DLLMcond1.run_grad, fd_step=1.e-8)
ok, df_fd, df = val_grad.compare(x0,
treshold=1.e-6,
split_out=True,
return_all=True)
for j in xrange(len(df[:, 0])):
fid = open('gradient_file' + str(j) + '.dat', 'w')
for i in xrange(len(x0)):
fid.write(str(i) + ' ' + str(df_fd[j, i]) + ' ' + str(df[j, i]) + '\n')
fid.close()
print '\n****************************************************'
if ok:
print 'DLLMWrapper gradients are valid.'
else:
