def test_2peer_drivers(self): # # D1--> # | | # |<--C1------>| # | # D2-->| # | | # |<---C2 global exec_order print "*** test_2peer_drivers ***" top = set_as_top(Assembly()) top.add('C1', ExprComp(expr='x+1')) top.add('C2', ExprComp2(expr='x+y')) top.connect('C1.f_x', 'C2.x') top.add('D1', Summer()) top.D1.add_objective('C1.f_x') top.D1.add_parameter('C1.x', low=-999, high=999) top.D1.max_iterations = 2 top.add('D2', Summer()) top.D2.add_objective('C2.f_xy') top.D2.add_parameter('C2.y', low=-999, high=999) top.D2.max_iterations = 3 top.driver.workflow.add(['D1', 'D2']) top.D1.workflow = SequentialWorkflow(top.D1, members=['C1']) top.D2.workflow = SequentialWorkflow(top.D1, members=['C2']) top.run() self.assertEqual(top.D2.runcount, 1) self.assertEqual(top.D1.runcount, 1) self.assertEqual(top.C1.runcount, top.D1.max_iterations) self.assertEqual(top.C2.runcount, top.D2.max_iterations) self.assertEqual(exec_order, ['D1', 'C1', 'C1', 'D2', 'C2', 'C2', 'C2']) top.C1.runcount = 0 top.C2.runcount = 0 top.D1.runcount = 0 top.D2.runcount = 0 top.D1.set('max_iterations', 5) top.D2.set('max_iterations', 4) exec_order = [] top.run() self.assertEqual(top.D2.runcount, 1) self.assertEqual(top.D1.runcount, 1) self.assertEqual(top.C1.runcount, top.D1.max_iterations) self.assertEqual(top.C2.runcount, top.D2.max_iterations) self.assertEqual(exec_order, ['D1', 'C1', 'C1', 'C1', 'C1', 'C1', 'D2', 'C2', 'C2', 'C2', 'C2'])
def test_tracing(self): # Check tracing of iteration coordinates. top = Assembly() comp = top.add('comp1', Dummy()) top.add('driverA', Driver()) comp = top.add('comp2', Dummy()) top.add('driverB', Driver()) sub = top.add('subassy', Assembly()) comp = sub.add('comp3', Dummy()) sub.driver.workflow.add('comp3') top.driver.workflow = SequentialWorkflow() top.driver.workflow.add(('comp1', 'driverA', 'driverB')) top.driverA.workflow.add(('comp1', 'comp2')) top.driverB.workflow.add(('comp2', 'subassy')) trace_out = cStringIO.StringIO() enable_trace(trace_out) top.run() expected = """\ 1-comp1 1-driverA.1-comp1 1-driverA.1-comp2 1-driverB.1-comp2 1-driverB.1-subassy.1-comp3 """ self.assertEqual(trace_out.getvalue(), expected) disable_trace() top.run() self.assertEqual(trace_out.getvalue(), expected)
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 __init__(self): super(Analysis, self).__init__() # --------------------------------------------------------------------------- # # --- Instantiate LHC DOE Driver # --------------------------------------------------------------------------- # self.add('doe_driver', DOEdriver()) self.doe_driver.DOEgenerator = Uniform(num_samples = 5) self.doe_driver.workflow = SequentialWorkflow() # --------------------------------------------------------------------------- # # --- Instantiate Geometry Component # --------------------------------------------------------------------------- # self.add('geometry', GeometryComp()) # 1--- Top Level Workflow self.driver.workflow.add(['doe_driver']) self.doe_driver.workflow.add(['geometry']) # --------------------------------------------------------------------------- # # --- Add parameters to DOE driver # --------------------------------------------------------------------------- # self.doe_driver.add_parameter('geometry.dC1P_X') self.doe_driver.add_parameter('geometry.dC2P_X') self.doe_driver.add_parameter('geometry.dC3P_X') self.doe_driver.add_parameter('geometry.dC4P_X') self.doe_driver.add_parameter('geometry.dC1P_R') self.doe_driver.add_parameter('geometry.dC2P_R') self.doe_driver.add_parameter('geometry.dC3P_R') self.doe_driver.add_parameter('geometry.dC4P_R') self.doe_driver.add_parameter('geometry.dC1S_X') self.doe_driver.add_parameter('geometry.dC2S_X') self.doe_driver.add_parameter('geometry.dC3S_X') self.doe_driver.add_parameter('geometry.dC4S_X') self.doe_driver.add_parameter('geometry.dC1S_R') self.doe_driver.add_parameter('geometry.dC2S_R') self.doe_driver.add_parameter('geometry.dC3S_R') self.doe_driver.add_parameter('geometry.dC4S_R') self.doe_driver.add_parameter('geometry.dC1S_T') self.doe_driver.add_parameter('geometry.dC2S_T') self.doe_driver.add_parameter('geometry.dC3S_T') self.doe_driver.add_parameter('geometry.dC1C_X') self.doe_driver.add_parameter('geometry.dC2C_X') self.doe_driver.add_parameter('geometry.dC3C_X') self.doe_driver.add_parameter('geometry.dC4C_X') self.doe_driver.add_parameter('geometry.dC1C_R') self.doe_driver.add_parameter('geometry.dC2C_R') self.doe_driver.add_parameter('geometry.dC3C_R') self.doe_driver.add_parameter('geometry.dC4C_R') self.doe_driver.add_parameter('geometry.dC1C_T') self.doe_driver.add_parameter('geometry.dC2C_T') self.doe_driver.add_parameter('geometry.dC3C_T')
def configure(self): self.add('driver',Smarty()) self.add('dumcomp',Dummy()) self.add('dum2',DummyAssembly()) self.driver.add_parameter(("dumcomp.dummy3",'dum2.dummy3'),low=-1000,high=1000) self.driver.add_parameter(("dumcomp.dummy4",'dum2.dummy4'),low=-1000,high=1000) self.driver.add_objective('dumcomp.dummy2') #Doesn't work. self.driver.workflow = SequentialWorkflow() self.driver.workflow.add(['dumcomp','dum2'])
def __init__(self): super(Analysis, self).__init__() # --------------------------------------------------------------------------- # # --- Instantiate LHC DOE Driver # --------------------------------------------------------------------------- # self.add('doe_driver', DOEdriver()) self.doe_driver.DOEgenerator = OptLatinHypercube(num_samples=10) self.doe_driver.workflow = SequentialWorkflow() # --------------------------------------------------------------------------- # # --- Instantiate LHC Adapter Component # --- Modifies LHC to convert continuous design variable to discrete # --------------------------------------------------------------------------- # self.add('adapter', AdapterComp()) # --------------------------------------------------------------------------- # # --- Instantiate Geometry Component # --------------------------------------------------------------------------- # self.add('geometry', GeometryComp()) # 1--- Top Level Workflow self.driver.workflow.add(['doe_driver']) self.doe_driver.workflow.add(['adapter', 'geometry']) # --------------------------------------------------------------------------- # # --- Add parameters to DOE driver # --------------------------------------------------------------------------- # self.doe_driver.add_parameter('adapter.vane_num') self.doe_driver.add_parameter('adapter.injector_loc') self.doe_driver.add_parameter('adapter.injector_dia') self.doe_driver.add_parameter('geometry.vane_pitch') self.doe_driver.add_parameter('geometry.venturi_angle') # --------------------------------------------------------------------------- # # Specify DBcaseRecorder for DOE # --------------------------------------------------------------------------- # self.doe_driver.case_outputs = [ 'adapter.vane_num_out', 'adapter.injector_loc_out', 'adapter.injector_dia_out', 'geometry.vane_num', 'geometry.injector_loc', 'geometry.injector_dia' ] self.doe_driver.recorder = DBCaseRecorder(DOE_OUT_DB) #self.add('DOE_restart', DBCaseIterator(DOE_OUT_DB)) # --------------------------------------------------------------------------- # # --- Specify Non-NPSS Data Connections # --------------------------------------------------------------------------- # self.connect('adapter.vane_num_out', 'geometry.vane_num') self.connect('adapter.injector_loc_out', 'geometry.injector_loc') self.connect('adapter.injector_dia_out', 'geometry.injector_dia')
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 configure(self): self._tdir = mkdtemp() self.comp_name = None #check to make sure no more than one component is being referenced compnames = set() for param in self.parent.get_parameters().values(): compnames.update(param.get_referenced_compnames()) if len(compnames) > 1: self.parent.raise_exception('The EGO architecture can only be used on one' 'component at a time, but parameters from %s ' 'were added to the problem formulation.' %compnames, ValueError) self.comp_name = compnames.pop() #change name of component to add '_model' to it. # lets me name the metamodel as the old name self.comp= getattr(self.parent,self.comp_name) self.comp.name = "%s_model"%self.comp_name #add in the metamodel meta_model = self.parent.add(self.comp_name,MetaModel()) #metamodel now replaces old component with same name meta_model.default_surrogate = KrigingSurrogate() meta_model.model = self.comp meta_model_recorder = DBCaseRecorder(os.path.join(self._tdir,'trainer.db')) meta_model.recorder = meta_model_recorder EI = self.parent.add("EI",ExpectedImprovement()) self.objective = self.parent.get_objectives().keys()[0] EI.criteria = self.objective pfilter = self.parent.add("filter",ParetoFilter()) pfilter.criteria = [self.objective] pfilter.case_sets = [meta_model_recorder.get_iterator(),] #Driver Configuration DOE_trainer = self.parent.add("DOE_trainer",DOEdriver()) DOE_trainer.sequential = True DOE_trainer.DOEgenerator = OptLatinHypercube(num_samples=self.initial_DOE_size) for name,param in self.parent.get_parameters().iteritems(): DOE_trainer.add_parameter(param) DOE_trainer.add_event("%s.train_next"%self.comp_name) DOE_trainer.case_outputs = [self.objective] DOE_trainer.recorders = [DBCaseRecorder(':memory:')] EI_opt = self.parent.add("EI_opt",Genetic()) EI_opt.opt_type = "maximize" EI_opt.population_size = 100 EI_opt.generations = 10 #EI_opt.selection_method = "tournament" for name,param in self.parent.get_parameters().iteritems(): EI_opt.add_parameter(param) EI_opt.add_objective("EI.%s"%self.EI_PI) retrain = self.parent.add("retrain",Driver()) retrain.recorders = self.data_recorders retrain.add_event("%s.train_next"%self.comp_name) iter = self.parent.add("iter",IterateUntil()) iter.max_iterations = self.sample_iterations iter.add_stop_condition('EI.PI <= %s'%self.min_ei_pi) #Data Connections self.parent.connect("filter.pareto_set","EI.best_case") self.parent.connect(self.objective,"EI.predicted_value") #Iteration Heirarchy self.parent.driver.workflow.add(['DOE_trainer', 'iter']) #DOE_trainer.workflow.add(self.comp_name) iter.workflow = SequentialWorkflow() iter.workflow.add(['filter', 'EI_opt', 'retrain']) #EI_opt.workflow.add([self.comp_name,'EI']) retrain.workflow.add(self.comp_name)
def configure(self): """Setup a BLISS2000 architecture inside this assembly. """ global_dvs = self.parent.get_global_des_vars() des_vars=self.parent.get_des_vars_by_comp() local_dvs_by_comp = self.parent.get_local_des_vars_by_comp() global_dvs_by_comp = self.parent.get_global_des_vars_by_comp() locals=self.parent.get_local_des_vars() objective = self.parent.get_objectives().items()[0] comp_constraints = self.parent.get_constraints_by_comp() coupling = self.parent.list_coupling_vars() couple_deps = self.parent.get_coupling_deps_by_comp() couple_indeps = self.parent.get_coupling_indeps_by_comp() driver=self.parent.add("driver",FixedPointIterator()) driver.workflow = SequentialWorkflow() driver.max_iteration=15 #should be enough to converge driver.tolerance = .005 meta_models = {} self.sub_system_opts = {} system_var_map = {} for comp in des_vars: mm_name = "meta_model_%s"%comp meta_model = self.parent.add(mm_name,MetaModel()) #metamodel now replaces old component with same name driver.add_event("%s.reset_training_data"%mm_name) meta_models[comp] = meta_model meta_model.default_surrogate = ResponseSurface() #if there are locals, you need to make a SubSystemOpt assembly comp_obj = self.parent.get(comp) sso = self.parent.add('sub_system_opt_%s'%comp, SubSystemOpt(comp_obj, global_dvs_by_comp.get(comp), local_dvs_by_comp.get(comp), couple_deps.get(comp), couple_indeps.get(comp), comp_constraints.get(comp))) self.sub_system_opts[comp] = sso meta_model.model = sso for name,mapped_name in sso.var_map.iteritems(): system_var_map[name] = "%s.%s"%(mm_name,mapped_name) meta_model.recorder = DBCaseRecorder() #add a doe trainer for each metamodel dis_doe=self.parent.add("DOE_Trainer_%s"%comp,NeighborhoodDOEdriver()) for couple in couple_indeps[comp] : mapped_name = system_var_map[couple.indep.target] dis_doe.add_parameter(mapped_name,low=-1e99,high=1e99) #change to -1e99/1e99 for dv in global_dvs_by_comp[comp]: dis_doe.add_parameter(system_var_map[dv.target],low=dv.low, high=dv.high,start=dv.start) if local_dvs_by_comp.get(comp): #add weights if they are there for w in meta_model.model.weights: dis_doe.add_parameter("meta_model_%s.%s"%(comp,w),low=-3,high=3) num_params = len(dis_doe.get_parameters()) dis_doe.DOEgenerator = LatinHypercube((num_params**2+3*num_params+2)/2) dis_doe.alpha= .1 dis_doe.beta = .01 dis_doe.add_event("meta_model_%s.train_next"%comp) dis_doe.force_execute = True driver.workflow.add(dis_doe.name) #run all doe training before system optimziation #optimization of system objective function using the discipline meta models sysopt=self.parent.add('sysopt', SLSQPdriver()) sysopt.recorders = self.data_recorders sysopt.iprint = 0 sysopt.differentiator = FiniteDifference() obj2= objective[1].text #for comp in objective[1].get_referenced_compnames(): # obj2=obj2.replace(comp,"meta_model_%s"%comp) for var_name, mapped_name in system_var_map.iteritems(): obj2=obj2.replace(var_name,mapped_name) sysopt.add_objective(obj2) #add global design variables as parameters for param,group in global_dvs: plist=[system_var_map[t] for t in group.targets] sysopt.add_parameter(plist, low=group.low, high=group.high,start=group.start) #add the subsytem weights to the system optimization for comp,sso in self.sub_system_opts.iteritems(): mm_name = "meta_model_%s"%comp for w in sso.weights: sysopt.add_parameter("%s.%s"%(mm_name,w),low=-3,high=3) for key,couple in coupling.iteritems(): s=couple.indep.target mapped_name = system_var_map[s] sysopt.add_parameter(mapped_name, low=-1e99, high=1e99) #feasibility constraints, referenced to metamodels s1,s2= system_var_map[couple.dep.target], system_var_map[couple.indep.target] sysopt.add_constraint('(%s-%s)**2<=0.0001'%(s2,s1)) #sysopt.add_constraint('%s>=%s'%(s2,s1)) #add constraints, referenced to metamodels for comp,constraints in comp_constraints.iteritems(): for c in constraints: new_c = str(c) for var,mapped_name in system_var_map.iteritems(): new_c = new_c.replace(var,mapped_name) sysopt.add_constraint(new_c) driver.workflow.add('sysopt') #setup paramter for fixedpointiterator comp=des_vars.keys()[0] mm='meta_model_%s'%comp #create some placeholder variables for the fixed point iteration for l in locals: s=system_var_map[l[0]].replace(".","_") s2='%s_store'%s self.parent.add(s2,Float(0.0)) driver.add_parameter(s2 , low=l[1].low, high=l[1].high) driver.add_constraint('%s = %s'%(system_var_map[l[1].target],s2)) for i,g in enumerate(global_dvs): s2='global%d_store'%i self.parent.add(s2,Float(0.0)) driver.add_parameter(s2 , low=g[1].low, high=g[1].high) driver.add_constraint('%s = %s'%(system_var_map[g[1].target],s2))
def test_itername(self): # top # comp1 # driverA # comp1 # comp2 # driverB # comp2 # subassy # comp3 trace_buf = [] top = TracedAssembly(trace_buf) top.add('driver', TracedIterator(trace_buf, 2)) top.add('comp1', TracedComponent(trace_buf)) top.add('driverA', TracedIterator(trace_buf, 3)) top.add('comp2', TracedComponent(trace_buf)) top.add('driverB', TracedIterator(trace_buf, 2)) sub = top.add('subassy', TracedAssembly(trace_buf)) sub.add('driver', TracedIterator(trace_buf, 2)) sub.add('comp3', TracedComponent(trace_buf)) sub.driver.workflow.add('comp3') # Default didn't execute comp1 first. top.driver.workflow = SequentialWorkflow() top.driver.workflow.add(('comp1', 'driverA', 'driverB')) top.driverA.workflow.add(('comp1', 'comp2')) top.driverB.workflow.add(('comp2', 'subassy')) top.run() top.run(case_id='ReRun') expected = """\ : driver: comp1: 1-1 driverA: 1-2 comp1: 1-2.1-1 comp2: 1-2.1-2 comp1: 1-2.2-1 comp2: 1-2.2-2 comp1: 1-2.3-1 comp2: 1-2.3-2 driverB: 1-3 comp2: 1-3.1-1 subassy: 1-3.1-2 subassy.driver: 1-3.1-2 subassy.comp3: 1-3.1-2.1-1 subassy.comp3: 1-3.1-2.2-1 comp2: 1-3.2-1 subassy: 1-3.2-2 subassy.driver: 1-3.2-2 subassy.comp3: 1-3.2-2.1-1 subassy.comp3: 1-3.2-2.2-1 comp1: 2-1 driverA: 2-2 comp1: 2-2.1-1 comp2: 2-2.1-2 comp1: 2-2.2-1 comp2: 2-2.2-2 comp1: 2-2.3-1 comp2: 2-2.3-2 driverB: 2-3 comp2: 2-3.1-1 subassy: 2-3.1-2 subassy.driver: 2-3.1-2 subassy.comp3: 2-3.1-2.1-1 subassy.comp3: 2-3.1-2.2-1 comp2: 2-3.2-1 subassy: 2-3.2-2 subassy.driver: 2-3.2-2 subassy.comp3: 2-3.2-2.1-1 subassy.comp3: 2-3.2-2.2-1 : driver: comp1: ReRun.1-1 driverA: ReRun.1-2 comp1: ReRun.1-2.1-1 comp2: ReRun.1-2.1-2 comp1: ReRun.1-2.2-1 comp2: ReRun.1-2.2-2 comp1: ReRun.1-2.3-1 comp2: ReRun.1-2.3-2 driverB: ReRun.1-3 comp2: ReRun.1-3.1-1 subassy: ReRun.1-3.1-2 subassy.driver: ReRun.1-3.1-2 subassy.comp3: ReRun.1-3.1-2.1-1 subassy.comp3: ReRun.1-3.1-2.2-1 comp2: ReRun.1-3.2-1 subassy: ReRun.1-3.2-2 subassy.driver: ReRun.1-3.2-2 subassy.comp3: ReRun.1-3.2-2.1-1 subassy.comp3: ReRun.1-3.2-2.2-1 comp1: ReRun.2-1 driverA: ReRun.2-2 comp1: ReRun.2-2.1-1 comp2: ReRun.2-2.1-2 comp1: ReRun.2-2.2-1 comp2: ReRun.2-2.2-2 comp1: ReRun.2-2.3-1 comp2: ReRun.2-2.3-2 driverB: ReRun.2-3 comp2: ReRun.2-3.1-1 subassy: ReRun.2-3.1-2 subassy.driver: ReRun.2-3.1-2 subassy.comp3: ReRun.2-3.1-2.1-1 subassy.comp3: ReRun.2-3.1-2.2-1 comp2: ReRun.2-3.2-1 subassy: ReRun.2-3.2-2 subassy.driver: ReRun.2-3.2-2 subassy.comp3: ReRun.2-3.2-2.1-1 subassy.comp3: ReRun.2-3.2-2.2-1""" expected = expected.split('\n') errors = 0 for i, line in enumerate(trace_buf): if line != expected[i]: logging.error('%d: expected %r, got %r', i, expected[i], line) errors += 1 self.assertEqual(errors, 0) self.assertEqual(len(trace_buf), len(expected))
def configure(self): # --------------------------------------------------------------------------- # # --- Instantiate Counter Component # --------------------------------------------------------------------------- # self.add('counter', DOECounterComp()) # --------------------------------------------------------------------------- # # --- Instantiate Subcounter Component # --------------------------------------------------------------------------- # self.add('subcounter', SubCounterComp()) # --------------------------------------------------------------------------- # # --- Instantiate Restart Component # --------------------------------------------------------------------------- # self.add('restart_doe', RestartComp()) # --------------------------------------------------------------------------- # # --- Instantiate NPSS Non-Reacting Component # --------------------------------------------------------------------------- # self.add('npss_nonreacting', NpssNonreacting()) self.npss_nonreacting.Comb_dPqPBase = init_dP() # --------------------------------------------------------------------------- # # --- Instantiate NPSS Reacting Component # --------------------------------------------------------------------------- # self.add('npss_reacting', NpssReacting()) self.npss_reacting.Comb_dPqPBase = init_dP() # --------------------------------------------------------------------------- # # --- Instantiate Geometry Component # --------------------------------------------------------------------------- # self.add('geometry', GeometryComp()) # --------------------------------------------------------------------------- # # --- Instantiate Mesh Component # --------------------------------------------------------------------------- # self.add('mesh', MeshComp()) # --------------------------------------------------------------------------- # # --- Instantiate NCC Non-reacting Component (1-Step Chemistry) # --------------------------------------------------------------------------- # self.add('ncc_nonreacting', NCCcomponent()) self.ncc_nonreacting.max_iterations_per_time_step = 40000 self.ncc_nonreacting.nonreacting = True self.ncc_nonreacting.continuity_goal = 2000 self.ncc_nonreacting.restarts = 40000 self.ncc_nonreacting.CFL = 0.8 self.ncc_nonreacting.mass_imbalance_goal = 1.0E-2 self.ncc_nonreacting.aero2 = -1.0E-3 self.ncc_nonreacting.k_e2 = -1.0E-3 self.ncc_nonreacting.species2 = -1.0E-3 self.ncc_nonreacting.enthalpy2 = -1.0E-3 self.ncc_nonreacting.aero4 = 0.05 self.ncc_nonreacting.k_e4 = 0.05 self.ncc_nonreacting.species4 = 0.05 self.ncc_nonreacting.enthalpy4 = 0.05 self.ncc_nonreacting.twall_run = 4.0 self.ncc_nonreacting._num_procs = 400 # --- Must be divisible by 20 to run on Ivy Bridge # --------------------------------------------------------------------------- # # --- Instantiate NCC Reacting Component (1-Step Chemistry) # --------------------------------------------------------------------------- # self.add('ncc_reacting', NCCcomponent()) self.ncc_reacting.reacting = True self.ncc_reacting.continuity_goal = 750 self.ncc_reacting.max_iterations_per_time_step = 15000 self.ncc_reacting.restarts = 15000 self.ncc_reacting.CFL = 0.8 self.ncc_reacting.pbcfl = 0.375 self.ncc_reacting.etau_beta = 0.15 self.ncc_reacting.mass_imbalance_goal = 1.0E-3 self.ncc_reacting.aux_var_name_list = "'unmixed' 'C12H23'" self.ncc_reacting.spec_name_ignite = 'C12H23' self.ncc_reacting.fuel_symbol = 'C12H23' self.ncc_reacting.combust = True self.ncc_reacting.lspray = True self.ncc_reacting.aero2 = -2.5E-3 self.ncc_reacting.k_e2 = -2.5E-3 self.ncc_reacting.species2 = -2.5E-3 self.ncc_reacting.enthalpy2 = -2.5E-3 self.ncc_reacting.aero4 = 0.05 self.ncc_reacting.k_e4 = 0.05 self.ncc_reacting.species4 = 0.05 self.ncc_reacting.enthalpy4 = 0.05 self.ncc_reacting.ignite_done_model = 0 self.ncc_reacting.ignition_on = True self.ncc_reacting.no_of_streams = 16 self.ncc_reacting.twall_run = 4.0 self.ncc_reacting._num_procs = 400 # --- Must be divisible by 20 to run on Ivy Bridge # --------------------------------------------------------------------------- # # --- Instantiate NCC Reacting Component (Detailed Chemistry) # --------------------------------------------------------------------------- # self.add('ncc_reacting2', NCCcomponent()) self.ncc_reacting2.reacting2 = True self.ncc_reacting2.continuity_goal = 750 self.ncc_reacting2.max_iterations_per_time_step = 10000 self.ncc_reacting2.restarts = 10000 self.ncc_reacting2.CFL = 0.9 self.ncc_reacting.pbcfl = 0.5 self.ncc_reacting2.mass_imbalance_goal = 1.0E-3 self.ncc_reacting2.aux_var_name_list = "'unmixed' 'C11H21'" self.ncc_reacting2.spec_name_ignite = 'C11H21' self.ncc_reacting2.fuel_symbol = 'C11H21' self.ncc_reacting2.combust = True self.ncc_reacting2.lspray = True self.ncc_reacting2.aero2 = -1.0E-3 self.ncc_reacting2.k_e2 = -1.0E-3 self.ncc_reacting2.species2 = -1.0E-3 self.ncc_reacting2.enthalpy2 = -1.0E-3 self.ncc_reacting2.aero4 = 0.05 self.ncc_reacting2.k_e4 = 0.05 self.ncc_reacting2.species4 = 0.05 self.ncc_reacting2.enthalpy4 = 0.05 self.ncc_reacting2.energy = 0.0001 self.ncc_reacting2.when_start_spray = 1 self.ncc_reacting2.ignite_done_model = 0 self.ncc_reacting2.ignition_on = True self.ncc_reacting2.twall_run = 7.5 self.ncc_reacting2._num_procs = 400 # --- Must be divisible by 20 to Run on Ivy Bridge # --------------------------------------------------------------------------- # # --- Instantiate Tecplot Nonreacting Component # --------------------------------------------------------------------------- # self.add('tecplot_nonreacting', TecplotComp()) self.tecplot_nonreacting.nonreacting = True # --------------------------------------------------------------------------- # # --- Instantiate Tecplot Reacting Spray Component # --------------------------------------------------------------------------- # self.add('tecplot_reacting', TecplotComp()) self.tecplot_reacting.reacting = True # --------------------------------------------------------------------------- # # --- Instantiate Tecplot Reacting Spray Component # --------------------------------------------------------------------------- # self.add('tecplot_reacting2', TecplotComp()) self.tecplot_reacting2.reacting2 = True # --------------------------------------------------------------------------- # # --- Create Driver Instances # --------------------------------------------------------------------------- # # --- Top Level Assembly Driver self.add('driver', IterateUntil()) self.driver.max_iterations = 1 self.driver.workflow = SequentialWorkflow() # --- Inner Nonreacting Driver (Fixed Point) self.add('nonreacting_driver', FixedPointIterator()) self.nonreacting_driver.workflow = SequentialWorkflow() self.nonreacting_driver.step_size = 0.125 self.nonreacting_driver.max_iteration = 1 self.nonreacting_driver.tolerance = 0.001 # --- Inner Reacting Driver self.add('reacting_driver', IterateUntil()) self.reacting_driver.max_iterations = 1 self.reacting_driver.workflow = SequentialWorkflow() # --- Inner Reacting Driver #2 self.add('reacting_driver2', IterateUntil()) self.reacting_driver2.max_iterations = 2 self.reacting_driver2.workflow = SequentialWorkflow() self.reacting_driver2.add_stop_condition( 'tecplot_reacting2.dTqTBase < 0.0025') # --- Run Design at All ICAO Power Settings self.add('power_hook', CaseIteratorDriver()) self.power_hook.workflow = SequentialWorkflow() self.power_hook.iterator = CSVCaseIterator(filename='ICAOsettings.csv') self.power_hook.workflow.add(['reacting_driver2']) # --------------------------------------------------------------------------- # # --- Create Main Assembly Workflow # --------------------------------------------------------------------------- # # --- Add component instances to top-level assembly #self.driver.workflow.add(['counter', 'restart_doe', 'geometry', 'mesh', 'nonreacting_driver', 'reacting_driver', 'reacting_driver2']) #self.driver.workflow.add(['counter', 'restart_doe', 'geometry', 'nonreacting_driver', 'reacting_driver', 'reacting_driver2']) #self.driver.workflow.add(['counter', 'restart_doe', 'geometry', 'reacting_driver2']) #self.driver.workflow.add(['counter', 'restart_doe', 'geometry', 'npss_nonreacting', 'npss_reacting']) self.driver.workflow.add( ['counter', 'restart_doe', 'geometry', 'power_hook']) # --------------------------------------------------------------------------- # # --- Create Sub-Assembly Workflows # --------------------------------------------------------------------------- # # --- Inner Nonreacting Loop - Solve via fixed point iteration self.nonreacting_driver.workflow.add([ 'subcounter', 'npss_nonreacting', 'ncc_nonreacting', 'tecplot_nonreacting' ]) # --- Add solver independents and dependents for fixed point iterator self.nonreacting_driver.add_parameter( ['npss_nonreacting.Comb_dPqPBase', 'npss_reacting.Comb_dPqPBase'], low=-9.e99, high=9.e99) self.nonreacting_driver.add_constraint( 'tecplot_nonreacting.dPqPBase = npss_nonreacting.Comb_dPqPBase') # --- Inner Reacting Loop - Run Once self.reacting_driver.workflow.add([ 'subcounter', 'npss_reacting', 'ncc_reacting', 'tecplot_reacting' ]) # --- Inner Reacting Loop #2 - Run Once self.reacting_driver2.workflow.add([ 'subcounter', 'npss_reacting', 'ncc_reacting2', 'tecplot_reacting2' ]) # --------------------------------------------------------------------------- # # --- Add Driver Events --- Comment this section out to override numbering # --------------------------------------------------------------------------- # if (self.subcounter._iteration == 0): self.driver.add_event('subcounter.reset_iteration') self.driver.add_event('ncc_nonreacting.clean_start') self.power_hook.add_event('subcounter.reset_iteration') self.power_hook.add_event('ncc_nonreacting.clean_start') # --------------------------------------------------------------------------- # # --- Specify Case Recorders # --------------------------------------------------------------------------- # self.driver.case_outputs = [ 'geometry.pilot_recession', 'geometry.vane_height', 'geometry.venturi_angle', 'nonreacting_driver.ncc_nonreacting.FAR', 'nonreacting_driver.tecplot_nonreacting.dPqPBase' ] self.power_hook.recorders = [DumpCaseRecorder()] # --------------------------------------------------------------------------- # # --- Create Data Connections # --------------------------------------------------------------------------- # self.connect('counter.config', [ 'subcounter.case', 'restart_doe.config', 'geometry.config', 'mesh.config' ]) self.connect('subcounter.config', [ 'ncc_nonreacting.config', 'ncc_reacting.config', 'ncc_reacting2.config', 'tecplot_nonreacting.config', 'tecplot_reacting.config', 'tecplot_reacting2.config' ]) self.connect('restart_doe.pilot_recession', ['geometry.pilot_recession', 'mesh.pilot_recession']) self.connect('restart_doe.venturi_angle', ['geometry.venturi_angle', 'mesh.venturi_angle']) self.connect('restart_doe.vane_height', ['geometry.vane_height', 'mesh.vane_height']) self.connect('geometry.injector_dia', [ 'ncc_nonreacting.injector_dia', 'ncc_nonreacting.bc1_Lmix', 'ncc_reacting.injector_dia', 'ncc_reacting.bc1_Lmix', 'ncc_reacting2.injector_dia', 'ncc_reacting2.bc1_Lmix' ]) self.connect('geometry.sector_area', [ 'npss_nonreacting.Inlet_Fl_O_Aphy', 'npss_nonreacting.Comb_Fl_O_Aphy', 'npss_nonreacting.Bld1_Fl_O_Aphy', 'npss_nonreacting.Bld2_Fl_O_Aphy' ]) self.connect('geometry.sector_area', [ 'npss_reacting.Inlet_Fl_O_Aphy', 'npss_reacting.Comb_Fl_O_Aphy', 'npss_reacting.Bld1_Fl_O_Aphy', 'npss_reacting.Bld2_Fl_O_Aphy' ]) self.connect('geometry.venturi_throat_area', [ 'npss_nonreacting.Conv_Duct_Fl_O_Aphy', 'npss_reacting.Conv_Duct_Fl_O_Aphy' ]) self.connect('geometry.venturi_exit_area', [ 'npss_nonreacting.Div_Duct_Fl_O_Aphy', 'npss_reacting.Div_Duct_Fl_O_Aphy' ]) self.connect('npss_nonreacting.Conv_Duct_Fl_O_W', 'ncc_nonreacting.bc1_mdot') self.connect('npss_nonreacting.Inlet_Fl_O_V', 'ncc_nonreacting.u_init') self.connect( 'npss_nonreacting.Inlet_Fl_O_Ts', ['ncc_nonreacting.bc1_Tstatic', 'ncc_nonreacting.Tstatic_init']) self.connect( 'npss_nonreacting.Comb_Fl_O_Ps', ['ncc_nonreacting.bc2_Pstatic', 'ncc_nonreacting.Pstatic_init']) self.connect('npss_nonreacting.Comb_Fl_O_Ts', 'ncc_nonreacting.bc2_Tstatic') self.connect('npss_nonreacting.Comb_FAR', 'ncc_nonreacting.FAR') self.connect('npss_nonreacting.Inlet_Fl_O_rhos', 'ncc_nonreacting.rho_air') self.connect('npss_nonreacting.Bld1_BldOut_W', 'ncc_nonreacting.bc7_mdot') self.connect('npss_nonreacting.Bld1_Fl_O_Ts', 'ncc_nonreacting.bc7_Tstatic') self.connect('npss_reacting.Conv_Duct_Fl_O_W', ['ncc_reacting.bc1_mdot', 'ncc_reacting2.bc1_mdot']) self.connect('npss_reacting.Inlet_Fl_O_Ts', ['ncc_reacting.bc1_Tstatic', 'ncc_reacting2.bc1_Tstatic']) self.connect('npss_reacting.Comb_Fl_O_Ps', [ 'ncc_reacting.bc2_Pstatic', 'ncc_reacting2.bc2_Pstatic', 'ncc_reacting.Pstatic_init', 'ncc_reacting2.Pstatic_init' ]) self.connect('npss_reacting.Comb_Fl_O_Ts', [ 'ncc_reacting.bc2_Tstatic', 'ncc_reacting2.bc2_Tstatic', 'ncc_reacting.Tstatic_init', 'ncc_reacting2.Tstatic_init' ]) self.connect('npss_reacting.Comb_FAR', ['ncc_reacting.FAR', 'ncc_reacting2.FAR']) self.connect('npss_reacting.Inlet_Fl_O_rhos', ['ncc_reacting.rho_air', 'ncc_reacting2.rho_air']) self.connect('npss_reacting.Bld1_BldOut_W', ['ncc_reacting.bc7_mdot', 'ncc_reacting2.bc7_mdot']) self.connect('npss_reacting.Bld1_Fl_O_Ts', ['ncc_reacting.bc7_Tstatic', 'ncc_reacting2.bc7_Tstatic'])
def test_itername(self): # top # comp1 # driverA # comp1 # comp2 # driverB # comp2 # subassy # comp3 trace_buf = [] top = set_as_top(TracedAssembly(trace_buf)) top.add('driver', TracedIterator(trace_buf, 2)) top.add('comp1', TracedComponent(trace_buf)) top.add('driverA', TracedIterator(trace_buf, 3)) top.add('comp2', TracedComponent(trace_buf)) top.add('driverB', TracedIterator(trace_buf, 2)) sub = top.add('subassy', TracedAssembly(trace_buf)) sub.add('driver', TracedIterator(trace_buf, 2)) sub.add('comp3', TracedComponent(trace_buf)) sub.driver.workflow.add('comp3') # Default didn't execute comp1 first. top.driver.workflow = SequentialWorkflow() top.driver.workflow.add(('comp1', 'driverA', 'driverB')) top.driverA.workflow.add(('comp1', 'comp2')) top.driverB.workflow.add(('comp2', 'subassy')) top.run() top.set_itername('ReRun') top.run() expected = """\ : driver: comp1: 1-comp1 driverA: 1-driverA comp1: 1-driverA.1-comp1 comp2: 1-driverA.1-comp2 comp1: 1-driverA.2-comp1 comp2: 1-driverA.2-comp2 comp1: 1-driverA.3-comp1 comp2: 1-driverA.3-comp2 driverB: 1-driverB comp2: 1-driverB.1-comp2 subassy: 1-driverB.1-subassy subassy.driver: 1-driverB.1-subassy subassy.comp3: 1-driverB.1-subassy.1-comp3 subassy.comp3: 1-driverB.1-subassy.2-comp3 comp2: 1-driverB.2-comp2 subassy: 1-driverB.2-subassy subassy.driver: 1-driverB.2-subassy subassy.comp3: 1-driverB.2-subassy.1-comp3 subassy.comp3: 1-driverB.2-subassy.2-comp3 comp1: 2-comp1 driverA: 2-driverA comp1: 2-driverA.1-comp1 comp2: 2-driverA.1-comp2 comp1: 2-driverA.2-comp1 comp2: 2-driverA.2-comp2 comp1: 2-driverA.3-comp1 comp2: 2-driverA.3-comp2 driverB: 2-driverB comp2: 2-driverB.1-comp2 subassy: 2-driverB.1-subassy subassy.driver: 2-driverB.1-subassy subassy.comp3: 2-driverB.1-subassy.1-comp3 subassy.comp3: 2-driverB.1-subassy.2-comp3 comp2: 2-driverB.2-comp2 subassy: 2-driverB.2-subassy subassy.driver: 2-driverB.2-subassy subassy.comp3: 2-driverB.2-subassy.1-comp3 subassy.comp3: 2-driverB.2-subassy.2-comp3 : ReRun driver: ReRun comp1: ReRun.1-comp1 driverA: ReRun.1-driverA comp1: ReRun.1-driverA.1-comp1 comp2: ReRun.1-driverA.1-comp2 comp1: ReRun.1-driverA.2-comp1 comp2: ReRun.1-driverA.2-comp2 comp1: ReRun.1-driverA.3-comp1 comp2: ReRun.1-driverA.3-comp2 driverB: ReRun.1-driverB comp2: ReRun.1-driverB.1-comp2 subassy: ReRun.1-driverB.1-subassy subassy.driver: ReRun.1-driverB.1-subassy subassy.comp3: ReRun.1-driverB.1-subassy.1-comp3 subassy.comp3: ReRun.1-driverB.1-subassy.2-comp3 comp2: ReRun.1-driverB.2-comp2 subassy: ReRun.1-driverB.2-subassy subassy.driver: ReRun.1-driverB.2-subassy subassy.comp3: ReRun.1-driverB.2-subassy.1-comp3 subassy.comp3: ReRun.1-driverB.2-subassy.2-comp3 comp1: ReRun.2-comp1 driverA: ReRun.2-driverA comp1: ReRun.2-driverA.1-comp1 comp2: ReRun.2-driverA.1-comp2 comp1: ReRun.2-driverA.2-comp1 comp2: ReRun.2-driverA.2-comp2 comp1: ReRun.2-driverA.3-comp1 comp2: ReRun.2-driverA.3-comp2 driverB: ReRun.2-driverB comp2: ReRun.2-driverB.1-comp2 subassy: ReRun.2-driverB.1-subassy subassy.driver: ReRun.2-driverB.1-subassy subassy.comp3: ReRun.2-driverB.1-subassy.1-comp3 subassy.comp3: ReRun.2-driverB.1-subassy.2-comp3 comp2: ReRun.2-driverB.2-comp2 subassy: ReRun.2-driverB.2-subassy subassy.driver: ReRun.2-driverB.2-subassy subassy.comp3: ReRun.2-driverB.2-subassy.1-comp3 subassy.comp3: ReRun.2-driverB.2-subassy.2-comp3""" expected = expected.split('\n') errors = 0 for i, line in enumerate(trace_buf): if line.strip() != expected[i].strip(): logging.error('%d: expected %r, got %r', i, expected[i], line) errors += 1 self.assertEqual(errors, 0) self.assertEqual(len(trace_buf), len(expected))
def configure(self): """ Creates a new Assembly with this problem Optimal Design at (1.9776, 0, 0) Optimal Objective = 3.18339""" # Disciplines self.add('dis1', sellar.Discipline1()) self.add('dis2', sellar.Discipline2()) objective = '(dis1.x1)**2 + dis1.z2 + dis1.y1 + exp(-dis2.y2)' constraint1 = 'dis1.y1 > 3.16' constraint2 = 'dis2.y2 < 24.0' # Top level is Fixed-Point Iteration self.add('driver', FixedPointIterator()) self.driver.add_parameter('dis1.x1', low=0.0, high=10.0, start=1.0) self.driver.add_parameter(['dis1.z1', 'dis2.z1'], low=-10.0, high=10.0, start=5.0) self.driver.add_parameter(['dis1.z2', 'dis2.z2'], low=0.0, high=10.0, start=2.0) self.driver.add_constraint('x1_store = dis1.x1') self.driver.add_constraint('z_store[0] = dis1.z1') self.driver.add_constraint('z_store[1] = dis1.z2') self.driver.max_iteration = 50 self.driver.tolerance = .001 # Multidisciplinary Analysis self.add('mda', BroydenSolver()) self.mda.add_parameter('dis1.y2', low=-9.e99, high=9.e99, start=0.0) self.mda.add_constraint('dis2.y2 = dis1.y2') self.mda.add_parameter('dis2.y1', low=-9.e99, high=9.e99, start=3.16) self.mda.add_constraint('dis2.y1 = dis1.y1') # Discipline 1 Sensitivity Analysis self.add('sa_dis1', SensitivityDriver()) self.sa_dis1.workflow.add(['dis1']) self.sa_dis1.add_parameter('dis1.x1', low=0.0, high=10.0, fd_step=.001) self.sa_dis1.add_constraint(constraint1) self.sa_dis1.add_constraint(constraint2) self.sa_dis1.add_objective(objective, name='obj') self.sa_dis1.differentiator = FiniteDifference() self.sa_dis1.default_stepsize = 1.0e-6 # Discipline 2 Sensitivity Analysis # dis2 has no local parameter, so there is no need to treat it as # a subsystem. # System Level Sensitivity Analysis # Note, we cheat here and run an MDA instead of solving the # GSE equations. Have to put this on the TODO list. self.add('ssa', SensitivityDriver()) self.ssa.workflow.add(['mda']) self.ssa.add_parameter(['dis1.z1', 'dis2.z1'], low=-10.0, high=10.0) self.ssa.add_parameter(['dis1.z2', 'dis2.z2'], low=0.0, high=10.0) self.ssa.add_constraint(constraint1) self.ssa.add_constraint(constraint2) self.ssa.add_objective(objective, name='obj') self.ssa.differentiator = FiniteDifference() self.ssa.default_stepsize = 1.0e-6 # Discipline Optimization # (Only discipline1 has an optimization input) self.add('bbopt1', CONMINdriver()) self.bbopt1.add_parameter('x1_store', low=0.0, high=10.0, start=1.0) self.bbopt1.add_objective( 'sa_dis1.F[0] + sa_dis1.dF[0][0]*(x1_store-dis1.x1)') self.bbopt1.add_constraint( 'sa_dis1.G[0] + sa_dis1.dG[0][0]*(x1_store-dis1.x1) < 0') #this one is technically unncessary self.bbopt1.add_constraint( 'sa_dis1.G[1] + sa_dis1.dG[1][0]*(x1_store-dis1.x1) < 0') self.bbopt1.add_constraint('(x1_store-dis1.x1)<.5') self.bbopt1.add_constraint('(x1_store-dis1.x1)>-.5') self.bbopt1.iprint = 0 self.bbopt1.linobj = True # Global Optimization self.add('sysopt', CONMINdriver()) self.sysopt.add_parameter('z_store[0]', low=-10.0, high=10.0, start=5.0) self.sysopt.add_parameter('z_store[1]', low=0.0, high=10.0, start=2.0) self.sysopt.add_objective( 'ssa.F[0]+ ssa.dF[0][0]*(z_store[0]-dis1.z1) + ssa.dF[0][1]*(z_store[1]-dis1.z2)' ) self.sysopt.add_constraint( 'ssa.G[0] + ssa.dG[0][0]*(z_store[0]-dis1.z1) + ssa.dG[0][1]*(z_store[1]-dis1.z2) < 0' ) self.sysopt.add_constraint( 'ssa.G[1] + ssa.dG[1][0]*(z_store[0]-dis1.z1) + ssa.dG[1][1]*(z_store[1]-dis1.z2) < 0' ) self.sysopt.add_constraint('z_store[0]-dis1.z1<.5') self.sysopt.add_constraint('z_store[0]-dis1.z1>-.5') self.sysopt.add_constraint('z_store[1]-dis1.z2<.5') self.sysopt.add_constraint('z_store[1]-dis1.z2>-.5') self.sysopt.iprint = 0 self.sysopt.linobj = True self.driver.workflow = SequentialWorkflow() self.driver.workflow.add(['ssa', 'sa_dis1', 'bbopt1', 'sysopt'])
def configure(self): self._tdir = mkdtemp() #Components self.add("branin_meta_model", MetaModel()) self.branin_meta_model.default_surrogate = KrigingSurrogate() self.branin_meta_model.model = BraninComponent() self.branin_meta_model.recorder = DBCaseRecorder(':memory:') self.branin_meta_model.force_execute = True self.add("EI", ExpectedImprovement()) self.EI.criteria = "branin_meta_model.f_xy" self.add("filter", ParetoFilter()) self.filter.criteria = ['branin_meta_model.f_xy'] self.filter.case_sets = [ self.branin_meta_model.recorder.get_iterator(), ] self.filter.force_execute = True #Driver Configuration self.add("DOE_trainer", DOEdriver()) self.DOE_trainer.sequential = True self.DOE_trainer.DOEgenerator = OptLatinHypercube(num_samples=15) #self.DOE_trainer.DOEgenerator = FullFactorial(num_levels=5) self.DOE_trainer.add_parameter("branin_meta_model.x", low=-5., high=10.) self.DOE_trainer.add_parameter("branin_meta_model.y", low=0., high=15.) self.DOE_trainer.add_event("branin_meta_model.train_next") self.DOE_trainer.case_outputs = ["branin_meta_model.f_xy"] self.DOE_trainer.recorders = [ DBCaseRecorder(os.path.join(self._tdir, 'trainer.db')) ] self.add("EI_opt", Genetic()) self.EI_opt.opt_type = "maximize" self.EI_opt.population_size = 100 self.EI_opt.generations = 10 #self.EI_opt.selection_method = "tournament" self.EI_opt.add_parameter("branin_meta_model.x", low=-5., high=10.) self.EI_opt.add_parameter("branin_meta_model.y", low=0., high=15.) self.EI_opt.add_objective("EI.PI") self.add("retrain", MyDriver()) self.retrain.add_event("branin_meta_model.train_next") self.retrain.recorders = [ DBCaseRecorder(os.path.join(self._tdir, 'retrain.db')) ] self.add("iter", IterateUntil()) self.iter.max_iterations = 30 self.iter.add_stop_condition('EI.EI <= .0001') #Iteration Heirarchy self.driver.workflow.add(['DOE_trainer', 'iter']) self.DOE_trainer.workflow.add('branin_meta_model') self.iter.workflow = SequentialWorkflow() self.iter.workflow.add(['filter', 'EI_opt', 'retrain']) self.EI_opt.workflow.add(['branin_meta_model', 'EI']) self.retrain.workflow.add('branin_meta_model') #Data Connections self.connect("filter.pareto_set", "EI.best_case") self.connect("branin_meta_model.f_xy", "EI.predicted_value")
def configure(self): global_dvs = self.parent.get_global_des_vars() local_dvs = self.parent.get_local_des_vars_by_comp() objective = self.parent.get_objectives().items()[0] constraints = self.parent.list_constraints() comp_constraints = self.parent.get_constraints_by_comp() coupling = self.parent.list_coupling_vars() self.parent.add('driver', FixedPointIterator()) self.parent.driver.max_iteration = 15 self.parent.driver.tolerance = .005 initial_conditions = [param.start for comp, param in global_dvs] self.parent.add_trait('global_des_vars', Array(initial_conditions)) for i, (comps, param) in enumerate(global_dvs): targets = param.targets self.parent.driver.add_parameter(targets, low=param.low, high=param.high) self.parent.driver.add_constraint("global_des_vars[%d]=%s" % (i, targets[0])) for comp, local_params in local_dvs.iteritems(): initial_conditions = [param.start for param in local_params] self.parent.add_trait('%s_local_des_vars' % comp, Array(initial_conditions)) for i, param in enumerate(local_params): self.parent.driver.add_parameter(param.targets, low=param.low, high=param.high) self.parent.driver.add_constraint('%s_local_des_vars[%d]=%s' % (comp, i, param.targets[0])) # Multidisciplinary Analysis mda = self.parent.add('mda', BroydenSolver()) mda.force_execute = True for key, couple in coupling.iteritems(): mda.add_parameter(couple.indep.target, low=-9.e99, high=9.e99) mda.add_constraint("%s=%s" % (couple.indep.target, couple.dep.target)) #Global Sensitivity Analysis ssa = self.parent.add("ssa", SensitivityDriver()) ssa.workflow.add("mda") ssa.differentiator = FiniteDifference() ssa.default_stepsize = 1.0e-6 ssa.add_objective(objective[1].text, name=objective[0]) for comps, param in global_dvs: ssa.add_parameter(param.targets, low=param.low, high=param.high) for constraint in constraints: ssa.add_constraint(constraint) #discipline sensitivity analyses sa_s = [] for comp, local_params in local_dvs.iteritems(): sa = self.parent.add('sa_%s' % comp, SensitivityDriver()) sa.default_stepsize = 1.0e-6 sa_s.append('sa_%s' % comp) for param in local_params: sa.add_parameter(param.targets, low=param.low, high=param.high, fd_step=.001) for constraint in constraints: sa.add_constraint(constraint) sa.add_objective(objective[1].text, name=objective[0]) sa.differentiator = FiniteDifference() #Linear System Optimizations # Discipline Optimization # (Only discipline1 has an optimization input) bbopts = [] for comp, local_params in local_dvs.iteritems(): bbopt = self.parent.add('bbopt_%s' % comp, SLSQPdriver()) bbopt.differentiator = FiniteDifference() bbopt.iprint = 0 bbopts.append('bbopt_%s' % comp) x_store = "%s_local_des_vars" % comp delta_x = [] df = [] dg = [] for i, param in enumerate(local_params): x_store_i = "%s[%d]" % (x_store, i) bbopt.add_parameter(x_store_i, low=param.low, high=param.high) dx = "(%s-%s)" % (x_store_i, param.targets[0]) delta_x.append(dx) move_limit = (param.high - param.low) * 20.0 / 100.0 #bbopt.add_constraint("%s < %f*%s"%(dx,.2,param.targets[0])) #bbopt.add_constraint("%s > -%f*%s"%(dx,.2,param.targets[0])) bbopt.add_constraint("%s < .5" % (dx, )) bbopt.add_constraint("%s > -.5" % (dx, )) df.append("sa_%s.dF[0][%d]*%s" % (comp, i, dx)) #build the linear constraint string for each constraint for j, const in enumerate(constraints): dg_j = [ "sa_%s.dG[%d][%d]*%s" % (comp, j, i, x) for i, x in enumerate(delta_x) ] constraint_parts = ["sa_%s.G[%d]" % (comp, j)] constraint_parts.extend(dg_j) lin_constraint = "%s < 0" % "+".join(constraint_parts) bbopt.add_constraint(lin_constraint) #build the linear objective string objective_parts = ["sa_%s.F[0]" % comp] objective_parts.extend(df) lin_objective = "+".join(objective_parts) bbopt.add_objective(lin_objective) # Global Optimization delta_z = [] df = [] dg = [] sysopt = self.parent.add('sysopt', SLSQPdriver()) sysopt.differentiator = FiniteDifference() sysopt.recorders = self.data_recorders sysopt.iprint = 0 for i, (comps, param) in enumerate(global_dvs): z_store = "global_des_vars[%d]" % i target = list(param.targets)[0] sysopt.add_parameter(z_store, low=param.low, high=param.high) dz = "(%s-%s)" % (z_store, target) delta_z.append(dz) move_limit = (param.high - param.low) * 20.00 / 100.0 #sysopt.add_constraint("%s < %f*%s"%(dz,.1,target)) #sysopt.add_constraint("%s > -%f*%s"%(dz,.1,target)) sysopt.add_constraint("%s < .5" % (dz, )) sysopt.add_constraint("%s > -.5" % (dz, )) df.append("ssa.dF[0][%d]*%s" % (i, dz)) dg_j = [ "ssa.dG[%d][%d]*%s" % (j, i, dz) for j, const in enumerate(constraints) ] dg.append(dg_j) objective_parts = ["ssa.F[0]"] objective_parts.extend(df) lin_objective = "+".join(objective_parts) sysopt.add_objective(lin_objective) #build the linear constraint string for each constraint for j, const in enumerate(constraints): dg_j = [ "ssa.dG[%d][%d]*%s" % (j, i, x) for i, x in enumerate(delta_z) ] constraint_parts = ["ssa.G[%d]" % j] constraint_parts.extend(dg_j) lin_constraint = "%s < 0" % "+".join(constraint_parts) sysopt.add_constraint(lin_constraint) self.parent.driver.workflow = SequentialWorkflow() self.parent.driver.workflow.add("mda") self.parent.driver.workflow.add(sa_s) if global_dvs: self.parent.driver.workflow.add("ssa") self.parent.driver.workflow.add(bbopts) if global_dvs: self.parent.driver.workflow.add("sysopt")
def configure(self): self._tdir = mkdtemp() #Components self.add("spiral_meta_model", MetaModel()) self.spiral_meta_model.surrogate = {'default': KrigingSurrogate()} self.spiral_meta_model.model = SpiralComponent() self.spiral_meta_model.recorder = DBCaseRecorder(':memory:') self.spiral_meta_model.force_execute = True self.add("MOEI", MultiObjExpectedImprovement()) self.MOEI.criteria = [ 'spiral_meta_model.f1_xy', 'spiral_meta_model.f2_xy' ] self.add("filter", ParetoFilter()) self.filter.criteria = [ 'spiral_meta_model.f1_xy', 'spiral_meta_model.f2_xy' ] self.filter.case_sets = [ self.spiral_meta_model.recorder.get_iterator() ] self.filter.force_execute = True #Driver Configuration self.add("DOE_trainer", DOEdriver()) self.DOE_trainer.sequential = True self.DOE_trainer.DOEgenerator = OptLatinHypercube(num_samples=25) self.DOE_trainer.add_parameter("spiral_meta_model.x") self.DOE_trainer.add_parameter("spiral_meta_model.y") self.DOE_trainer.add_event("spiral_meta_model.train_next") self.DOE_trainer.case_outputs = [ 'spiral_meta_model.f1_xy', 'spiral_meta_model.f2_xy' ] self.DOE_trainer.recorders = [ DBCaseRecorder(os.path.join(self._tdir, 'trainer.db')) ] self.add("MOEI_opt", Genetic()) self.MOEI_opt.opt_type = "maximize" self.MOEI_opt.population_size = 100 self.MOEI_opt.generations = 10 #self.MOEI_opt.selection_method = "tournament" self.MOEI_opt.add_parameter("spiral_meta_model.x") self.MOEI_opt.add_parameter("spiral_meta_model.y") self.MOEI_opt.add_objective("MOEI.PI") self.add("retrain", MyDriver()) self.retrain.add_event("spiral_meta_model.train_next") self.retrain.recorders = [ DBCaseRecorder(os.path.join(self._tdir, 'retrain.db')) ] self.add("iter", IterateUntil()) self.iter.iterations = 30 self.iter.add_stop_condition('MOEI.PI <= .0001') #Iteration Heirarchy self.driver.workflow.add(['DOE_trainer', 'iter']) self.DOE_trainer.workflow.add('spiral_meta_model') self.iter.workflow = SequentialWorkflow() self.iter.workflow.add(['filter', 'MOEI_opt', 'retrain']) self.MOEI_opt.workflow.add(['spiral_meta_model', 'MOEI']) self.retrain.workflow.add('spiral_meta_model') #Data Connections self.connect("filter.pareto_set", "MOEI.best_cases") self.connect("spiral_meta_model.f1_xy", "MOEI.predicted_values[0]") self.connect("spiral_meta_model.f2_xy", "MOEI.predicted_values[1]")