def initialize_ship_parameters_and_values(self): #, rgp=None): #if rgp is None: # rgp = self.rgp #----------------------------------------- # quantities of m**1 self.ship_beam = lp.PStates(name='ship_beam') # note: could use bare_hull var names instead. # e.g. lp.PStates(name=self.init_ship_beam.name) self.ship_depth = lp.PStates(name='ship_depth') self.ship_Lpp = lp.PStates(name='ship_Lpp') # #quantities of m**2 self.ship_Amshp = lp.PStates(name='ship_Amshp') self.ship_Acp = lp.PStates(name='ship_Acp') self.ship_Awp = lp.PStates(name='ship_Awp') # #quantities of m**3 self.ship_Vol = lp.PStates(name='ship_Vol') #----------------------------------------- # #existing ship: #----------------------------------------- # set the ship values in the bulb environement: self.ship_beam = self.ship_beam == self.get_value(self.init_ship_beam) self.ship_depth = self.ship_depth == self.get_value( self.init_ship_depth) self.ship_Lpp = self.ship_Lpp == self.get_value(self.init_ship_Lpp) self.ship_Amshp = self.ship_Amshp == self.get_value( self.init_ship_Amshp) self.ship_Acp = self.ship_Acp == self.get_value(self.init_ship_Acp) self.ship_Awp = self.ship_Awp == self.get_value(self.init_ship_Awp) self.ship_Vol = self.ship_Vol == self.get_value(self.init_ship_Vol) #----------------------------------------- #----------------------------------------- self.rgp.add_one_rule(self.ship_beam, self.ship_beam.name) self.rgp.add_one_rule(self.ship_depth, self.ship_depth.name) self.rgp.add_one_rule(self.ship_Lpp, self.ship_Lpp.name) self.rgp.add_one_rule(self.ship_Amshp, self.ship_Amshp.name) self.rgp.add_one_rule(self.ship_Acp, self.ship_Acp.name) self.rgp.add_one_rule(self.ship_Awp, self.ship_Awp.name) self.rgp.add_one_rule(self.ship_Vol, self.ship_Vol.name) #----------------------------------------- self.rgp.compute_fresh_rules_graph() return #rgp
def coupling_constants(self, rgp=None): if rgp is None: rgp = self.rgp # #linear #----------------------------------------- self.Cbb = lp.PStates(name='Cbb') self.Clpr = lp.PStates(name='Clpr') self.Czb = lp.PStates(name='Czb') # #nonlinear #----------------------------------------- self.Cabt = lp.PStates(name='Cabt') self.Cabl = lp.PStates(name='Cabl') self.Cvpr = lp.PStates(name='Cvpr') # return rgp
# # self.arc_sets[c] = set([]) # # self.get_arc_sets() # # self.var_sets[c] = set([]) # count += 1 # print count # # return # #============================================================================== if __name__ == "__main__": print '\n\n\n Do Not Use\n\n\n' print 'BulbRules2 ' print 'testing ' A_BT = lp.PStates(name='A_BT') A_BL = lp.PStates(name='A_BL') Bb = lp.PStates(name='Bb') c = lp.PStates(name='c') d = lp.PStates(name='d') C_BB = lp.PStates(name='C_BB') A_Bb = lp.PStates(name='A_Bb') A_Bmid = lp.PStates(name='A_Bmid') A_Llateral = lp.PStates(name='A_Llateral') A_Lflat = lp.PStates(name='A_Lflat') A_mid = lp.PStates(name='A_mid') A_lateral = lp.PStates(name='A_lateral') A_flat = lp.PStates(name='A_flat')
@author: luke """ import copy import sqKanren as lp import sobol ia = lp.ia # #from extended_interval_arithmetic import ia #use import from lp instead to match isinstance GraphScaleNode = lp.GraphScaleNode RulesGraphProcessor = lp.RulesGraphProcessor if __name__ == """__main__""": A_mid = lp.PStates(name='A_mid') A_lateral = lp.PStates(name='A_lateral') #use the principle of the minimum square enclosing box (cartesian b/c ia is cartesian) BulbBeam = lp.PStates(name='BulbBeam') #Bulb half beam BulbDepth = lp.PStates(name='BulbDepth') #Bulb depth BulbLength = lp.PStates( name='BulbLength') #Bulb max length (min square enclosing box length) BulbVolume = lp.PStates(name='BulbVolume') CBulbMid = lp.PStates(name='CBulbMid') #Bulb midsection coefficient CBulbBlock = lp.PStates(name='CBulbBlock') CBulbPrismatic = lp.PStates(name='CBulbPrismatic')
******************************************* ******************************************* Done with Checkers ''' if __name__ == """__main__""": start = True after_ship = True check_interval_splitting = True start_ship_to_bulb = True final_test = True if start: A_mid = lp.PStates(name='A_mid') A_lateral = lp.PStates(name='A_lateral') #use the principle of the minimum square enclosing box (cartesian b/c ia is cartesian) BulbBeam = lp.PStates(name='BulbBeam') #Bulb half beam BulbDepth = lp.PStates(name='BulbDepth') #Bulb depth BulbLength = lp.PStates( name='BulbLength' ) #Bulb max length (min square enclosing box length) BulbVolume = lp.PStates(name='BulbVolume') CBulbMid = lp.PStates(name='CBulbMid') #Bulb midsection coefficient CBulbBlock = lp.PStates(name='CBulbBlock') CBulbPrismatic = lp.PStates(name='CBulbPrismatic')
def old_test(): print 'Kraft Bulbous Bow Parameters' print '\n Linear Parameters:' A_BT = lp.PStates(name='A_BT') #cross section area at fwd pp A_BL = lp.PStates(name='A_BL') #area in longitudinal plane Bb = lp.PStates(name='Bb') #c = lp.PStates(name='c') #d = lp.PStates(name='d') C_BB = lp.PStates(name='C_BB') #breadth parameter A_Bb = lp.PStates(name='A_Bb') # A_Bmid = lp.PStates(name='A_Bmid') A_Llateral = lp.PStates(name='A_Llateral') A_Lflat = lp.PStates(name='A_Lflat') A_mid = lp.PStates(name='A_mid') A_lateral = lp.PStates(name='A_lateral') A_flat = lp.PStates(name='A_flat') A_BBwl = lp.PStates(name='A_BBwl') #use the principle of the minimum square enclosing box (cartesian b/c ia is cartesian) BulbBeam = lp.PStates(name='BulbBeam') #Bulb half beam BulbDepth = lp.PStates(name='BulbDepth') #Bulb depth BulbLength = lp.PStates( name='BulbLength') #Bulb max length (min square enclosing box length) CBulbMid = lp.PStates(name='CBulbMid') #Bulb midsection coefficient CBulbCtrPln = lp.PStates( name='CBulbCtrPln') #Bulb centerplane profile area coefficient CBulbWtrPln = lp.PStates( name='CBulbWtrPln') #Bulb waterplane area coefficient #TODO: fix this with class to construct rules graph! A_mid = A_mid == ia(10., 20.) #issue: order of assignment "matters" BulbBeam = BulbBeam == ia(5., 10.) CBulbMid = CBulbMid == ia(.5, 1.) CBulbWtrPln = CBulbWtrPln == ia(.5, 1.) #BulbDepth = BulbDepth == ia(-10.1,10.) bgp = RulesGraphProcessor() #""" #bgp.add_one_rule(BulbDepth,'BulbDepth') bgp.add_one_rule(A_mid, 'A_mid') bgp.add_one_rule(BulbBeam, 'BulbBeam') bgp.add_one_rule(CBulbMid, 'CBulbMid') bgp.add_one_rule(CBulbWtrPln, 'CBulbWtrPln') bgp.compute_rules_graph() #bgp.add_one_rule(BulbDepth,'BulbDepth') #should not be needed! bgp.compute_rules_graph() #bgp.AC_revise() #bgp.env """----------------------------------------------- Rule: Midbulb_Area < max_Beam * max_Depth CBulbMid -> [0.,1.] CBulbMid == A_mid/(BulbBeam*BulbDepth) """ CBulbMid = CBulbMid == A_mid / (BulbBeam * BulbDepth) """----------------------------------------------- Rule: z-y_area < max_length * max_Depth """ CBulbCtrPln = CBulbCtrPln == A_lateral / (BulbLength * BulbDepth) """----------------------------------------------- Rule: wL_area < max_length * max_Depth """ #CBulbWtrPln = CBulbWtrPln == A_BBwl/(BulbLength*BulbDepth) CBulbWtrPln = CBulbWtrPln == A_BBwl / (BulbLength * BulbBeam) bgp.add_one_rule(CBulbMid, 'CBulbMid') bgp.add_one_rule(CBulbCtrPln, 'CBulbCtrPln') bgp.add_one_rule(CBulbWtrPln, 'CBulbWtrPln') bgp.compute_rules_graph() #""" BulbLength = BulbLength == ia(10., 15.) CBulbCtrPln = CBulbCtrPln == ia(.5, 1.) bgp.add_one_rule(BulbLength, 'BulbLength') bgp.add_one_rule(CBulbCtrPln, 'CBulbCtrPln') bgp.compute_rules_graph() BulbDepth = BulbDepth == ia(5., 10.) bgp.add_one_rule(BulbDepth, 'BulbDepth') bgp.compute_rules_graph() print '\n\n state after:' #print st print bgp.env return
def setup_dummy_bare_hull(bbobj, rgp=None): if rgp is None: rgp = bbobj.rgp #----------------------------------------- # quantities of m**1 bbobj.ship_beam = lp.PStates(name='ship_beam') # note: could use bare_hull var names instead. # e.g. lp.PStates(name=self.init_ship_beam.name) bbobj.ship_depth = lp.PStates(name='ship_depth') bbobj.ship_Lpp = lp.PStates(name='ship_Lpp') # #quantities of m**2 bbobj.ship_Amshp = lp.PStates(name='ship_Amshp') bbobj.ship_Acp = lp.PStates(name='ship_Acp') bbobj.ship_Awp = lp.PStates(name='ship_Awp') # #quantities of m**3 bbobj.ship_Vol = lp.PStates(name='ship_Vol') #----------------------------------------- # #existing ship: #----------------------------------------- # quantities of m**1 ship_beam = bbobj.ship_beam ship_depth = bbobj.ship_depth ship_Lpp = bbobj.ship_Lpp # #quantities of m**2 ship_Amshp = bbobj.ship_Amshp ship_Acp = bbobj.ship_Acp ship_Awp = bbobj.ship_Awp # #quantities of m**3 ship_Vol = bbobj.ship_Vol #----------------------------------------- # #----------------------------------------- # set the ship values in the bulb environement: ship_beam = ship_beam == ia(17.4663142374, 17.4663142374) ship_depth = ship_depth == ia(16.2051841085, 16.2051841085) ship_Lpp = ship_Lpp == ia(111.099919763, 111.099919763) ship_Amshp = ship_Amshp == ia(261.639572047, 261.639572047) ship_Acp = ship_Acp == ia(1656.36308186, 1656.36308186) ship_Awp = ship_Awp == ia(1736.75296874, 1736.75296874) ship_Vol = ship_Vol == ia(27043.7825521, 27043.7825521) #----------------------------------------- #----------------------------------------- rgp.add_one_rule(ship_beam, 'ship_beam') rgp.add_one_rule(ship_depth, 'ship_depth') rgp.add_one_rule(ship_Lpp, 'ship_Lpp') rgp.add_one_rule(ship_Amshp, 'ship_Amshp') rgp.add_one_rule(ship_Acp, 'ship_Acp') rgp.add_one_rule(ship_Awp, 'ship_Awp') rgp.add_one_rule(ship_Vol, 'ship_Vol') #----------------------------------------- rgp.compute_rules_graph() return bbobj, rgp
def DOIT(self, rgp=None): if rgp is None: rgp = self.rgp # #linear #----------------------------------------- self.Cbb = lp.PStates(name='Cbb') self.Clpr = lp.PStates(name='Clpr') self.Czb = lp.PStates(name='Czb') # #nonlinear #----------------------------------------- self.Cabt = lp.PStates(name='Cabt') self.Cabl = lp.PStates(name='Cabl') self.Cvpr = lp.PStates(name='Cvpr') # #-------------------- # quantities of m**1 self.ship_beam = lp.PStates(name='ship_beam') # note: could use bare_hull var names instead. # e.g. lp.PStates(name=self.init_ship_beam.name) self.ship_depth = lp.PStates(name='ship_depth') self.ship_Lpp = lp.PStates(name='ship_Lpp') # #quantities of m**2 self.ship_Amshp = lp.PStates(name='ship_Amshp') self.ship_Acp = lp.PStates(name='ship_Acp') self.ship_Awp = lp.PStates(name='ship_Awp') # #quantities of m**3 self.ship_Vol = lp.PStates(name='ship_Vol') #----------------------------------------- # #existing ship: #----------------------------------------- # quantities of m**1 ship_beam = self.ship_beam ship_depth = self.ship_depth ship_Lpp = self.ship_Lpp # #quantities of m**2 ship_Amshp = self.ship_Amshp ship_Acp = self.ship_Acp ship_Awp = self.ship_Awp # #quantities of m**3 ship_Vol = self.ship_Vol #----------------------------------------- # #----------------------------------------- # set the ship values in the bulb environement: self.ship_beam = self.ship_beam == self.get_value(self.init_ship_beam) self.ship_depth = self.ship_depth == self.get_value( self.init_ship_depth) self.ship_Lpp = self.ship_Lpp == self.get_value(self.init_ship_Lpp) self.ship_Amshp = self.ship_Amshp == self.get_value( self.init_ship_Amshp) self.ship_Acp = self.ship_Acp == self.get_value(self.init_ship_Acp) self.ship_Awp = self.ship_Awp == self.get_value(self.init_ship_Awp) self.ship_Vol = self.ship_Vol == self.get_value(self.init_ship_Vol) #----------------------------------------- #----------------------------------------- rgp.add_one_rule(self.ship_beam, 'ship_beam') rgp.add_one_rule(self.ship_depth, 'ship_depth') rgp.add_one_rule(self.ship_Lpp, 'ship_Lpp') rgp.add_one_rule(self.ship_Amshp, 'ship_Amshp') rgp.add_one_rule(self.ship_Acp, 'ship_Acp') rgp.add_one_rule(self.ship_Awp, 'ship_Awp') rgp.add_one_rule(self.ship_Vol, 'ship_Vol') #----------------------------------------- rgp.compute_rules_graph() #def initialize_bulb_parameters(self, rgp=None): #bulb areas self.A_mid = lp.PStates(name='A_mid') self.A_lateral = lp.PStates(name='A_lateral') self.A_flat = lp.PStates(name='A_flat') self.A_BBwl = lp.PStates(name='A_BBwl') #use the principle of the minimum square enclosing box (cartesian b/c ia is cartesian) self.BulbBeam = lp.PStates(name='BulbBeam') #Bulb half beam self.BulbDepth = lp.PStates(name='BulbDepth') #Bulb depth self.BulbLength = lp.PStates( name='BulbLength' ) #Bulb max length (min square enclosing box length) self.BulbVolume = lp.PStates(name='BulbVolume') self.CBulbMid = lp.PStates( name='CBulbMid') #Bulb midsection coefficient self.CBulbCtrPln = lp.PStates( name='CBulbCtrPln') #Bulb centerplane profile area coefficient self.CBulbWtrPln = lp.PStates( name='CBulbWtrPln') #Bulb waterplane area coefficient self.CBulbBlock = lp.PStates( name='CBulbBlock') #Bulb block coefficient self.CBulbPrismatic = lp.PStates( name='CBulbPrismatic') #Bulb prismatic coefficient """----------------------------------------------- Rule: Midbulb_Area < max_Beam * max_Depth CBulbMid -> [0.,1.] CBulbMid == A_mid/(BulbBeam*BulbDepth) """ self.CBulbMid = self.CBulbMid == self.A_mid / (self.BulbBeam * self.BulbDepth) # """----------------------------------------------- Rule: z-y_area < max_length * max_Depth """ self.CBulbCtrPln = self.CBulbCtrPln == self.A_lateral / ( self.BulbLength * self.BulbDepth) # """----------------------------------------------- Rule: wL_area < max_length * max half-Beam """ self.CBulbWtrPln = self.CBulbWtrPln == self.A_BBwl / (self.BulbLength * self.BulbBeam) # """----------------------------------------------- Rule: Bulb_vol < max_length * max_Depth * max *BulbBeam """ self.CBulbBlock = self.CBulbBlock == self.BulbVolume / ( self.BulbLength * self.BulbDepth * self.BulbBeam) # """----------------------------------------------- Rule: Bulb_vol < max_length * mid_bulb_area """ self.CBulbPrismatic = self.CBulbPrismatic == self.BulbVolume / ( self.BulbLength * self.A_mid) # rgp.add_one_rule(self.CBulbMid, 'CBulbMid') rgp.add_one_rule(self.CBulbCtrPln, 'CBulbCtrPln') rgp.add_one_rule(self.CBulbWtrPln, 'CBulbWtrPln') rgp.add_one_rule(self.CBulbBlock, 'CBulbBlock') rgp.add_one_rule(self.CBulbPrismatic, 'CBulbPrismatic') # rgp.compute_rules_graph() # #def linear_parameters(self, rgp=None): """Kracht Design of Bulbous Bows, 1978 """ #Kracht linear relations: self.Cbb = self.Cbb == self.BulbBeam / self.ship_beam self.Clpr = self.Clpr == self.BulbLength / self.ship_Lpp self.Czb = self.Czb == self.BulbLength / self.ship_depth # rgp.add_one_rule(self.Cbb, 'Cbb') rgp.add_one_rule(self.Clpr, 'Clpr') rgp.add_one_rule(self.Czb, 'Czb') # rgp.compute_rules_graph() # #def nonlinear_parameters(self, rgp=None): """Kracht Design of Bulbous Bows, 1978 """ #Kracht nonlinear relations: self.Cabt = self.Cabt == self.A_mid / self.ship_Amshp self.Cabl = self.Cabl == self.A_lateral / self.ship_Acp #departure from Kracht self.Cvpr = self.Cvpr == self.BulbVolume / self.ship_Vol # self.rgp.add_one_rule(self.Cabt) self.rgp.add_one_rule(self.Cabl) self.rgp.add_one_rule(self.Cvpr) # rgp.compute_rules_graph() # #def experiment_bulb_parameters(self, rgp=None): self.A_mid = self.A_mid == ia( 10., 15.) #20.) #issue: order of assignment "matters" self.BulbBeam = self.BulbBeam == ia(5., 10.) self.CBulbMid = self.CBulbMid == ia(.5, 1.) self.CBulbWtrPln = self.CBulbWtrPln == ia(.5, 1.) #BulbDepth = BulbDepth == ia(-10.1,10.) #bgp.add_one_rule(BulbDepth,'BulbDepth') rgp.add_one_rule(self.A_mid, 'A_mid') rgp.add_one_rule(self.BulbBeam, 'BulbBeam') rgp.add_one_rule(self.CBulbMid, 'CBulbMid') rgp.add_one_rule(self.CBulbWtrPln, 'CBulbWtrPln') #self.bgp.add_one_rule(self.BulbDepth,'BulbDepth') self.BulbLength = self.BulbLength == ia(10., 15.) self.BulbDepth = self.BulbDepth == ia(5., 10.) self.CBulbCtrPln = self.CBulbCtrPln == ia(.5, 1.) rgp.add_one_rule(self.BulbLength, 'BulbLength') rgp.add_one_rule(self.BulbDepth, 'BulbDepth') rgp.add_one_rule(self.CBulbCtrPln, 'CBulbCtrPln') rgp.compute_rules_graph() return
#print st print bgp.env return if __name__ == "__main__": #old_test() #self = BulbGenerator() #self.rgp._verbose = True #print self.rgp.env #type(self.rgp.nodes[0].vars['ship_beam']) low_down_dirty_testing = False x1 = lp.PStates(name='x1') x2 = lp.PStates(name='x2') x3 = lp.PStates(name='x3') #x4 = lp.PStates(name='x4') x1 = x1 == ia(1., 10.) x2 = x2 == ia(1., 10.) x3 = x3 == ia(1., 10.) env = lp.States(lp.State()) # add x1 rule to env env, vars_ = x1.construct(x1, env, {}) fundict = x1.compile(x1, vars_) for el in fundict: env = fundict[el](env)
def older_test(): print 'Kraft Bulbous Bow Parameters' print '\n Linear Parameters:' ## ##************************************* bulb ## A_mid = lp.PStates(name='A_mid') A_lateral = lp.PStates(name='A_lateral') #A_flat = lp.PStates(name='A_flat') #BBwl instead A_BBwl = lp.PStates(name='A_BBwl') #use the principle of the minimum square enclosing box (cartesian b/c ia is cartesian) BulbBeam = lp.PStates(name='BulbBeam') #Bulb half beam BulbDepth = lp.PStates(name='BulbDepth') #Bulb depth BulbLength = lp.PStates( name='BulbLength') #Bulb max length (min square enclosing box length) BulbVolume = lp.PStates(name='BulbVolume') CBulbMid = lp.PStates(name='CBulbMid') #Bulb midsection coefficient CBulbCtrPln = lp.PStates( name='CBulbCtrPln') #Bulb centerplane profile area coefficient CBulbWtrPln = lp.PStates( name='CBulbWtrPln') #Bulb waterplane area coefficient CBulbBlock = lp.PStates(name='CBulbBlock') CBulbPrismatic = lp.PStates(name='CBulbPrismatic') #TODO: fix this with class to construct rules graph! A_mid = A_mid == ia(10., 20.) #issue: order of assignment "matters" BulbBeam = BulbBeam == ia(5., 10.) CBulbMid = CBulbMid == ia(.5, 1.) CBulbWtrPln = CBulbWtrPln == ia(.5, 1.) #BulbDepth = BulbDepth == ia(-10.1,10.) rgp = RulesGraphProcessor() #""" #rgp.add_one_rule(BulbDepth,'BulbDepth') rgp.add_one_rule(A_mid, 'A_mid') rgp.add_one_rule(BulbBeam, 'BulbBeam') rgp.add_one_rule(CBulbMid, 'CBulbMid') rgp.add_one_rule(CBulbWtrPln, 'CBulbWtrPln') #rgp.add_one_rule(BulbDepth,'BulbDepth') #should not older_testbe needed! rgp.compute_fresh_rules_graph() #rgp.compute_rules_graph() #rgp.AC_revise() #rgp.env ## ##************************************* end bulb ## ## ##************************************* ship ## ship_beam = lp.PStates(name='ship_beam') # note: could use bare_hull var names instead. # e.g. lp.PStates(name=self.init_ship_beam.name) ship_depth = lp.PStates(name='ship_depth') ship_Lpp = lp.PStates(name='ship_Lpp') # #quantities of m**2 ship_Amshp = lp.PStates(name='ship_Amshp') ship_Acp = lp.PStates(name='ship_Acp') ship_Awp = lp.PStates(name='ship_Awp') # #quantities of m**3 ship_Vol = lp.PStates(name='ship_Vol') #----------------------------------------- # set the ship values in the bulb environement: ship_beam = ship_beam == ia(17.4663142374, 17.4663142374) ship_depth = ship_depth == ia(16.2051841085, 16.2051841085) ship_Lpp = ship_Lpp == ia(111.099919763, 111.099919763) ship_Amshp = ship_Amshp == ia(261.639572047, 261.639572047) ship_Acp = ship_Acp == ia(1656.36308186, 1656.36308186) ship_Awp = ship_Awp == ia(1736.75296874, 1736.75296874) ship_Vol = ship_Vol == ia(27043.7825521, 27043.7825521) #----------------------------------------- #----------------------------------------- rgp.add_one_rule(ship_beam, 'ship_beam') rgp.add_one_rule(ship_depth, 'ship_depth') rgp.add_one_rule(ship_Lpp, 'ship_Lpp') rgp.add_one_rule(ship_Amshp, 'ship_Amshp') rgp.add_one_rule(ship_Acp, 'ship_Acp') rgp.add_one_rule(ship_Awp, 'ship_Awp') rgp.add_one_rule(ship_Vol, 'ship_Vol') #----------------------------------------- ## ##************************************* end ship ## rgp.compute_fresh_rules_graph() #rgp.compute_rules_graph() ## ##************************************* bulb rules ## """----------------------------------------------- Rule: Midbulb_Area < max_Beam * max_Depth CBulbMid -> [0.,1.] CBulbMid == A_mid/(BulbBeam*BulbDepth) """ CBulbMid = CBulbMid == A_mid / (BulbBeam * BulbDepth) """----------------------------------------------- Rule: z-y_area < max_length * max_Depth """ CBulbCtrPln = CBulbCtrPln == A_lateral / (BulbLength * BulbDepth) """----------------------------------------------- Rule: wL_area < max_length * max_Depth """ #CBulbWtrPln = CBulbWtrPln == A_BBwl/(BulbLength*BulbDepth) CBulbWtrPln = CBulbWtrPln == A_BBwl / (BulbLength * BulbBeam) #2 more rules! """----------------------------------------------- Rule: Bulb_vol < max_length * max_Depth * max *BulbBeam """ CBulbBlock = CBulbBlock == BulbVolume / (BulbLength * BulbDepth * BulbBeam) # """----------------------------------------------- Rule: Bulb_vol < max_length * mid_bulb_area """ CBulbPrismatic = CBulbPrismatic == BulbVolume / (BulbLength * A_mid) # rgp.add_one_rule(CBulbMid, 'CBulbMid') rgp.add_one_rule(CBulbCtrPln, 'CBulbCtrPln') rgp.add_one_rule(CBulbWtrPln, 'CBulbWtrPln') rgp.add_one_rule(CBulbBlock, 'CBulbBlock') rgp.add_one_rule(CBulbPrismatic, 'CBulbPrismatic') rgp.compute_fresh_rules_graph() #rgp.compute_rules_graph() #""" #BulbLength = BulbLength == ia(10.,15.) BulbLength = BulbLength == ia(1., 15.) #CBulbCtrPln = CBulbCtrPln == ia(.5,1.) CBulbCtrPln = CBulbCtrPln == ia(0., 1.) rgp.add_one_rule(BulbLength, 'BulbLength') rgp.add_one_rule(CBulbCtrPln, 'CBulbCtrPln') rgp.compute_fresh_rules_graph() #rgp.compute_rules_graph() #BulbDepth = BulbDepth == ia(1.,10.) BulbDepth = BulbDepth == ia(5., 10.) rgp.add_one_rule(BulbDepth, 'BulbDepth') CBulbBlock = CBulbBlock == ia(0., 1.) CBulbPrismatic = CBulbPrismatic == ia(0., 1.) rgp.add_one_rule(BulbLength, 'CBulbBlock') rgp.add_one_rule(CBulbPrismatic, 'CBulbPrismatic') rgp.compute_fresh_rules_graph() #rgp.compute_rules_graph() ## ##************************************* end bulb rules ## ## ##************************************* Ship to Bulb Coefficients ## # #linear #----------------------------------------- Cbb = lp.PStates(name='Cbb') Clpr = lp.PStates(name='Clpr') Czb = lp.PStates(name='Czb') # #nonlinear #----------------------------------------- Cabt = lp.PStates(name='Cabt') Cabl = lp.PStates(name='Cabl') Cvpr = lp.PStates(name='Cvpr') # ## ##************************************* end Ship to Bulb Coefficients ## ## ##************************************* nonlinear relations ## #Kracht nonlinear relations: Cabt = Cabt == A_mid / ship_Amshp Cabl = Cabl == A_lateral / ship_Acp #departure from Kracht Cvpr = Cvpr == BulbVolume / ship_Vol # """ rgp.add_one_rule( Cbb, 'Cbb') rgp.add_one_rule(Clpr, 'Clpr') rgp.add_one_rule( Czb, 'Czb') #""" # rgp.compute_fresh_rules_graph() #rgp.compute_rules_graph() # ## ##************************************* end nonlinear relations ## ## ##************************************* linear relations ## #Kracht linear relations: Cbb = Cbb == BulbBeam / ship_beam Clpr = Clpr == BulbLength / ship_Lpp Czb = Czb == BulbLength / ship_depth # """ rgp.add_one_rule( Cbb, 'Cbb') rgp.add_one_rule(Clpr, 'Clpr') rgp.add_one_rule( Czb, 'Czb') #""" # rgp.compute_fresh_rules_graph() #rgp.compute_rules_graph() # ## ##************************************* end linear relations ## print '\n\n state after:' #print st print rgp.env ellist = [ BulbDepth, CBulbMid, CBulbBlock, BulbBeam, BulbLength, BulbVolume, #A_mid, #A_lateral, #A_BBwl, CBulbCtrPln, CBulbWtrPln, CBulbPrismatic ] sobol_seq = sobol.sobolSeq([1, 1], [1, 1]) ith = -1 #x=.5 redo = [] for i in range(len(ellist)): x = sobol_seq.next() var = ellist[i] mk_name, mk_val = rgp.get_name_and_value(var) print mk_name, mk_val val = mk_val[ith].getpoint(x) value = ia(val, val) var = var == value #----------------------------------------- ret_state = copy.copy(rgp.env) rgp.add_one_rule(var, var.name) rgp.compute_fresh_rules_graph() #rgp.compute_rules_graph() #----------------------------------------- if len(rgp.env.states) == 0: rgp.env = ret_state #rgp.env.states = ret_state.states redo.append(var) else: if rgp._verbose: print 'done ', mk_name, '=>', value def checker(): print '\n CBulbMid' print gv(A_mid) / (gv(BulbBeam) * gv(BulbDepth)) print gv(CBulbMid) print '\n CBulbCtrPln' print gv(A_lateral) / (gv(BulbLength) * gv(BulbDepth)) print gv(CBulbCtrPln) print '\n CBulbWtrPln' print gv(A_BBwl) / (gv(BulbLength) * gv(BulbBeam)) print gv(CBulbWtrPln) print '\n CBulbBlock' print gv(BulbVolume) / (gv(BulbLength) * gv(BulbBeam) * gv(BulbDepth)) print gv(CBulbBlock) print '\n CBulbPrismatic' print gv(BulbVolume) / (gv(BulbLength) * gv(A_mid)) print gv(CBulbPrismatic) return def gv(var): return rgp.get_name_and_value(var)[1][0] checker() return redo, rgp
def old_test(): print 'Kraft Bulbous Bow Parameters' print '\n Linear Parameters:' A_mid = lp.PStates(name='A_mid') #use the principle of the minimum square enclosing box (cartesian b/c ia is cartesian) BulbBeam = lp.PStates(name='BulbBeam') #Bulb half beam BulbDepth = lp.PStates(name='BulbDepth') #Bulb depth CBulbMid = lp.PStates(name='CBulbMid') #Bulb midsection coefficient #TODO: fix this with class to construct rules graph! A_mid = A_mid == ia(10., 20.) #issue: order of assignment "matters" BulbBeam = BulbBeam == ia(5., 10.) CBulbMid = CBulbMid == ia(.5, 1.) rgp = RulesGraphProcessor() rgp.add_one_rule(A_mid, A_mid.name) rgp.add_one_rule(BulbBeam, BulbBeam.name) rgp.add_one_rule(CBulbMid, CBulbMid.name) rgp.compute_fresh_rules_graph() """----------------------------------------------- Rule: Midbulb_Area < max_Beam * max_Depth CBulbMid -> [0.,1.] CBulbMid == A_mid/(BulbBeam*BulbDepth) """ CBulbMid = CBulbMid == A_mid / (BulbBeam * BulbDepth) #rgp.add_one_rule(BulbDepth,BulbDepth.name) rgp.add_one_rule(CBulbMid, CBulbMid.name) rgp.compute_fresh_rules_graph() #""" #rgp.compute_fresh_rules_graph() #BulbDepth = BulbDepth == ia(5.,10.) #rgp.add_one_rule(BulbDepth,BulbDepth.name) #rgp.compute_fresh_rules_graph() print '\n\n state after:' #print st print rgp.env ellist = [BulbDepth, CBulbMid, BulbBeam, A_mid] ith = -1 x = .5 redo = [] for i in range(len(ellist)): var = ellist[i] mk_name, mk_val = rgp.get_name_and_value(var) print mk_name, mk_val val = mk_val[ith].getpoint(x) value = ia(val, val) var = var == value #----------------------------------------- ret_state = copy.copy(rgp.env) rgp.add_one_rule(var, var.name) rgp.compute_fresh_rules_graph() #rgp.compute_rules_graph() #----------------------------------------- if len(rgp.env.states) == 0: rgp.env = ret_state redo.append(var) else: if rgp._verbose: print 'done ', mk_name, '=>', value return
def initialize_bulb_parameters(self): #, rgp=None): #if rgp is None: # rgp = self.rgp #bulb areas self.A_mid = lp.PStates(name='A_mid') self.A_lateral = lp.PStates(name='A_lateral') #self.A_flat = lp.PStates(name='A_flat') #A_BBwl instead self.A_BBwl = lp.PStates(name='A_BBwl') #use the principle of the minimum square enclosing box (cartesian b/c ia is cartesian) self.BulbBeam = lp.PStates(name='BulbBeam') #Bulb half beam self.BulbDepth = lp.PStates(name='BulbDepth') #Bulb depth self.BulbLength = lp.PStates( name='BulbLength' ) #Bulb max length (min square enclosing box length) self.BulbVolume = lp.PStates(name='BulbVolume') self.CBulbMid = lp.PStates( name='CBulbMid') #Bulb midsection coefficient self.CBulbCtrPln = lp.PStates( name='CBulbCtrPln') #Bulb centerplane profile area coefficient self.CBulbWtrPln = lp.PStates( name='CBulbWtrPln') #Bulb waterplane area coefficient self.CBulbBlock = lp.PStates( name='CBulbBlock') #Bulb block coefficient self.CBulbPrismatic = lp.PStates( name='CBulbPrismatic') #Bulb prismatic coefficient return #rgp
#st.update({_:None}) #st.bind(_) st.bind_if_not_extant(_) #st.states[0].update({_:None}) #st.states[0] = st.states[0].bind('_') #smm = (st + ( ( _,'+',[x,y,_] ), z, a) ) # import inspect # # def fi(st): # spec = inspect.getargs(st) # return spec,st # # spec,sc = fi([y,ia(1.,2.)]), y, ia(2.,4.)) ps = lp.PStates(name='ps') a = lp.PStates(name='a') b = lp.PStates(name='b') c = lp.PStates(name='c') d = lp.PStates(name='d') #ps1 = (ps == (a,b) ) #does not work this way anymore... ps1 = a == b #e = ( ps + (a,b,c) ) e = a + b + c e.name = 'e' f = a + b + c * d f.name = 'f' ps1 = (ps == (d, (ps + (a, b, c))))