def load(self, fname):
try:
from speed import speed
except:
speed = lambda x:x
import cPickle
d = cPickle.load(file(fname))
# Adding experiments
print "Adding experiments"
for eID, spec, reqCount in speed(d['experiments']):
self.addExperiment(spec, reqCount)
# Adding bundles
print "Adding bundles"
for bundleID in speed(d['bundles']):
self.addBundle(bundleID[0], {})
print "Assembling results"
resDict = {}
for res in speed(d['results']):
resDict.setdefault(res[0].encode('hex'),[] ).append(res[1])
print "Adding results"
import uuid
self.addBundle(uuid.uuid4().hex, resDict)
def load(self, fname):
try:
from speed import speed
except:
speed = lambda x: x
import cPickle
d = cPickle.load(file(fname))
# Adding experiments
print "Adding experiments"
for eID, spec, reqCount in speed(d['experiments']):
self.addExperiment(spec, reqCount)
# Adding bundles
print "Adding bundles"
for bundleID in speed(d['bundles']):
self.addBundle(bundleID[0], {})
print "Assembling results"
resDict = {}
for res in speed(d['results']):
resDict.setdefault(res[0].encode('hex'), []).append(res[1])
print "Adding results"
import uuid
self.addBundle(uuid.uuid4().hex, resDict)
def dump(self, fname):
try:
from speed import speed
except:
speed = lambda x: x
d = {}
# get experiments
print "getting experiments"
experiments = []
for eID in speed(self.experimentIDs):
spec = self.getExperiment(eID)
reqCount = self.getRequiredCount(eID)
experiments.append((eID, spec, reqCount))
d['experiments'] = experiments
# get results
print "getting results"
d['results'] = self.conn.execute(
"SELECT eid, result FROM results").fetchall()
# get bundles
print "getting bundles"
d['bundles'] = [
x[0] for x in self.conn.execute("SELECT bundleID FROM bundles")
]
# dump to file
print "dumping to file"
import cPickle
cPickle.dump(d, file(fname, 'w'), protocol=2)
def dump(self, fname):
try:
from speed import speed
except:
speed = lambda x:x
d = {}
# get experiments
print "getting experiments"
experiments = []
for eID in speed(self.experimentIDs):
spec = self.getExperiment(eID)
reqCount = self.getRequiredCount(eID)
experiments.append((eID, spec, reqCount))
d['experiments'] = experiments
# get results
print "getting results"
d['results'] = self.conn.execute("SELECT eid, result FROM results").fetchall()
# get bundles
print "getting bundles"
d['bundles'] = [x[0] for x in self.conn.execute("SELECT bundleID FROM bundles")]
# dump to file
print "dumping to file"
import cPickle
cPickle.dump(d, file(fname,'w'), protocol=2)
def speed(self, board, l, b):
screen = board.getscreen()
start = 20
start = start + random.randint(100, 200)
loc = random.randint(3, l - 7)
self.__speed = speed(screen, loc, start, self.__o[4][0][0])
return loc, start
board.setscreen(screen)
def dumpRequests(requestIterable, fileDirectory):
'''
Storing the requests with cPickle in randomly chosen filenames in the
given directory
@param requestIterable: iterable that provides requests
@param fileDirectory: directory to write request files
'''
import uuid
for reqInd, request in speed(enumerate(requestIterable)):
fname = "spec%06d.request" % reqInd
fname = os.path.join(fileDirectory, fname)
file(fname, 'w').write(request)
def dumpRequests(requestIterable, fileDirectory):
"""
Storing the requests with cPickle in randomly chosen filenames in the
given directory
@param requestIterable: iterable that provides requests
@param fileDirectory: directory to write request files
"""
import uuid
for reqInd, request in speed(enumerate(requestIterable)):
fname = "spec%06d.request" % reqInd
fname = os.path.join(fileDirectory, fname)
file(fname, "w").write(request)
def main():
screen = display.set_mode(game_borders.SCREEN_SIZE)
davids_hair = image.load(HERO_IMG)
key_type = None
davids_hair_rect = davids_hair.get_rect()
davids_hair_rect.inflate_ip(*INIT_SIZE_REDUCTION)
davids_hair_rect = davids_hair_rect.move(INIT_LOC)
davids_speed = speed(INIT_SPEED)
characters = {davids_hair: davids_hair_rect}
change_frame(screen, characters)
game_events_handler = get_next_event()
print("Start Game")
while 1:
time.sleep(0.01)
try:
game_event = next(game_events_handler)
except StopIteration:
game_events_handler = get_next_event()
if game_event.type == QUIT:
sys.exit()
elif game_event.type == KEYDOWN:
key_type = game_event.key
elif game_event.type == KEYUP:
key_type = None
if key_type == K_SPACE:
davids_speed.change_speed(KEY_SENSITIVITY)
elif key_type in DIRECTIONS.keys():
davids_speed.turn(key_type)
print("x:{0}, y:{1}, angle:{2}".format(davids_speed.x,
davids_speed.y,
davids_speed.angle.angle))
characters[davids_hair] = move_character(characters[davids_hair],
davids_speed)
change_frame(screen, characters)
#%% Critical stags
crit = iflow.IsentropicFlow(k, 1)
M_crit = crit.Mach
# Pressure Ratio
pstar_p0 = crit.p_p0
print('p_pcrit:', pstar_p0)
# Temperature Ratio
Tstar_T0 = crit.T_T0
print('T_Tcrit:', Tstar_T0)
# Density Ratio
rho_rhocrit = crit.rho_rho0
print('rho_rhocrit', rho_rhocrit)
# Area Ratio
A_Astar = crit.A_Astar
print('A_Astar', A_Astar)
T_crit = Tstar_T0 * T0
p_crit = (pstar_p0) * p0
#rho0=1/rho_rho0*rho
print('Pcritical:{}\nTcritical:{}'.format(p_crit, T_crit))
#%% Flow Peoperties
a, V = sp.speed(k, T, R, M) ## Speed of Sound and Flow Velocity
print('Speed of Sound: {}\nFlow Velocity: {}'.format(a, V))
# arg2.append(i)
# return arg2
#%%
p_1=0.5*101325 # Initial Pressure (Pascal)
T_1=200 # Initial Temperature (Kelvin)
k=1.4 # Specific heat ratio
R=287 #J/kg-K
rho_1=p_1/(R*T_1) #Inital Density kg/m3
M_1,M_2,p,T,rho=shock_parameters(k,M_1=3)
rho_2=rho_1*rho
p_2=p_1*p
T_2=T*T_1
#ppp=round_function(M_2,p_2,T_2,rho_2)
import speed as sp
a_2,u_2=sp.speed(k,T_2,R,M_2)
#print('Final Pressure=',p_2/101325,'atm\nFinal Velocity=',u_2,'m/s')
#print('Final Temperature=',T_2,'K\nFinal Speed of Sound=',a_2,'m/s')
del_s=entropy_calc(M_1,M_2,p_1,p_2)
#print("Entropy Change",del_s)
#%% Plot
M1,M2,P2,T2,rho2,P02=[],[],[],[],[],[]
M=1
while M<=4.2:
M_1,M_2,p_2,T_2,rho_2=shock_relations(M,k)
M1.append(M)
M2.append(M_2)
P2.append(p_2)
import speed a=speed.distance() b=speed.time() print speed.speed(4,2),"m/s"
def main():
from threading import Thread
_logger = logger()
def log(string):
if _logger.q:
_logger.q.put('%s%s' % (datetime.now().strftime('%X'), string))
_logger.start()
setup()
m = motor()
sv = SensorVote(new_vote_callback = lambda x:direction(m, x) or log('[NEW-VOTE] %s' % x))
#t = Tracer.Tracer()
#sv.add_voter(t)
l = Light.Light()
sv.add_voter(l)
h = HumanOverride.HumanOverride()
sv.add_voter(h)
spd = speed()
spd.start_monitor()
class hb(Thread):
def __init__(self):
Thread.__init__(self)
self.exit = False
def run(self):
while not self.exit:
try:
time.sleep(1.5)
res = sv.vote_full()
s = spd.get_speed()
log('[%s] %s %s' % ('CAUTION' if res[1] else 'HEARTBEAT', res[0], s))
direction(m, res[0])
if sum(s) == 0 and m.status != motor.STATUS_STOP:
log('[OBSTACLE] !!!!!')
m.do_reverse()
except KeyboardInterrupt:
return
m.set_speed(int(raw_input('Speed > ') or '10'))
b = hb()
b.setDaemon(True)
b.start()
#m.go(start = True)
while True:
try:
inp = raw_input('Override >')
h.do_override(inp)
if inp == 'b':
m.back(start = True)
elif inp == 'g':
m.go(start = True)
elif inp == 's':
m.stop()
except KeyboardInterrupt:
break
b.exit = True
_logger.q = None
b.join()
_logger.join()
cleanup(m)
