def setup_cb(comm):
# Create the solver
CFDSolver = ADFLOW(options=options, comm=comm, debug=False)
# Setup geometry/mesh
DVGeo = DVGeometry(ffdFile)
nTwist = 6
DVGeo.addRefAxis(
'wing',
Curve(x=numpy.linspace(5.0 / 4.0, 1.5 / 4.0 + 7.5, nTwist),
y=numpy.zeros(nTwist),
z=numpy.linspace(0, 14, nTwist),
k=2))
def twist(val, geo):
for i in range(nTwist):
geo.rot_z['wing'].coef[i] = val[i]
DVGeo.addGeoDVGlobal('twist', [0] * nTwist,
twist,
lower=-10,
upper=10,
scale=1.0)
DVGeo.addGeoDVLocal('shape', lower=-0.5, upper=0.5, axis='y', scale=10.0)
mesh = USMesh(options=meshOptions, comm=comm)
CFDSolver.setMesh(mesh)
CFDSolver.setDVGeo(DVGeo)
return CFDSolver, mesh, DVGeo, None
def setUp(self):
if not hasattr(self, "name"):
# return immediately when the setup method is being called on the based class and NOT the
# classes created using parametrized
# this will happen when training, but will hopefully be fixed down the line
return
super().setUp()
options = copy.copy(adflowDefOpts)
options["outputdirectory"] = os.path.join(baseDir, options["outputdirectory"])
options.update(self.options)
self.ffdFile = os.path.join(baseDir, "../../input_files/mdo_tutorial_ffd.fmt")
mesh_options = copy.copy(IDWarpDefOpts)
mesh_options.update({"gridFile": options["gridfile"]})
self.ap = copy.deepcopy(self.aero_prob)
# Setup aeroproblem
self.ap.evalFuncs = self.evalFuncs
# add the default dvs to the problem
for dv in defaultAeroDVs:
self.ap.addDV(dv)
self.CFDSolver = ADFLOW(options=options, debug=True)
self.CFDSolver.setMesh(USMesh(options=mesh_options))
self.CFDSolver.setDVGeo(setDVGeo(self.ffdFile, cmplx=False))
# propagates the values from the restart file throughout the code
self.CFDSolver.getResidual(self.ap)
def setUp(self):
super().setUp()
gridFile = os.path.join(
baseDir, "../../input_files/mdo_tutorial_euler_scalar_jst.cgns")
options = copy.copy(adflowDefOpts)
options["outputdirectory"] = os.path.join(baseDir,
options["outputdirectory"])
options.update({
"gridfile": gridFile,
"solutionprecision": "double",
"gridprecision": "double",
"mgcycle": "2w",
"ncyclescoarse": 250,
"ncycles": 500,
"usenksolver": True,
"nkswitchtol": 1e-2,
"l2convergence": 1e-14,
"l2convergencecoarse": 1e-2,
})
# Setup aeroproblem
self.ap = copy.copy(ap_tutorial_wing)
# Create the solver
self.CFDSolver = ADFLOW(options=options, debug=False)
def setup_cb(comm):
solver = ADFLOW(options=options, comm=comm, debug=False)
solver.addFamilyGroup('upstream',['INFLOW'])
solver.addFamilyGroup('downstream',['OUTFLOW'])
solver.addFamilyGroup('all_flow',['INFLOW', 'OUTFLOW'])
solver.addFunction('mdot', 'upstream', name="mdot_up")
solver.addFunction('mdot', 'downstream', name="mdot_down")
solver.addFunction('mavgptot', 'downstream', name="mavgptot_down")
solver.addFunction('mavgptot', 'upstream', name="mavgptot_up")
solver.addFunction('aavgptot', 'downstream', name="aavgptot_down")
solver.addFunction('aavgptot', 'upstream', name="aavgptot_up")
solver.addFunction('mavgttot', 'downstream', name="mavgttot_down")
solver.addFunction('mavgttot', 'upstream', name="mavgttot_up")
solver.addFunction('mavgps', 'downstream', name="mavgps_down")
solver.addFunction('mavgps', 'upstream', name="mavgps_up")
solver.addFunction('aavgps', 'downstream', name="aavgps_down")
solver.addFunction('aavgps', 'upstream', name="aavgps_up")
solver.addFunction('mavgmn', 'downstream', name="mavgmn_down")
solver.addFunction('mavgmn', 'upstream', name="mavgmn_up")
solver.addFunction('drag', 'all_flow', name="thrust") # this naming makes it seem like wishful thinking
solver.addFunction('dragpressure', 'all_flow', name="thrust_pressure")
solver.addFunction('dragviscous', 'all_flow', name="thrust_viscous")
solver.addFunction('dragmomentum', 'all_flow', name="thrust_momentum")
return solver, None, None, None
def setUp(self):
if not hasattr(self, "name"):
# return immediately when the setup method is being called on the based class and NOT the
# classes created using parametrized
# this will happen when training, but will hopefully be fixed down the line
return
super().setUp()
# start with the default options dictionary
options = copy.copy(adflowDefOpts)
# set the output directory
options["outputdirectory"] = os.path.join(baseDir,
options["outputdirectory"])
# these are the modified options common to these tests
options.update(commonTestOptions)
# finally, bring in the specific options for each parameterized test
options.update(self.options)
self.ap = copy.deepcopy(ap_simple_cart_cube)
# Create the solver
self.CFDSolver = ADFLOW(options=options, debug=False)
def test_import(self):
CFDSolver = ADFLOW(options=self.options, debug=False)
res = CFDSolver.getResidual(ap_tutorial_wing)
res_norm = np.linalg.norm(res)
np.testing.assert_allclose(res_norm,
0.0,
atol=1e-11,
err_msg="residual")
def test_import_block_splitting(self):
self.options["partitionLikeNProc"] = 50
CFDSolver = ADFLOW(options=self.options, debug=False)
res = CFDSolver.getResidual(ap_tutorial_wing)
res_norm = np.linalg.norm(res)
np.testing.assert_allclose(res_norm,
0.0,
atol=1e-11,
err_msg="residual")
def setUp(self):
super().setUp()
options = copy.copy(adflowDefOpts)
options["outputdirectory"] = os.path.join(baseDir,
options["outputdirectory"])
options.update(self.options)
# Create the solver
self.CFDSolver = ADFLOW(options=options, debug=False)
self.CFDSolver.addFamilyGroup("upstream", ["INFLOW"])
self.CFDSolver.addFamilyGroup("downstream", ["OUTFLOW"])
self.CFDSolver.addFamilyGroup("all_flow", ["INFLOW", "OUTFLOW"])
self.CFDSolver.addFunction("mdot", "upstream", name="mdot_up")
self.CFDSolver.addFunction("mdot", "downstream", name="mdot_down")
self.CFDSolver.addFunction("mavgptot",
"downstream",
name="mavgptot_down")
self.CFDSolver.addFunction("mavgptot", "upstream", name="mavgptot_up")
self.CFDSolver.addFunction("aavgptot",
"downstream",
name="aavgptot_down")
self.CFDSolver.addFunction("aavgptot", "upstream", name="aavgptot_up")
self.CFDSolver.addFunction("mavgttot",
"downstream",
name="mavgttot_down")
self.CFDSolver.addFunction("mavgttot", "upstream", name="mavgttot_up")
self.CFDSolver.addFunction("mavgps", "downstream", name="mavgps_down")
self.CFDSolver.addFunction("mavgps", "upstream", name="mavgps_up")
self.CFDSolver.addFunction("aavgps", "downstream", name="aavgps_down")
self.CFDSolver.addFunction("aavgps", "upstream", name="aavgps_up")
self.CFDSolver.addFunction("mavgmn", "downstream", name="mavgmn_down")
self.CFDSolver.addFunction("mavgmn", "upstream", name="mavgmn_up")
self.CFDSolver.addFunction(
"drag", "all_flow",
name="thrust") # this naming makes it seem like wishful thinking
self.CFDSolver.addFunction("dragpressure",
"all_flow",
name="thrust_pressure")
self.CFDSolver.addFunction("dragviscous",
"all_flow",
name="thrust_viscous")
self.CFDSolver.addFunction("dragmomentum",
"all_flow",
name="thrust_momentum")
def setUp(self):
super().setUp()
options = copy.copy(adflowDefOpts)
options.update(self.options)
# Setup aeroproblem
self.ap.setBCVar("Pressure", 79326.7, "downstream")
self.ap.addDV("Pressure", family="downstream")
self.ap.setBCVar("PressureStagnation", 100000.0, "upstream")
self.ap.addDV("PressureStagnation", family="upstream")
self.ap.setBCVar("TemperatureStagnation", 500.0, "upstream")
self.ap.addDV("TemperatureStagnation", family="upstream")
# Create the solver
self.CFDSolver = ADFLOW(options=options, debug=False)
self.CFDSolver.addFamilyGroup("upstream", ["inlet"])
self.CFDSolver.addFamilyGroup("downstream", ["outlet"])
self.CFDSolver.addFamilyGroup("all_flow", ["inlet", "outlet"])
self.CFDSolver.addFamilyGroup("output_fam", ["all_flow", "allWalls"])
self.CFDSolver.addFunction("mdot", "upstream", name="mdot_up")
self.CFDSolver.addFunction("mdot", "downstream", name="mdot_down")
self.CFDSolver.addFunction("mavgptot",
"downstream",
name="mavgptot_down")
self.CFDSolver.addFunction("mavgptot", "upstream", name="mavgptot_up")
self.CFDSolver.addFunction("aavgptot",
"downstream",
name="aavgptot_down")
self.CFDSolver.addFunction("aavgptot", "upstream", name="aavgptot_up")
self.CFDSolver.addFunction("mavgttot",
"downstream",
name="mavgttot_down")
self.CFDSolver.addFunction("mavgttot", "upstream", name="mavgttot_up")
self.CFDSolver.addFunction("mavgps", "downstream", name="mavgps_down")
self.CFDSolver.addFunction("mavgps", "upstream", name="mavgps_up")
self.CFDSolver.addFunction("aavgps", "downstream", name="aavgps_down")
self.CFDSolver.addFunction("aavgps", "upstream", name="aavgps_up")
def setUp(self):
if not hasattr(self, "name"):
# return immediately when the setup method is being called on the based class and NOT the
# classes created using parametrized
# this will happen when training, but will hopefully be fixed down the line
return
super().setUp()
options = copy.copy(adflowDefOpts)
options["outputdirectory"] = os.path.join(baseDir, options["outputdirectory"])
options.update(self.options)
self.ap = copy.deepcopy(self.aero_prob)
# Create the solver
self.CFDSolver = ADFLOW(options=options, debug=False)
def setup_cb(comm):
solver = ADFLOW(options=options, comm=comm, debug=True)
solver.addIntegrationSurface('../inputFiles/integration_plane_viscous.fmt',
'viscous_plane')
solver.finalizeUserIntegrationSurfaces()
solver.addFamilyGroup('upstream', ['inlet'])
solver.addFamilyGroup('downstream', ['outlet'])
solver.addFamilyGroup('all_flow', ['inlet', 'outlet'])
solver.addFamilyGroup('output_fam', ['all_flow', 'allWalls'])
solver.addFunction('mdot', 'upstream', name="mdot_up")
solver.addFunction('mdot', 'downstream', name="mdot_down")
solver.addFunction('mdot', 'viscous_plane', name="mdot_plane")
solver.addFunction('mavgptot', 'downstream', name="mavgptot_down")
solver.addFunction('mavgptot', 'upstream', name="mavgptot_up")
solver.addFunction('mavgptot', 'viscous_plane', name="mavgptot_plane")
solver.addFunction('aavgptot', 'downstream', name="aavgptot_down")
solver.addFunction('aavgptot', 'upstream', name="aavgptot_up")
solver.addFunction('aavgptot', 'viscous_plane', name="aavgptot_plane")
solver.addFunction('mavgttot', 'downstream', name="mavgttot_down")
solver.addFunction('mavgttot', 'upstream', name="mavgttot_up")
solver.addFunction('mavgttot', 'viscous_plane', name="mavgttot_plane")
solver.addFunction('mavgps', 'downstream', name="mavgps_down")
solver.addFunction('mavgps', 'upstream', name="mavgps_up")
solver.addFunction('mavgps', 'viscous_plane', name="mavgps_plane")
solver.addFunction('aavgps', 'downstream', name="aavgps_down")
solver.addFunction('aavgps', 'upstream', name="aavgps_up")
solver.addFunction('aavgps', 'viscous_plane', name="aavgps_plane")
solver.setOption('ncycles', 1000)
return solver, None, None, None
def test_failed_mesh(self):
options = copy.copy(adflowDefOpts)
options.update({
"outputdirectory":
os.path.join(baseDir, options["outputdirectory"]),
"gridFile":
os.path.join(
baseDir,
"../../input_files/mdo_tutorial_euler_scalar_jst.cgns"),
"mgcycle":
"sg",
})
# Create the solver
CFDSolver = ADFLOW(options=options)
ap = copy.copy(ap_tutorial_wing)
# pretend mesh warping failed
CFDSolver.adflow.killsignals.fatalfail = True
# Solve
CFDSolver(ap)
self.failed_mesh = os.path.join(options["outputDirectory"],
f"failed_mesh_{ap.name}_000.cgns")
self.assertTrue(os.path.isfile(self.failed_mesh))
def setUp(self):
if not hasattr(self, "name"):
# return immediately when the setup method is being called on the based class and NOT the
# classes created using parametrized
# this will happen when testing, but will hopefully be fixed down the line
return
super().setUp()
options = copy.copy(adflowDefOpts)
options["outputdirectory"] = os.path.join(baseDir,
options["outputdirectory"])
options.update(self.options)
# Create the solver
self.CFDSolver = ADFLOW(options=copy.deepcopy(options), debug=True)
self.ap = copy.deepcopy(self.aero_prob)
# add the default dvs to the problem
for dv in defaultAeroDVs:
self.ap.addDV(dv)
# propagates the values from the restart file throughout the code
self.CFDSolver.getResidual(self.ap)
def MLMC(self):
# Use an MLMC algorithm to determine an optimal sample distribution between existing mesh levels
# We do this once before optimization, then compute statistics with the same set of samples at every iteration
# start with initial samples
# Get a set of UQ sample points (LHS), enough for each level at the start
#sys.stdout = open(os.devnull, "w")
# flow characteristics
alpha = 0.0
mach = self.ooptions['mach'] #0.95
Re = self.ooptions['Re'] #50000
Re_L = 1.0
tempR = 540
arearef = 2.0
chordref = 1.0
a_init = self.DVGeo.getValues()
a_init['pnts'][:] = self.ooptions['DVInit']
self.current_samples = self.NS0 * self.Lmax
if rank == 0:
rank0sam = plate_sa_lhs.genLHS(s=self.current_samples)
else:
rank0sam = None
self.sample = comm.bcast(rank0sam, root=0)
# Scatter samples on each level, multi-point parallelism
for i in range(self.Lmax):
self.cases.append(divide_cases(self.NS0, size))
for j in range(len(self.cases[i])):
for k in range(len(self.cases[i][j])):
self.cases[i][j][k] += i * self.NS0
#self.nsp.append(len(self.cases[i][rank]))#int(ns/size) # samples per processor
self.samplep.append(self.sample[self.cases[i][rank]])
#import pdb; pdb.set_trace()
#self.samplep = self.sample[self.cases[rank]]#self.sample[(rank*self.nsp):(rank*self.nsp+(self.nsp))] #shouldn't really need to "scatter" per se
#import pdb; pdb.set_trace()
# for i in range(self.Lmax):
# assert len(self.samplep[i]) == self.nsp[i]
# Actually create solvers (and aeroproblems?) (and mesh?) now
nslp = []
nslt = []
for k in range(self.Lmax):
alist = []
slist = []
mlist = []
alist2 = []
slist2 = []
mlist2 = []
nslp.append(len(self.cases[k][rank]))
nslt.append(sum([len(self.cases[k][x]) for x in range(size)]))
for i in range(nslp[k]):
namestr = self.gridSol + "_" + str(self.cases[k][rank][i])
# create meshes
leveloptions = self.woptions
leveloptions['gridFile'] = self.meshnames[k]
mlist.append(USMesh(options=leveloptions, comm=MPI.COMM_SELF))
# create aeroproblems
aloptions = self.aoptions
aloptions['gridFile'] = self.meshnames[k]
alist.append(
AeroProblem(name=namestr,
alpha=alpha,
mach=mach,
reynolds=Re,
reynoldsLength=Re_L,
T=tempR,
areaRef=arearef,
chordRef=chordref,
evalFuncs=['cd']))
time.sleep(0.1) # this solves a few problems for some reason
# create solvers
slist.append(ADFLOW(options=aloptions, comm=MPI.COMM_SELF))
# if not self.ooptions['run_once']:
# saconstsm = self.samplep[i].tolist()
# else:
saconstsm = self.samplep[k][i].tolist()
self.saconsts = saconstsm + self.saconstsb
slist[i].setOption('SAConsts', self.saconsts)
slist[i].setDVGeo(self.DVGeo)
slist[i].setMesh(mlist[i])
coords = slist[i].getSurfaceCoordinates(
groupName=slist[i].allWallsGroup)
slist[i].DVGeo.addPointSet(coords, 'coords')
if k > 0: #create additional solvers at higher levels for the estimators
# create meshes
namestr = self.gridSol + "_" + str(
self.cases[k][rank][i]) + "_m"
leveloptions = self.woptions
leveloptions['gridFile'] = self.meshnames[k - 1]
mlist2.append(
USMesh(options=leveloptions, comm=MPI.COMM_SELF))
# create aeroproblems
aloptions = self.aoptions
aloptions['gridFile'] = self.meshnames[k - 1]
alist2.append(
AeroProblem(name=namestr,
alpha=alpha,
mach=mach,
reynolds=Re,
reynoldsLength=Re_L,
T=tempR,
areaRef=arearef,
chordRef=chordref,
evalFuncs=['cd']))
time.sleep(
0.1) # this solves a few problems for some reason
# create solvers
slist2.append(ADFLOW(options=aloptions,
comm=MPI.COMM_SELF))
slist2[i].setOption('SAConsts', self.saconsts)
slist2[i].setDVGeo(self.DVGeo)
slist2[i].setMesh(mlist2[i])
coords = slist[i].getSurfaceCoordinates(
groupName=slist2[i].allWallsGroup)
slist2[i].DVGeo.addPointSet(coords, 'coords')
self.aps.append(alist)
self.solvers.append(slist)
self.meshes.append(mlist)
if k > 0:
self.aps[k] += alist2
self.solvers[k] += slist2
self.meshes[k] += mlist2
#import pdb; pdb.set_trace()
# start looping over mesh levels
L = 0
M = 4.0 #0.5 #refinement factor?
converged = 0
eps = self.uoptions['vartol']
sum1 = []
mus = []
sump = []
musp = []
sumpm = []
muspm = []
summ = []
musm = []
E = []
V = []
N1 = []
while ~converged & L < self.Lmax:
# compute start up samples to estimate variance
dvdict = {'pnts': a_init['pnts']}
funcs = {}
nslp = []
nslt = []
for k in range(self.Lmax):
nslp.append(len(self.cases[k][rank]))
nslt.append(sum([len(self.cases[k][x]) for x in range(size)]))
sump.append(0.)
musp.append(numpy.zeros(nslp[L]))
sumpm.append(0.)
muspm.append(numpy.zeros(nslp[L]))
for i in range(nslp[L]):
# just do this again in case
saconstsm = self.samplep[L][i].tolist()
self.saconsts = saconstsm + self.saconstsb
self.solvers[L][i].setOption('SAConsts', self.saconsts)
self.solvers[L][i].DVGeo.setDesignVars(dvdict)
self.aps[L][i].setDesignVars(dvdict)
self.solvers[L][i](self.aps[L][i])
self.solvers[L][i].evalFunctions(self.aps[L][i], funcs)
astr = self.gridSol + "_" + str(self.cases[L][rank][i]) + "_cd"
musp[L][i] = funcs[astr]
sump[L] += funcs[astr]
#import pdb; pdb.set_trace()
if L > 0:
self.solvers[L][i + nslp[L]].setOption(
'SAConsts', self.saconsts)
self.solvers[L][i + nslp[L]].DVGeo.setDesignVars(dvdict)
self.aps[L][i + nslp[L]].setDesignVars(dvdict)
self.solvers[L][i + nslp[L]](self.aps[L][i + nslp[L]])
self.solvers[L][i + nslp[L]].evalFunctions(
self.aps[L][i + nslp[L]], funcs)
astr = self.gridSol + "_" + str(
self.cases[L][rank][i]) + "_m_cd"
muspm[L][i] = -funcs[astr]
sumpm[L] += -funcs[astr]
# compute mean and variance estimate from start up samples
sum1.append(comm.allreduce(sump[L]))
mus.append(comm.allgather(musp[L]))
summ.append(comm.allreduce(sumpm[L]))
musm.append(comm.allgather(muspm[L]))
#import pdb; pdb.set_trace()
# mean at each level
E = numpy.zeros(L + 1)
for l in range(L + 1):
E[l] = (sum1[l] + summ[l]) / nslt[l]
# variance at each level
V = numpy.zeros(L + 1)
for l in range(L + 1):
sum2 = 0.
for i in range(len(mus[l])): #range(size):
for j in range(len(mus[l][i])): #range(self.nsp):
if l > 0:
sum2 += ((mus[l][i][j] + musm[l][i][j]) - E[l])**2
else:
sum2 += (mus[l][i][j] - E[l])**2
V[l] = sum2 / nslt[l]
#import pdb; pdb.set_trace()
# now determine the optimal number of samples at each level
N1.append(0.)
worksum = 0
for l in range(L + 1):
worksum += numpy.sqrt(V[l] * (M**l))
for l in range(L + 1):
nlf = 2 * numpy.sqrt(V[l] / (M**l)) * worksum / (eps * eps)
nlfm = max(nslt[l], math.ceil(nlf))
N1[l] = nlfm
# now compute and generate additional samples at each level
# first partition samples NEVERMIND (just do it once at each level, no need to repeat)
# create the extra number of solvers at each (the current) level
# need to loop everything from here on
for l in range(L + 1):
alist = self.aps[l][0:nslp[l]]
slist = self.solvers[l][0:nslp[l]]
mlist = self.meshes[l][0:nslp[l]]
if l > 0:
alist2 = self.aps[l][nslp[l]:]
slist2 = self.solvers[l][nslp[l]:]
mlist2 = self.meshes[l][nslp[l]:]
self.naddedtot[l] = N1[l] - nslt[l]
self.current_samples += self.naddedtot[l]
#import pdb; pdb.set_trace()
if rank == 0:
rank0sam = plate_sa_lhs.genLHS(s=self.current_samples)
else:
rank0sam = None
self.sample = comm.bcast(rank0sam, root=0)
if self.naddedtot[l] > 0:
temp = divide_cases(self.naddedtot[l], size)
for i in range(len(temp)):
for j in range(len(temp[i])):
temp[i][j] += self.current_samples - self.naddedtot[
l] #self.Lmax*self.NS0 + sum(self.naddedtot[0:L])
else:
temp = []
if len(temp):
for ns in range(size):
self.cases[l][ns] += temp[ns] #append
nslpnew = len(self.cases[l][rank])
nsltnew = sum([len(self.cases[l][x]) for x in range(size)])
#self.nsp[L] = len(self.cases[L][rank]) #int(ns/size) # samples per processor
self.samplep[l] = self.sample[self.cases[l][rank]]
for i in range(nslp[l],
nslpnew): #need it to be just the extra cases
#import pdb; pdb.set_trace()
namestr = self.gridSol + "_" + str(self.cases[l][rank][i])
# create meshes
leveloptions = self.woptions
leveloptions['gridFile'] = self.meshnames[l]
mlist.append(
USMesh(options=leveloptions, comm=MPI.COMM_SELF))
# create aeroproblems
aloptions = self.aoptions
aloptions['gridFile'] = self.meshnames[l]
alist.append(
AeroProblem(name=namestr,
alpha=alpha,
mach=mach,
reynolds=Re,
reynoldsLength=Re_L,
T=tempR,
areaRef=arearef,
chordRef=chordref,
evalFuncs=['cd']))
time.sleep(
0.1) # this solves a few problems for some reason
# create solvers
slist.append(ADFLOW(options=aloptions, comm=MPI.COMM_SELF))
saconstsm = self.samplep[l][i].tolist()
self.saconsts = saconstsm + self.saconstsb
slist[i].setOption('SAConsts', self.saconsts)
slist[i].setDVGeo(self.DVGeo)
slist[i].setMesh(mlist[i])
coords = slist[i].getSurfaceCoordinates(
groupName=slist[i].allWallsGroup)
slist[i].DVGeo.addPointSet(coords, 'coords')
time.sleep(0.1)
if l > 0: #create additional solvers at higher levels for the estimators
# create meshes
#import pdb; pdb.set_trace()
namestr = self.gridSol + "_" + str(
self.cases[l][rank][i]) + "_m"
leveloptions = self.woptions
leveloptions['gridFile'] = self.meshnames[l - 1]
mlist2.append(
USMesh(options=leveloptions, comm=MPI.COMM_SELF))
# create aeroproblems
aloptions = self.aoptions
aloptions['gridFile'] = self.meshnames[l - 1]
alist2.append(
AeroProblem(name=namestr,
alpha=alpha,
mach=mach,
reynolds=Re,
reynoldsLength=Re_L,
T=tempR,
areaRef=arearef,
chordRef=chordref,
evalFuncs=['cd']))
time.sleep(
0.1) # this solves a few problems for some reason
# create solvers
slist2.append(
ADFLOW(options=aloptions, comm=MPI.COMM_SELF))
slist2[i].setOption('SAConsts', self.saconsts)
slist2[i].setDVGeo(self.DVGeo)
slist2[i].setMesh(mlist2[i])
coords = slist[i].getSurfaceCoordinates(
groupName=slist2[i].allWallsGroup)
slist2[i].DVGeo.addPointSet(coords, 'coords')
nslp[l] = nslpnew
nslt[l] = nsltnew
self.aps[l] = alist
self.solvers[l] = slist
self.meshes[l] = mlist
if l > 0:
self.aps[l] += alist2
self.solvers[l] += slist2
self.meshes[l] += mlist2
# compute remaining samples
sump[l] = 0
sumpm[l] = 0
musp[l] = numpy.zeros(nslp[l])
muspm[l] = numpy.zeros(nslp[l])
for i in range(nslp[l]):
# just do this again in case
saconstsm = self.samplep[l][i].tolist()
self.saconsts = saconstsm + self.saconstsb
self.solvers[l][i].setOption('SAConsts', self.saconsts)
self.solvers[l][i].DVGeo.setDesignVars(dvdict)
self.aps[l][i].setDesignVars(dvdict)
self.solvers[l][i](self.aps[l][i])
self.solvers[l][i].evalFunctions(self.aps[l][i], funcs)
astr = self.gridSol + "_" + str(
self.cases[l][rank][i]) + "_cd"
musp[l][i] = funcs[astr]
sump[l] += funcs[astr]
#import pdb; pdb.set_trace()
if l > 0:
self.solvers[l][i + nslp[l]].setOption(
'SAConsts', self.saconsts)
self.solvers[l][i +
nslp[l]].DVGeo.setDesignVars(dvdict)
self.aps[l][i + nslp[l]].setDesignVars(dvdict)
self.solvers[l][i + nslp[l]](self.aps[l][i + nslp[l]])
self.solvers[l][i + nslp[l]].evalFunctions(
self.aps[l][i + nslp[l]], funcs)
astr = self.gridSol + "_" + str(
self.cases[l][rank][i]) + "_m_cd"
muspm[l][i] = -funcs[astr]
sumpm[l] += -funcs[astr]
# compute mean and variance estimate from all samples
sum1[l] = comm.allreduce(sump[l])
mus[l] = comm.allgather(musp[l])
summ[l] = comm.allreduce(sumpm[l])
musm[l] = comm.allgather(muspm[l])
# mean at each level
E[l] = (sum1[l] + summ[l]) / nslt[l]
# variance at each level
sum2 = 0.
for i in range(len(mus[l])): #range(size):
for j in range(len(mus[l][i])): #range(self.nsp):
if l > 0:
sum2 += ((mus[l][i][j] + musm[l][i][j]) - E[l])**2
else:
sum2 += (mus[l][i][j] - E[l])**2
V[l] = sum2 / nslt[l]
# if L == 1:
# import pdb; pdb.set_trace()
L += 1
#import pdb; pdb.set_trace()
#sys.stdout = sys.__stdout__
if rank == 0:
print("MLMC Completed, Samples per level: ", N1)
self.N1 = N1
def setUp(self):
super().setUp()
self.ap = copy.copy(ap_conic_conv_nozzle)
options = copy.copy(adflowDefOpts)
options.update(self.options)
# Setup aeroproblem
planeFile = os.path.join(
baseDir, "../../input_files/integration_plane_viscous.fmt")
options = copy.copy(adflowDefOpts)
options.update(self.options)
# Setup aeroproblem
self.ap.evalFuncs.extend([
"mdot_plane", "mavgptot_plane", "aavgptot_plane", "mavgttot_plane",
"mavgps_plane", "aavgps_plane"
])
# Create the solver
self.CFDSolver = ADFLOW(options=options, debug=False)
self.CFDSolver.addIntegrationSurface(planeFile, "viscous_plane")
self.CFDSolver.finalizeUserIntegrationSurfaces()
self.CFDSolver.addFamilyGroup("upstream", ["inlet"])
self.CFDSolver.addFamilyGroup("downstream", ["outlet"])
self.CFDSolver.addFamilyGroup("all_flow", ["inlet", "outlet"])
self.CFDSolver.addFamilyGroup("output_fam", ["all_flow", "allWalls"])
self.CFDSolver.addFunction("mdot", "upstream", name="mdot_up")
self.CFDSolver.addFunction("mdot", "downstream", name="mdot_down")
self.CFDSolver.addFunction("mdot", "viscous_plane", name="mdot_plane")
self.CFDSolver.addFunction("mavgptot",
"downstream",
name="mavgptot_down")
self.CFDSolver.addFunction("mavgptot", "upstream", name="mavgptot_up")
self.CFDSolver.addFunction("mavgptot",
"viscous_plane",
name="mavgptot_plane")
self.CFDSolver.addFunction("aavgptot",
"downstream",
name="aavgptot_down")
self.CFDSolver.addFunction("aavgptot", "upstream", name="aavgptot_up")
self.CFDSolver.addFunction("aavgptot",
"viscous_plane",
name="aavgptot_plane")
self.CFDSolver.addFunction("mavgttot",
"downstream",
name="mavgttot_down")
self.CFDSolver.addFunction("mavgttot", "upstream", name="mavgttot_up")
self.CFDSolver.addFunction("mavgttot",
"viscous_plane",
name="mavgttot_plane")
self.CFDSolver.addFunction("mavgps", "downstream", name="mavgps_down")
self.CFDSolver.addFunction("mavgps", "upstream", name="mavgps_up")
self.CFDSolver.addFunction("mavgps",
"viscous_plane",
name="mavgps_plane")
self.CFDSolver.addFunction("aavgps", "downstream", name="aavgps_down")
self.CFDSolver.addFunction("aavgps", "upstream", name="aavgps_up")
self.CFDSolver.addFunction("aavgps",
"viscous_plane",
name="aavgps_plane")
def setUp(self):
super().setUp()
self.options = {
"gridfile": os.path.join(baseDir, "../../input_files/actuator_test_pipe.cgns"),
# the restart file was ran with thrust = 600 N and heat = 1e5 W
"restartfile": os.path.join(baseDir, "../../input_files/actuator_test_pipe.cgns"),
"writevolumesolution": False,
"writesurfacesolution": False,
"writetecplotsurfacesolution": False,
"mgcycle": "sg",
"ncycles": 1000,
"useanksolver": True,
"usenksolver": True,
"anksecondordswitchtol": 1e-2,
"nkswitchtol": 1e-4,
"volumevariables": ["temp", "mach", "resrho"],
"surfacevariables": ["temp", "vx", "vy", "vz", "p", "ptloss", "mach", "rho"],
"equationType": "Euler",
"l2convergence": 1e-13,
"adjointl2convergence": 1e-13,
}
options = copy.copy(adflowDefOpts)
options["outputdirectory"] = os.path.join(baseDir, options["outputdirectory"])
options.update(self.options)
CFDSolver = ADFLOW(options=options)
CFDSolver.addFunction("mdot", "inlet", name="mdot_in")
CFDSolver.addFunction("mdot", "outlet", name="mdot_out")
CFDSolver.addFunction("aavgptot", "outlet", name="aavgptot_out")
CFDSolver.addFunction("aavgptot", "inlet", name="aavgptot_in")
CFDSolver.addFunction("mavgttot", "outlet", name="mavgttot_out")
CFDSolver.addFunction("mavgttot", "inlet", name="mavgttot_in")
CFDSolver.addFunction("aavgps", "outlet", name="aavgps_out")
CFDSolver.addFunction("aavgps", "inlet", name="aavgps_in")
CFDSolver.addFunction("area", "inlet", name="area_in")
CFDSolver.addFunction("area", "outlet", name="area_out")
CFDSolver.addFunction("mavgvx", "inlet", name="mavgvx_in")
CFDSolver.addFunction("mavgvx", "outlet", name="mavgvx_out")
CFDSolver.addFunction("forcexpressure", "inlet", name="forcexpressure_in")
CFDSolver.addFunction("forcexpressure", "outlet", name="forcexpressure_out")
CFDSolver.addFunction("forcexmomentum", "inlet", name="forcexmomentum_in")
CFDSolver.addFunction("forcexmomentum", "outlet", name="forcexmomentum_out")
self.CFDSolver = CFDSolver
# this is imported from reg_aeroproblems utility script
self.ap = ap_actuator_pipe
actuatorFile = os.path.join(baseDir, "../../input_files/actuator_test_disk.xyz")
self.CFDSolver.addActuatorRegion(
actuatorFile,
np.array([0, 0, 0]),
np.array([1, 0, 0]),
"actuator_region",
# we will set these individually in the tests below
thrust=0.0,
torque=0.0,
heat=0.0,
)
# add thrust and heat as AP DVs
self.ap.setBCVar("Thrust", 0.0, "actuator_region")
self.ap.addDV("Thrust", family="actuator_region", units="N", name="thrust")
self.ap.setBCVar("Heat", 0.0, "actuator_region")
self.ap.addDV("Heat", family="actuator_region", units="J/s", name="heat")
# also add flowpower as an AZ function
CFDSolver.addFunction("flowpower", "actuator_region", name="flowpower_az")
def test_import(self):
gridFile = "input_files/mdo_tutorial_euler.cgns"
options = {"gridfile": os.path.join(baseDir, "../../", gridFile)}
ADFLOW(options=options, debug=False)
def dist_samples(self):
# If we already have the number of samples, just create as many solvers as needed at each level
# Just do this after running MLMC() anyway
# flow characteristics
alpha = 0.0
mach = self.ooptions['mach'] #0.95
Re = self.ooptions['Re'] #50000
Re_L = 1.0
tempR = 540
arearef = 2.0
chordref = 1.0
a_init = self.DVGeo.getValues()
a_init['pnts'][:] = self.ooptions['DVInit']
self.current_samples = sum(self.N1)
if rank == 0:
rank0sam = plate_sa_lhs.genLHS(s=self.current_samples)
else:
rank0sam = None
self.sample = comm.bcast(rank0sam, root=0)
#import pdb; pdb.set_trace()
# Scatter samples on each level, multi-point parallelism
self.cases = []
self.samplep = []
for i in range(self.Lmax):
self.cases.append(divide_cases(self.N1[i], size))
for j in range(len(self.cases[i])):
for k in range(len(self.cases[i][j])):
self.cases[i][j][k] += sum(self.N1[0:i])
#self.nsp.append(len(self.cases[i][rank]))#int(ns/size) # samples per processor
self.samplep.append(self.sample[self.cases[i][rank]])
# Actually create solvers (and aeroproblems?) (and mesh?) now
self.aps = []
self.solvers = []
self.meshes = []
nslp = []
nslt = []
for k in range(self.Lmax):
alist = []
slist = []
mlist = []
nslp.append(len(self.cases[k][rank]))
nslt.append(sum([len(self.cases[k][x]) for x in range(size)]))
for i in range(nslp[k]):
namestr = self.gridSol + "_" + str(self.cases[k][rank][i])
# create meshes
leveloptions = self.woptions
leveloptions['gridFile'] = self.meshnames[self.mord[k]]
mlist.append(USMesh(options=leveloptions, comm=MPI.COMM_SELF))
# create aeroproblems
aloptions = self.aoptions
aloptions['gridFile'] = self.meshnames[self.mord[k]]
alist.append(
AeroProblem(name=namestr,
alpha=alpha,
mach=mach,
reynolds=Re,
reynoldsLength=Re_L,
T=tempR,
areaRef=arearef,
chordRef=chordref,
evalFuncs=['cd']))
time.sleep(0.1) # this solves a few problems for some reason
# create solvers
slist.append(ADFLOW(options=aloptions, comm=MPI.COMM_SELF))
saconstsm = self.samplep[self.Lmax - 1][i].tolist()
self.saconsts = saconstsm + self.saconstsb
slist[i].setOption('SAConsts', self.saconsts)
slist[i].setDVGeo(self.DVGeo)
slist[i].setMesh(mlist[i])
coords = slist[i].getSurfaceCoordinates(
groupName=slist[i].allWallsGroup)
slist[i].DVGeo.addPointSet(coords, 'coords')
self.aps.append(alist)
self.solvers.append(slist)
self.meshes.append(mlist)
def setUp(self):
# Introduce a transfer class for displacement transfer from struct to aero.
class Transfer:
# simplified transfer class
# converting csd displacement to cfd surface nodes
def __init__(self, alpha, xRot, aeroSolver):
# takes in displacement history
self.alpha = alpha
self.ntimeintervalsspectral = len(alpha)
self.aeroSolver = aeroSolver # a shallow copy of CFD solver
self.xRot = xRot
def getUndeformedSurfaceNodes(self):
self.MDGroup = self.aeroSolver.allWallsGroup
self.cfdPts0 = self.aeroSolver.getSurfaceCoordinates(self.MDGroup, includeZipper=False)
def setDisplacements(self):
xRot = self.xRot
ntimeintervalsspectral = self.ntimeintervalsspectral
alpha = self.alpha # notice a shallow copy introduced here; dont change the underlying obj!
cfdPoints_init = self.cfdPts0 # notice a shallow copy introduced here; dont change the underlying obj!
N_pts = cfdPoints_init.shape[0]
self.cfdPts = []
for sps in range(ntimeintervalsspectral):
cfdPoints_deformed = numpy.zeros((N_pts, 3))
ptch_loc = alpha[sps]
cc = numpy.cos(ptch_loc)
ss = numpy.sin(ptch_loc)
for j in range(N_pts):
cfdPoints_deformed[j, 0] = cc * (cfdPoints_init[j, 0] - xRot) + ss * cfdPoints_init[j, 1] + xRot
cfdPoints_deformed[j, 1] = -ss * (cfdPoints_init[j, 0] - xRot) + cc * cfdPoints_init[j, 1]
cfdPoints_deformed[j, 2] = cfdPoints_init[j, 2]
self.cfdPts.append(cfdPoints_deformed)
def setVolumeMesh(self):
ntimeintervalsspectral = self.ntimeintervalsspectral
for sps in range(ntimeintervalsspectral):
self.aeroSolver.mesh.setSurfaceCoordinates(self.cfdPts[sps])
self.aeroSolver.mesh.warpMesh()
m = self.aeroSolver.mesh.getSolverGrid()
self.aeroSolver.adflow.warping.setgridforoneinstance(m, sps=sps + 1)
self.aeroSolver._updateGeomInfo = True
self.aeroSolver.updateGeometryInfo()
# Set up the test for the parent RegTest class.
super().setUp()
gridFile = os.path.join(baseDir, "../../input_files/naca64A010_euler-L2.cgns")
ntimeintervalsspectral = 3
options = copy.copy(adflowDefOpts)
options.update(
{
"gridfile": gridFile,
"outputDirectory": os.path.join(baseDir, "../output_files"),
"writeVolumeSolution": False,
"writeSurfaceSolution": False,
"blocksplitting": True,
"useblockettes": False,
"equationtype": "Euler",
"equationmode": "time spectral",
"mgcycle": "sg",
"l2convergence": 1e-15,
"ncycles": 200000,
"monitorvariables": ["resrho", "cl"],
"usenksolver": True,
"nkswitchtol": 1e-4,
"NKSubSpaceSize": 400,
"applypcsubspacesize": 400,
"useanksolver": True,
"ankswitchtol": 1e-2,
"anksubspacesize": 50,
"alphafollowing": False,
"timeintervals": ntimeintervalsspectral,
"useexternaldynamicmesh": True,
"usetsinterpolatedgridvelocity": True,
}
)
# Grid option
meshOptions = {
"gridFile": gridFile,
}
# Setup aeroproblem
self.ap = copy.copy(ap_naca64A010_time_spectral)
# Motion history
alpha_0 = 1.01
deltaAlpha = -alpha_0 * numpy.pi / 180.0
alpha = numpy.linspace(0.0, 2.0 * numpy.pi, ntimeintervalsspectral + 1)[:-1]
alpha = -numpy.sin(alpha)
alpha *= deltaAlpha
# Create the solver
self.CFDSolver = ADFLOW(options=options, debug=False)
# self.CFDSolver.addSlices("z", [0.5])
# Deform the mesh
mesh = USMesh(options=meshOptions)
self.CFDSolver.setMesh(mesh)
# deformation
xRot = 0.25 # Hard copied from the reference file.
TSTransfer = Transfer(alpha, xRot, self.CFDSolver)
TSTransfer.getUndeformedSurfaceNodes()
TSTransfer.setDisplacements()
TSTransfer.setVolumeMesh()
'blocksplitting': True
})
# Setup aeroproblem, cfdsolver
ap = AeroProblem(name='mdo_tutorial',
alpha=1.8,
mach=0.80,
R=287.87,
altitude=10000.0,
areaRef=45.5,
chordRef=3.25,
evalFuncs=['cd', 'lift', 'cmz'])
ap.addDV('alpha')
ap.addDV('mach')
ap.addDV('altitude')
CFDSolver = ADFLOW(options=aeroOptions, debug=True)
if not 'complex' in sys.argv:
# Solve system
CFDSolver(ap, writeSolution=False)
funcs = {}
CFDSolver.evalFunctions(ap, funcs)
# Solve sensitivities
funcsSens = {}
CFDSolver.evalFunctionsSens(ap, funcsSens)
# Write values and derivatives out:
if MPI.COMM_WORLD.rank == 0:
for key in ['cd', 'cmz', 'lift']:
print('funcs[%s]:' % key)
reg_write(funcs['mdo_tutorial_%s' % key], 1e-10, 1e-10)
def initialize(self):
# Need to modify this dictionary when we change the SA constants
#import pdb; pdb.set_trace()
#sys.stdout = open(os.devnull, "w")
self.aoptions = aeroOptions
self.woptions = warpOptions
self.ooptions = optOptions
self.uoptions = uqOptions
self.Pr = 0.
self.P = self.uoptions['P']
self.NS0 = self.uoptions['NS0']
# Generate FFD and DVs
if rank == 0:
rank0dvg = pf.createFFD()
else:
rank0dvg = None
self.DVGeo = comm.bcast(rank0dvg, root=0)
# starting flat mesh
meshname = self.aoptions['gridFile']
gridFile = meshname
# flow characteristics
alpha = 0.0
mach = self.ooptions['mach'] #0.95
Re = self.ooptions['Re'] #50000
Re_L = 1.0
temp = 540
arearef = 2.0
chordref = 1.0
# Spalart Allmaras model constants, to be changed in UQ (4 for now)
saconstsm = [0.41, 0.1355, 0.622, 0.66666666667]
self.saconstsb = [7.1, 0.3, 2.0, 1.0, 2.0, 1.2, 0.5, 2.0]
self.saconsts = saconstsm + self.saconstsb
self.aoptions['SAConsts'] = self.saconsts
#self.gridSol = f'{meshname}_{saconstsm}_sol'
solname = self.ooptions['prob_name']
self.gridSol = f'{solname}_sol'
# Get a set of UQ sample points (LHS)
#if self.ooptions['run_once']:
# self.sample = self.uoptions['dist']
#else
# Scatter samples, multi-point parallelism
if self.uoptions['MCTimeBudget']:
self.aps = []
self.solvers = []
self.meshes = []
self.current_samples = self.NS0
if rank == 0:
rank0sam = plate_sa_lhs.genLHS(s=self.current_samples)
else:
rank0sam = None
self.sample = comm.bcast(rank0sam, root=0)
self.cases = divide_cases(self.NS0, size)
# Scatter samples on each level, multi-point parallelism
self.samplep = self.sample[self.cases[rank]]
self.nsp = len(self.cases[rank])
# Create solvers for the preliminary data
for i in range(self.nsp):
namestr = self.gridSol + "_" + str(self.cases[rank][i])
# create meshes
self.meshes.append(
USMesh(options=self.woptions, comm=MPI.COMM_SELF))
# create aeroproblems
self.aps.append(
AeroProblem(name=namestr,
alpha=alpha,
mach=mach,
reynolds=Re,
reynoldsLength=Re_L,
T=temp,
areaRef=arearef,
chordRef=chordref,
evalFuncs=['cd']))
time.sleep(0.1) # this solves a few problems for some reason
# create solvers
self.solvers.append(
ADFLOW(options=self.aoptions, comm=MPI.COMM_SELF))
saconstsm = self.samplep[i].tolist()
self.saconsts = saconstsm + self.saconstsb
self.solvers[i].setOption('SAConsts', self.saconsts)
self.solvers[i].setDVGeo(self.DVGeo)
self.solvers[i].setMesh(self.meshes[i])
print("what up %i", str(rank))
coords = self.solvers[i].getSurfaceCoordinates(
groupName=self.solvers[i].allWallsGroup)
self.solvers[i].DVGeo.addPointSet(coords, 'coords')
# start looping over mesh levels
sumt = 0.
sumtp = 0.
Et = 0.
funcs = {}
a_init = self.DVGeo.getValues()
a_init['pnts'][:] = self.ooptions['DVInit']
dvdict = {'pnts': a_init['pnts']}
for i in range(self.nsp):
saconstsm = self.samplep[i].tolist()
self.saconsts = saconstsm + self.saconstsb
self.solvers[i].setOption('SAConsts', self.saconsts)
self.solvers[i].DVGeo.setDesignVars(dvdict)
self.aps[i].setDesignVars(dvdict)
pc0 = time.process_time()
self.solvers[i](self.aps[i])
self.solvers[i].evalFunctions(self.aps[i], funcs)
pc1 = time.process_time()
astr = self.gridSol + "_" + str(self.cases[rank][i]) + "_cd"
sumtp += (pc1 - pc0)
sumt = comm.allreduce(sumtp)
Et = sumt / self.NS0
self.NS = math.ceil(self.P / Et)
self.Pr = self.NS * Et
else:
self.NS = self.uoptions['NS']
#import pdb; pdb.set_trace()
if rank == 0:
rank0sam = plate_sa_lhs.genLHS(s=self.NS)
else:
rank0sam = None
self.sample = comm.bcast(rank0sam, root=0)
self.cases = divide_cases(self.NS, size)
self.nsp = len(self.cases[rank]) #int(ns/size) # samples per processor
#import pdb; pdb.set_trace()
self.samplep = self.sample[self.cases[
rank]] #self.sample[(rank*self.nsp):(rank*self.nsp+(self.nsp))] #shouldn't really need to "scatter" per se
#import pdb; pdb.set_trace()
#assert len(self.samplep) == self.nsp
# Actually create solvers (and aeroproblems?) (and mesh?) now
self.aps = []
self.solvers = []
self.meshes = []
#self.mesh = USMesh(options=self.woptions, comm=MPI.COMM_SELF)
for i in range(self.nsp):
namestr = self.gridSol + "_" + str(self.cases[rank][i])
# create meshes
self.meshes.append(
USMesh(options=self.woptions, comm=MPI.COMM_SELF))
# create aeroproblems
self.aps.append(
AeroProblem(name=namestr,
alpha=alpha,
mach=mach,
reynolds=Re,
reynoldsLength=Re_L,
T=temp,
areaRef=arearef,
chordRef=chordref,
evalFuncs=['cd']))
time.sleep(0.1) # this solves a few problems for some reason
# create solvers
self.solvers.append(
ADFLOW(options=self.aoptions, comm=MPI.COMM_SELF))
# if not self.ooptions['run_once']:
# saconstsm = self.samplep[i].tolist()
# else:
saconstsm = self.samplep[i].tolist()
self.saconsts = saconstsm + self.saconstsb
self.solvers[i].setOption('SAConsts', self.saconsts)
self.solvers[i].setDVGeo(self.DVGeo)
self.solvers[i].setMesh(self.meshes[i])
print("what up %i", str(rank))
coords = self.solvers[i].getSurfaceCoordinates(
groupName=self.solvers[i].allWallsGroup)
self.solvers[i].DVGeo.addPointSet(coords, 'coords')
# Set constraints, should only need one of those solvers, the meshes are all the same
self.DVCon = DVConstraints()
self.DVCon2 = DVConstraints()
self.DVCon.setDVGeo(self.solvers[0].DVGeo.getFlattenedChildren()[1])
self.DVCon2.setDVGeo(self.solvers[0].DVGeo)
self.DVCon.setSurface(self.solvers[0].getTriangulatedMeshSurface(
groupName='allSurfaces'))
# set extra group for surface area condition
self.DVCon2.setSurface(self.solvers[0].getTriangulatedMeshSurface(),
name='wall')
# DV should be same into page (not doing anything right now)
#import pdb; pdb.set_trace()
lIndex = self.solvers[0].DVGeo.getFlattenedChildren()[1].getLocalIndex(
0)
indSetA = []
indSetB = []
nXc = optOptions['NX']
self.NC = math.trunc(
((1.0 - self.ooptions['DVFraction']) * self.ooptions['NX']))
ind = [
int(nXc / 2) - int(self.NC / 2),
int(nXc / 2) + int(self.NC / 2)
]
for i in range(ind[0], ind[1]):
indSetA.append(lIndex[i, 0, 1])
indSetB.append(lIndex[i, 1, 1])
# for i in range(lIndex.shape[0]):
# indSetA.append(lIndex[i, 0, 1])
# indSetB.append(lIndex[i, 1, 1])
self.DVCon.addLinearConstraintsShape(indSetA,
indSetB,
factorA=1.0,
factorB=-1.0,
lower=0,
upper=0,
name='eqs')
# Thickness constraints (one for each active DV)
#import pdb; pdb.set_trace()
# Maximum thickness of the domain, translates to minimum thickness of bump
ub = 1.0 - self.ooptions['DCMinThick']
tcf = self.ooptions['DCThickFrac']
ra = self.ooptions['bumpBounds']
lim = self.ooptions['DCMinArea']
span = numpy.linspace(0, 1, nXc)
xc = span * (ra[1] - ra[0]) + ra[0]
#ind = range(int(nXc/2) - int(self.NC/2), int(nXc/2) + int(self.NC/2)))
ind = [
int(nXc / 2) - int(tcf * self.NC / 2),
int(nXc / 2) + int(tcf * self.NC / 2)
]
ptList = numpy.zeros([2, 3])
ptList[:, 0] = xc[ind]
ptList[:, 1] = 0.5
ptList[:, 2] = 0.5
if self.ooptions['use_area_con']:
self.DVCon2.addSurfaceAreaConstraint(lower=lim,
upper=10.,
name='sas',
surfaceName='wall')
else:
self.DVCon2.addThicknessConstraints1D(ptList,
self.NC, [0, 0, 1],
lower=0.5,
upper=ub,
name='tcs')
print("excuse me")
dummy = rank
dsum = comm.allgather(dummy)
sys.stdout = sys.__stdout__
# dictionary with name of the zone as a key and a factor to multiply it with.
oversetpriority = {}
aeroOptions = {
# Common Parameters
'gridFile': args.gridfile,
'outputDirectory': outputDirectory,
'mgcycle': 'sg',
'volumevariables': ['blank'],
'surfacevariables': ['blank'],
# Physics Parameters
'equationType': 'rans',
# Debugging parameters
'debugzipper': False,
'usezippermesh': False,
'nrefine': 10, # number of times to run IHC cycle
'nearwalldist': 0.1,
'oversetpriority': oversetpriority
}
# Create solver
CFDSolver = ADFLOW(options=aeroOptions, debug=False)
# Uncoment this if just want to check flooding
CFDSolver.setAeroProblem(ap)
name = '.'.join(args.gridfile.split('.')[0:-1])
CFDSolver.writeVolumeSolutionFile(name + '_IHC.cgns', writeGrid=True)
#rst end
def setup_cb(comm):
# Create the solver
CFDSolver = ADFLOW(options=options, debug=False)
return CFDSolver, None, None, None
def setUp(self):
self.wall_temps = np.linspace(100, 900, 9)
self.CFDSolver = ADFLOW(options=aeroOptions)
def setup_cb(comm):
CFDSolver = ADFLOW(options=options, comm=comm)
CFDSolver.addSlices('z', [0.5])
CFDSolver(ap)
return CFDSolver, None, None, None
def MFMC(self):
# Use an MFMC algorithm to determine optimal sample distribution and coefficients among mesh levels
# We do this once before optimization, then compute statistics with the same set of samples and coeffs at every iteration
# start with initial samples
# Get a set of UQ sample points (LHS), enough for each level at the start
#sys.stdout = open(os.devnull, "w")
# flow characteristics
alpha = 0.0
mach = self.ooptions['mach'] #0.95
Re = self.ooptions['Re'] #50000
Re_L = 1.0
tempR = 540
arearef = 2.0
chordref = 1.0
a_init = self.DVGeo.getValues()
a_init['pnts'][:] = self.ooptions['DVInit']
self.current_samples = self.NS0 * self.Lmax
if rank == 0:
rank0sam = plate_sa_lhs.genLHS(s=self.current_samples)
else:
rank0sam = None
self.sample = comm.bcast(rank0sam, root=0)
N1 = []
a1 = numpy.zeros(self.Lmax)
r1 = numpy.zeros(self.Lmax)
# Scatter samples on each level, multi-point parallelism
for i in range(self.Lmax):
self.cases.append(divide_cases(self.NS0, size))
for j in range(len(self.cases[i])):
for k in range(len(self.cases[i][j])):
self.cases[i][j][k] += i * self.NS0
#self.nsp.append(len(self.cases[i][rank]))#int(ns/size) # samples per processor
self.samplep.append(self.sample[self.cases[i][rank]])
#import pdb; pdb.set_trace()
#self.samplep = self.sample[self.cases[rank]]#self.sample[(rank*self.nsp):(rank*self.nsp+(self.nsp))] #shouldn't really need to "scatter" per se
#import pdb; pdb.set_trace()
# for i in range(self.Lmax):
# assert len(self.samplep[i]) == self.nsp[i]
# Create solvers for the preliminary data
nslp = []
nslt = []
for k in range(self.Lmax):
alist = []
slist = []
mlist = []
nslp.append(len(self.cases[k][rank]))
nslt.append(sum([len(self.cases[k][x]) for x in range(size)]))
for i in range(nslp[k]):
namestr = self.gridSol + "_" + str(self.cases[k][rank][i])
# create meshes
leveloptions = self.woptions
leveloptions['gridFile'] = self.meshnames[self.mord[k]]
#import pdb; pdb.set_trace()
mlist.append(USMesh(options=leveloptions, comm=MPI.COMM_SELF))
# create aeroproblems
aloptions = self.aoptions
aloptions['gridFile'] = self.meshnames[self.mord[k]]
alist.append(
AeroProblem(name=namestr,
alpha=alpha,
mach=mach,
reynolds=Re,
reynoldsLength=Re_L,
T=tempR,
areaRef=arearef,
chordRef=chordref,
evalFuncs=['cd']))
time.sleep(0.1) # this solves a few problems for some reason
# create solvers
slist.append(ADFLOW(options=aloptions, comm=MPI.COMM_SELF))
# if not self.ooptions['run_once']:
# saconstsm = self.samplep[i].tolist()
# else:
saconstsm = self.samplep[0][i].tolist()
self.saconsts = saconstsm + self.saconstsb
slist[i].setOption('SAConsts', self.saconsts)
slist[i].setDVGeo(self.DVGeo)
slist[i].setMesh(mlist[i])
coords = slist[i].getSurfaceCoordinates(
groupName=slist[i].allWallsGroup)
slist[i].DVGeo.addPointSet(coords, 'coords')
self.aps.append(alist)
self.solvers.append(slist)
self.meshes.append(mlist)
# Solve the preliminary samples
# start looping over mesh levels
sumt = []
sumtp = []
nslp = []
nslt = []
sum1 = []
mus = []
sump = []
musp = []
sumpm = []
muspm = []
summ = []
musm = []
Et = numpy.zeros(self.Lmax)
E = numpy.zeros(self.Lmax)
V = numpy.zeros(self.Lmax)
S = numpy.zeros(self.Lmax)
N1 = []
for k in range(self.Lmax):
nslp.append(len(self.cases[k][rank]))
nslt.append(sum([len(self.cases[k][x]) for x in range(size)]))
dvdict = {'pnts': a_init['pnts']}
funcs = {}
sumtp.append(0.0)
sump.append(0.)
musp.append(numpy.zeros(nslp[k]))
sumpm.append(0.)
muspm.append(numpy.zeros(nslp[k]))
for i in range(nslp[k]):
# just do this again in case
saconstsm = self.samplep[0][i].tolist()
self.saconsts = saconstsm + self.saconstsb
self.solvers[k][i].setOption('SAConsts', self.saconsts)
self.solvers[k][i].DVGeo.setDesignVars(dvdict)
self.aps[k][i].setDesignVars(dvdict)
pc0 = time.process_time()
self.solvers[k][i](self.aps[k][i])
self.solvers[k][i].evalFunctions(self.aps[k][i], funcs)
pc1 = time.process_time()
astr = self.gridSol + "_" + str(self.cases[k][rank][i]) + "_cd"
musp[k][i] = funcs[astr]
sump[k] += funcs[astr]
sumtp[k] += (pc1 - pc0)
# compute mean and variance estimate from start up samples
for k in range(self.Lmax):
sumt.append(comm.allreduce(sumtp[k]))
sum1.append(comm.allreduce(sump[k]))
mus.append(comm.allgather(musp[k]))
summ.append(comm.allreduce(sumpm[k]))
musm.append(comm.allgather(muspm[k]))
mus[k] = numpy.concatenate(mus[k][:])
musm[k] = numpy.concatenate(musm[k][:])
#import pdb; pdb.set_trace()
# mean at each level
Et[k] = sumt[k] / nslt[k]
E[k] = (sum1[k]) / nslt[k] #+summ[k]
sum2 = 0.
for i in range(len(mus[k])): #loop over processors
sum2 += (mus[k][i] - E[k])**2
V[k] = sum2 / nslt[k]
S[k] = math.sqrt(V[k])
# compute correlation matrix and rearrange models if necessary
ordered = False
while not ordered:
rho = numpy.corrcoef(mus)
ordered = True # check if contradicted
#tarr = rho[0,1:]
for k in range(self.Lmax - 2):
test = rho[0, 1 + k]**2 - rho[0, 2 + k]**2
if test < 0:
ordered = False
tarr = -rho[0, :]**2
if not ordered:
sind = numpy.argsort(tarr)
#import pdb; pdb.set_trace()
self.mord[:] = [self.mord[i] for i in sind]
E[:] = [E[i] for i in sind]
Et[:] = [Et[i] for i in sind]
V[:] = [V[i] for i in sind]
S[:] = [S[i] for i in sind]
mus[:] = [mus[i] for i in sind]
# now compute N1 and a1 using sigma, rho, w, and p
for k in range(self.Lmax):
a1[k] = S[0] * rho[0, k] / S[k]
if k == 0:
r1[k] = 1
elif k == self.Lmax - 1:
work = Et[0] * (rho[0, k]**2)
work /= Et[k] * (1 - rho[0, 1]**2)
r1[k] = math.sqrt(work)
else:
work = Et[0] * (rho[0, k - 1]**2 - rho[0, k]**2)
work /= Et[k] * (1 - rho[0, 1]**2)
r1[k] = math.sqrt(work)
for k in range(self.Lmax):
N1.append(0)
nsf = self.P / numpy.dot(Et, r1)
N1[0] = math.ceil(nsf)
for k in range(self.Lmax):
nsf = N1[0] * r1[k]
N1[k] = math.ceil(nsf)
# limit the number of samples on the last one to pass the sanity check, for debug
sanity = numpy.dot(N1, Et)
if sanity > 1.2 * self.P:
N1n = (self.P - numpy.dot(N1[0:self.Lmax - 2],
Et[0:self.Lmax - 2])) / Et[self.Lmax - 1]
N1[self.Lmax - 1] = math.ceil(N1n)
self.Pr = numpy.dot(N1, Et)
self.N1 = N1
self.a1 = a1
#import pdb; pdb.set_trace()
if rank == 0:
print("MFMC Completed, Samples per level: ", N1)
# General
'monitorvariables': ['resrho', 'resturb', 'cl', 'cd'],
'printIterations': True,
'writeSurfaceSolution': True,
'writeVolumeSolution': True,
'outputsurfacefamily': 'wall',
'surfacevariables': ['cp', 'vx', 'vy', 'vz', 'mach', 'blank'],
'volumevariables': ['resrho', 'blank'],
'liftIndex': 3,
'nCycles': 20000,
'L2Convergence': 1e-14,
}
# Create solver
CFDSolver = ADFLOW(options=aeroOptions)
# Add features
#CFDSolver.addLiftDistribution(150, 'z')
#CFDSolver.addSlices('z', numpy.linspace(0.1, 14, 10))
name = 'Re{}_M{}_AoA{}_{}'.format(reynolds, mach, alpha, level)
ap = AeroProblem(name=name,
alpha=alpha,
mach=mach,
reynolds=reynolds,
reynoldsLength=0.64607,
T=T,
areaRef=0.75296,
chordRef=0.64607,
evalFuncs=['cl', 'cd', 'cmz'])
def setUp(self):
super().setUp()
gridFile = os.path.join(baseDir,
"../../inputFiles/naca0012_rans-L2.cgns")
f = 10.0 # [Hz] Forcing frequency of the flow
period = 1.0 / f # [sec]
nStepPerPeriod = 8
nPeriods = 1
nfineSteps = nStepPerPeriod * nPeriods
dt = period / nStepPerPeriod # [s] The actual timestep
options = copy.copy(adflowDefOpts)
options.update({
"gridfile":
gridFile,
"outputdirectory":
os.path.join(baseDir, "../output_files"),
"writevolumesolution":
False,
"vis4":
0.025,
"vis2":
0.5,
"restrictionrelaxation":
0.5,
"smoother":
"dadi",
"equationtype":
"RANS",
"equationmode":
"unsteady",
"timeIntegrationscheme":
"bdf",
"ntimestepsfine":
nfineSteps,
"deltat":
dt,
"nsubiterturb":
10,
"nsubiter":
5,
"useale":
False,
"usegridmotion":
True,
"cfl":
2.5,
"cflcoarse":
1.2,
"ncycles":
2000,
"mgcycle":
"3w",
"mgstartlevel":
1,
"monitorvariables": ["cpu", "resrho", "cl", "cd", "cmz"],
"usenksolver":
False,
"l2convergence":
1e-6,
"l2convergencecoarse":
1e-4,
"qmode":
True,
"alphafollowing":
False,
"blockSplitting":
True,
"useblockettes":
False,
})
# Setup aeroproblem
self.ap = copy.copy(ap_naca0012_time_acc)
# Create the solver
self.CFDSolver = ADFLOW(options=options, debug=False)
self.CFDSolver.addSlices("z", [0.5])
"infchangecorrection": True,
# ANK Solver Parameters
"useANKSolver": True,
# NK Solver Parameters
"useNKSolver": True,
"nkswitchtol": 1e-6,
# Termination Criteria
"L2Convergence": 1e-10,
"L2ConvergenceCoarse": 1e-2,
"nCycles": 10000,
# Adjoint Parameters
"adjointL2Convergence": 1e-10,
}
# Create solver
CFDSolver = ADFLOW(options=aeroOptions, comm=comm)
CFDSolver.addLiftDistribution(150, "z")
CFDSolver.addSlices("z", np.linspace(0.1, 14, 10))
# rst adflow (end)
# ======================================================================
# Set up flow conditions with AeroProblem
# ======================================================================
# rst aeroproblem (beg)
ap = AeroProblem(name="wing",
alpha=1.5,
mach=0.8,
altitude=10000,
areaRef=45.5,
chordRef=3.25,
evalFuncs=["cl", "cd"])
def initialize(self):
# Need to modify this dictionary when we change the SA constants
sys.stdout = open(os.devnull, "w")
self.aoptions = aeroOptions
self.woptions = warpOptions
self.ooptions = optOptions
# Generate FFD and DVs
self.DVGeo = pf.createFFD()
# starting flat mesh
meshname = self.aoptions['gridFile']
gridFile = meshname
# flow characteristics
alpha = 0.0
mach = self.ooptions['mach']#0.95
Re = self.ooptions['Re']#50000
Re_L = 1.0
temp = 540
arearef = 2.0
chordref = 1.0
# Spalart Allmaras model constants, to be changed in UQ
saconstsm = [0.41, 0.1355, 0.622, 0.66666666667, 7.1, 0.3, 2.0]
self.saconsts = saconstsm + [1.0, 2.0, 1.2, 0.5, 2.0]
self.aoptions['SAConsts'] = self.saconsts
#self.gridSol = f'{meshname}_{saconstsm}_sol'
solname = self.ooptions['prob_name']
self.gridSol = f'{solname}_sol'
# Aerodynamic problem description
self.ap = AeroProblem(name=self.gridSol, alpha=alpha, mach=mach, reynolds=Re, reynoldsLength=Re_L, T=temp, areaRef=arearef, chordRef=chordref,
evalFuncs=['cd'])
# Create solver
self.CFDSolver = ADFLOW(options=self.aoptions, comm=MPI.COMM_WORLD)
self.CFDSolver.setDVGeo(self.DVGeo)
# Set up mesh warping
self.mesh = USMesh(options=self.woptions, comm=MPI.COMM_WORLD)
self.CFDSolver.setMesh(self.mesh)
# Try setting the DVGeo coordinates here
coords = self.CFDSolver.getSurfaceCoordinates(groupName=self.CFDSolver.allWallsGroup)
self.CFDSolver.DVGeo.addPointSet(coords, 'coords')
self.CFDSolver.DVGeo.getFlattenedChildren()[1].writePlot3d("ffdp_opt_def.xyz")
# Set constraints
self.DVCon = DVConstraints()
self.DVCon2 = DVConstraints()
self.DVCon.setDVGeo(self.CFDSolver.DVGeo.getFlattenedChildren()[1])
self.DVCon2.setDVGeo(self.CFDSolver.DVGeo)
self.DVCon.setSurface(self.CFDSolver.getTriangulatedMeshSurface(groupName='allSurfaces'))
# set extra group for surface area condition
self.DVCon2.setSurface(self.CFDSolver.getTriangulatedMeshSurface(), name='wall')
# DV should be same into page (not doing anything right now)
#import pdb; pdb.set_trace()
lIndex = self.CFDSolver.DVGeo.getFlattenedChildren()[1].getLocalIndex(0)
indSetA = []
indSetB = []
nXc = optOptions['NX']
self.NC = math.trunc(((1.0 - self.ooptions['DVFraction'])*self.ooptions['NX']))
ind = [int(nXc/2) - int(self.NC/2), int(nXc/2) + int(self.NC/2)]
for i in range(ind[0], ind[1]):
indSetA.append(lIndex[i, 0, 1])
indSetB.append(lIndex[i, 1, 1])
# for i in range(lIndex.shape[0]):
# indSetA.append(lIndex[i, 0, 1])
# indSetB.append(lIndex[i, 1, 1])
self.DVCon.addLinearConstraintsShape(indSetA, indSetB, factorA=1.0, factorB=-1.0, lower=0, upper=0, name='eqs')
# Thickness constraints (one for each active DV)
#import pdb; pdb.set_trace()
# Maximum thickness of the domain, translates to minimum thickness of bump
ub = 1.0 - self.ooptions['DCMinThick']
tcf = self.ooptions['DCThickFrac']
ra = self.ooptions['bumpBounds']
lim = self.ooptions['DCMinArea']
span = numpy.linspace(0, 1, nXc)
xc = span * (ra[1] - ra[0]) + ra[0]
#ind = range(int(nXc/2) - int(self.NC/2), int(nXc/2) + int(self.NC/2)))
ind = [int(nXc/2) - int(tcf*self.NC/2), int(nXc/2) + int(tcf*self.NC/2)]
ptList = numpy.zeros([2, 3])
ptList[:,0] = xc[ind]
ptList[:,1] = 0.5
ptList[:,2] = 0.5
if self.ooptions['use_area_con']:
self.DVCon2.addSurfaceAreaConstraint(lower=lim, upper=10., name='sas', surfaceName='wall')
else:
self.DVCon2.addThicknessConstraints1D(ptList, self.NC, [0,0,1], lower=0.5, upper=ub, name='tcs')
sys.stdout = sys.__stdout__
