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__