def main():
pop = []
for i in range(Config.pop_size):
pop.append(Grn())
simulate(pop)
# print("Population")
# print(pop[0])
# print()
# print(pop[1])
# print()
# print(pop[2])
# print()
#
# print("Crossover")
# print()
# c1,c2 = std_crossover(pop)
#
# print("Children")
# print(c1)
# print(c1.initial_proteins)
# print()
# print(c2)
# print(c2.initial_proteins)
print()
def handle(self):
# self.request is the TCP socket connected to the client
self.data = self.request.recv(1024).strip()
if self.data:
sim.simulate(self.data)
print self.data
def createSimulate(netParams=None, simConfig=None, output=False):
''' Sequence of commands create, simulate and analyse network '''
(pops, cells, conns, stims, simData) = sim.create(netParams,
simConfig,
output=True)
sim.simulate()
if output: return (pops, cells, conns, stims, simData)
def track_ws(ws):
results = api.rankings("closeness", 4000)
sim_running = False
while True:
message = ws.receive()
print message
if message != "" and sim_running == False:
rocket = getRocketParticle(obj=json.loads(message))
sim.simulate(rocket, results)
ws.send(message)
def track_ws(ws):
results = api.rankings("closeness", 4000)
sim_running = False
while True:
message = ws.receive()
print message
if message != "" and sim_running == False:
rocket = getRocketParticle(obj=json.loads(message))
sim.simulate(rocket, results)
ws.send(message)
def launch():
try:
getRocketParticle(args=request.args)
sim.simulate(rocket, results)
return json.dumps(sim.convert_to_orbit(rocket))
except Exception, e:
resp = jsonify({'error': 'bad request', 'details': str(e)})
resp.status_code = 500
return resp
def launch():
try:
getRocketParticle(args=request.args)
sim.simulate(rocket, results)
return json.dumps(sim.convert_to_orbit(rocket))
except Exception, e:
resp = jsonify({'error': 'bad request', 'details': str(e)})
resp.status_code = 500
return resp
def main_prompt(khan):
while True:
num = None
print("\n")
print("[1] Load infections from file.")
print("[2] Load users from file.")
print("[3] Infect a user with a disease (total_infection).")
print("[4] Infect at most a certain amount of users if possible (limited_infection).")
print("[5] Infect exactly a certain amount of users if possible (limited_infection_perfect).")
print("[6] Simulate real-time user-infection interaction.")
print("[7] Print the infection hierarchy.")
print("[8] Print the user hierarchy and each user's associated infections.")
print("[9] Reset all users and infections to defaults.")
print("[10] Clear all users and infections.")
print("[11] Exit.")
try:
num = int(input("Please select an action to perform: "))
except:
pass
print("")
if num == 1:
get_infections(khan)
elif num == 2:
get_users(khan)
elif num == 3:
total_infection(khan)
elif num == 4:
limited_infection(khan)
elif num == 5:
limited_infection_perfect(khan)
elif num == 6:
sim.simulate(khan)
elif num == 7:
print("***** Infections *****")
khan.print_infections(True)
elif num == 8:
print("***** Users *****")
khan.print_users(print_infections=True)
elif num == 9:
reset(khan)
elif num == 10:
clear(khan)
elif num == 11:
print("Goodbye!")
return
else:
print("Please enter a valid number!")
def frac_grey_against_both(num_samples=50, max_moths=30, granularity=0.1):
probs_white_death = np.arange(0, 1 + granularity, granularity)
nums_moths = np.arange(1, max_moths + 1)
results = np.zeros((len(nums_moths), len(probs_white_death)))
probs_white_death, nums_moths = np.meshgrid(probs_white_death, nums_moths)
stacked = np.dstack((probs_white_death, nums_moths))
for i, group in enumerate(stacked):
for j, pair in enumerate(group):
prob_white_death, num_moths = pair[0], pair[1]
results[i][j] = sum(
simulate({'ww':0, 'wg':num_moths, 'gg':0}, prob_white_death)
for _ in range(num_samples)) / float(num_samples)
fig = plt.figure()
ax = fig.gca(projection='3d')
surf = ax.plot_surface(probs_white_death, nums_moths, results, rstride=1,
cstride=1, cmap=cm.Greys, linewidth=0, antialiased=False)
ax.set_zlim(0, 1.00)
ax.zaxis.set_major_locator(LinearLocator(10))
ax.zaxis.set_major_formatter(FormatStrFormatter('%.02f'))
fig.colorbar(surf, shrink=0.5, aspect=5)
plt.title('Fraction of Grey Moths')
ax.set_xlabel('Probability of white moth death')
ax.set_ylabel('Number of moths')
ax.set_zlabel('Fraction of grey moths')
plt.show()
def main():
data, _t = simulate(X0,U)
theta = data[0]
theta_dot = data[1]
#get all of our theta within -pi:pi
i = len(data[0]) - 1
while i > -1:
while not -pi <= data[0][i] <= pi:
if data[0][i] < -pi:
data[0][i] = data[0][i] + 2*pi
else:
data[0][i] = data[0][i] - 2*pi
i = i - 1
#because our version of savetxt doesn't have the header option for some reason
with open(OUTFILE_NAME, 'w') as f:
f.write("theta,theta_dot,u\n")
f.write("float,float,float\n")
f.write(",,\n")
trimmed_data = data[:2]
trimmed_data = numpy.vstack([trimmed_data, U])
numpy.savetxt(f, numpy.transpose(trimmed_data), delimiter=',', fmt="%.18f")
plot_traj(data, U, _t)
def search(S):
s = 0
p = param.Parameters()
while s < S:
p.randomize()
solution = sim.simulate(sat.Satellite(planet.Earth, p))
print (s+1, ": <eval>\t$", eval.evaluate(solution), "\t", solution.distMin, "\t",
solution.tMin, "\t", p.velX, "\t", p.velY, "\t", p.friction)
s += 1
def auto_standard(list_lg=None, list_le=None, trials=4, sim_time=6):
lg, le = list_lg, list_le
if list_lg is None:
lg = [x / 100.0 for x in range(20, -2, -2)]
if list_le is None:
le = [x / 100.0 for x in range(20, -2, -2)]
trial_names = string.ascii_letters[:trials]
for i in lg:
for j in le:
dir_string = str(int(i * 100)).zfill(2) + str(int(
j * 100)).zfill(2)
mkdir(dir_string)
for k in trial_names:
file_name = dir_string + k
sim.simulate(lg=i,
le=j,
save_dir=f"{dir_string +'/'+ file_name}",
sim_time=sim_time)
def search(S):
s = 0
p = param.Parameters()
while s < S:
p.randomize()
solution = sim.simulate(sat.Satellite(planet.Earth, p))
print(s + 1, ": <eval>\t$", eval.evaluate(solution), "\t",
solution.distMin, "\t", solution.tMin, "\t", p.velX, "\t",
p.velY, "\t", p.friction)
s += 1
def prob_against_white_death(num_samples=100, num_moths=30, granularity=0.05):
samples = []
for prob_white_death in np.arange(0, 1 + granularity, granularity):
samples.append(sum(
simulate({'ww':0, 'wg':num_moths, 'gg':0}, prob_white_death)
for _ in range(num_samples)) / float(num_samples))
plt.plot(np.arange(0, 1 + granularity, granularity), samples)
plt.title('Grey Moths Versus Probability of White Death')
plt.xlabel('Probability of white death')
plt.ylabel('Fraction of grey moths')
plt.show()
def worker3d(users, events, rounds):
''' make rounds of simulation of users '''
print "{0} users with {1} events started".format(users, events)
paths = []
for _ in range(rounds):
log, attacker_log = sim.simulate(users, messages=events)
path = sim.match_paths(log, attacker_log)
paths.append(path)
# build mean and confidence interval
mean, conf = sim.mean_confidence_interval(paths)
print "{0} users with {1} events finished".format(users, events)
return users, events, mean
def prob_all_grey(num_samples=100, max_moths=50, prob_white=0.8):
samples = []
for num_moths in range(1, max_moths + 1):
samples.append(
sum(simulate({'ww':0, 'wg':num_moths, 'gg':0},
prob_white, fraction=False)
for _ in range(num_samples)) / float(num_samples))
plt.plot(samples)
plt.title(
'Probability All Moths Turn Grey (prob_white = {})'.format(prob_white))
plt.xlabel('Number of moths')
plt.ylabel('Probability')
plt.show()
def main_loop():
while True:
attacking_unit, weapon, n_shots = input_attack(FRIENDLY_ARMY)
if n_shots is None:
continue
abilities_by_target = map_abilities(attacking_unit, weapon, ENEMY_ARMY,
FRIENDLY_ARMY, ENEMY_ARMY)
all_sim_results = simulate(attacking_unit, weapon, n_shots, ENEMY_ARMY,
abilities_by_target)
print_sim_results(all_sim_results)
input('Press any key to continue...')
def epsilon_greedy(students, arms, bound, epsilon, log_file):
"""
arms is a list of configurations, each config can be passed as a
numpy array.
bound is the number of arm pulls we will limit ourselves to
"""
# logging header
log_file.write("\n--- Epsilon Greedy ---\n")
# build list of sampleArm objects to track rewards and averages
s = list()
for arm in arms:
s_arm = sim.LineConfig(arm[0], arm[1], arm[2], arm[3], arm[4])
s_arm.set_config_mu(students)
s.append(s_arm)
# find actual max arm, calculate deltas and log
max_arm = get_actual_max(s)
calculate_delta(s, max_arm)
logger.log_arms(log_file, s)
for i in range(bound):
# because we are not using a simple numpy.array we will sort
# the list in place on each interval (ineffeciennnncy)
# to get the greedy arm
j = pick_arm(s, epsilon)
s[j].set_num_pulls(s[j].get_num_pulls() + 1)
# pull the arm
reward = sim.simulate(s[j], students, log_file)
s[j].set_total_reward(
s[j].get_total_reward() + reward)
s[j].set_average(
s[j].get_total_reward() / s[j].get_num_pulls())
# sort the arms
current_max = s[0]
s.sort(key=operator.attrgetter('average'), reverse=True)
if i != 0 and ((i + 1) % 100) == 0:
# log current best arm
logger.log_pulled_arm(log_file, s[0], i+1)
# log current best arm
logger.log_best_arm(log_file, s[0], bound)
for arm in s:
logger.log_num_pulls(log_file, arm)
return str(s[0])
def lil_ucb(students, arms, delta, epsilon, lambda_p, beta, sigma, log_file, max_pulls):
# delta == confidence
#
time = 0
n = len(arms)
mu = numpy.zeros(n) # set of rewards
T = numpy.zeros(n) # T[i] is the number of times arm i has been pulled
armList = list()
timestep = 0
for arm in arms:
s_arm = sim.LineConfig(arm[0], arm[1], arm[2], arm[3], arm[4])
s_arm.set_config_mu(students)
armList.append(s_arm)
# actual max used for comparison
actual_max = get_actual_max(armList)
# set deltas
calculate_delta(armList, actual_max)
#sample each of the n arms once, set T_i(t) = 1, for all i and set t=n
for i in range(n):
T[i] = 1
mu[i] = sim.simulate(armList[i], students, log_file) #pull the arm
log_file.write("ARM: %s\tCONFIGMU %s\tDELTA: %f\n" %(str(armList[i]), armList[i].get_config_mu(), armList[i].get_delta()))
timestep += 1
prevIndex = -1;
while True:
done = False
total_pulls = sum(T)
timestep += 1
for i in range(n):
#check if an arm has been pulled more than all others combined
print("t[i]: %d >= %d\n" %(T[i], (1 + lambda_p*(total_pulls - T[i]))))
if T[i] >= 1 + lambda_p*(total_pulls - T[i]):
done = True
break
if done:
break
index = 0
upper_bound_value = 0
for i in range(n):
#temp is that magic value used to determine the best, next arm to pull
temp = math.sqrt((2*sigma**2 * (1 + epsilon) * math.log( math.log((1 + epsilon)* T[i])/delta))/T[i])
temp = mu[i] + (1 + beta)*(1 + math.sqrt(epsilon))*temp
if(temp > upper_bound_value):
upper_bound_value = temp
index = i
T[index] += 1
reward = sim.simulate(armList[index], students, log_file)
mu[index] = ((T[index]-1)*mu[index] + reward) / T[index] #average the rewards
if(timestep % 100 == 0):
#log_file.write("ITERATION: %6d ARM: %s\tCONFIGMU: %f\tDELTA: %f\n" %(timestep, str(armList[index]), armList[index].get_config_mu(), armList[index].get_delta()))
empercial_best = max(mu)
best_arm_index = [i for i,j in enumerate(mu) if j == empercial_best]
best_arm = armList[best_arm_index[0]]
log_file.write("ITERATION: %6d\tBEST_ARM: %s\tCONFIG_MU: %f\tDELTA: %f\n" %(timestep, str(best_arm), best_arm.get_config_mu(), best_arm.get_delta()))
#prevIndex = index
if(timestep == max_pulls):
break
arm = armList[T.argmax()]
log_file.write("\nBEST ARM: %s\tCONFIG_MU: %f\tDELTA: %f\n"
%(str(arm), arm.get_config_mu(), arm.get_delta()))
for count,arm in enumerate(armList):
log_file.write("ARMPULLCOUNT: %s\t%d\n" %(str(arm), T[count]))
return armList[T.argmax()]
from pylab import *
from sim import simulate
from curve import curvature
l = 10
dests = array(curvature(10))
# initial point
initial = [0.0, 0.0]
[x, y, gx, gy, corr, err] = simulate(
9, l, initial, pi / 2, dests, 1.0, 1.0, 100, c_slip=0.21, c_mag=0.1, c_align=0.1037
)
print err
print corr
plot(x, y, label="Actual path", linewidth=2)
axis([0, l, 0, l])
for i in gx:
plot([i, i], [0, l], "red")
for i in gy:
plot([0, l], [i, i], "red")
destx = [initial[0]]
desty = [initial[1]]
for i in dests:
destx.append(i[0])
desty.append(i[1])
plot(destx, desty, "g--", label="Desired path", linewidth=2)
# xlabel('x coordinate position, x(m)')
(gait, waypoints_B) = B.get_gait(robot_pos, target, obstacles, 0, ax,
show_sub)
times_B.append(time.time() - start)
#if draw:
#ax.plot([robot_pos[0], target[0]],[robot_pos[1], target[1]], c='black') # straight trajectory line from robot_pos to target
# Naiv
if algorithm == 3:
start = time.time()
gait = N.compute_gait(robot_pos, target, obstacles)
times_naiv.append(time.time() - start)
# simulate the gait
if not pause and not do_skip_a:
gait, target, robot_pos, rot, rot_a, actual_path_B, actual_path_LPG, actual_path_naiv, obstacles, LPG_obstacles = sim.simulate(
gait, target, robot_pos, rot, rot_a, actual_path_B,
actual_path_LPG, actual_path_naiv, obstacles, orig_obstacles,
LPG_obstacles, algorithm, sim_obst)
deadlock = (len(actual_path_naiv) > 200 and algorithm
== 3) or (len(actual_path_LPG) > 200
and algorithm == 1) or (len(actual_path_B) > 200
and algorithm == 2)
if deadlock:
if algorithm == 1:
actual_path_LPG = []
print(" ------------ DEADLOCK LPG ------------")
elif algorithm == 2:
print(" ------------ DEADLOCK BISEC ------------")
actual_path_B = []
elif algorithm == 3:
print(" ------------ DEADLOCK NAIV ------------")
actual_path_naiv = []
def sequential_halving(students, arms, bound, log_file):
"""
Sequential Halving -- (Fixed Bound)
Parameters:
* let arms be an array of vectors, where each vector is a configuration
* bound is an integer which represents the maximum number of
arms pulls the algorithm is limited to find optimal arms with
** still unsure how we will set up our s, right now it is a list of
the array arms, which shrinks by half on each iteration
"""
# logging header
log_file.write("\n--- Sequential Halving ---\n")
s = list()
# add arms with initialized values to the list
inner_list = list()
for arm in arms:
s_arm = sim.LineConfig(arm[0], arm[1], arm[2], arm[3], arm[4])
s_arm.set_config_mu(students)
inner_list.append(s_arm)
s.append(inner_list)
# get the arm with the highest config_mu for comparison
actual_max = get_actual_max(s[0])
# set deltas
calculate_delta(s[0], actual_max)
# log all arms
logger.log_arms(log_file, s[0])
current_pulls = 0
# run through iterations of algorithm
for r in range(int(math.ceil(math.log(len(arms), 2)))):
# compute the pulls per arm per iteration
pulls_per_arm = int(
math.floor(bound /
(len(s[r]) * math.ceil(math.log(len(arms), 2)))))
current_pulls += pulls_per_arm + 1
# sample each arm pulls_per_arm times and average results
for i in range(len(s[r])):
total = 0.0
for j in range(pulls_per_arm):
s[r][i].set_num_pulls(s[r][i].get_num_pulls() + 1)
total += sim.simulate(s[r][i], students, log_file)
s[r][i].set_average(total / pulls_per_arm)
# sort the remaining arms by average from above sample
s[r].sort(key=operator.attrgetter('average'), reverse=False)
# create next iteration which the upper half of the sorted list
s.append(s[r][int(math.ceil(len(s[r]) / 2)):])
# log the current empirical best arm
logger.log_pulled_arm(log_file, s[r][len(s[r]) - 1], current_pulls)
arm = s[int(math.ceil(math.log(len(arms), 2)))][0]
logger.log_pulled_arm(log_file, arm, bound)
logger.log_best_arm(log_file, arm, bound)
for arm in s[0]:
logger.log_num_pulls(log_file, arm)
return arm
from pylab import *
from sim import simulate
from curve import curvature
v = []
avg_errors = []
max_errors = []
initial = [0.0,0.0]
l = 10.0
#dests=array(curvature(10))
dests = []
for i in arange(0.1*l, 1.1*l, 0.1*l):
dests.append([i,i])
dests = array(dests)
for n in arange(1.0, 5.5,0.5):
errs = []
for j in range(0,10):
print n, j
tmp = simulate(9, l, initial, pi/2, dests, n,1,100)
errs.append(tmp[-1])
v.append(n)
avg_errors.append(average(errs))
max_errors.append(max(errs))
print n, avg_errors[-1], max_errors[-1]
print v
print avg_errors
print max_errors
forceAC = 10**-6
delta0= np.pi/3
q0 = 0
t = np.linspace(0,10,10**6)
counter = 0
freqs = list()
for f in ["series","parallel"]:
if f == "parallel":
Ls = [10**-3,10**1]
else:
Ls = [10**-15,10**-10]
for R in Rs:
for C in Cs:
for L in Ls:
delta,successful = simulate(R,L,C,forceDC,forceAC,w,delta0,q0,f)
i = np.sin(delta)
if f =="series":
freqs.append(nFrequencies(3,phi0/(2*np.pi*Ic*R)*t,i))
else:
freqs.append(nFrequencies(3,R*C*t,i))
plt.close()
fig, ax = plt.subplots(figsize=(14,10))
ax.plot(t,i,'grey')
ax.set_xlabel(r'$\tau$')
ax.set_ylabel(r'$I/I_c$')
ax.set_ylim(-1.05,1.05)
ax.set_title(f"$R = \\num{{{R:.2e}}}\:\si{{\ohm}},\:L = \\num{{{L:.2e}}}\:\si{{\henry}},$"+"\n"+f"$\:C = \\num{{{C:.2e}}}\:\si{{\\farad}}$",pad=20,multialignment='center')
plt.tight_layout()
fig.savefig(f"./figures/manual/{counter}")
counter +=1
#[l/5,l/5],
#[2*l/5,2*l/5],
#[3*l/5,3*l/5],
#[4*l/5,4*l/5],
#[l,l]
#])
dests = []
for i in arange(0.1*l, 1.1*l, 0.1*l):
dests.append([i,i])
dests = array(dests)
#dests = array(curvature(10))
for b in range(1, 11):
errs = []
for j in range(0,100):
print b, j
tmp = simulate(9, l, initial, pi/2, dests, 1.0,b,100)
errs.append(tmp[-1])
p.append(b)
avg_errors.append(average(errs))
max_errors.append(max(errs))
print b, avg_errors[-1], max_errors[-1]
print p
print avg_errors
print max_errors
def loadSimulateAnalyze(filename, simConfig=None, output=False):
sim.load(filename, simConfig)
sim.simulate()
sim.analyze()
def sequential_halving(students, arms, bound, log_file):
"""
Sequential Halving -- (Fixed Bound)
Parameters:
* let arms be an array of vectors, where each vector is a configuration
* bound is an integer which represents the maximum number of
arms pulls the algorithm is limited to find optimal arms with
** still unsure how we will set up our s, right now it is a list of
the array arms, which shrinks by half on each iteration
"""
# logging header
log_file.write("\n--- Sequential Halving ---\n")
s = list()
# add arms with initialized values to the list
inner_list = list()
for arm in arms:
s_arm = sim.LineConfig(arm[0], arm[1], arm[2], arm[3], arm[4])
s_arm.set_config_mu(students)
inner_list.append(s_arm)
s.append(inner_list)
# get the arm with the highest config_mu for comparison
actual_max = get_actual_max(s[0])
# set deltas
calculate_delta(s[0], actual_max)
# log all arms
logger.log_arms(log_file, s[0])
current_pulls = 0
# run through iterations of algorithm
for r in range(int(math.ceil(math.log(len(arms), 2)))):
# compute the pulls per arm per iteration
pulls_per_arm = int(math.floor(bound / (len(s[r])
* math.ceil(math.log(len(arms), 2)))))
current_pulls += pulls_per_arm + 1
# sample each arm pulls_per_arm times and average results
for i in range(len(s[r])):
total = 0.0
for j in range(pulls_per_arm):
s[r][i].set_num_pulls(s[r][i].get_num_pulls() + 1)
total += sim.simulate(s[r][i], students, log_file)
s[r][i].set_average(total/pulls_per_arm)
# sort the remaining arms by average from above sample
s[r].sort(key=operator.attrgetter('average'), reverse=False)
# create next iteration which the upper half of the sorted list
s.append(s[r][int(math.ceil(len(s[r])/2)):])
# log the current empirical best arm
logger.log_pulled_arm(log_file, s[r][len(s[r]) - 1], current_pulls)
arm = s[int(math.ceil(math.log(len(arms), 2)))][0]
logger.log_pulled_arm(log_file, arm, bound)
logger.log_best_arm(log_file, arm, bound)
for arm in s[0]:
logger.log_num_pulls(log_file, arm)
return arm
def lil_ucb(students, arms, delta, epsilon, lambda_p, beta, sigma, log_file,
max_pulls):
# delta == confidence
#
time = 0
n = len(arms)
mu = numpy.zeros(n) # set of rewards
T = numpy.zeros(n) # T[i] is the number of times arm i has been pulled
armList = list()
timestep = 0
for arm in arms:
s_arm = sim.LineConfig(arm[0], arm[1], arm[2], arm[3], arm[4])
s_arm.set_config_mu(students)
armList.append(s_arm)
# actual max used for comparison
actual_max = get_actual_max(armList)
# set deltas
calculate_delta(armList, actual_max)
#sample each of the n arms once, set T_i(t) = 1, for all i and set t=n
for i in range(n):
T[i] = 1
mu[i] = sim.simulate(armList[i], students, log_file) #pull the arm
log_file.write("ARM: %s\tCONFIGMU %s\tDELTA: %f\n" % (str(
armList[i]), armList[i].get_config_mu(), armList[i].get_delta()))
timestep += 1
prevIndex = -1
while True:
done = False
total_pulls = sum(T)
timestep += 1
for i in range(n):
#check if an arm has been pulled more than all others combined
print("t[i]: %d >= %d\n" % (T[i],
(1 + lambda_p * (total_pulls - T[i]))))
if T[i] >= 1 + lambda_p * (total_pulls - T[i]):
done = True
break
if done:
break
index = 0
upper_bound_value = 0
for i in range(n):
#temp is that magic value used to determine the best, next arm to pull
temp = math.sqrt((2 * sigma**2 * (1 + epsilon) *
math.log(math.log(
(1 + epsilon) * T[i]) / delta)) / T[i])
temp = mu[i] + (1 + beta) * (1 + math.sqrt(epsilon)) * temp
if (temp > upper_bound_value):
upper_bound_value = temp
index = i
T[index] += 1
reward = sim.simulate(armList[index], students, log_file)
mu[index] = ((T[index] - 1) * mu[index] +
reward) / T[index] #average the rewards
if (timestep % 100 == 0):
#log_file.write("ITERATION: %6d ARM: %s\tCONFIGMU: %f\tDELTA: %f\n" %(timestep, str(armList[index]), armList[index].get_config_mu(), armList[index].get_delta()))
empercial_best = max(mu)
best_arm_index = [
i for i, j in enumerate(mu) if j == empercial_best
]
best_arm = armList[best_arm_index[0]]
log_file.write(
"ITERATION: %6d\tBEST_ARM: %s\tCONFIG_MU: %f\tDELTA: %f\n" %
(timestep, str(best_arm), best_arm.get_config_mu(),
best_arm.get_delta()))
#prevIndex = index
if (timestep == max_pulls):
break
arm = armList[T.argmax()]
log_file.write("\nBEST ARM: %s\tCONFIG_MU: %f\tDELTA: %f\n" %
(str(arm), arm.get_config_mu(), arm.get_delta()))
for count, arm in enumerate(armList):
log_file.write("ARMPULLCOUNT: %s\t%d\n" % (str(arm), T[count]))
return armList[T.argmax()]
#[2*l/5,2*l/5],
#[3*l/5,3*l/5],
#[4*l/5,4*l/5],
#[l,l]
#])
dests = array(curvature(10))
#dests = []
#for i in arange(0.1*l, 1.1*l, 0.1*l):
# dests.append([i,i])
#dests = array(dests)
for n in range(0, 10):
errs = []
corrs=[]
for j in range(0,100):
print n,j
tmp = simulate(n, l, initial, pi/2, dests, 1.0,1,100,0.21)
errs.append(tmp[-1])
# corrs.append(tmp[-2])
p.append(n)
avg_errors.append(average(errs))
max_errors.append(max(errs))
#avg_corrs.append(average(corrs))
#max_corrs.append(max(corrs))
print n, avg_errors[-1], max_errors[-1]
print p
print avg_errors
print max_errors
#print avg_corrs
#print max_corrs
from pylab import * from sim import simulate from curve import curvature l = 10.0 #Destination dests = array(curvature(10)) #initial point initial = [0.0, 0.0] #stud mag without grid [x, y, gx, gy, corr, err] = simulate(0, l, initial, pi/2, dests, 1.0,1,100, c_mag = 1e-2,c_align=0) print err plot(x,y, 'black', label='High-res sensor', linewidth=2) #stud mag with grid [x, y, gx, gy, corr, err] = simulate(9, l, initial, pi/2, dests, 1.0,1,100, c_mag = 1e-2,c_align=0) print err plot(x,y, 'black', label='High-res sensor with Grid', linestyle='-.', linewidth=3) #hagga mag without grid [x, y, gx, gy, corr, err] = simulate(0, l, initial, pi/2, dests, 1.0, 1,100,c_mag = 1.5e-1,c_align=0) print err plot(x,y, 'gray', label='Low-res sensor', linewidth=2) #hagga mag with grid [x, y, gx, gy, corr, err] = simulate(9, l, initial, pi/2, dests, 1.0, 1,100,c_mag = 1.5e-1,c_align=0) print err plot(x,y, 'gray',label='Low-res sensor with Grid', linestyle='-.', linewidth=3)
])
start = np.array([0, .5])
#anca(start, goals)
#plt.show()
for thre in [np.pi / 4, np.pi / 4, np.pi / 8]:
f, (a1, a2) = plt.subplots(1,
2,
sharex=False,
sharey=False,
figsize=(9, 4))
(t, b, uh, ur) = sim.simulate(start,
goals,
0,
lazy(thre),
shared_sampled(lazylike(thre),
lazy(thre)),
prior=np.array([0.5, 0.5]))
print(uh)
visualize(a1, start, goals, trajectories=[t], u_hs=[uh], c="k")
(t, b1, uh, ur) = sim.simulate(start,
goals,
0,
lazy(thre),
active(lazylike(thre), lazy(thre), 100),
prior=np.array([0.2, 0.8]))
print(uh)
visualize(a2, start, goals, trajectories=[t], u_hs=[uh], c="r")
f, a = plt.subplots(1)
compare_beliefs(a, [b, b1], labels=["shared", "active"])
sim.simulate(filepath,
filedir,
f,
write,
analyze,
makefig,
diffuse,
antibunch,
pulsed,
numlines,
maxlines,
endtime,
temp,
concentration,
absXsec,
k_emission,
emwavelength,
bfrate,
r,
eta,
n,
accConc,
racc,
crashtransferprob,
tripem,
dftime,
reprate,
wavelength,
lp,
pulselength,
foclen,
NA,
darkcounts,
sensitivity,
deadtime,
afterpulse,
order,
mode,
gnpwr,
numbins,
pulsebins,
channels,
dopic=0,
normalize=normalize,
ac=10**4,
timestep=timestep,
units='ns')
def plotTraces (include = None, timeRange = None, overlay = False, oneFigPer = 'cell', rerun = False,
figSize = (10,8), saveData = None, saveFig = None, showFig = True):
'''
Plot recorded traces
- include (['all',|'allCells','allNetStims',|,120,|,'E1'|,('L2', 56)|,('L5',[4,5,6])]): List of cells for which to plot
the recorded traces (default: [])
- timeRange ([start:stop]): Time range of spikes shown; if None shows all (default: None)
- overlay (True|False): Whether to overlay the data lines or plot in separate subplots (default: False)
- oneFigPer ('cell'|'trace'): Whether to plot one figure per cell (showing multiple traces)
or per trace (showing multiple cells) (default: 'cell')
- rerun (True|False): rerun simulation so new set of cells gets recorded (default: False)
- figSize ((width, height)): Size of figure (default: (10,8))
- saveData (None|True|'fileName'): File name where to save the final data used to generate the figure;
if set to True uses filename from simConfig (default: None)
- saveFig (None|True|'fileName'): File name where to save the figure;
if set to True uses filename from simConfig (default: None)
- showFig (True|False): Whether to show the figure or not (default: True)
- Returns figure handles
'''
print('Plotting recorded cell traces ...')
if include is None: include = [] # If not defined, initialize as empty list
# rerun simulation so new include cells get recorded from
if rerun:
cellsRecord = [cell.gid for cell in sim.getCellsList(include)]
for cellRecord in cellsRecord:
if cellRecord not in sim.cfg.recordCells:
sim.cfg.recordCells.append(cellRecord)
sim.setupRecording()
sim.simulate()
colorList = [[0.42,0.67,0.84], [0.90,0.76,0.00], [0.42,0.83,0.59], [0.90,0.32,0.00],
[0.34,0.67,0.67], [0.90,0.59,0.00], [0.42,0.82,0.83], [1.00,0.85,0.00],
[0.33,0.67,0.47], [1.00,0.38,0.60], [0.57,0.67,0.33], [0.5,0.2,0.0],
[0.71,0.82,0.41], [0.0,0.2,0.5]]
tracesList = sim.cfg.recordTraces.keys()
tracesList.sort()
cells, cellGids, _ = getCellsInclude(include)
gidPops = {cell['gid']: cell['tags']['popLabel'] for cell in cells}
# time range
if timeRange is None:
timeRange = [0,sim.cfg.duration]
recordStep = sim.cfg.recordStep
figs = []
tracesData = []
# Plot one fig per cell
if oneFigPer == 'cell':
for gid in cellGids:
figs.append(figure()) # Open a new figure
fontsiz = 12
for itrace, trace in enumerate(tracesList):
if 'cell_'+str(gid) in sim.allSimData[trace]:
data = sim.allSimData[trace]['cell_'+str(gid)][int(timeRange[0]/recordStep):int(timeRange[1]/recordStep)]
t = arange(timeRange[0], timeRange[1]+recordStep, recordStep)
tracesData.append({'t': t, 'cell_'+str(gid)+'_'+trace: data})
color = colorList[itrace]
if not overlay:
subplot(len(tracesList),1,itrace+1)
color = 'blue'
plot(t[:len(data)], data, linewidth=1.5, color=color, label=trace)
xlabel('Time (ms)', fontsize=fontsiz)
ylabel(trace, fontsize=fontsiz)
xlim(timeRange)
if itrace==0: title('Cell %d, Pop %s '%(int(gid), gidPops[gid]))
if overlay:
maxLabelLen = 10
subplots_adjust(right=(0.9-0.012*maxLabelLen))
legend(fontsize=fontsiz, bbox_to_anchor=(1.04, 1), loc=2, borderaxespad=0.)
# Plot one fig per cell
elif oneFigPer == 'trace':
for itrace, trace in enumerate(tracesList):
figs.append(figure()) # Open a new figure
fontsiz = 12
for igid, gid in enumerate(cellGids):
if 'cell_'+str(gid) in sim.allSimData[trace]:
data = sim.allSimData[trace]['cell_'+str(gid)][int(timeRange[0]/recordStep):int(timeRange[1]/recordStep)]
t = arange(timeRange[0], timeRange[1]+recordStep, recordStep)
tracesData.append({'t': t, 'cell_'+str(gid)+'_'+trace: data})
color = colorList[igid]
if not overlay:
subplot(len(cellGids),1,igid+1)
color = 'blue'
ylabel(trace, fontsize=fontsiz)
plot(t[:len(data)], data, linewidth=1.5, color=color, label='Cell %d, Pop %s '%(int(gid), gidPops[gid]))
xlabel('Time (ms)', fontsize=fontsiz)
xlim(timeRange)
title('Cell %d, Pop %s '%(int(gid), gidPops[gid]))
if overlay:
maxLabelLen = 10
subplots_adjust(right=(0.9-0.012*maxLabelLen))
legend(fontsize=fontsiz, bbox_to_anchor=(1.04, 1), loc=2, borderaxespad=0.)
try:
tight_layout()
except:
pass
#save figure data
if saveData:
figData = {'tracesData': tracesData, 'include': include, 'timeRange': timeRange, 'oneFigPer': oneFigPer,
'saveData': saveData, 'saveFig': saveFig, 'showFig': showFig}
_saveFigData(figData, saveData, 'traces')
# save figure
if saveFig:
if isinstance(saveFig, str):
filename = saveFig
else:
filename = sim.cfg.filename+'_'+'traces.png'
savefig(filename)
# show fig
if showFig: _showFigure()
return figs
#dests = array([
#[l/5,l/5],
#[2*l/5,2*l/5],
#[3*l/5,3*l/5],
#[4*l/5,4*l/5],
#[l,l]
#])
#dests = array(curvature(10))
dests = []
for i in arange(0.1*l, 1.1*l, 0.1*l):
dests.append([i,i])
dests = array(dests)
for b in arange (10,110,10):
errs = []
for j in range(0,100):
print b, j
tmp = simulate(9, l, initial, pi/2, dests, 1.0,1,b)
errs.append(tmp[-1])
p.append(b)
avg_errors.append(average(errs))
max_errors.append(max(errs))
print b, avg_errors[-1], max_errors[-1]
print p
print avg_errors
print max_errors
l = 10.0
#Destination
dests = []
for i in arange(0.1*l, 1.1*l, 0.1*l):
dests.append([i,i])
dests = array(dests)
#initial point
initial = [0.0, 0.0]
err_range = arange(0, 0.11, 0.01)
print err_range
errs = []
for i in err_range:
[x, y, gx, gy, corr, err] = sim.simulate(9, l, initial, pi/2, dests, 1.0,1,100, c_slip=i)
errs.append(err)
print errs
errs = []
for i in err_range:
[x, y, gx, gy, corr, err] = sim.simulate(9, l, initial, pi/2, dests, 1.0,1,100, c_mag=i)
errs.append(err)
print errs
mesh = []
errs = []
for i in err_range:
for j in err_range:
mesh.append([i, j])
[x, y, gx, gy, corr, err] = monte.simulate(9, l, initial, pi/2, dests, 1.0,1,100, c_slip=i, c_mag=j)
#dests = array([ #[l/5,l/5], #[2*l/5,2*l/5], #[3*l/5,3*l/5], #[4*l/5,4*l/5], #[l,l] #]) dests = [] for i in arange(0.1*l, 1.1*l, 0.1*l): dests.append([i,i]) dests = array(dests) #initial point initial = [0.0, 0.0] #actual plot1 [x, y, gx, gy, corr, err] = simulate(0, l, initial, pi/2, dests, 1.0, 1, 100) print err plot(array(x)*10,array(y)*10, 'black', label='0 correction', linewidth=2) #actual plot2 [x, y, gx, gy, corr, err] = simulate(1, l, initial, pi/2, dests, 1.0, 1, 100) print err plot(array(x)*10,array(y)*10, 'green', label='1 correction', linewidth=2) #actual plot3 [x, y, gx, gy, corr, err] = simulate(2, l, initial, pi/2, dests, 1.0, 1, 100) print err plot(array(x)*10,array(y)*10, 'blue', label='2 corrections', linewidth=2) legend(loc=2) l *= 10 dests *= 10 gx *= 10
from pylab import *
from sim import simulate
a = []
avg_errors = []
max_errors = []
initial = [0.0, 0.0]
l = 10.0
for n in arange(0, (pi / 2) + 0.05, pi / 20):
errs = []
dests = array([[l * cos(n), l * sin(n)]])
for j in range(0, 10):
print n, j
tmp = simulate(10, l, initial, pi / 2, dests, 1.0)
errs.append(tmp[-1])
a.append(n)
avg_errors.append(average(errs))
max_errors.append(max(errs))
print n, avg_errors[-1], max_errors[-1]
print a
print avg_errors
print max_errors
numbins = 8192
pulsebins = (10**2)-1#should always be an odd number
channels = 2
#Miscellaneous simulation parameters
picyzoom = [-1,-1]
timestep = 1000000 #average number of photons per "round" of calculations
seq = 1
i = 0
f = filenames[0]
sim.simulate(filepath, filedir, f, write, analyze, makefig, diffuse, antibunch,
pulsed, numlines, maxlines, endtime,temp, concentration,
dabsXsec, labsXsec, k_demission, k_sem,
emwavelength, r,eta, n, k_tem, k_fiss, k_trans,
reprate, wavelength, laserpwr, pulselength, foclen,
NA, darkcounts, sensitivity, nligands, deadtime, afterpulse, order,
mode, gnpwr, numbins, pulsebins, channels, seq)
'''
for laserpwr in [0.005,0.0005,0.5]:
for concentration in [2*10**(-8),2*10**(-6),2*10**(-10)]:
i = i + 1
for sensitivity in [0.1,0.5,0.01]:
for k_demission in [1400000,15]:
for nligands in [100,1,10000]:
for diffuse in range(2):
f = filenames[0]
def loadSimulate(filename, simConfig=None, output=False):
import sim
sim.load(filename, simConfig)
sim.simulate()