def __init__(self, name, throttle=1.0, ISA=0.0, **kwargs): # Initialize AeroProblem AeroProblem.__init__(self, name, **kwargs) # Set initial throttle or ISA self.throttle = throttle self.ISA = ISA # Update AeroProblem variable sets with possible engine variables newVars = ['throttle', 'ISA'] self.allVarFuncs += newVars self.possibleDVs.update(newVars) self.possibleFunctions.update(newVars)
def setUp(self): # import petsc4py # petsc4py.init(arch='real-debug-gfortran-3.7.7') # from petsc4py import PETSc gridFile = os.path.join(baseDir, '../input_files/conic_conv_nozzle_mb_L4.cgns') intSurfFile = os.path.join(baseDir, '../input_files/integration_plane_viscous.fmt') self.options = {'gridfile': gridFile} self.options['mgstartlevel'] = 1 self.options['ncycles'] = 1 self.options['useanksolver'] = False self.options['l2convergence'] = 1e-12 ap = AeroProblem(name='nozzle_flow', alpha=90, mach=0.5, altitude=0, areaRef=1.0, chordRef=1.0, R=287.87, evalFuncs=['mdot_up', 'mdot_down', 'mdot_plane', 'mavgptot_up', 'mavgptot_down', 'mavgptot_plane', 'mavgttot_up', 'mavgttot_down', 'mavgttot_plane', 'mavgps_up', 'mavgps_down', 'mavgps_plane', ]) self.ap = ap CFDSolver = ADFLOW(options=self.options) CFDSolver.addIntegrationSurface(intSurfFile, 'viscous_plane') CFDSolver.finalizeUserIntegrationSurfaces() CFDSolver.addFamilyGroup('upstream',['inlet']) CFDSolver.addFamilyGroup('downstream',['outlet']) CFDSolver.addFamilyGroup('all_flow',['inlet', 'outlet']) CFDSolver.addFamilyGroup('output_fam',['all_flow', 'allWalls']) CFDSolver.addFunction('mdot', 'upstream', name="mdot_up") CFDSolver.addFunction('mdot', 'downstream', name="mdot_down") CFDSolver.addFunction('mdot', 'viscous_plane', name="mdot_plane") CFDSolver.addFunction('mavgptot', 'downstream', name="mavgptot_down") CFDSolver.addFunction('mavgptot', 'upstream', name="mavgptot_up") CFDSolver.addFunction('mavgptot', 'viscous_plane', name="mavgptot_plane") CFDSolver.addFunction('aavgptot', 'downstream', name="aavgptot_down") CFDSolver.addFunction('aavgptot', 'upstream', name="aavgptot_up") CFDSolver.addFunction('aavgptot', 'viscous_plane', name="aavgptot_plane") CFDSolver.addFunction('mavgttot', 'downstream', name="mavgttot_down") CFDSolver.addFunction('mavgttot', 'upstream', name="mavgttot_up") CFDSolver.addFunction('mavgttot', 'viscous_plane', name="mavgttot_plane") CFDSolver.addFunction('mavgps', 'downstream', name="mavgps_down") CFDSolver.addFunction('mavgps', 'upstream', name="mavgps_up") CFDSolver.addFunction('mavgps', 'viscous_plane', name="mavgps_plane") CFDSolver.addFunction('aavgps', 'downstream', name="aavgps_down") CFDSolver.addFunction('aavgps', 'upstream', name="aavgps_up") CFDSolver.addFunction('aavgps', 'viscous_plane', name="aavgps_plane") self.CFDSolver= CFDSolver
def setUp(self): gridFile = os.path.join(baseDir, '../input_files/conic_conv_nozzle_mb_L4.cgns') self.options = {'gridfile': gridFile} # Aerodynamic problem description (taken from test 17) ap = AeroProblem(name='nozzle', alpha=90, mach=0.5, altitude=0, areaRef=1.0, chordRef=1.0, R=287.87) # these values come from inspecting the cgns mesh itself self.initial_dvs = { 'downstream': { 'Pressure': 79326.7, }, 'upstream': { 'PressureStagnation': 100000.0, 'TemperatureStagnation': 500, 'VelocityUnitVectorX': 0., 'VelocityUnitVectorY': 1., 'VelocityUnitVectorZ': 0., } } self.set_dvs = { 'downstream': { 'Pressure': 89326.7, }, 'upstream': { 'PressureStagnation': 100001.0, 'TemperatureStagnation': 450, 'VelocityUnitVectorX': 0.1, 'VelocityUnitVectorY': 0.9, 'VelocityUnitVectorZ': 0.1, } }
def setUp(self): gridFile = os.path.join(baseDir, '../input_files/pipe.cgns') self.options = {'gridfile': gridFile, 'mgcycle':'sg', 'ncycles':1000, 'useanksolver':True, 'usenksolver':True, 'volumevariables': ['temp', 'mach', 'resrho' ], 'surfacevariables':['temp', 'vx', 'vy', 'vz', 'p', 'ptloss', 'mach', 'rho'], 'equationType':'euler', 'l2convergence': 1e-13} CFDSolver = ADFLOW(options=self.options) CFDSolver.addFunction('mdot', 'inlet', name="mdot_in") CFDSolver.addFunction('mdot', 'outlet', name="mdot_out") CFDSolver.addFunction('mavgptot', 'outlet', name="mavgptot_out") CFDSolver.addFunction('mavgptot', 'inlet', name="mavgptot_in") 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('mavgps', 'outlet', name="mavgps_out") CFDSolver.addFunction('mavgps', 'inlet', name="mavgps_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="vx_in") CFDSolver.addFunction('mavgvx', 'outlet', name="vx_out") CFDSolver.addFunction('mavgps', 'inlet', name="ps_in") CFDSolver.addFunction('mavgps', 'outlet', name="ps_out") self.CFDSolver = CFDSolver self.ap = AeroProblem(name='actuator_in_pipe', alpha=00, mach=0.6, altitude=0, areaRef=1.0, chordRef=1.0, evalFuncs=['mdot_in', 'mdot_out', 'mavgptot_in', 'mavgptot_out', 'mavgttot_in', 'mavgttot_out', 'mavgps_in', 'mavgps_out', 'area_in', 'area_out', 'aavgps_in', 'aavgps_out', 'aavgptot_in', 'aavgptot_out', 'ps_in', 'ps_out', 'vx_in', 'vx_out'] ) self.force = 600 actuatorFile = os.path.join(baseDir, '../input_files/actuator_disk.xyz') self.CFDSolver.addActuatorRegion(actuatorFile, np.array([0,0,0]),np.array([1,0,0]), 'actuator', thrust=self.force )
def regression_test(self, handler): ''' This is where the actual testing happens. ''' import copy from baseclasses import AeroProblem from commonUtils import solution_test, adflowDefOpts, defaultFuncList from ... import ADFLOW gridFile = 'input_files/mdo_tutorial_viscous_scalar_jst.cgns' options = copy.copy(adflowDefOpts) options.update({ 'gridfile': gridFile, 'mgcycle': '2w', 'equationtype': 'Laminar NS', 'cfl': 1.5, 'cflcoarse': 1.25, 'ncyclescoarse': 250, 'ncycles': 10000, 'monitorvariables': ['cpu', 'resrho', 'resturb', 'cl', 'cd', 'totalr'], 'usenksolver': True, 'l2convergence': 1e-15, 'l2Convergencecoarse': 1e-2, 'nkswitchtol': 1e-2, 'adjointl2convergence': 1e-14, }) # Setup aeroproblem, cfdsolver, mesh and geometry. ap = AeroProblem(name='mdo_tutorial', alpha=1.8, beta=0.0, mach=0.50, P=137.0, T=293.15, R=287.87, areaRef=45.5, chordRef=3.25, xRef=0.0, yRef=0.0, zRef=0.0, evalFuncs=defaultFuncList) # Create the solver CFDSolver = ADFLOW(options=options, debug=False) solution_test(handler, CFDSolver, ap)
def regression_test(self, handler): ''' This is where the actual testing happens. ''' import copy from baseclasses import AeroProblem from commonUtils import adflowDefOpts from ... import ADFLOW gridFile = 'input_files/mdo_tutorial_euler_scalar_jst.cgns' options = copy.copy(adflowDefOpts) options.update({ 'gridfile': gridFile, 'mgcycle': '2w', 'ncyclescoarse': 250, 'ncycles': 500, 'monitorvariables': ['resrho', 'cl', 'cd', 'cmz', 'totalr'], 'usenksolver': True, 'l2convergence': 1e-14, 'l2convergencecoarse': 1e-2, 'nkswitchtol': 1e-2, 'adjointl2convergence': 1e-14, 'solutionprecision': 'single', 'gridprecision': 'double', }) # Setup aeroproblem, cfdsolver, mesh and geometry. ap = AeroProblem(name='mdo_tutorial', alpha=1.20, mach=0.80, altitude=10000.0, areaRef=45.5, chordRef=3.25) # Create the solver CFDSolver = ADFLOW(options=options, debug=True) # Run CL solve CFDSolver.solveCL(ap, 0.475, alpha0=1.20, delta=0.025, tol=1e-4, autoReset=False) funcs = {} CFDSolver.evalFunctions(ap, funcs, evalFuncs=['cl']) handler.root_add_val(funcs['mdo_tutorial_cl'] - 0.475, 1e-4, 1e-4)
def regression_test(self, handler, solve=False): ''' This is where the actual testing happens. ''' import copy from baseclasses import AeroProblem from commonUtils import standard_test, adflowDefOpts, defaultFuncList from ... import ADFLOW gridFile = 'input_files/mdo_tutorial_euler_scalar_jst.cgns' options = copy.copy(adflowDefOpts) options.update({ 'gridfile': gridFile, 'mgcycle': '2w', 'ncyclescoarse': 250, 'ncycles': 500, 'monitorvariables': ['cpu', 'resrho', 'cl', 'cd', 'cmz', 'totalr'], 'usenksolver': True, 'l2convergence': 1e-14, 'l2convergencecoarse': 1e-2, 'nkswitchtol': 1e-2, 'adjointl2convergence': 1e-14, 'solutionprecision': 'double', 'gridprecision': 'double', }) # Setup aeroproblem, cfdsolver, mesh and geometry. ap = AeroProblem(name='mdo_tutorial', alpha=1.8, mach=0.80, P=20000.0, T=220.0, areaRef=45.5, chordRef=3.25, beta=0.0, R=287.87, xRef=0.0, yRef=0.0, zRef=0.0, evalFuncs=defaultFuncList) if not solve: options['restartfile'] = gridFile # Create the solver CFDSolver = ADFLOW(options=options, debug=True) standard_test(handler, CFDSolver, ap, solve)
def setUp(self): gridFile = os.path.join(baseDir, '../input_files/conic_conv_nozzle_mb_L4.cgns') self.options = {'gridfile': gridFile} ap = AeroProblem(name='nozzle_flow', alpha=90, mach=0.5, altitude=0, areaRef=1.0, chordRef=1.0, R=287.87, evalFuncs=['mdot_up', 'mdot_down', 'mdot_plane', 'mavgptot_up', 'mavgptot_down', 'mavgptot_plane', 'mavgttot_up', 'mavgttot_down', 'mavgttot_plane', 'mavgps_up', 'mavgps_down', 'mavgps_plane', ]) self.ap = ap
'ncycles':400, 'monitorvariables':['resrho','cl','cd','cmz','totalr'], 'usenksolver':True, 'l2convergence':1e-15, 'l2convergencecoarse':1e-2, 'nkswitchtol':1e-2, 'adjointl2convergence': 1e-15, 'nkls':'non monotone', 'blocksplitting': True } ) h = 1e-40 # 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=['cl','cmz','drag']) CFDSolver = ADFLOW(options=aeroOptions) if 'complex' in sys.argv: DVGeo = DVGeometry('../inputFiles/mdo_tutorial_ffd.fmt', complex=True) else: DVGeo = DVGeometry('../inputFiles/mdo_tutorial_ffd.fmt', complex=False) nTwist = 2 DVGeo.addRefAxis('wing', pyspline.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]
os.system('mkdir -p %s' % stdoutDir) MP.gcomm.barrier() if comm.rank == 0: fName = os.path.join(stdoutDir, '%s_%d.out' % (setName, ptID)) outFile = open(fName, 'w', buffering=0) redirectIO(outFile) # ============================================================================== # Set up case problems # ============================================================================== # Setup cruise problems cruiseProblems = [] ap = AeroProblem(name='cruise', mach=0.8, altitude=10000, areaRef=Sref, alpha=2.0, chordRef=chordRef, evalFuncs=['lift', 'drag']) ap.addDV('alpha', lower=0, upper=10.0, scale=0.1) sp = StructProblem(ap.name, evalFuncs=['mass']) cruiseProblems.append(AeroStructProblem(ap, sp)) # Setup maneuver problems maneuverProblems = [] # List of maneuver AeroStruct problem objects ap = AeroProblem(name='maneuver', mach=0.75, altitude=5000, areaRef=Sref, alpha=2.0, chordRef=chordRef,
} # Create solver CFDSolver = ADFLOW(options=aeroOptions, comm=comm) CFDSolver.addLiftDistribution(200, "z") # rst adflow (end) # ====================================================================== # Set up flow conditions with AeroProblem # ====================================================================== # rst aeroproblem (beg) aeroProblems = [] for i in range(nFlowCases): ap = AeroProblem( name="fc%d" % i, alpha=alpha[i], mach=mach[i], altitude=alt[i], areaRef=1.0, chordRef=1.0, evalFuncs=["cl", "cd"], ) # Add angle of attack variable ap.addDV("alpha", value=alpha[i], lower=0, upper=10.0, scale=1.0) aeroProblems.append(ap) # rst aeroproblem (end) # ====================================================================== # Geometric Design Variable Set-up # ====================================================================== # rst dvgeo (beg) # Create DVGeometry object FFDFile = "ffd.xyz"
def regression_test(self, handler): ''' This is where the actual testing happens. ''' import copy, os from baseclasses import AeroProblem from commonUtils import adflowDefOpts, defaultFuncList from ... import ADFLOW gridFile = 'input_files/naca0012_rans-L2.cgns' options = copy.copy(adflowDefOpts) k = 0.0808 M = 0.6 gamma = 1.4 R = 287.085 T = 280.0 c = 1.0 alpha_m = 2.77 # 2.89 #2.77 #Modified numbers alpha_0 = 2.34 # 2.41 #2.34 omega = 2 * M * numpy.sqrt(gamma * R * T) * k / c deltaAlpha = -alpha_0 * numpy.pi / 180.0 # Set forcing frequency and other information 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.update({ 'gridfile': gridFile, 'writevolumesolution': False, 'vis4': .025, 'vis2': 0.5, 'restrictionrelaxation': .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 ap = AeroProblem(name='0012pitching', alpha=alpha_m, mach=M, machRef=M, reynolds=4800000.0, reynoldsLength=c, T=T, R=R, areaRef=1.0, chordRef=c, evalFuncs=['cl', 'cd', 'cmz'], xRef=0.25, xRot=0.25, degreePol=0, coefPol=[0.0], degreeFourier=1, omegaFourier=omega, cosCoefFourier=[0.0, 0.0], sinCoefFourier=[deltaAlpha]) # Create the solver CFDSolver = ADFLOW(options=options) CFDSolver.addSlices('z', [0.5]) # Run test CFDSolver(ap) funcs = {} CFDSolver.evalFunctions(ap, funcs) CFDSolver.checkSolutionFailure(ap, funcs) handler.root_add_dict(funcs, 1e-6, 1e-6)
'ncycles':500, 'monitorvariables':['resrho','resturb','cl','cd','cmz','yplus','totalr'], 'usenksolver':True, 'l2convergence':1e-16, 'l2convergencecoarse':1e-2, 'nkswitchtol':1e-2, 'adjointl2convergence': 1e-15, 'nkls':'non monotone', 'blocksplitting': True } ) # Setup aeroproblem, cfdsolver ap = AeroProblem(name='mdo_tutorial', alpha=1.8, mach=0.50, R=287.87, reynolds=50000.0, reynoldsLength=3.25, T=293.15, areaRef=45.5, chordRef=3.25, evalFuncs=['cd','cmz','lift']) ap.addDV('alpha') ap.addDV('mach') CFDSolver = ADFLOW(options=aeroOptions) if not 'complex' in sys.argv: # Solve system CFDSolver(ap, writeSolution=False) funcs = {} CFDSolver.evalFunctions(ap, funcs) # Solve sensitivities funcsSens = {} CFDSolver.evalFunctionsSens(ap, funcsSens)
'nkswitchtol': 1e-2, 'adjointl2convergence': 1e-15, 'nkls': 'non monotone', 'blocksplitting': True }) h = 1e-40 # Setup aeroproblem, cfdsolver ap = AeroProblem(name='mdo_tutorial', alpha=1.8, mach=0.50, R=287.87, reynolds=50000.0, reynoldsLength=3.25, T=293.15, areaRef=45.5, chordRef=3.25, evalFuncs=['cl', 'cmz', 'drag']) CFDSolver = ADFLOW(options=aeroOptions) if 'complex' in sys.argv: DVGeo = DVGeometry('../inputFiles/mdo_tutorial_ffd.fmt', complex=True) else: DVGeo = DVGeometry('../inputFiles/mdo_tutorial_ffd.fmt', complex=False) nTwist = 2 DVGeo.addRefAxis( 'wing', pyspline.Curve(x=numpy.linspace(5.0 / 4.0, 1.5 / 4.0 + 7.5, nTwist),
import numpy as np from baseclasses import AeroProblem from reg_default_options import defaultFuncList ap_tutorial_wing = AeroProblem( name="mdo_tutorial", alpha=1.8, mach=0.80, P=20000.0, T=220.0, areaRef=45.5, chordRef=3.25, beta=0.0, R=287.87, xRef=0.0, yRef=0.0, zRef=0.0, evalFuncs=defaultFuncList, ) ap_tutorial_wing_laminar = AeroProblem( name="mdo_tutorial", alpha=1.8, beta=0.0, mach=0.50, P=137.0, T=293.15, R=287.87, areaRef=45.5, chordRef=3.25, xRef=0.0,
def __init__(self, comm=None, options=None, debug=False): # Load the compiled module using MExt, allowing multiple # imports curDir = os.path.dirname(os.path.realpath(__file__)) self.adflow = MExt.MExt('libadflow', [curDir], debug=debug)._module # Information for base class: name = 'ADFLOW' category = 'Three Dimensional CFD' informs = {} # If 'options' is not None, go through and make sure all keys # are lower case: if options is not None: for key in options.keys(): options[key.lower()] = options.pop(key) else: raise Error( "The 'options' keyword argument must be passed " "adflow. The options dictionary must contain (at least) " "the gridFile entry for the grid") # Load all the option/objective/DV information: defOpts = self._getDefOptions() self.optionMap = self._getOptionMap() self.ignoreOptions, self.deprecatedOptions, self.specialOptions = \ self._getSpecialOptionLists() self.possibleAeroDVs, self.basicCostFunctions = ( self._getObjectivesAndDVs()) # This is the real solver so dtype is 'd' self.dtype = 'd' # Next set the MPI Communicators and associated info if comm is None: comm = MPI.COMM_WORLD self.comm = comm self.adflow.communication.adflow_comm_world = self.comm.py2f() self.adflow.communication.adflow_comm_self = MPI.COMM_SELF.py2f() self.adflow.communication.sendrequests = numpy.zeros(self.comm.size) self.adflow.communication.recvrequests = numpy.zeros(self.comm.size) self.myid = self.adflow.communication.myid = self.comm.rank self.adflow.communication.nproc = self.comm.size # Initialize the inherited aerosolver AeroSolver.__init__(self, name, category, defOpts, informs, options=options) # Initialize petec in case the user has not already self.adflow.initializepetsc() # Set the stand-alone adflow flag to false...this changes how # terminate calls are handled. self.adflow.iteration.standalonemode = False # Set the frompython flag to true... this also changes how # terminate calls are handled self.adflow.killsignals.frompython = True # Set default values self.adflow.setdefaultvalues() self.adflow.inputio.autoparameterupdate = False # Make sure all the params are ok for option in self.options: if option != 'defaults': self.setOption(option.lower(), self.options[option][1]) dummyAP = AeroProblem(name='dummy', mach=0.5, altitude=10000.0, areaRef=1.0, chordRef=1.0, alpha=0.0, degreePol=0, coefPol=[0, 0], degreeFourier=1, omegaFourier=6.28, sinCoefFourier=[0, 0], cosCoefFourier=[0, 0]) self.curAP = dummyAP self._setAeroProblemData(firstCall=True) # Finally complete loading self.adflow.dummyreadparamfile() self.adflow.partitionandreadgrid(False) self.adflow.preprocessingcustomoverset()
"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"]) # Add angle of attack variable ap.addDV("alpha", value=1.5, lower=0, upper=10.0, scale=0.1) # rst aeroproblem (end) # ====================================================================== # Geometric Design Variable Set-up # ====================================================================== # rst dvgeo (beg) # Create DVGeometry object FFDFile = "ffd.xyz" DVGeo = DVGeometry(FFDFile)
'liftindex': 3, 'solutionprecision': 'double', 'gridprecision': 'double', }) # Setup aeroproblem, cfdsolver, mesh and geometry. ap = AeroProblem(name='CRM', alpha=1.8, mach=0.80, P=20000.0, T=220.0, areaRef=45.5, chordRef=3.25, beta=0.0, R=287.87, xRef=0.0, yRef=0.0, zRef=0.0, evalFuncs=defaultFuncList) def setup_cb(comm): # Create the solver CFDSolver = ADFLOW(options=options, debug=False) return CFDSolver, None, None, None
'mgstartlevel': 1, 'monitorvariables': ['cpu', 'resrho', 'cl', 'cd', 'cmz'], 'usenksolver': False, 'l2convergence': 1e-6, 'l2convergencecoarse': 1e-4, 'qmode': False, 'alphafollowing': False, 'blockSplitting': True, }) ap = AeroProblem(name=name, alpha=alpha_m, mach=M, machRef=M, reynolds=4800000.0, reynoldsLength=c, T=T, R=R, areaRef=1.0, chordRef=c, evalFuncs=['cl', 'cd', 'cmz'], xRef=0.25, xRot=0.25) def callback(refGrid, t, ts): newGrid = numpy.copy(refGrid) x = refGrid[:, 0] y = refGrid[:, 1] p = deltaAlpha * numpy.sin(omega * t) c = numpy.cos(p) s = numpy.sin(p)
def regression_test(self, handler): ''' This is where the actual testing happens. ''' import copy from baseclasses import AeroProblem from commonUtils import adflowDefOpts from ... import ADFLOW gridFile = 'input_files/euler_conv_nozzle.cgns' options = copy.copy(adflowDefOpts) options.update({ 'gridfile': gridFile, 'equationType': 'euler', 'smoother': 'dadi', 'liftIndex': 2, 'CFL': 3., 'CFLCoarse': 1.5, 'MGCycle': '2w', 'MGStartLevel': 2, 'nCyclesCoarse': 500, 'nCycles': 2500, 'monitorvariables': ['resrho', 'cl', 'cd', 'yplus'], 'nsubiterturb': 3, 'useNKSolver': True, 'NKSubSpaceSize': 60, 'L2Convergence': 1e-14, 'L2ConvergenceCoarse': 1e-2, 'NKSwitchTol': 1e-2, 'nkadpc': False, 'vis4': 0.006, 'vis2': 0.0, 'blocksplitting': True, 'solutionPrecision': 'double', 'flowtype': 'internal', }) # Setup aeroproblem ap = AeroProblem( name='conv_nozzle', alpha=00.0, mach=0.25, T=500, P=79326.7, areaRef=1., chordRef=2., R=287.87, evalFuncs=[ 'mdot', 'mdot_up', 'mdot_down', 'mavgptot_up', 'mavgptot_down', 'aavgptot_up', 'aavgptot_down', 'mavgttot_up', 'mavgttot_down', 'mavgps_up', 'mavgps_down', 'aavgps_up', 'aavgps_down', 'mavgmn_up', 'mavgmn_down', 'thrust', 'thrust_pressure', 'thrust_viscous', 'thrust_momentum' ]) # Create the solver CFDSolver = ADFLOW(options=options) CFDSolver.addFamilyGroup('upstream', ['INFLOW']) CFDSolver.addFamilyGroup('downstream', ['OUTFLOW']) CFDSolver.addFamilyGroup('all_flow', ['INFLOW', 'OUTFLOW']) CFDSolver.addFunction('mdot', 'upstream', name="mdot_up") CFDSolver.addFunction('mdot', 'downstream', name="mdot_down") CFDSolver.addFunction('mavgptot', 'downstream', name="mavgptot_down") CFDSolver.addFunction('mavgptot', 'upstream', name="mavgptot_up") CFDSolver.addFunction('aavgptot', 'downstream', name="aavgptot_down") CFDSolver.addFunction('aavgptot', 'upstream', name="aavgptot_up") CFDSolver.addFunction('mavgttot', 'downstream', name="mavgttot_down") CFDSolver.addFunction('mavgttot', 'upstream', name="mavgttot_up") CFDSolver.addFunction('mavgps', 'downstream', name="mavgps_down") CFDSolver.addFunction('mavgps', 'upstream', name="mavgps_up") CFDSolver.addFunction('aavgps', 'downstream', name="aavgps_down") CFDSolver.addFunction('aavgps', 'upstream', name="aavgps_up") CFDSolver.addFunction('mavgmn', 'downstream', name="mavgmn_down") CFDSolver.addFunction('mavgmn', 'upstream', name="mavgmn_up") CFDSolver.addFunction( 'drag', 'all_flow', name="thrust") # this naming makes it seem like wishful thinking CFDSolver.addFunction('dragpressure', 'all_flow', name="thrust_pressure") CFDSolver.addFunction('dragviscous', 'all_flow', name="thrust_viscous") CFDSolver.addFunction('dragmomentum', 'all_flow', name="thrust_momentum") # Run test CFDSolver(ap) # Check the residual res = CFDSolver.getResidual(ap) totalR0, totalRStart, totalRFinal = CFDSolver.getResNorms() res /= totalR0 handler.par_add_norm(res, 1e-10, 1e-10) # Get and check the states handler.par_add_norm(CFDSolver.getStates(), 1e-10, 1e-10) funcs = {} CFDSolver.evalFunctions(ap, funcs) handler.root_add_dict(funcs, 1e-10, 1e-10)
npAero = gcomm.size - npStruct # Create aero/structural comms comm, flags = createGroups([npStruct, npAero], comm=gcomm) structID = 0 # zeroth group is structure aeroID = 1 # first group is aero #rst comms (end) # ============================================================================== # Set up case problems # ============================================================================== #rst problems (start) # Set up aerodynamic problem ap = AeroProblem(name='cruise', mach=0.8, altitude=10000, areaRef=45.5, alpha=2.0, chordRef=3.25, evalFuncs=['lift', 'drag']) # Set up structural problem sp = StructProblem(ap.name, evalFuncs=['mass']) # Create aerostructural problem asp = AeroStructProblem(ap, sp) #rst problems (end) # ============================================================================== # Set up aerodynamic analysis # ============================================================================== #rst aeroOptions (start) aeroOptions = {
1e-2, 'adjointl2convergence': 1e-14, 'solutionprecision': 'double', 'gridprecision': 'double', }) # Setup aeroproblem, cfdsolver, mesh and geometry. ap = AeroProblem(name='mdo_tutorial', alpha=1.8, mach=0.80, P=20000.0, T=220.0, areaRef=45.5, chordRef=3.25, beta=0.0, xRef=0.0, yRef=0.0, zRef=0.0, evalFuncs=defaultFuncList) def setup_cb(comm): # Create the solver CFDSolver = ADFLOW(options=options, debug=False) return CFDSolver, None, None, None
} temp_air = 273 # kelvin Pr = 0.72 mu = 1.81e-5 # kg/(m * s) # Rex = u_inf = 30 # m/s\ p_inf = 101e3 rho_inf = p_inf / (287 * temp_air) ap = AeroProblem(name='fc_therm', V=u_inf, T=temp_air, P=p_inf, areaRef=1.0, chordRef=1.0, evalFuncs=['heatflux'], alpha=0.0, beta=0.00, xRef=0.0, yRef=0.0, zRef=0.0) # Create the solver CFDSolver = ADFLOW(options=options, debug=False) res = CFDSolver.getResidual(ap) fluxes = CFDSolver.getHeatFluxes() print(fluxes.imag / 1e-40) # from python.pyADflow import ADFLOW
'ncycles':750, 'monitorvariables':['resrho','resturb','cl','cd','cmz','yplus','totalr'], 'usenksolver':True, 'l2convergence':1e-17, 'l2convergencecoarse':1e-2, 'nkswitchtol':1e-4, 'adjointl2convergence': 1e-16, 'nkls': 'non monotone', 'frozenturbulence':False, 'nkjacobianlag':2, 'blocksplitting': True } ) h = 1e-40 # 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=['cl','cmz','drag']) ap.addDV('alpha') ap.addDV('mach') CFDSolver = ADFLOW(options=aeroOptions) if 'complex' in sys.argv: DVGeo = DVGeometry('../inputFiles/mdo_tutorial_ffd.fmt', complex=True) else: DVGeo = DVGeometry('../inputFiles/mdo_tutorial_ffd.fmt', complex=False) nTwist = 2 DVGeo.addRefAxis('wing', pyspline.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 xrange(nTwist):
'nkls': 'non monotone', 'frozenturbulence': False, 'nkjacobianlag': 2, 'blocksplitting': True }) h = 1e-40 # 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', 'cmz', 'lift']) 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 = {}
'gridfile': gridFile, 'mgcycle': '2w', 'ncyclescoarse': 250, 'ncycles': 500, 'monitorvariables': ['resrho', 'cl', 'cd', 'cmz', 'totalr'], 'usenksolver': True, 'l2convergence': 1e-14, 'l2convergencecoarse': 1e-2, 'nkswitchtol': 1e-2, 'adjointl2convergence': 1e-14, 'solutionprecision': 'single', 'gridprecision': 'double', }) ap = AeroProblem(name='mdo_tutorial', alpha=1.20, mach=0.80, altitude=10000.0, areaRef=45.5, chordRef=3.25) def setup_cb(comm): # Create the solver CFDSolver = ADFLOW(options=options, debug=True) return CFDSolver, None, None, None if __name__ == "__main__": CFDSolver, _, _, _ = setup_cb(MPI.COMM_WORLD)
'double', 'gridprecision': 'double', }) meshOptions = copy.copy(IDWarpDefOpts) meshOptions.update({'gridFile': gridFile}) # Setup aeroproblem, cfdsolver, mesh and geometry. ap = AeroProblem(name='mdo_tutorial', alpha=1.8, mach=0.80, P=20000.0, T=220.0, areaRef=45.5, chordRef=3.25, beta=0.0, R=287.87, xRef=0.0, yRef=0.0, zRef=0.0, evalFuncs=['cl', 'cd']) def setup_cb(comm): # Create the solver CFDSolver = ADFLOW(options=options, comm=comm, debug=False) # Setup geometry/mesh DVGeo = DVGeometry(ffdFile)
"L2ConvergenceCoarse": 1e-2, "nCycles": 1000, } # rst Start ADflow # Create solver CFDSolver = ADFLOW(options=aeroOptions) # Add features CFDSolver.addLiftDistribution(150, "z") CFDSolver.addSlices("z", np.linspace(0.1, 14, 10)) # rst Create AeroProblem ap = AeroProblem(name="wing", mach=0.8, altitude=10000, alpha=1.5, areaRef=45.5, chordRef=3.25, evalFuncs=["cl", "cd"]) # rst Create polar arrays # Create an array of alpha values. # In this case we create 6 evenly spaced values from 0 - 5. alphaList = np.linspace(0, 5, 6) # Create storage for the evaluated lift and drag coefficients CL = [] CD = [] # rst Start loop # Loop over the alpha values and evaluate the polar
# Aerodynamic problem description ap = AeroProblem(name=name, alpha=alpha, mach=mach, altitude=altitude, areaRef=areaRef, chordRef=chordRef, R=287.87, evalFuncs=[ 'mdot_up', 'mdot_down', 'mdot_plane', 'mavgptot_up', 'mavgptot_down', 'mavgptot_plane', 'aavgptot_up', 'aavgptot_down', 'aavgptot_plane', 'mavgttot_up', 'mavgttot_down', 'mavgttot_plane', 'mavgps_up', 'mavgps_down', 'mavgps_plane', 'aavgps_up', 'aavgps_down', 'aavgps_plane', ]) ap.setBCVar('Pressure', 79326.7, 'downstream')
'l2convergencecoarse': 1e-4, 'qmode': True, 'alphafollowing': False, 'blockSplitting': True, 'useblockettes': False, }) ap = AeroProblem(name=name, alpha=alpha_m, mach=M, machRef=M, reynolds=4800000.0, reynoldsLength=c, T=T, R=R, areaRef=1.0, chordRef=c, evalFuncs=['cl', 'cd', 'cmz'], xRef=0.25, xRot=0.25, degreePol=0, coefPol=[0.0], degreeFourier=1, omegaFourier=omega, cosCoefFourier=[0.0, 0.0], sinCoefFourier=[deltaAlpha]) def setup_cb(comm): CFDSolver = ADFLOW(options=options, comm=comm) CFDSolver.addSlices('z', [0.5]) CFDSolver(ap)