def part_iii_evaluation(sim_filename):
print sim_filename
mdp = MDP("blank_2_actions_81_states_mdp.txt")
results = []
# prior: assume each transition seen once
transition_count = [[[0.1 for _ in range(81)] for _ in range(81)]
for _ in range(2)]
for n in range(10):
print "Big loop " + str(n)
results.append([])
for i in range(100):
mdp, transition_count = adp_rl(mdp, Sim(MDP(sim_filename)),
transition_count)
value_fn, policy, iterations = plan(mdp, 0.99, 0.01)
print "Value: " + str(value_fn)
print "Policy: " + str(policy)
#print "Reward: " + str(mdp.rewards)
#print "Transitions: " + str(mdp.transitions)
for i in range(100):
reward = run_policy(Sim(MDP(sim_filename)), policy)
results[n].append(reward)
print "Average reward of policy: " + str(average(results[n]))
for l in results:
print average(l)
def __init__(self, username=None, password=None, uni='145'):
self.uni = uni
self.username = username
self.password = password
self.logged_in = False
self._prepare_logger()
self._prepare_browser()
self.MAIN_URL = 'https://s%s-pl.ogame.gameforge.com/game/index.php' % self.uni
self.PAGES = {
'main': self.MAIN_URL + '?page=overview',
'resources': self.MAIN_URL + '?page=resources',
'station': self.MAIN_URL + '?page=station',
'research': self.MAIN_URL + '?page=research',
'shipyard': self.MAIN_URL + '?page=shipyard',
'defense': self.MAIN_URL + '?page=defense',
'fleet': self.MAIN_URL + '?page=fleet1',
'galaxy': self.MAIN_URL + '?page=galaxy',
'galaxyCnt': self.MAIN_URL + '?page=galaxyContent',
'events': self.MAIN_URL + '?page=eventList',
}
self.planets = []
self.moons = []
self.active_attacks = []
self.fleet_slots = 0
self.active_fleets = 0
self.transport_manager = TransportManager()
self.server_time = self.local_time = datetime.now()
self.time_diff = 0
self.sim = Sim()
def plot_range_for_velocity(v_min, v_max, step=500, save_to_file=None):
vx, vy_min, vy_max = [], [], []
for v in range(v_min, v_max, step):
# print v to indicate progress
print(v)
# run sim for desired velocity
sim = Sim(planet_name, capsule_name, 80000)
sim.set_v0(v)
rng = get_angle_range(sim, step=0.01)
if len(rng) > 0: # makes sure that even if it is impossible to land, the program won't crash after hours
# store data
vx.append(v)
vy_min.append(rng[0])
vy_max.append(rng[-1])
# plot
f, ax = plt.subplots(1)
ax.plot(vx, vy_min, 'bo')
ax.plot(vx, vy_max, 'ro')
plt.xlabel('$ v_0 $ [m/s]')
plt.ylabel('$ \phi_0 [°]$')
plt.title(r'Min and max $ \phi_0(v_0) $')
if save_to_file is not None:
plt.savefig(save_to_file)
plt.show()
def gemRun(reps):
taxMeans = []
taxSEs = []
p['verboseDebugging'] = False
p['singleRunGraphs'] = False
p['interactiveGraphics'] = False
dataFile = open('GEMSA data new.txt', 'a')
meansFile = open('GEMSA means new.txt', 'a')
outFile = open('GEMSA outputs new.txt', 'a')
# agingParentList = [ 0.0, 0.1, 0.2, 0.4 ]
# careProbList = [ 0.0004, 0.0008, 0.0012, 0.0016 ]
# retiredHoursList = [ 20.0, 30.0, 40.0, 60.0 ]
# retiredAgeList = [ 60.0 ]
# ageingParentList = [ 0.0, 0.1 ]
# careProbList = [ 0.0004 ]
# retiredHoursList = [ 20.0 ]
# retiredAgeList = [ 60.0 ]
for variableCare in p['ageingParentList']:
for variableProb in p['careProbList']:
for variableRetired in p['retiredHoursList']:
for variableAge in p['retiredAgeList']:
p['agingParentsMoveInWithKids'] = variableCare
p['personCareProb'] = variableProb
p['retiredHours'] = variableRetired
p['ageOfRetirement'] = variableAge
print "Trying parents-moving-in probability: ", variableCare
print "Trying person care probability: ", variableProb
print "Trying retired hours: ", variableRetired
print "Trying retirement age: ", variableAge
taxList = []
taxSum = 0.0
meansFile.write(
str(variableCare) + "\t" + str(variableProb) + "\t" +
str(variableRetired) + "\t" + str(variableAge) + "\n")
for i in range(0, reps):
print i,
s = Sim(p)
tax, seed = s.run()
taxList.append(tax)
taxSum += tax
print tax
dataFile.write(
str(seed) + "\t" + str(variableCare) + "\t" +
str(variableProb) + "\t" + str(variableRetired) +
"\t" + str(variableAge) + "\t" + str(tax) + "\n")
taxMeans.append(pylab.mean(taxList))
outFile.write(str(taxSum / reps) + "\n")
taxSEs.append(pylab.std(taxList) / math.sqrt(reps))
dataFile.close()
meansFile.close()
outFile.close()
def __init__(self, planets=None):
if planets is None:
planets = []
self.planets = planets
self.sim = Sim()
self.dest_planet = None
self.building = None
self.resources_needed = {'metal': 0, 'crystal': 0, 'deuterium': 0}
self.resources_sent = self.resources_needed
self.building_queue = set()
def multiprocessingSim(params):
# Create Sim instance
folderRun = params[0]['rootFolder'] + '/Rep_' + str(params[0]['repeatIndex'])
s = Sim(params[0]['scenarioIndex'], params[0], folderRun)
print''
print params[1]['policyIndex']
print''
s.run(params[1]['policyIndex'], params[1], params[1]['randomSeed'])
def sensitivityRun(runtype, ageingList, careList, retiredHList, retiredAList,
reps):
taxMeans = []
taxSEs = []
p['verboseDebugging'] = False
p['singleRunGraphs'] = False
p['interactiveGraphics'] = False
dataFile = open(runtype + ' GEMSA data.txt', 'a')
meansFile = open(runtype + ' GEMSA means.txt', 'a')
outFile = open(runtype + ' GEMSA outputs.txt', 'a')
# agingParentList = [ 0.0, 0.1, 0.2, 0.4 ]
# careProbList = [ 0.0004, 0.0008, 0.0012, 0.0016 ]
# retiredHoursList = [ 20.0, 30.0, 40.0, 60.0 ]
# retiredAgeList = [ 60.0 ]
# ageingParentList = [ 0.0, 0.1 ]
# careProbList = [ 0.0004 ]
# retiredHoursList = [ 20.0 ]
# retiredAgeList = [ 60.0 ]
for run in xrange(len(ageingList)):
p['agingParentsMoveInWithKids'] = ageingList[run]
p['personCareProb'] = careList[run]
p['retiredHours'] = retiredHList[run]
p['ageOfRetirement'] = retiredAList[run]
print "Trying parents-moving-in probability: ", ageingList[run]
print "Trying person care probability: ", careList[run]
print "Trying retired hours: ", retiredHList[run]
print "Trying retirement age: ", retiredAList[run]
taxList = []
taxSum = 0.0
meansFile.write(
str(ageingList[run]) + "\t" + str(careList[run]) + "\t" +
str(retiredHList[run]) + "\t" + str(retiredAList[run]) + "\n")
for i in range(0, reps):
print i,
s = Sim(p)
tax, seed = s.run()
taxList.append(tax)
taxSum += tax
print tax
dataFile.write(
str(seed) + "\t" + str(ageingList[run]) + "\t" +
str(careList[run]) + "\t" + str(retiredHList[run]) + "\t" +
str(retiredAList[run]) + "\t" + str(tax) + "\n")
taxMeans.append(pylab.mean(taxList))
outFile.write(str(taxSum / reps) + "\n")
taxSEs.append(pylab.std(taxList) / math.sqrt(reps))
dataFile.close()
meansFile.close()
outFile.close()
def batchRun(num):
p['interactiveGraphics'] = False
dataFile = open('batchRunData.txt', 'w')
for i in range(0, num):
print "Doing batch run: ", i
taxList = []
s = Sim(p)
tax = s.run()
taxList.append(tax)
print "Social care cost per taxpayer: ", tax
dataFile.write(str(i) + "\t" + str(tax) + "\n")
dataFile.close()
def run_a_sim(run_id):
logging.debug('**** Starting run {}'.format(run_id))
sim = Sim(TRIBUTE_COUNT)
while not sim.game_over():
sim.epoch()
logging.debug('**** Ending run {}'.format(run_id))
output = {
'run_id': run_id,
'tributes': sim.compressed_result(),
'ticks': sim.ticks
}
return output
def part_ii_evaluation():
random_results_1 = []
safe_results_1 = []
range_results_1 = []
random_results_2 = []
safe_results_2 = []
range_results_2 = []
for i in range(1000):
print i
random_results_1.append(
random_policy(Sim(MDP("parking_mdp_linear_rewards_n_10.txt"))))
random_results_2.append(
random_policy(Sim(MDP("parking_mdp_quad_rewards_n_10.txt"))))
safe_results_1.append(
safe_policy(Sim(MDP("parking_mdp_linear_rewards_n_10.txt")), 0.5))
safe_results_2.append(
safe_policy(Sim(MDP("parking_mdp_quad_rewards_n_10.txt")), 0.5))
range_results_1.append(
range_policy(Sim(MDP("parking_mdp_linear_rewards_n_10.txt")), 2,
8))
range_results_2.append(
range_policy(Sim(MDP("parking_mdp_quad_rewards_n_10.txt")), 2, 6))
print average(random_results_1)
print average(safe_results_1)
print average(range_results_1)
print average(random_results_2)
print average(safe_results_2)
print average(range_results_2)
def sensitivityLarge(runtype, input_list, reps):
taxMeans = []
taxSEs = []
p['verboseDebugging'] = False
p['singleRunGraphs'] = False
p['interactiveGraphics'] = False
outFile = open(runtype + ' GEMSA outputs large.txt', 'a')
for run in xrange(len(input_list[0])):
print("Running simulation number {}...".format(run))
print("Number of reps: {}".format(reps))
sim_list = np.array(input_list)
print(sim_list)
p['agingParentsMoveInWithKids'] = sim_list[0, run]
print(p['agingParentsMoveInWithKids'])
p['personCareProb'] = sim_list[1, run]
p['retiredHours'] = sim_list[2, run]
p['ageOfRetirement'] = sim_list[3, run]
p['baseDieProb'] = sim_list[4, run]
p['babyDieProb'] = sim_list[5, run]
p['personCareProb'] = sim_list[6, run]
p['maleAgeCareScaling'] = sim_list[7, run]
p['femaleAgeCareScaling'] = sim_list[8, run]
p['childHours'] = sim_list[9, run]
p['homeAdultHours'] = sim_list[10, run]
p['workingAdultHours'] = sim_list[11, run]
p['lowCareHandicap'] = sim_list[12, run]
p['growingPopBirthProb'] = sim_list[13, run]
p['basicDivorceRate'] = sim_list[14, run]
p['variableDivorce'] = sim_list[15, run]
p['basicMaleMarriageProb'] = sim_list[16, run]
p['basicFemaleMarriageProb'] = sim_list[17, run]
p['probApartWillMoveTogether'] = sim_list[18, run]
p['coupleMovesToExistingHousehold'] = sim_list[19, run]
p['basicProbAdultMoveOut'] = sim_list[20, run]
p['variableMoveBack'] = sim_list[21, run]
taxList = []
taxSum = 0.0
for i in range(0, reps):
print i,
s = Sim(p)
tax, seed = s.run()
taxList.append(tax)
taxSum += tax
print tax
taxMeans.append(pylab.mean(taxList))
outFile.write(str(taxSum / reps) + "\n" + str(seed) + "\n")
taxSEs.append(pylab.std(taxList) / math.sqrt(reps))
outFile.close()
def __init__(self):
self.sim = Sim()
pygame.init()
pygame.font.init()
self.screen = pygame.display.set_mode((G.screenWidth, G.screenHeight))
pygame.display.set_caption("AntBridgeSim")
self.clock = pygame.time.Clock()
self.setupButtons()
self.drawGrid()
for button in self.buttons:
button.draw(self.screen)
oldpos = self.sim.ant.pos
oldId = self.sim.antId
dead = None
while G.running:
time.sleep(G.sleep)
self.eventHandler()
self.drawBlock(self.sim.ant.pos)
self.drawJoint(self.sim.ant.pos)
self.drawBlock(oldpos)
self.drawJoint(oldpos)
oldpos = self.sim.ant.pos
if self.sim.antId != oldId:
oldId = self.sim.antId
self.drawGrid()
self.drawJoints() #TODO incrementally draw
pygame.display.flip()
if not dead:
try:
if not self.sim.step():
break
except Error as e:
print e
dead = True
except Success as e:
print e
dead = True
else:
paused = True
while paused:
for event in pygame.event.get():
if event.type == pygame.QUIT:
paused = False
G.running = False
def test_sim(do_plot=False):
mesh = df.BoxMesh(0, 0, 0, 2, 2, 2, 1, 1, 1)
sim = Sim(mesh, 8.6e5, unit_length=1e-9)
alpha = 0.1
sim.alpha = alpha
sim.set_m((1, 0, 0))
sim.set_up_solver()
H0 = 1e5
sim.add(Zeeman((0, 0, H0)))
exchange = Exchange(13.0e-12)
sim.add(exchange)
dt = 1e-12
ts = np.linspace(0, 500 * dt, 100)
precession_coeff = sim.gamma / (1 + alpha**2)
mz_ref = []
mz = []
real_ts = []
for t in ts:
sim.run_until(t)
real_ts.append(sim.t)
mz_ref.append(np.tanh(precession_coeff * alpha * H0 * sim.t))
mz.append(sim.m[-1]) # same as m_average for this macrospin problem
mz = np.array(mz)
if do_plot:
ts_ns = np.array(real_ts) * 1e9
plt.plot(ts_ns, mz, "b.", label="computed")
plt.plot(ts_ns, mz_ref, "r-", label="analytical")
plt.xlabel("time (ns)")
plt.ylabel("mz")
plt.title("integrating a macrospin")
plt.legend()
plt.savefig(os.path.join(MODULE_DIR, "test_sllg.png"))
print("Deviation = {}, total value={}".format(np.max(np.abs(mz - mz_ref)),
mz_ref))
assert np.max(np.abs(mz - mz_ref)) < 8e-7
def main():
# Create first generation
pool = Pop(size_gen)
# Step through generations
for _ in range(num_gen):
# initialize data histogram for sim visualization
hist = Data()
terrain = Terrain(400, 4)
# create pybox2d dynamic bodies based on individual's gene
gen = [Biped(pool.population[i].name, pool.population[i].gene)
for i in range(size_gen)]
for k, biped in enumerate(gen):
# specify terrain and biped to race
race = Sim(terrain, biped)
if not hist.terrain:
hist.set_terrain(terrain)
# run simulation without visualization
score, bb, time = race.run(1e4)
# store sim data and fitness evaluation
pool.population[k].fitness = score
hist.timelines[biped.name] = race.history.timelines['timeline']
# resort gene pool
pool.population = list(
sorted(pool.population, key=lambda x: x.fitness))
# visualize top bipeds' simulations
shown = pool.population[-num_shown:]
timelines = [s.name for s in shown]
view.start()
view.run(hist, timelines, speed=3)
# evolve gene pool
pool.evolve()
def parse(path):
with open(path, 'r') as f:
replay = json.load(f)
size = replay['mapHeight'] * replay['mapWidth']
tiles = [const.EMPTY] * size
for x in replay['mountains']:
tiles[x] = const.MOUNTAIN
armies = [0] * size
for x, n in zip(replay['cities'], replay['cityArmies']):
armies[x] = n
for i, x in enumerate(replay['generals']):
armies[x] = 1
tiles[x] = i
sim = Sim(replay['mapWidth'],
replay['mapHeight'],
replay['generals'],
replay['cities'],
tiles,
armies)
num_players = len(replay['generals'])
turns = max(move['turn'] for move in replay['moves']) + 1 if replay['moves'] else 0
moves = [{i: (-1, -1, False, False)
for i in range(num_players)}
for _ in range(turns)]
for move in replay['moves']:
turn = move['turn']
player = move['index']
moves[turn][player] = move['start'], move['end'], move['is50'], False
for afk in replay['afks']:
player = afk['index']
turn = afk['turn'] + 50
if turn < len(moves):
moves[turn][player][-1] = True
return sim, moves
def retireRun(reps):
taxMeans = []
taxSEs = []
p['verboseDebugging'] = False
p['singleRunGraphs'] = False
p['interactiveGraphics'] = False
dataFile = open('retirementAgeData2.txt', 'w')
#p['ageingParentList'] = [50, 55, 65, 70, 75, 80]
for variableCare in p['ageingParentList']:
p['ageOfRetirement'] = variableCare
print "Trying retirement age: ", variableCare
taxList = []
for i in range(0, reps):
print i,
s = Sim(p)
tax = s.run()
taxList.append(tax)
print tax
dataFile.write(
str(variableCare) + "\t" + str(i) + "\t" + str(tax) + "\n")
taxMeans.append(pylab.mean(taxList))
taxSEs.append(pylab.std(taxList) / math.sqrt(reps))
dataFile.close()
indices1 = pylab.arange(len(p['ageingParentList']))
taxFig = pylab.figure()
taxBar = taxFig.add_subplot(1, 1, 1)
taxBar.bar(indices1,
taxMeans,
facecolor='red',
align='center',
yerr=taxSEs,
ecolor='black')
taxBar.set_ylabel('Mean social care cost per taxpayer')
taxBar.set_xlabel('Age of retirement')
taxBar.set_xticks(indices1)
taxBar.set_xticklabels(p['ageingParentList'])
pylab.savefig('retirementAgeRunSet1.pdf')
pylab.show()
def sensitivityTenParams(runtype, input_list, reps):
taxMeans = []
taxSEs = []
p['verboseDebugging'] = False
p['singleRunGraphs'] = False
p['interactiveGraphics'] = False
outFile = open(runtype + ' GEMSA outputs.txt', 'a')
for run in xrange(len(input_list[0])):
print("Running simulation number {}...".format(run))
print("Number of reps: {}".format(reps))
sim_list = np.array(input_list)
print(sim_list)
p['agingParentsMoveInWithKids'] = sim_list[0, run]
p['baseCareProb'] = sim_list[1, run]
p['retiredHours'] = sim_list[2, run]
p['ageOfRetirement'] = sim_list[3, run]
p['personCareProb'] = sim_list[4, run]
p['maleAgeCareScaling'] = sim_list[5, run]
p['femaleAgeCareScaling'] = sim_list[6, run]
p['childHours'] = sim_list[7, run]
p['homeAdultHours'] = sim_list[8, run]
p['workingAdultHours'] = sim_list[9, run]
taxList = []
taxSum = 0.0
for i in range(0, reps):
print i,
s = Sim(p)
tax, seed = s.run()
taxList.append(tax)
taxSum += tax
print tax
taxMeans.append(pylab.mean(taxList))
outFile.write(str(taxSum / reps) + "\t" + str(seed) + "\n")
taxSEs.append(pylab.std(taxList) / math.sqrt(reps))
outFile.close()
def solve_w_SharedArray(model, sol_init, Nsteps, dt, Nspm, processes=None):
try:
shm_y = SharedArray.create("shm://y", [sol_init.y.shape[0], Nspm],
dtype=float)
shm_t = SharedArray.create("shm://t", [Nspm], dtype=float)
shm_i_app = SharedArray.create("shm://i_app", [Nspm], dtype=float)
except:
SharedArray.delete("shm://y")
SharedArray.delete("shm://t")
SharedArray.delete("shm://i_app")
shm_y = SharedArray.create("shm://y", [sol_init.y.shape[0], Nspm],
dtype=float)
shm_t = SharedArray.create("shm://t", [Nspm], dtype=float)
shm_i_app = SharedArray.create("shm://i_app", [Nspm], dtype=float)
i_app = 1.0
for i in range(Nspm):
shm_y[:, i] = sol_init.y[:, -1]
shm_t[i] = 0.0
shm_i_app[i] = i_app * (1 + (i + 1) / Nspm)
time = 0
tstep = 0
end_time = Nsteps * dt
while time < end_time:
work = [Sim(model, sol_init, dt, ind, tstep) for ind in range(Nspm)]
with ProcessPoolExecutor() as ex:
ex.map(shm_step, work)
ex.shutdown(wait=True)
time += dt
tstep += 1
y = copy_array(shm_y)
t = copy_array(shm_t)
SharedArray.delete("shm://y")
SharedArray.delete("shm://t")
SharedArray.delete("shm://i_app")
return y, t
def __init__(self, username, password, server):
self.username = username
self.password = password
self.logged_in = False
self._prepare_logger()
self._prepare_browser()
farms = options['farming']['farms']
self.farm_no = randint(0, len(farms) - 1) if farms else 0
self.MAIN_URL = 'http://labdcc.fceia.unr.edu.ar/~jgalat/game.php'
server = server.replace('http://', '')
if server[-1] == '/':
server = server[:-1]
self.MAIN_URL = 'http://' + server + '/game.php'
self.PAGES = {
'main': self.MAIN_URL + '?page=overview',
'buildings': self.MAIN_URL + '?page=buildings',
'station': self.MAIN_URL + '?page=station',
'research': self.MAIN_URL + '?page=buildings&mode=research',
'shipyard': self.MAIN_URL + '?page=buildings&mode=fleet',
'defense': self.MAIN_URL + '?page=defense',
'fleet': self.MAIN_URL + '?page=fleet',
'galaxy': self.MAIN_URL + '?page=galaxy',
'galaxyCnt': self.MAIN_URL + '?page=galaxyContent',
'events': self.MAIN_URL + '?page=eventList',
}
self.planets = []
self.moons = []
self.active_attacks = []
self.fleet_slots = 0
self.active_fleets = 0
self.server_time = self.local_time = datetime.now()
self.time_diff = 0
self.emergency_sms_sent = False
self.transport_manager = TransportManager()
self.sim = Sim()
def __init__(self, username=None, password=None, uni='69'):
self.uni = uni
self.username = username
self.password = password
self.logged_in = False
self._prepare_logger()
self._prepare_browser()
farms = options['farming']['farms']
self.farm_no = randint(0, len(farms) - 1) if farms else 0
self.MAIN_URL = 'https://s%s-%s.ogame.gameforge.com/game/index.php' % (
self.uni, options['credentials']['server'])
self.PAGES = {
'main': self.MAIN_URL + '?page=overview',
'resources': self.MAIN_URL + '?page=resources',
'station': self.MAIN_URL + '?page=station',
'research': self.MAIN_URL + '?page=research',
'shipyard': self.MAIN_URL + '?page=shipyard',
'defense': self.MAIN_URL + '?page=defense',
'fleet': self.MAIN_URL + '?page=fleet1',
'galaxy': self.MAIN_URL + '?page=galaxy',
'galaxyCnt': self.MAIN_URL + '?page=galaxyContent',
'events': self.MAIN_URL + '?page=eventList',
'resSettings': self.MAIN_URL + '?page=resourceSettings',
}
self.planets = []
self.moons = []
self.active_attacks = []
self.fleet_slots = 0
self.active_fleets = 0
self.server_time = self.local_time = datetime.now()
self.time_diff = 0
self.emergency_sms_sent = False
self.transport_manager = TransportManager()
self.sim = Sim()
fSeed = int(metaParams['favouriteSeed'])
if metaParams['multiprocessing'] == False or parametersFromFiles == False:
for r in range(numRepeats):
# Create Run folders
folderRun = folder + '/Rep_' + str(r)
if not os.path.exists(folderRun):
os.makedirs(folderRun)
# Set seed
seed = fSeed
if r > 0:
seed = int(time.time() / (r + 1))
for i in range(len(scenariosParams)):
n = OrderedDict(scenariosParams[i])
s = Sim(i, n, folderRun)
for j in range(len(policiesParams[i])):
p = OrderedDict(policiesParams[i][j])
s.run(j, p, seed) # Add policy paramters later
else:
processors = int(metaParams['numberProcessors'])
if processors > multiprocessing.cpu_count():
processors = multiprocessing.cpu_count()
pool = multiprocessing.Pool(processors)
# Create a list of dictionaries (number repetitions times number of scenarios), adding repeat index for folders' creation
params = multiprocessParams(scenariosParams, policiesParams,
metaParams['numRepeats'], fSeed, folder, 0)
pool.map(multiprocessingSim, params)
pool.close()
# toggle variables
self._holding = False
self._last_buy_price = None
self._last_buy_time = None
def pnl(self):
return sum([(x.sell_price - x.buy_price) * x.amount
for x in self._txs])
def transactions(self):
return self._txs
if __name__ == '__main__':
fname = './data/eth_usdt_med.csv'
sim = Sim(fname)
sim_iters = 50000
buy_len = 3
sell_len = 2
limit = 0.01 # amount to buy
trader = SimpleTrader(buy_len, sell_len, limit)
done = False
for i in range(sim_iters):
exchange_data, done = sim.step()
if done:
break
trader.act(exchange_data)
p['popY'] = 50
p['pixelsInPopPyramid'] = 2000
p['careLevelColour'] = ['blue', 'green', 'yellow', 'orange', 'red']
p['houseSizeColour'] = ['brown', 'purple', 'yellow']
p['pixelsPerTown'] = 56
p['maxTextUpdateList'] = 22
return p
p = init_params()
#######################################################
## A basic single run
s = Sim(p)
tax = s.run()
##runs for sensitivity analysis using GEM-SA
##taxMeans = []
##taxSEs = []
##
##p['verboseDebugging'] = False
##p['singleRunGraphs'] = False
##p['interactiveGraphics'] = False
##
##dataFile = open('GEMSA data new.txt','a')
##meansFile = open('GEMSA means new.txt', 'a')
##
##agingParentList = [ 0.0, 0.1, 0.2, 0.4 ]
##careProbList = [ 0.0004, 0.0008, 0.0012, 0.0016 ]
def __init__(self, numRuns, output):
# desired statistics
antsPerRun = 0
successfulRuns = 0
failedRuns = 0
maxHeightAchieved = 0
heightPerRun = 0
success = True
if output is not None:
outfile = open(output, "w")
G.outfile = outfile
for i in range(numRuns):
if G.verbose:
print >> G.outfile, "RUNNING BATCH " + str(i + 1)
print "RUNNING BATCH " + str(i + 1)
try:
self.sim = Sim()
while G.running:
if not self.sim.step():
break
G.running = True
except Error as e:
if G.verbose:
print e
success = None
except Success as s:
if G.verbose:
print s
# accumulate statistics
heightPerRun += self.sim.maxHeight + 1
if self.sim.maxHeight > maxHeightAchieved:
maxHeightAchieved = self.sim.maxHeight
if success:
antsPerRun += self.sim.numAnts
successfulRuns += 1
else:
failedRuns += 1
success = True
#sanity check
if numRuns != successfulRuns + failedRuns:
raise WeirdError("Runs weren't counted right... weird!")
# summarize statistics
statsString = "Ran a batch of " + str(numRuns) \
+ " simulations. "
if successfulRuns != 0:
statsString += "\n Average Ants To Complete a Bridge: " \
+ str(float(antsPerRun) / float(successfulRuns))
statsString += "\n Percentage of Successful Runs: " \
+ str(float(successfulRuns) * 100.0 / float(numRuns)) \
+ "%" \
+ "\n Average Height of Bridges Built: " \
+ str(float(heightPerRun) / float(numRuns)) \
+ "\n Maximum Height of Bridges Built: " \
+ str(maxHeightAchieved + 1)
print >> G.outfile, statsString
)[0] - 8 # Note: this is 8+payload length. The 8 bytes are the beginning of the UDP packet: source port, dest port, length, and checksum
# In the SafeUDP section
safeudp_pre = struct.unpack(
'!LHH', bytes[42:50]
) #sequence (4 bytes => uint), packet type (2 bytes => ushort), safeudp payload length (2 bytes => ushort)
safeudp_seq = safeudp_pre[0]
safeudp_packet_type = safeudp_pre[1]
safeudp_payload_length = safeudp_pre[2]
return
return "Dest port: {}, SafeUDP Pre: {}".format(dest_port, safeudp_pre)
def payload_from_eth2(cls, byte_sequence, length):
#bytes = b"".join(map(chr, byte_sequence[0:length]))
return byte_sequence[50:length]
if __name__ == "__main__":
from sim import Sim
config = Config()
config.loadfile("conf/sim_config.yaml")
sim = Sim(config.sim)
#print config.sim.networking
PodComms(sim, config.sim.networking)
names = ('max', 'quad', 'hash')
for cols, name in zip(all_cols, names):
R_min_data = find_R_mins(self.R_data, cols)
the_min_idx = R_min_data['Lowest R'].idxmin()
minimum_R[name] = tuple(R_min_data[['Lowest R',
'Mode']].iloc[the_min_idx])
return minimum_R
if __name__ == '__main__':
import numpy
#Create a Simulation object composed of a laminate.
sim = Sim(laminate=Laminate(
'0_2/p25/0_2s',
materialID=5, #5
core_thick=0.01))
#Define and apply load
P = Q_(1000, 'N')
b = Q_(0.11, 'm')
L = Q_(0.51, 'm')
M1 = -P * L / (4 * b)
N1 = 0.5 * P / b
M = Q_([M1.magnitude, 0, 0], M1.units)
N = Q_([N1.magnitude, 0, 0], N1.units)
#Apply load
sim.apply_M(M)
sim.apply_N(N)
sim.solve()
fail = FailureAnalysis(sim)
R_data = fail.make_table()
if save_to_file is not None:
plt.savefig(save_to_file)
plt.show()
# check for arguments
if len(sys.argv) < 3:
print('Please provide planet and capsule name.')
exit(1)
planet_name, capsule_name = sys.argv[1:3]
# init simulation environments
# basic = Sim(planet_name, capsule_name, 80000, ignore_buoyancy=True)
realistic = Sim(planet_name, capsule_name, 80000)
# basic_range = get_angle_range(basic, step=0.01)
realistic_range = get_angle_range(realistic, step=0.01)
# print(range_to_tex_table(basic_range, basic, step=0.2))
# print()
# print(range_to_tex_table(realistic_range, realistic, step=0.2))
# draw scheme
realistic.draw_scheme(4.15, 'planet', save_to_file='4_15_scheme.pdf')
# realistic.plot_height_over_time(5.8, save_to_file='5_8_height.pdf')
# realistic.plot_height_over_x(5.8, save_to_file='5_8_height_over_x.pdf')
# realistic.plot_velocity_over_time(5.8, save_to_file='5_8_velocity.pdf')
# plot range for initial velocities
from ibvs import IBVS
from util import rigid_tf
from scipy.spatial.distance import cdist
VOTE_THRESHOLD = 5
CAM_WIDTH = 450 # pixels
CAM_HEIGHT = 450 # pixels
CAM_CLOSEST = 0.1 # meters
CAM_FARTHEST = 8.0 # meters
CONSTELLATION_SIZE = 5 # number of points
X_HASH_SIZE = 15. # meters
Y_HASH_SIZE = 15. # meters
Z_HASH_SIZE = 1. # meters
sim = Sim(headless=True)
finder = FeatureFinder()
# Intel camera configuration:
# ibvs = IBVS(np.array([800, 450]), 1280, 1204, 0.0000014)
# Sim camera configuration:
ibvs = IBVS(
np.array([CAM_WIDTH / 2., CAM_HEIGHT / 2.]), 543.19, 543.19, 0.001)
start = time.time()
prev_root_pnt = None
# Geometric hashing for constellation
constellation = GeoHasher((X_HASH_SIZE, Y_HASH_SIZE, Z_HASH_SIZE),
VOTE_THRESHOLD,
CONSTELLATION_SIZE)
def main():
parser = argparse.ArgumentParser(description='Placement')
parser.add_argument("-c",
"--config",
help="path to config file",
default="")
parser.add_argument("-i", "--input", help="path to data file", default="")
parser.add_argument("-d",
"--debug",
help="debug mode",
action="store_const",
dest="loglevel",
const=logging.DEBUG,
default=logging.WARNING)
parser.add_argument("-p",
"--pickle",
help="create pickle files",
action="store_true",
dest="create_pickle")
parser.add_argument("-v",
"--verbose",
help="verbose mode",
action="store_const",
dest="loglevel",
const=logging.INFO)
args = parser.parse_args(sys.argv[1:])
logging.basicConfig(format='%(asctime)s main: %(message)s',
level=args.loglevel)
config = pandas.read_csv(args.config, sep=',')
X = pandas.read_csv(args.input, sep=',',
header=None).values.astype(np.float64)
"""
discretize the space into cells
"""
geo_utils = helpers.GeoUtilities(config['lat_min'].iloc[0],
config['lat_max'].iloc[0],
config['lng_min'].iloc[0],
config['lng_max'].iloc[0],
cell_length_meters)
geo_utils.set_grids()
"""
segregate data based on time bins
"""
train_time_utils = helpers.TimeUtilities(time_bin_width_secs)
train_time_utils.set_bounds(X)
logging.info("Loaded %d data points", len(X))
sim = Sim(X, len(geo_utils.lng_grids), train_time_utils, geo_utils,
action_dim, time_bins_per_hour)
"""
starting time-step for training and testing time bins (tb)
"""
test_tb_starts = [time_bins_per_hour]
train_tb_starts = [
time_bins_per_day * 4 + time_bins_per_hour,
time_bins_per_day * 5 + time_bins_per_hour,
time_bins_per_day * 6 + time_bins_per_hour
]
train_bins = range(time_bins_per_day * 4 + time_bins_per_hour,
time_bins_per_day * 7, time_bins_per_day)
if args.create_pickle:
helpers.load_create_pickle(sim, train_time_utils, geo_utils, X,
train_tb_starts, test_tb_starts)
with open(r"rrs.pickle", "rb") as input_file:
sim.rrs = cPickle.load(input_file)
sim.n_reqs = cPickle.load(input_file)
sim.pre_sim_pickups = cPickle.load(input_file)
with tf.Session() as sess:
worker = Worker('worker', sim, 10, train_bins, test_tb_starts,
sim.num_cells, sim.n_actions)
sess.run(tf.global_variables_initializer())
worker.train(sess)
"""
model = A2C(sim, 10,
train_windows, test_window,
sim.num_cells,
sim.n_actions, hidden_units)
model.train()
"""
'''
t_sim_end = 60 # sec
sampling_rate = 100 # Hz
N = t_sim_end * sampling_rate + 1
time = np.linspace(0, t_sim_end, num=N)
''' Define flight plan as below '''
wpt_list = np.array([20., 0., 20., 800.])
wpt_arr = np.ndarray(shape=(2, 2), dtype=float, buffer=wpt_list)
''' Define simulation components '''
sys = System(phi=phi_init, psi=0, use_jac=True)
env = Env(wind_dir_to=np.deg2rad(120), wind_spd=13)
fpl = FlightPlan(wpt_arr)
ac = Aircraft(fpl)
''
sim = Sim(ac, sys, env, time, verbose=False)
#sim.override_roll(np.deg2rad(40))
sim.run_simulation()
fig1 = plt.figure()
wp = ac.flight_plan.wpt_arr
plt.plot(sim.logs['S_x'][:-2], sim.logs['S_y'][:-2], wp[:, 0], wp[:, 1], 'ro',
wp[:, 0], wp[:, 1], 'r')
# plt.plot(time[:-2], sim.logs['x'][:-2])
plt.grid()
plt.title("Trajectory")
plt.xlabel("x [m]")
plt.ylabel("y [m]")
ax1 = fig1.gca()
dr.set_1to1_scale(ax1)
