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__
import plate_ffd as pf
import math
from mpi4py import MPI
from idwarp import USMesh
from baseclasses import *
from adflow import ADFLOW
from pygeo import DVGeometry, DVConstraints
from plate_comp_opts import aeroOptions, warpOptions, optOptions
'''Just generate a mesh moved with a set of design variables'''
aoptions = aeroOptions
woptions = warpOptions
ooptions = optOptions
# Generate FFD and DVs
DVGeo = pf.createFFD()
# starting flat mesh
meshname = aoptions['gridFile']
mesh = USMesh(options=warpOptions)
coords = mesh.getSurfaceCoordinates()
DVGeo.addPointSet(coords, "coords")
vars = optOptions['ro_shape']
dvDict = {'pnts': vars}
DVGeo.setDesignVars(dvDict)
new_coords = DVGeo.update("coords")
# move the mesh using idwarp
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.
# Generate FFD and DVs
if rank == 0:
rank0dvg = pf.createFFD()
else:
rank0dvg = None
self.DVGeo = comm.bcast(rank0dvg, root=0)
# Get a full list of every mesh name we have, assume they are ordered properly by level
self.meshnames = self.uoptions['gridFileLevels']
self.Lmax = len(self.meshnames) #as many levels as we have meshes
self.mord = [*range(self.Lmax)]
self.mord.reverse()
if self.Lmax < 3:
raise ValueError('Not enough meshes available, ' + self.Lmax +
' < 3')
# 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'
self.cases = []
#self.nsp = [] #keep track per level
self.samplep = []
self.naddedtot = []
for i in range(self.Lmax):
self.naddedtot.append(0)
self.aps = []
self.solvers = []
self.meshes = []
self.NS0 = self.uoptions['NS0']
self.current_samples = self.NS0 * self.Lmax
self.N1 = None
self.a1 = None
self.P = self.uoptions['P']
##########
# call distribute samples here?
if not self.uoptions['use-predetermined-samples']:
self.MFMC()
else:
self.N1 = self.uoptions['predet-N1']
self.a1 = self.uoptions['predet-a1']
self.dist_samples()
##########
# Set constraints, should only need one of those solvers, the meshes are all the same
if rank == 0:
self.DVCon = DVConstraints()
self.DVCon2 = DVConstraints()
self.DVCon.setDVGeo(
self.solvers[0][0].DVGeo.getFlattenedChildren()[1])
self.DVCon2.setDVGeo(self.solvers[0][0].DVGeo)
self.DVCon.setSurface(
self.solvers[0][0].getTriangulatedMeshSurface(
groupName='allSurfaces'))
# set extra group for surface area condition
self.DVCon2.setSurface(
self.solvers[0][0].getTriangulatedMeshSurface(), name='wall')
# DV should be same into page (not doing anything right now)
#import pdb; pdb.set_trace()
lIndex = self.solvers[0][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')
dummy = rank
dsum = comm.allgather(dummy)
sys.stdout = sys.__stdout__
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__