def do_first(sobol_seq=None, ellist=None):
if sobol_seq is None:
sobol_seq = sobol.sobolSeq([1, 1], [1, 1])
if ellist is None:
ellist = [BulbDepth, CBulbMid, CBulbBlock]
ith = -1
#x=.5
redo = []
#last_valid = None
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()
#-----------------------------------------
if len(rgp.env.states) == 0:
#rgp.nodes.pop()
#rgp.env = ret_state
rgp.reset(ret_state, var)
#rgp.env.states = ret_state.states
redo.append(var)
#last_valid = ret_state
else:
if rgp._verbose: print 'done ', mk_name, '=>', value
return rgp, redo, None, sobol_seq
def __init__(self, spec, verbose=False):
self._verbose = verbose
self.spec = spec
self.sobol_seq = sobol.sobolSeq([1, 1], [1, 1])
#alternatvely, initialize a true IA hull
self.hdp = hullclp() #hull_use_HICLP.hullclp()
self.hdp.lwl = ia(spec.lwl[0], spec.lwl[1])
self.hdp.draft = ia(spec.draft[0], spec.draft[1])
self.hdp.bwl = ia(spec.bwl[0], spec.bwl[1])
self.hdp.vol = ia(spec.vol[0], spec.vol[1])
self.hdp.Cb = ia(spec.Cb[0], spec.Cb[1])
self.hdp.Cwp = ia(spec.Cwp[0], spec.Cwp[1])
self.hdp.Ccp = ia(spec.Ccp[0], spec.Ccp[1])
self.hdp.LCG = ia(spec.LCG[0], spec.LCG[1])
self.hdp.Cmidshp = ia(spec.Cmidshp[0], spec.Cmidshp[1])
self.hdp.AC_revise()
#"""
self.hdp.states = self.hdp.shape_bow_section_inizers()
self.hdp.states = self.hdp.shape_stern_section_inizers()
self.hdp.states = self.hdp.SAC_run_area_ini()
self.hdp.states = self.hdp.SAC_Xc_init()
self.hdp.states = self.hdp.LCG_constraints()
#"""
self.hdp.AC_revise()
self.feasible_designs = []
self.infeasible_designs = []
def generate_quasirandom_sequence(self, allow_range):
s1 = sobol.sobolSeq([1, 1], [1, 1])
inf = allow_range[0]
sup = allow_range[1]
r = sup - inf
x = np.asarray([next(s1) for _ in range(self.N)])
return r * x + inf
def __init__(self,
ship_beam=None,
ship_depth=None,
ship_Lpp=None,
ship_Amshp=None,
ship_Acp=None,
ship_Awp=None,
ship_Vol=None,
bare_hull=None):
self.init_ship_beam = ship_beam
self.init_ship_depth = ship_depth
self.init_ship_Lpp = ship_Lpp
self.init_ship_Amshp = ship_Amshp
self.init_ship_Acp = ship_Acp
self.init_ship_Awp = ship_Awp
self.init_ship_Vol = ship_Vol
self.bare_hull = bare_hull # sqKanren States() processed by opt_simple_hull
self.rgp = RulesGraphProcessor(verbose=False)
self.sobol_seq = sobol.sobolSeq([1, 1], [1, 1])
if bare_hull is None:
self = setup_dummy_bare_hull(self)
self.rgp.compute_fresh_rules_graph()
else:
self.initialize_ship_parameters_and_values()
# self.rgp = self.initialize_bulb_parameters(self.rgp)
# self.rgp = self.coupling_constants(self.rgp)
#
# self.rgp = self.linear_parameters(self.rgp)
# self.rgp = self.nonlinear_parameters(self.rgp)
#
#
# self.initialize_lists()
# self.rgp = ini_coeffs(self.Coefficients, self.rgp)
#self.rgp = self.experiment_bulb_parameters(self.rgp)
#self.rgp = self.basic_bulb_rules(self.rgp)
self.initialize_bulb_parameters()
self.coupling_constants()
self.linear_parameters()
self.nonlinear_parameters()
self.initialize_lists()
self = ini_coeffs(self) #.Coefficients, self.rgp)
self.experiment_bulb_parameters()
self.basic_bulb_rules()
def __init__(self,
ship_beam=None,
ship_depth=None,
ship_Lpp=None,
ship_Amshp=None,
ship_Acp=None,
ship_Awp=None,
ship_Vol=None,
bare_hull=None):
self.nCV = 7
self.idealdict = {} #this will eventually store primary bulb curves
self.init_ship_beam = ship_beam
self.init_ship_depth = ship_depth
self.init_ship_Lpp = ship_Lpp
self.init_ship_Amshp = ship_Amshp
self.init_ship_Acp = ship_Acp
self.init_ship_Awp = ship_Awp
self.init_ship_Vol = ship_Vol
self.bare_hull = bare_hull # sqKanren States() processed by opt_simple_hull
self.rgp = RulesGraphProcessor(verbose=False)
self.sobol_seq = sobol.sobolSeq([1, 1], [1, 1])
self.tol = 1.e-4
self.verbose = True
if bare_hull is None:
self = setup_dummy_bare_hull(self)
self.rgp.compute_fresh_rules_graph()
else:
self.initialize_ship_parameters_and_values()
self.initialize_bulb_parameters()
self.coupling_constants()
self.linear_parameters()
self.nonlinear_parameters()
self.initialize_lists()
self = ini_coeffs(self) #.Coefficients, self.rgp)
self.experiment_bulb_parameters() #add new rules here
self.basic_bulb_rules()
def __init__(self,
ship_beam=None,
ship_depth=None,
ship_Lpp=None,
ship_Amshp=None,
ship_Acp=None,
ship_Awp=None,
ship_Vol=None,
bare_hull=None):
self.init_ship_beam = ship_beam
self.init_ship_depth = ship_depth
self.init_ship_Lpp = ship_Lpp
self.init_ship_Amshp = ship_Amshp
self.init_ship_Acp = ship_Acp
self.init_ship_Awp = ship_Awp
self.init_ship_Vol = ship_Vol
self.bare_hull = bare_hull # sqKanren States() processed by opt_simple_hull
self.rgp = RulesGraphProcessor(verbose=False)
self.sobol_seq = sobol.sobolSeq([1, 1], [1, 1])
#
rgp.compute_fresh_rules_graph()
# #
# ##
# ##************************************* end linear relations
# ##
#
#
# print '\n\n state after:'
# #print st
#
# print rgp.env
if final_test:
self = rgp
sbs = sobol.sobolSeq([1, 1], [1, 1])
redo = None
ellist = [CBulbMid]
rgp, redo, last_valid, sbs = do_first(sbs, ellist)
rgp, redo, last_valid, sbs = do_first(sbs, redo)
ellist = [CBulbBlock]
rgp, redo, last_valid, sbs = do_first(sbs, ellist)
rgp, redo, last_valid, sbs = do_first(sbs, redo)
ellist = [BulbDepth]
rgp, redo, last_valid, sbs = do_first(sbs, ellist)
rgp, redo, last_valid, sbs = do_first(sbs, redo)
ellist = [A_mid]
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
