def configure(self): super(hyperTop, self).configure() #--------------------------Component Setup----------------------------------- self.add('NPSS', DesignCase()) #imported from npssCases.py #---------------------------DOE Setup---------------------------------------- self.add('driver', DOEdriver()) self.driver.add_parameter('NPSS.tube_Pt', low=99.0 / 0.5282, high=300.) #low=1760., high=1960.) self.driver.add_parameter('NPSS.capsule_MN', low=0.6, high=1.) #low=1760., high=1960.) self.driver.add_parameter('NPSS.bearing_Pt', low=11000., high=12000.) #low=1760., high=1960.) self.driver.DOEgenerator = FullFactorial(num_levels=1) #------------------------Case Recorders Setup-------------------------------- #outfile = open('test_jeff.txt','w') #self.driver.recorders = [CSVCaseRecorder(filename='DOEoutdata.csv'), DumpCaseRecorder(outfile)] ##other options DBCase,ListCaseRecorder #self.driver.printvars = ['designInputs.*'] #self.driver.recorders[0].num_backups = 0 #save backup copies of previous runs (dated) #-------------------------- Assembly Setup ---------------------------------- # Assembly Workflow self.driver.workflow.add(['NPSS']) #
def configure(self): self.add('d', Dummy()) self.add('driver', NeighborhoodDOEdriver()) self.driver.DOEgenerator = FullFactorial(2) self.driver.recorders = [DumpCaseRecorder()] self.driver.add_parameter('d.x', low=0, high=10) self.driver.case_outputs = ['d.y', 'd.bad', 'd.z']
def __init__(self): super(Simulation,self).__init__() #Components self.add("sin_meta_model",MetaModel()) self.sin_meta_model.surrogate = {"default":KrigingSurrogate()} self.sin_meta_model.model = Sin() self.sin_meta_model.recorder = DBCaseRecorder() #Training the MetaModel self.add("DOE_Trainer",DOEdriver()) self.DOE_Trainer.DOEgenerator = FullFactorial() self.DOE_Trainer.DOEgenerator.num_levels = 25 self.DOE_Trainer.add_parameter("sin_meta_model.x",low=0,high=20) self.DOE_Trainer.case_outputs = ["sin_meta_model.f_x"] self.DOE_Trainer.add_event("sin_meta_model.train_next") self.DOE_Trainer.recorders = [DBCaseRecorder()] self.DOE_Trainer.force_execute = True #MetaModel Validation self.add("sin_calc",Sin()) self.add("DOE_Validate",DOEdriver()) self.DOE_Validate.DOEgenerator = Uniform() self.DOE_Validate.DOEgenerator.num_samples = 100 self.DOE_Validate.add_parameter(("sin_meta_model.x","sin_calc.x"),low=0,high=20) self.DOE_Validate.case_outputs = ["sin_calc.f_x","sin_meta_model.f_x"] self.DOE_Validate.recorders = [DBCaseRecorder()] self.DOE_Validate.force_execute = True #Iteration Hierarchy self.driver.workflow = SequentialWorkflow() self.driver.workflow.add(['DOE_Trainer','DOE_Validate']) self.DOE_Trainer.workflow.add('sin_meta_model') self.DOE_Validate.workflow.add('sin_meta_model') self.DOE_Validate.workflow.add('sin_calc')
def configure(self): # Components self.add("sin_meta_model", MetaModel()) self.sin_meta_model.model = Sin() self.sin_meta_model.default_surrogate = FloatKrigingSurrogate() # Training the MetaModel self.add("DOE_Trainer", DOEdriver()) self.DOE_Trainer.DOEgenerator = FullFactorial() self.DOE_Trainer.DOEgenerator.num_levels = 25 self.DOE_Trainer.add_parameter("sin_meta_model.x", low=0, high=20) self.DOE_Trainer.case_outputs = ["sin_meta_model.f_x"] self.DOE_Trainer.add_event("sin_meta_model.train_next") self.DOE_Trainer.recorders = [DBCaseRecorder()] # MetaModel Validation self.add("sin_calc", Sin()) self.add("DOE_Validate", DOEdriver()) self.DOE_Validate.DOEgenerator = Uniform() self.DOE_Validate.DOEgenerator.num_samples = 200 self.DOE_Validate.add_parameter(("sin_meta_model.x", "sin_calc.x"), low=0, high=20) self.DOE_Validate.case_outputs = ["sin_calc.f_x", "sin_meta_model.f_x"] self.DOE_Validate.recorders = [DBCaseRecorder()] # Iteration Hierarchy self.driver.workflow = SequentialWorkflow() self.driver.workflow.add(['DOE_Trainer', 'DOE_Validate']) self.DOE_Trainer.workflow.add('sin_meta_model') self.DOE_Validate.workflow.add('sin_meta_model') self.DOE_Validate.workflow.add('sin_calc')
def configure(self): comp = self.add('comp', Comp()) doe = self.add('doe', NeighborhoodDOEdriver()) doe.DOEgenerator = FullFactorial() doe.alpha = .1 doe.add_parameter('comp.x') doe.add_response('comp.y') doe.workflow.add('comp') meta = self.add('meta', MetaModel(params=('x', ), responses=('y', ))) meta.default_surrogate = ResponseSurface() self.connect('doe.case_inputs.comp.x', 'meta.params.x') self.connect('doe.case_outputs.comp.y', 'meta.responses.y') opt = self.add('opt', SLSQPdriver()) opt.add_parameter('meta.x', high=10., low=-10.) opt.add_objective('meta.y') opt.workflow.add('meta') drv = self.add('driver', FixedPointIterator()) drv.max_iteration = 2 drv.add_parameter('y') drv.add_constraint('y=meta.y') drv.workflow.add(['doe', 'opt'])
def configure(self): self.add('driver', DOEdriver()) self.add('driven', ComponentWhichRaisesException()) self.driver.workflow.add('driven') self.driver.error_policy = 'RETRY' self.driver.DOEgenerator = FullFactorial(2) self.driver.add_parameter('driven.x', low=-50, high=50) self.driver.add_response('driven.f_x')
def configure(self): self.add('driver', IterateUntil()) self.add('adaptive', AdaptiveSampleDriver()) self.add('driven', DrivenComponent()) self.driver.workflow.add('adaptive') self.adaptive.workflow.add('driven') self.adaptive.DOEgenerator = FullFactorial() self.adaptive.DOEgenerator.num_levels = 2 self.adaptive.add_parameter('driven.x', low=-10., high=10.) self.adaptive.add_response('driven.y') self.adaptive.record_doe = False
def test_AutoBEM_DOE(self): # perform a DOE self.top.replace('driver', DOEdriver()) self.top.driver.DOEgenerator = FullFactorial(3) self.top.driver.add_parameter('b.chord_hub', low=.1, high=2) self.top.driver.add_parameter('b.chord_tip', low=.1, high=2) self.top.driver.add_parameter('b.rpm', low=20, high=300) self.top.driver.add_parameter('b.twist_hub', low=-5, high=50) self.top.driver.add_parameter('b.twist_tip', low=-5, high=50) self.top.run() self.assertEqual(self.top.b.exec_count, 243)
def configure(self): # Our component to be meta-modeled self.add("trig_calc", Trig()) # Create meta_model for two responsese self.add("trig_meta_model", MetaModel(params=('x', ), responses=('f_x_sin', 'f_x_cos'))) # Use Kriging for the f_x output self.trig_meta_model.surrogates['f_x_sin'] = LogisticRegression() self.trig_meta_model.surrogates['f_x_cos'] = FloatKrigingSurrogate() # Training the MetaModel self.add("DOE_Trainer", DOEdriver()) self.DOE_Trainer.DOEgenerator = FullFactorial() self.DOE_Trainer.DOEgenerator.num_levels = 20 self.DOE_Trainer.add_parameter("trig_calc.x", low=0, high=20) self.DOE_Trainer.add_response('trig_calc.f_x_sin') self.DOE_Trainer.add_response('trig_calc.f_x_cos') # Pass training data to the meta model. self.connect('DOE_Trainer.case_inputs.trig_calc.x', 'trig_meta_model.params.x') self.connect('DOE_Trainer.case_outputs.trig_calc.f_x_sin', 'trig_meta_model.responses.f_x_sin') self.connect('DOE_Trainer.case_outputs.trig_calc.f_x_cos', 'trig_meta_model.responses.f_x_cos') #MetaModel Validation self.add("DOE_Validate", DOEdriver()) self.DOE_Validate.DOEgenerator = Uniform() self.DOE_Validate.DOEgenerator.num_samples = 20 self.DOE_Validate.add_parameter(("trig_meta_model.x", "trig_calc.x"), low=0, high=20) self.DOE_Validate.add_response("trig_calc.f_x_sin") self.DOE_Validate.add_response("trig_calc.f_x_cos") self.DOE_Validate.add_response("trig_meta_model.f_x_sin") self.DOE_Validate.add_response("trig_meta_model.f_x_cos") #Iteration Hierarchy self.driver.workflow.add(['DOE_Trainer', 'DOE_Validate']) self.DOE_Trainer.workflow.add('trig_calc') self.DOE_Validate.workflow.add(['trig_calc', 'trig_meta_model'])
def configure(self): """ Configure a simple DOE to set start points for CONMIN. """ self.add('gp_fun', GoldsteinPrice()) conmin = self.add('conmin', CONMINdriver()) conmin.workflow.add('gp_fun') conmin.add_parameter('gp_fun.x1') conmin.add_parameter('gp_fun.x2') conmin.add_objective('gp_fun.f') doe = self.add('driver', DOEdriver()) doe.workflow.add('conmin') doe.add_parameter('gp_fun.x1', low=-1.5, high=1.5, start=1) doe.add_parameter('gp_fun.x2', low=-1.5, high=1.5, start=1) doe.DOEgenerator = FullFactorial(5) doe.add_responses( ['gp_fun.f', 'gp_fun.x1', 'gp_fun.x2', 'gp_fun.exec_count']) self.recorders = [CSVCaseRecorder(), DumpCaseRecorder()]
def configure(self): self.add('paraboloid',Paraboloid()) self.add('driver',DOEdriver()) #There are a number of different kinds of DOE available in openmdao.lib.doegenerators self.driver.DOEgenerator = FullFactorial(10) #Full Factorial DOE with 10 levels for each variable #DOEdriver will automatically record the values of any parameters for each case self.driver.add_parameter('paraboloid.x',low=-50,high=50) self.driver.add_parameter('paraboloid.y',low=-50,high=50) #tell the DOEdriver to also record any other variables you want to know for each case self.driver.case_outputs = ['paraboloid.f_xy',] #Simple recorder which stores the cases in memory. self.driver.recorders = [ListCaseRecorder(),] self.driver.workflow.add('paraboloid')
def test_AutoBEM_DOE(self): # perform a DOE self.top.replace('driver', DOEdriver()) self.top.driver.DOEgenerator = FullFactorial(3) self.top.driver.recorders = [ListCaseRecorder()] self.top.driver.case_outputs = [ 'b.perf.data.tip_speed_ratio', 'b.perf.data.Cp', 'b.perf.data.Ct' ] self.top.driver.add_parameter('b.chord_hub', low=.1, high=2) self.top.driver.add_parameter('b.chord_tip', low=.1, high=2) self.top.driver.add_parameter('b.rpm', low=20, high=300) self.top.driver.add_parameter('b.twist_hub', low=-5, high=50) self.top.driver.add_parameter('b.twist_tip', low=-5, high=50) self.top.run() self.assertEqual(len(self.top.driver.recorders[0]), 243)
def configure(self): self.add("driver", DOEdriver()) self.recorders = [ListCaseRecorder()] self.driver.DOEgenerator = FullFactorial() # configure the specific DOE options self.driver.DOEgenerator.num_levels = 3 self.add("dis1", sellar.Discipline1()) self.add("dis2", sellar.Discipline2()) # setting some variables to fixed values self.dis1.y2 = 3.15 self.dis2.y1 = 3.78 # adding three parameters to the DOEDriver self.driver.add_parameter(("dis1.z1", "dis2.z1"), low=-10.0, high=10.0) self.driver.add_parameter(("dis1.z2", "dis2.z2"), low=0.0, high=10.0) self.driver.add_parameter("dis1.x1", low=0.0, high=10.0)
def configure(self): # Our component to be meta-modeled self.add("sin_calc", Sin()) # Another instance of our component for head-to-head comparison with # the metamodel. self.add("sin_verify", Sin()) # Create meta_model for f_x as the response self.add("sin_meta_model", MetaModel(params=('x', ), responses=('f_x', ))) # Use Kriging for the f_x output self.sin_meta_model.default_surrogate = FloatKrigingSurrogate() # Training the MetaModel self.add("DOE_Trainer", DOEdriver()) self.DOE_Trainer.DOEgenerator = FullFactorial() self.DOE_Trainer.DOEgenerator.num_levels = 25 self.DOE_Trainer.add_parameter("sin_calc.x", low=0, high=20) self.DOE_Trainer.add_response('sin_calc.f_x') # Pass training data to the meta model. self.connect('DOE_Trainer.case_inputs.sin_calc.x', 'sin_meta_model.params.x') self.connect('DOE_Trainer.case_outputs.sin_calc.f_x', 'sin_meta_model.responses.f_x') # Cross-validate the metamodel using random data self.add("DOE_Validate", DOEdriver()) self.DOE_Validate.DOEgenerator = Uniform() self.DOE_Validate.DOEgenerator.num_samples = 100 self.DOE_Validate.add_parameter(("sin_meta_model.x", "sin_verify.x"), low=0, high=20) # , name="combined_input" self.DOE_Validate.add_response("sin_verify.f_x") self.DOE_Validate.add_response("sin_meta_model.f_x") #Iteration Hierarchy self.driver.workflow.add(['DOE_Trainer', 'DOE_Validate']) self.DOE_Trainer.workflow.add('sin_calc') self.DOE_Validate.workflow.add(['sin_verify', 'sin_meta_model'])
def configure(self): #Components self.add("trig_meta_model", MetaModel()) self.trig_meta_model.surrogate = { "f_x_sin": LogisticRegression(), "f_x_cos": KrigingSurrogate() } self.trig_meta_model.model = Trig() self.trig_meta_model.recorder = DBCaseRecorder() #Training the MetaModel self.add("DOE_Trainer", DOEdriver()) self.DOE_Trainer.DOEgenerator = FullFactorial() self.DOE_Trainer.DOEgenerator.num_levels = 20 self.DOE_Trainer.add_parameter("trig_meta_model.x", low=0, high=20) self.DOE_Trainer.case_outputs = [ "trig_meta_model.f_x_sin", "trig_meta_model.f_x_cos" ] self.DOE_Trainer.add_event("trig_meta_model.train_next") self.DOE_Trainer.recorders = [DBCaseRecorder()] #MetaModel Validation self.add("trig_calc", Trig()) self.add("DOE_Validate", DOEdriver()) self.DOE_Validate.DOEgenerator = Uniform() self.DOE_Validate.DOEgenerator.num_samples = 20 self.DOE_Validate.add_parameter(("trig_meta_model.x", "trig_calc.x"), low=0, high=20) self.DOE_Validate.case_outputs = [ "trig_calc.f_x_sin", "trig_calc.f_x_cos", "trig_meta_model.f_x_sin", "trig_meta_model.f_x_cos" ] self.DOE_Validate.recorders = [DBCaseRecorder()] #Iteration Hierarchy self.driver.workflow = SequentialWorkflow() self.driver.workflow.add(['DOE_Trainer', 'DOE_Validate']) self.DOE_Trainer.workflow.add('trig_meta_model') self.DOE_Validate.workflow.add('trig_meta_model') self.DOE_Validate.workflow.add('trig_calc')
def __init__(self): super(Simulation, self).__init__() #Components self.add("sin_calc", Sin()) self.add("sin_verify", Sin()) self.add("sin_meta_model", MetaModel(params=('x',), responses=('f_x',))) self.sin_meta_model.default_surrogate = NeuralNet(n_hidden_nodes=5) #Training the MetaModel self.add("DOE_Trainer", DOEdriver()) self.DOE_Trainer.DOEgenerator = FullFactorial() # Seems to need a lot of training data for decent prediction of sin(x), # at least with default 'cg' method. self.DOE_Trainer.DOEgenerator.num_levels = 2500 self.DOE_Trainer.add_parameter("sin_calc.x", low=0, high=20) self.DOE_Trainer.add_response("sin_calc.f_x") self.connect('DOE_Trainer.case_inputs.sin_calc.x', 'sin_meta_model.params.x') self.connect('DOE_Trainer.case_outputs.sin_calc.f_x', 'sin_meta_model.responses.f_x') #MetaModel Validation self.add("DOE_Validate", DOEdriver()) self.DOE_Validate.DOEgenerator = Uniform() self.DOE_Validate.DOEgenerator.num_samples = 100 self.DOE_Validate.add_parameter(("sin_meta_model.x", "sin_verify.x"), low=0, high=20) self.DOE_Validate.add_response("sin_verify.f_x") self.DOE_Validate.add_response("sin_meta_model.f_x") #Iteration Hierarchy self.driver.workflow.add(['DOE_Trainer', 'DOE_Validate']) self.DOE_Trainer.workflow.add('sin_calc') self.DOE_Validate.workflow.add(('sin_verify', 'sin_meta_model'))
def test_doegen_remove(self): top = set_as_top(Assembly()) top.add("driver", DOEdriver()) top.driver.remove("DOEgenerator") top.driver.add("DOEgenerator", FullFactorial())
def test_scaling(self): self.model.driver.DOEgenerator = ff = FullFactorial(num_levels=3) ff.num_parameters = 4 for case in self.model.driver._get_cases(): print case