def test_multiple_dimensions(self):
'''Simulator: Running a multidimensional simulator returns the correct result.'''
simulator = Simulator({(0, .3): 1.0, (.3, .7): 0, (.7, 1): -1.0}, 3, 3, seed=1234)
self.assertTrue(np.array_equal(simulator.run(), np.array(
[[1, 0, 0],
[-1, -1, 1],
[1, -1, -1]]
)))
def __init__(self, parent = None):
QDialog.__init__(self, parent)
self.setupUi(self)
self.simulator=Simulator()
self.displaytext = ''
self.thread1 = Thread()
self.thread2 = Thread()
self.opentxt=None
self.savetxt=None
self.loadyet = False
self.terminateFlag = False
self.connect(self.thread1, SIGNAL("next()"), self.step)
self.connect(self.thread1, SIGNAL("terminate()"), self.terminate)
self.connect(self.loadButton,SIGNAL("clicked()"),self.openFile)
self.connect(self.saveButton,SIGNAL("clicked()"),self.saveFile)
self.connect(self.runButton,SIGNAL("clicked()"),self.run)
self.connect(self.pauseButton,SIGNAL("clicked()"),self.pause)
#self.connect(self.begin,SIGNAL("clicked()"),self.loadFile)
self.connect(self.stepButton,SIGNAL("clicked()"),self.step)
self.connect(self.backButton,SIGNAL("clicked()"),self.back)
self.connect(self.resetButton,SIGNAL("clicked()"),self.reset)
self.frequency.setText('2.0s')
highlighter.MyHighlighter1( self.Code, 'Classic' )
highlighter.MemoryHighlighter( self.Memory, 'Classic' )
highlighter.CacheHighlighter(self.Cache, 'Classic')
def S_c(c): from Simulator import * import numpy as np s = Simulator(50000, 5.0e-3, c) s.trajectory() #s.draw_trajectory() #s.draw_energy() #m = s.force_dipole() #print m #c = s.correlation(10000) #print c t,x = s.correlation_spectrum(110.0,100) spec = s.correlation_integral(100.0,t,x) return spec
def runRoutesOverDays(s, dates, routesFile):
messageLimit = 10
warningLimit = 10
rawInstructions = Serialization.loadInstructionsFromFile(routesFile)
# if Array.length parseWarnings > 0 then
# printfn "%d instruction parse warnings" (Array.length parseWarnings)
routes = InstructionParser.ConvertRawInstructions(s.projection, rawInstructions)
flightCountsAndCosts = {}
for date in dates:
# weather = s.weather[date]
flights = s.flights[date]
airports = s.airports #.[date]
airspace = s.airspace[date]
print "Simulating " + str(date)
# airports = None
# print routes
# raw_input('routes')
weather = None
results = Simulator.simulateFlights(s.simulationParameters,
airports,
airspace,
weather,
flights,
routes)
# return a map of FlightId to
# print results
# raw_input('next')
# countArrived = [ x.ReachedDestination for x in results]
# cost = [x.Cost for x in results]
flightCosts = {}
cost = []
countArrived = 0
for k, v in results.iteritems():
flightCosts[k] = v['CostDetail']
countArrived += 1 if v['ReachedDestination'] else 0
cost.append(v['Cost'])
print 'countArrived'
print countArrived
print 'cost'
print cost
flightCountsAndCosts[date] = {
'date' : date,
'flightCount' : countArrived,
'meanCost' : sum(cost) / len(cost),
#flightLogs = logs
'flightCosts' : flightCosts
}
return flightCountsAndCosts
def reset(self):
self.thread1.terminate()
self.simulator=Simulator()
self.loadFile()
for item in [self.ZF, self.SF, self.OF,
self.F_stat, self.F_predPC,
self.D_stat,self.D_icode,self.D_ifun, self.D_rA, self.D_rB, self.D_valC, self.D_valP,
self.E_stat,self.E_icode, self.E_ifun,self.E_valC, self.E_valA, self.E_valB, self.E_srcA, self.E_srcB, self.E_dstE, self.E_dstM,
self.M_stat,self.M_icode,self.M_bch, self.M_valE, self.M_valA, self.M_dstE, self.M_dstM,
self.W_stat, self.W_icode, self.W_valE, self.W_valM, self.W_dstE, self.W_dstM,
self.eax, self.ecx, self.edx, self.ebx, self.esp, self.ebp, self.esi, self.edi, self.cycle]:
item.clear()
self.runButton.setEnabled(True)
self.stepButton.setEnabled(True)
self.backButton.setEnabled(True)
def test_returns_correct_result(self):
'''Simulator: running a one-dimensional simulator returns the correct result'''
simulator = Simulator({(0, .51): 1.0, (.51, 1): -1.0}, 1, 1, seed=1234)
self.assertEqual(simulator.run(), np.array([[1.0]]))
self.assertEqual(simulator.run(), np.array([[-1.0]]))
self.assertEqual(simulator.run(), np.array([[1.0]]))
self.assertEqual(simulator.run(), np.array([[-1.0]]))
self.assertEqual(simulator.run(), np.array([[-1.0]]))
self.assertEqual(simulator.run(), np.array([[1.0]]))
simulator = Simulator({(0, .51): 1.0, (.51, 1): -1.0}, 1, 5, seed=1234)
self.assertTrue(np.array_equal(simulator.run(), np.array([[1, -1, 1, -1, -1]])))
# Make sure a single outcome returns a single result
simulator = Simulator({(0, 1): 21}, 1, 5, seed=1234)
self.assertTrue(np.array_equal(simulator.run(), np.array([[21, 21, 21, 21, 21]])))
def J(hgt_spd, fullCoreFunctions, simulationParameters,
airportEnvironment,
airspace,
costParameters, weather, flightState,
flightParams, instruction):
"""
hgt_spd is a list of length twice as instruction
first half of hgt_spd is the altitude / 10000
send half of hgt_spd is air speed / 400
"""
hgt_spd = bulk_hgt_spd (hgt_spd, len(instruction))
hgt_spd = [np.max([1e-2,ii]) for ii in hgt_spd]
cur_instruction = update_instr(hgt_spd, instruction)
result = Simulator.simulateFlight(fullCoreFunctions, simulationParameters,
airportEnvironment,
airspace,
costParameters, weather, flightState,
flightParams, cur_instruction)
return result['Cost']
def J(hgt_spd, fullCoreFunctions, simulationParameters,
airportEnvironment,
airspace,
costParameters, weather, flightState,
flightParams, instruction):
"""
hgt_spd is a list of length twice as instruction
first half of hgt_spd is the altitude / 10000
send half of hgt_spd is air speed / 400
"""
if np.min(hgt_spd) < 0:
import pdb
pdb.set_trace()
cur_instruction = update_instr(hgt_spd, instruction)
result = Simulator.simulateFlight(fullCoreFunctions, simulationParameters,
airportEnvironment,
airspace,
costParameters, weather, flightState,
flightParams, cur_instruction)
print result['Cost']
return result['Cost']
class TestSimulator(TestCase):
"""
Tests for ``Simulator`` implementation.
"""
def setUp(self):
self.sim = Simulator()
def test_update(self):
"""
Tests that the update functions returns an object of World type.
"""
self.assertIsInstance(self.sim.update(), World)
def test_get_generation(self):
"""
Tests whether get_generation returns the correct value:
- Generation should be 0 when Simulator just created;
- Generation should be 2 after 2 updates.
"""
self.assertIs(self.sim.generation, self.sim.get_generation())
self.assertEqual(self.sim.get_generation(), 0)
self.sim.update()
self.sim.update()
self.assertEqual(self.sim.get_generation(), 2)
def test_get_world(self):
"""
Tests whether the object passed when get_world() is called is of World type, and has the required dimensions.
When no argument passed to construction of Simulator, world is square shaped with size 20.
"""
self.assertIs(self.sim.world, self.sim.get_world())
self.assertEqual(self.sim.get_world().width, 20)
self.assertEqual(self.sim.get_world().height, 20)
def test_set_world(self):
"""
Tests functionality of set_world function.
"""
world = World(10)
self.sim.set_world(world)
self.assertIsInstance(self.sim.get_world(), World)
self.assertIs(self.sim.get_world(), world)
def test_rules(self):
""""
Tests the basic set of rules on https://canvas.hu.nl/courses/20308/assignments/108690
Sets a random amount (max. a quarter of the grid) of squares with status 1.
Loops through every single square in the grid.
Gets the amount of neighbors.
Gets the status of the previous generation.
A cell with three neighbours, should always be alive in the next generation
despite if it was previously alive or not. (birth)
A cell with two neighbours, should be alive in the next generation if it was alive
in the generation prior to that. A dead cell with two neighbours stays dead. (survival)
A cell with one or less, or four or more neighbours are always dead in the next
generation (exposure/overcrowding)
"""
for _ in range(
randint(0,
(self.sim.world.width * self.sim.world.height) / 4)):
self.sim.world.set(randint(0, self.sim.world.width),
randint(0, self.sim.world.height), 1)
self.worldOld = deepcopy(
self.sim.world
) # Deep copies the old instance of the world, to compare it with later.
self.sim.update() # Go to the next generation in the original world.
# For every position in the grid.
for x in range(self.sim.world.width):
for y in range(self.sim.world.height):
neighborCount = np.count_nonzero(
self.worldOld.get_neighbours(
x, y)) # Counts amount of neighbours.
status = self.worldOld.get(
x, y) # Gets the old status of cell (dead/alive, 0/1)
if 2 <= neighborCount <= 3:
if neighborCount == 3: # Cells with three neighbours should ALWAYS be alive in generation n+1.
self.assertEqual(self.sim.world.get(x, y), 1)
elif neighborCount == 2: # Cells with two neighbors should stay unchanged (survival).
if status == 0: # Dead cells with two neighbors should stay dead.
self.assertEqual(self.sim.world.get(x, y), 0)
elif status != 0: # Alive cells with two neighbors should stay alive.
self.assertEqual(self.sim.world.get(x, y), 1)
else: # If a cell has less than two, or more than three neighbours, they die (exposure/overcrowding).
self.assertEqual(self.sim.world.get(x, y), 0)
import scipy
import matplotlib.pyplot as plt
import ObjectLibrary as OL
import FunctionLibrary as FL
import Ship_nofilter as Ship
import Simulator as S
import KalmanFilter as KF
f = open('log', 'w')
'''
SIMULATION STEP 1
Read / Generate coast, initialize simulator
'''
coastlength = 600
Sim = S.Simulator()
coast = Sim.SimulateCoast(coastlength)
startpos = OL.O_PosData(-80, -80, 1, 0)
Sim.SetDynamicModel(1, 1, 1, 1, 1, startpos)
'''
EMBEDDED STEP 1
Init AAUSHIP
'''
Startpos = OL.O_PosData(-80, -80, 0, 1)
AAUSHIP = Ship.O_Ship(Startpos, f)
'''
EMBEDDED OPTIONAL STEP 2/A
Waypoint planning
'''
allocs[n,:]=row
n = n+1
allocs = allocs[0:n,:]
print allocs
print len(allocs)
return allocs
if __name__ == '__main__':
symbols = ['AXP', 'HPQ', 'IBM', 'HNZ']
synbols = ['AAPL', 'GOOG', 'IBM', 'MSTF']
startdate = dt.datetime(2011, 1, 1)
enddate = dt.datetime(2011, 12, 31)
allocation = [0.2, 0.2, 0.2, 0.4]
minAllocatioon = allocation
#result = s.simulate(startdate, enddate, symbols, allocation)
maxResult = s.simulate(startdate, enddate, symbols, allocation)
minResult = maxResult
matrix = np.array(map(list, filter(lambda x: sum(x) == 1, itertools.product(np.linspace(0,1,11), repeat=4))))
count = len(matrix)
#matrix = np.array([[0.2, 0.2, 0.2, 0.4], [0.5, 0.0, 0.5, 0.0], [0.1, 0.1, 0.8, 0.0], [0.2, 0.0, 0.8, 0.0]])
#matrix = matrix2()
print '%d = %d' % (count, len(matrix))
for i in range(0, len(matrix)):
local = s.simulate(startdate, enddate, symbols, matrix[i])
print '%s = %f ' % (matrix[i], local[2])
if (maxResult[2] < local[2]):
maxResult = local
allocation = matrix[i]
if (minResult[2] > local[2]):
minResult = local
def press_(self):
Simulator.delay(1.2)
TimedActionFixture.press_(self)
convergeNumTaps = range(0,38,2)
#snapNumTaps = range(12,42,2)
#convergeNumTaps = range(0,30,2)
bands = [0.0, 1, 2, 50.0]
weights = [1, 0]
# Simulate the transmission and part of the reconstruction
startTimeTotal = time.time()
testData = []
staticJumps = [ [ [], [], [] ],
[ [], [], [] ],
[ [], [], [] ],
[ [], [], [] ] ]
for inputFile in inputFiles:
simulationData = sim.simulateTransmission(inputFile, logDir, predictionInterval,
samplingInterval, heartbeat, drThreshold,
delay, jitter, packetLoss)
simNumber = inputFile.split('/')[-2][-1]
snapReconstruction = sim.simulateSnapRecon(simulationData[4], logDir, simNumber, samplingInterval)[0]
snapLimitReconstruction = sim.simulateSnapLimitRecon(simulationData[4], logDir, simNumber, samplingInterval,
interpolationType, closeThreshold, snapLimit)[0]
convergedReconstruction = sim.simulateLinearConvergence(simulationData[4], logDir, simNumber, samplingInterval,
interpolationType, closeThreshold)[0]
testData.append([simulationData[0], simulationData[4], snapReconstruction,
snapLimitReconstruction, convergedReconstruction])
# Find intra-sample jump
threshold = 0
spacing = 1
jumpDataSets = []
jumpDataSets.append( sim.findDistanceBetweenSamples(simulationData[0], threshold, spacing) )
startTimeTotal = time.time()
transmittedData = []
for i, networkParam in enumerate(networkParams):
delay = networkParam[0]
jitter = networkParam[1]
packetLoss = networkParam[2]
transmittedData.append([])
print "Simulating the transmission for network params: " + \
str(delay) + " " + str(jitter) + " " + str(packetLoss)
for inputFile in inputFiles:
simNumber = inputFile.split('/')[-2][-1]
print "Simulating the transmission for data set: " + str(simNumber)
data = s.transmitData(inputFile, logDir, predictionInterval,
samplingInterval, heartbeat, drThreshold,
delay, jitter, packetLoss)
transmittedData[-1].append(data)
print
print "Total time spent simulating the transmission: " + str(time.time() - \
startTimeTotal)
print
# Simulate the reconstruction of the data
#------------------------------------------------------------------------------
startTimeRecon = time.time()
for i, txDataSets in enumerate(transmittedData):
startTimeData = time.time()
networkParam = networkParams[i]
delay = networkParam[0]
import Simulator
import YourController
import YourObserver
your_controller=YourController.controller()
your_observer=YourObserver.observer()
your_simulator=Simulator.simulator(total_step=1000,simulation_cycle=0.01,controller=your_controller,
observer=your_observer,GUI=True)
your_simulator.run()
from Visualisation import *
from Simulator import *
import time
# Configuratie
VISUALISATION = True
if __name__ == "__main__":
w = World(110)
sim = Simulator(w)
change_parameters = input(
'Do you wanna change the parameters? Right now we are using the standard B3/S23 rules. (Y/N): '
)
if change_parameters == 'Y' or 'y':
survived = []
birthed = []
while True:
survive = input(
'What number of neighbours do you want a cell to have in order to surive? (name one number): '
)
continuee = input('Do you want to add another number?: ')
if type(survive) != int and 0 <= int(survive) <= 8:
survived.append(int(survive))
if continuee != 'Y' and continuee != 'y':
break
while True:
birth = input(
'What number of neighbours do you want a dead cell to have in order to become alive? (name one number): '
)
import Simulator
import pygame
import numpy as np
from sklearn.preprocessing import StandardScaler
import ai_model
def get_action():
max_ = len(simulator.control_manager.controls)
return np.random.randint(0, max_)
simulator = Simulator.Simulator('172.16.175.136')
# simulator = Simulator.Simulator()
model = ai_model.Model(simulator, 6, len(simulator.control_manager.controls))
running = simulator.running
observation = simulator.get_observation()
prev = pygame.time.get_ticks()
curr_reward = 0
clock = pygame.time.Clock()
while running:
action = model.predict(observation)
curr = pygame.time.get_ticks()
observation, reward, done, _ = simulator.step(action)
curr_reward += reward
if (curr - prev) > 1000 / 200:
# print("Reward: ",simulator.reward_system.curr_reward)
# print(observation, end='\n\n')
def _runSimulation(self, parameters, initValues, blocks, threads):
totalThreads = blocks * threads
experiments = len(parameters)
#simulation specific parameters
param = np.zeros(
(totalThreads / self._beta + 1, self._parameterNumber),
dtype=np.float32)
try:
for i in range(experiments):
for j in range(self._parameterNumber):
param[i][j] = parameters[i][j]
except IndexError:
pass
if (not self._putIntoShared):
# parameter texture
ary = sim.create_2D_array(param)
sim.copy2D_host_to_array(ary, param, self._parameterNumber * 4,
totalThreads / self._beta + 1)
self._param_tex.set_array(ary)
sharedMemoryParameters = 0
else:
# parameter shared Mem
sharedMemoryParameters = self._parameterNumber * (
threads / self._beta + 2) * 4
sharedMemoryPerBlockForRNG = threads / self._warp_size * self._state_words * 4
sharedTot = sharedMemoryPerBlockForRNG + sharedMemoryParameters
if (self._putIntoShared):
parametersInput = np.zeros(self._parameterNumber * totalThreads /
self._beta,
dtype=np.float32)
speciesInput = np.zeros(self._speciesNumber * totalThreads,
dtype=np.float32)
result = np.zeros(self._speciesNumber * totalThreads *
self._resultNumber,
dtype=np.float32)
#non coalesced
try:
for i in range(len(initValues)):
for j in range(self._speciesNumber):
speciesInput[i * self._speciesNumber +
j] = initValues[i][j]
except IndexError:
pass
if (self._putIntoShared):
try:
for i in range(experiments):
for j in range(self._parameterNumber):
parametersInput[i * self._parameterNumber +
j] = parameters[i][j]
except IndexError:
pass
#set seeds using python rng
seeds = np.zeros(totalThreads / self._warp_size * self._state_words,
dtype=np.uint32)
for i in range(len(seeds)):
seeds[i] = np.uint32(4294967296 * np.random.uniform(0, 1))
#seeds[i] = np.random.random_integers(0,4294967295)
species_gpu = driver.mem_alloc(speciesInput.nbytes)
if (self._putIntoShared):
parameters_gpu = driver.mem_alloc(parametersInput.nbytes)
seeds_gpu = driver.mem_alloc(seeds.nbytes)
result_gpu = driver.mem_alloc(result.nbytes)
driver.memcpy_htod(species_gpu, speciesInput)
if (self._putIntoShared):
driver.memcpy_htod(parameters_gpu, parametersInput)
driver.memcpy_htod(seeds_gpu, seeds)
driver.memcpy_htod(result_gpu, result)
# run code
if (self._putIntoShared):
self._compiledRunMethod(species_gpu,
parameters_gpu,
seeds_gpu,
result_gpu,
block=(threads, 1, 1),
grid=(blocks, 1),
shared=sharedTot)
else:
self._compiledRunMethod(species_gpu,
seeds_gpu,
result_gpu,
block=(threads, 1, 1),
grid=(blocks, 1),
shared=sharedTot)
# fetch from GPU memory
driver.memcpy_dtoh(result, result_gpu)
# reshape result
result = result[0:experiments * self._beta * self._resultNumber *
self._speciesNumber]
result.shape = (experiments, self._beta, self._resultNumber,
self._speciesNumber)
return result
#Author: Alex Dawson-Elli
"""
noseTests.py:
provides tests for the methods and data structures used in
this project. The tests are organized by class, and can be
run from the command line, using the nosetest command
"""
#-------------------------import libraries------------------------------
import Simulator as Sim
import AnalysisTools as Analysis
from nose.tools import *
#-------------------------Simulator Tests--------------------------------
#instantiate Simulator object
sim = Sim.Simulator()
def test_simulateTime():
t1 = sim.simulateTime()
t2 = sim.simulateTime()
assert t1 - t2 == 0.0
def test_packageSample():
sample = sim.packageSample(123.456, (0.0, 3.5, 0.0))
assert sample['time'] == 123.456
assert sample['orientation'] == (0.0, 3.5, 0.0)
assert sample == {'time': 123.456, 'orientation': (0.0, 3.5, 0.0)}
sample = sim.packageSample(0.0, (0, 0, 0))
def initializeState(self, state):
self.simulator = Simulator.Simulator(self.simulation_duration, self.dt)
self.s = state
def main():
SynUI = UI.SynapseUI(className='Synapse UI')
SynUI.initialize(Sim.Simulator())
SynUI.mainloop()
def setUp(self):
self.sim = Simulator()
def handle(self, event): # event = air event
if event.m_event_type is AirportEvent.PLANE_ARRIVES:
self.m_in_the_air += 1
event.m_arriving_time = Simulator.get_current_time()
print(
str(Simulator.get_current_time()) + ": " +
str(event.m_plane.m_name) + " arrived at " +
str(self.m_airport_name))
if (Simulator.get_current_time() -
self.old_weather_time) >= self.duration:
rnd = random.randint(0, len(self.weather_array) - 1)
self.weather = self.weather_array[rnd]
self.duration = 10 - (
Simulator.get_current_time() -
(self.old_weather_time + self.duration)) % 10
self.old_weather_time = Simulator.get_current_time()
if not self.weather:
temp = AirportEvent(event.m_plane, 1, self,
AirportEvent.PLANE_ARRIVES, 3)
Simulator.schedule(temp)
else:
self.arriving_queue.put(event)
if self.m_land_1:
self.m_land_1 = False
first_arriving_event_1 = self.arriving_queue.get(
) # airport Event
print(
str(Simulator.get_current_time()) + ": " +
str(event.m_plane.m_name) +
" start landing at the first landing runway of " +
str(self.m_airport_name))
first_arriving_event_1.m_arrived_time = Simulator.get_current_time(
)
self.m_circling_time += first_arriving_event_1.get_wait_time(
)
self.m_arriving_passengers += first_arriving_event_1.m_plane.m_number_passengers
landed_event_1 = AirportEvent(
first_arriving_event_1.m_plane,
self.m_runway_time_to_land, self,
AirportEvent.PLANE_LANDED, 0)
Simulator.schedule(landed_event_1)
elif self.m_land_2:
self.m_land_2 = False
first_arriving_event_2 = self.arriving_queue.get(
) # airport Event
print(
str(Simulator.get_current_time()) + ": " +
str(event.m_plane.m_name) +
" start landing at the first landing runway of " +
str(self.m_airport_name))
first_arriving_event_2.m_arrived_time = Simulator.get_current_time(
)
self.m_circling_time += first_arriving_event_2.get_wait_time(
)
self.m_arriving_passengers += first_arriving_event_2.m_plane.m_number_passengers
landed_event_2 = AirportEvent(
first_arriving_event_2.m_plane,
self.m_runway_time_to_land, self,
AirportEvent.PLANE_LANDED, 0)
Simulator.schedule(landed_event_2)
if event.m_event_type is AirportEvent.PLANE_TAKEOFF:
if (Simulator.get_current_time() -
self.old_weather_time) >= self.duration:
rnd = random.randint(0, len(self.weather_array) - 1)
self.weather = self.weather_array[rnd]
self.duration = 10 - (
Simulator.get_current_time() -
(self.old_weather_time + self.duration)) % 10
self.old_weather_time = Simulator.get_current_time()
if not self.weather:
temp = AirportEvent(event.m_plane, 1, self,
AirportEvent.PLANE_DEPARTS, 3)
Simulator.schedule(temp)
else:
self.departure_queue.put(event)
if self.m_takeoff_1:
self.m_takeoff_1 = False
first_departure_event = self.departure_queue.get()
print(
str(Simulator.get_current_time()) + ": " +
str(first_departure_event.m_plane.m_name) +
" takeoff from the first takeoff runway of" +
str(self.m_airport_name))
takeoff_event = AirportEvent(
first_departure_event.m_plane,
self.m_runway_time_to_take_off, self,
AirportEvent.PLANE_DEPARTS, 2)
Simulator.schedule(takeoff_event)
if event.m_event_type is AirportEvent.PLANE_DEPARTS:
self.m_on_the_ground -= 1
print(
str(Simulator.get_current_time()) + ": " +
str(event.m_plane.m_name) + " departs from " +
str(self.m_airport_name))
event.m_plane.set_number_passengers()
self.m_departing_passengers += event.m_plane.m_number_passengers
airport_1 = self.m_airport_name
index = random.randint(0, len(AirportSim.airports) - 1)
while AirportSim.airports[index] is self:
index = random.randint(0, len(AirportSim.airports) - 1)
destination = AirportSim.airports[index]
airport_2 = destination.m_airport_name
distance = Airport.cal_distance(airport_1, airport_2)
speed = event.m_plane.m_speed
self.m_flight_time = distance / speed
temp = event.m_plane
self.gas_consumed_traveling += temp.cal_gas(
self.m_flight_time, temp.gas_speed_traveling)
depart_event = AirportEvent(temp, self.m_flight_time, destination,
AirportEvent.PLANE_ARRIVES,
3) # airport event
Simulator.schedule(depart_event)
if self.departure_queue.qsize() is not 0:
first_departure_event = self.departure_queue.get()
print(
str(Simulator.get_current_time()) + ": " +
str(first_departure_event.m_plane.m_name) +
" takeoff from the first takeoff runway of " +
str(self.m_airport_name))
takeoff_event = AirportEvent(first_departure_event.m_plane,
self.m_runway_time_to_take_off,
self, AirportEvent.PLANE_DEPARTS,
2)
Simulator.schedule(takeoff_event)
else:
self.m_takeoff_1 = True
if event.m_event_type is AirportEvent.PLANE_LANDED:
self.m_in_the_air -= 1
self.m_on_the_ground += 1
print(
str(Simulator.get_current_time()) + ": " +
str(event.m_plane.m_name) + " lands at " +
str(self.m_airport_name))
departure_event = AirportEvent(event.m_plane,
self.m_required_time_on_ground,
self, AirportEvent.PLANE_TAKEOFF, 2)
Simulator.schedule(departure_event)
runway = event.m_runway
if runway == 0:
self.m_land_1 = True
if runway == 1:
self.m_land_2 = True
if self.arriving_queue.qsize() != 0:
if self.m_land_1:
self.m_land_1 = False
first_arriving_event_1 = self.arriving_queue.get()
print(
str(Simulator.get_current_time()) + ": " +
str(first_arriving_event_1.m_plane.m_name) +
" start landing at the first landing runway of " +
str(self.m_airport_name))
first_arriving_event_1.m_arrived_time = Simulator.get_current_time(
)
self.m_circling_time += first_arriving_event_1.get_wait_time(
)
temp_1 = event.m_plane
self.gas_consumed_circulating += temp_1.cal_gas(
first_arriving_event_1.get_wait_time(),
temp_1.gas_speed_circulating)
print("airport" + str(self.m_airport_name) +
"circulating time1" + str(self.m_circling_time))
print("airport" + str(self.m_airport_name) +
"circulating gas consume" +
str(self.gas_consumed_circulating))
self.m_arriving_passengers += first_arriving_event_1.m_plane.m_number_passengers
landed_event_1 = AirportEvent(
first_arriving_event_1.m_plane,
self.m_runway_time_to_land, self,
AirportEvent.PLANE_LANDED, 0)
Simulator.schedule(landed_event_1)
elif self.m_land_2:
self.m_land_2 = False
first_arriving_event_2 = self.arriving_queue.get()
print(Simulator.get_current_time() + ": " +
first_arriving_event_2.m_plane.m_name +
" start landing at the first landing runway of " +
self.m_airport_name)
first_arriving_event_2.m_arrived_time = Simulator.get_current_time(
)
self.m_circling_time += first_arriving_event_2.get_wait_time(
)
temp_2 = event.m_plane()
self.gas_consumed_circulating += temp_2.cal_gas(
first_arriving_event_2.get_wait_time(),
temp_2.gas_speed_circulating)
print("airport" + self.m_airport_name +
"circulating time2" + self.m_circling_time)
print("airport" + self.m_airport_name +
"circulating gas consume" +
self.gas_consumed_circulating)
self.m_arriving_passengers += first_arriving_event_2.m_plane.m_number_passengers
landed_event_2 = AirportEvent(
first_arriving_event_2.m_plane,
self.m_runway_time_to_land, self,
AirportEvent.PLANE_LANDED, 1)
Simulator.schedule(landed_event_2)
packetLoss = 0
# Filter parameters
samplingFreq = 100
numberOfTaps = range(2,52,2)
weights = [1, 0]
minFreq = 0
maxFreq = 50
cutoffFreqs = [1, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40]
# Simulate the transmission
startTimeTotal = time.time()
testData = []
for inputFile in inputFiles:
simulationData = sim.simulateTransmission(inputFile, logDir, predictionInterval,
samplingInterval, heartbeat, drThreshold,
delay, jitter, packetLoss)
simNumber = inputFile.split('/')[-2][-1]
reconstruction = sim.simulateSnapRecon(simulationData[4], logDir, simNumber, samplingInterval)
testData.append([simulationData[0], reconstruction[0]])
# Simulate the quality for different filters
print
print "Curves: " + str(len(cutoffFreqs))
print "Taps: " + str(len(numberOfTaps))
print "Data Sets: " + str(len(testData))
errorCurves = []
delayCurves = []
for cutoffFreq in cutoffFreqs:
print "Working on filter with cutoff frequency: " + str(cutoffFreq)
from Visualisation import *
from Simulator import *
import time
# Configuratie
VISUALISATION = True
if __name__ == "__main__":
w = World(110)
sim = Simulator("B3/S23/A5", w)
if VISUALISATION:
vis = Visualisation(sim)
else:
while True:
# Create new world and print to screen
print(sim.update())
# slow down simulation
time.sleep(0.5)
if len(split_input) == 3:
b, s, a = split_input[:3]
b = [int(con) for con in b[1:]]
s = [int(con) for con in s[1:]]
a = int(a[1:])
elif len(split_input) == 2:
b, s = split_input[:2]
b = [int(con) for con in b[1:]]
s = [int(con) for con in s[1:]]
a = None
else:
b = [3]
s = [2, 3]
a = None
else:
b = [3]
s = [2, 3]
a = None
print(f"Rules;\nb={b}\ts={s}\ta={a}")
sim = Simulator(w, b=b, s=s, a=a)
if VISUALISATION:
vis = Visualisation(sim)
else:
while True:
# Create new world and print to screen
print(sim.update())
# slow down simulation
time.sleep(0.5)
from Simulator import *
import time
start_time = time.time()
sim = Simulator(100000)
field = sim.readFile("Initial_setup.txt")
for i in range(4):
print("Start position", [0 + i, 1])
red_prob, blue_prob, draw_prob, average_moves, average_moves_red, average_moves_blue, spies_prob = sim.runSimulation([0 + i, 1], field)
print("Probability that red wins: %s." % round(red_prob[1], 4), "Confidence interval: %s - %s." % (round(red_prob[0], 4), round(red_prob[2], 4)))
print("Probability that blue wins: %s." % round(blue_prob[1], 4), "Confidence interval: %s - %s." % (round(blue_prob[0], 4), round(blue_prob[2], 4)))
print("Probability of a draw: %s." % round(draw_prob[1], 4), "Confidence interval: %s - %s." % (round(draw_prob[0], 4), round(draw_prob[2], 4)))
print("Average moves: %s." % round(average_moves[1], 4), "Confidence interval: %s - %s." % (round(average_moves[0], 4), round(average_moves[2], 4)))
print("Average moves given red wins: %s." % round(average_moves_red[1], 4), "Confidence interval: %s - %s." % (round(average_moves_red[0], 4), round(average_moves_red[2], 4)))
print("Average moves given blue wins: %s." % round(average_moves_blue[1], 4), "Confidence interval: %s - %s." % (round(average_moves_blue[0], 4), round(average_moves_blue[2], 4)))
print("Probability that both spies live: %s." % round(spies_prob[1], 4), "Confidence interval: %s - %s." % (round(spies_prob[0], 3), round(spies_prob[2], 4)))
print("")
print("--- %s seconds ---" % (time.time() - start_time))
from Visualisation import *
from Simulator import *
import time
import random
# Configuratie
VISUALISATION = True
if __name__ == "__main__":
w = World(20)
rule = 'b3s23'
sim = Simulator(w, rule)
# quick and dirty start setup
for x in range(sim.get_world().width):
for y in range(sim.get_world().height):
if random.randint(0, 1) == 1:
sim.get_world().set(x, y, 6)
if VISUALISATION:
vis = Visualisation(sim)
else:
while True:
# Create new world and print to screen
print(sim.update())
# slow down simulation
time.sleep(0.5)
weights = [1, 0]
coefficients = scipy.signal.remez(taps, bands, weights, Hz=samplingFreq)
gain = 1.0 / sum(coefficients)
snapCoefficients = scipy.signal.remez(snapTaps, bands, weights, Hz=samplingFreq)
snapGain = 1.0 / sum(snapCoefficients)
# Plotting paramters
plotTimeDomain = True
plotFreqDomain = True
plotStatistics = True
# Simulate the algorithms
simNumber = inputFile.split('/')[-2][-1]
data = s.transmitData(inputFile, logDir, predictionInterval,
samplingInterval, heartbeat, drThreshold,
delay, jitter, packetLoss)
rawInputData = data[0]
filteredInputData = data[1]
predictedData = data[2]
drTxPackets = data[3]
drRxPackets = data[4]
drRxFilteredPackets = data[5]
snapReconData = s.snapReconstructData(drRxFilteredPackets, logDir, simNumber, samplingInterval)[0]
snapLimitReconData = s.snapLimitReconstructData(drRxFilteredPackets, logDir, simNumber, samplingInterval,
interpolationType, closeReconThreshold, snapLimit)[0]
closeConvergedData = s.convergeData(drRxFilteredPackets, logDir, simNumber, samplingInterval,
interpolationType, closeReconThreshold)[0]
farConveredData = s.convergeData(drRxFilteredPackets, logDir, simNumber, samplingInterval,
lowerTime = 18000
upperTime = 26500
yMax = 0.45
yMin = 0.05
useDb = False
errorBins = 50
jumpBins = 100
plotTimeDomain = True
plotFreqDomain = False
plotError = False
plotJump = False
# Simulate the algorithms
simNumber = inputFile.split('/')[-2][-1]
data = s.transmitData(inputFile, logDir, predictionInterval, samplingInterval,
heartbeat, drThreshold, delay, jitter, packetLoss)
rawInputData = data[0]
filteredInputData = data[1]
predictedData = data[2]
drTxPackets = data[3]
drRxPackets = data[4]
drRxFilteredPackets = data[5]
snapReconData = s.snapReconstructData(drRxFilteredPackets, logDir, simNumber,
samplingInterval)[0]
closeRelSnapLimitData = s.snapLimitReconstructData(drRxFilteredPackets, logDir,
simNumber, samplingInterval,
interpolationType,
SnapLimitType.Relative,
convergenceTime = 50
longConvergenceTime = 100
# Calculation parameters
#------------------------------------------------------------------------------
jumpThreshold = 0
jumpSpacing = 1
# Simulate the transmission and reconstruction algorithms
#------------------------------------------------------------------------------
startTimeTotal = time.time()
transmittedData = []
simNumber = inputFile.split('/')[-2][-1]
data = s.transmitData(inputFile, logDir, predictionInterval,
samplingInterval, heartbeat, drThreshold,
delay, jitter, packetLoss)
snapData = s.snapReconstructData(data[5],
logDir,
simNumber,
samplingInterval)[0]
convergeData = s.convergeData(data[5], logDir, simNumber, samplingInterval,
convergenceTime)[0]
varConvergeData = s.varConvergeData(data[5], logDir, simNumber, samplingInterval,
convergenceTime, longConvergenceTime)[0]
data.append(snapData)
data.append(convergeData)
data.append(varConvergeData)
print "Total time spent simulating the transmission: " + str(time.time() - \
def runcap(): import Simulator Simulator.run(createCapsule(1,'top'))
g_Cs = g_C * np.logspace(-1, 1, num=5)
# gamma_Cs = gamma_C * np.logspace(-1, 1, num=3)
Rs = R * np.logspace(-1, 1, num=5)
r = (25 * ureg.micrometer).to_base_units().magnitude
sigma = (5 * ureg.micrometer).to_base_units().magnitude
hbar = hbar.to_base_units().magnitude
charT = 1 / gamma_C
charL = 1 * np.sqrt(hbar / (2 * m * me * gamma_C))
ringParams = Simulator.ParameterContainer(g_C=g_C,
g_R=g_R,
gamma_C=gamma_C,
gamma_R=gamma_R,
R=R,
m=m,
charL=charL,
charT=charT)
params = ringParams.getGPEParams()
P0 = 4.0 * params['Pth']
pump = UtilityFunctions.AnnularPump(r, P0, sigma)
pumpFunction = pump.scaledFunction(ringParams.charL)
# Make Grid
grid = Simulator.Grid(ringParams.charL, max_XY=max_XY_unscaled, N=N)
x, y = grid.getSpatialGrid()
x_us, y_us = grid.getSpatialGrid(scaled=False)
solver = Simulator.GPESolver(
params,
jitter = 40 packetLoss = 0 reconThresh = 140 reconThresholds = range(20,510, 20) jumpThreshold = 0.01 spacing = 1 # Output results errors = [] deltaInput = [] deltaSnap = [] deltaConverge = [] # Simulate the transmission simulationData = sim.simulateTransmission(inputFile, logDir, predictionInterval, samplingInterval, heartbeat, drThreshold, delay, jitter, packetLoss) inputData = simulationData[0] snapRxData = sim.simulateSnapRecon(simulationData[4], logDir, "_ex1", samplingInterval)[0] convergeRxData = sim.simulateLinearConvergence(simulationData[4], logDir, "_ex1", samplingInterval, interpolationType, reconThresh)[0] deltaInput = sim.findDistanceBetweenSamples(inputData, jumpThreshold, spacing) deltaSnap = sim.findDistanceBetweenSamples(snapRxData, jumpThreshold, spacing) deltaConverge = sim.findDistanceBetweenSamples(convergeRxData, jumpThreshold, spacing) inputData = sim.splitData(inputData) snapRxData = sim.splitData(snapRxData) convergeTxData = sim.splitData(convergeRxData) #for reconThreshold in reconThresholds:
class TestSimulator(TestCase):
"""
Tests for ``Simulator`` implementation.
"""
def setUp(self):
self.sim = Simulator()
def test_update(self):
"""
Tests that the update functions returns an object of World type.
"""
self.assertIsInstance(self.sim.update(), World)
def test_get_generation(self):
"""
Tests whether get_generation returns the correct value:
- Generation should be 0 when Simulator just created;
- Generation should be 2 after 2 updates.
"""
self.assertIs(self.sim.generation, self.sim.get_generation())
self.assertEqual(self.sim.get_generation(), 0)
self.sim.update()
self.sim.update()
self.assertEqual(self.sim.get_generation(), 2)
def test_get_world(self):
"""
Tests whether the object passed when get_world() is called is of World type, and has the required dimensions.
When no argument passed to construction of Simulator, world is square shaped with size 20.
"""
self.assertIs(self.sim.world, self.sim.get_world())
self.assertEqual(self.sim.get_world().width, 20)
self.assertEqual(self.sim.get_world().height, 20)
def test_set_world(self):
"""
Tests functionality of set_world function.
"""
world = World(10)
self.sim.set_world(world)
self.assertIsInstance(self.sim.get_world(), World)
self.assertIs(self.sim.get_world(), world)
lowerTime = 18000 upperTime = 26500 yMax = 0.45 yMin = 0.05 # Simulate the algorithm stepFunc = [] for i in range(0,5001, 10): if i < 200: stepFunc.append( Sample(i, 0, 0, 0) ) else: stepFunc.append( Sample(i, 1, 1, 1) ) predictor = DRPredictor() predictedData = predictor.getPredictedData(stepFunc, predictionInterval, samplingInterval) s.exportData(logDir + "PredictionData.txt", predictedData) transmitter = DRTransmitter(heartbeat) drTxPackets = transmitter.getTransmittedPackets(.9, predictedData) s.exportData(logDir + "TransmittedData.txt", drTxPackets) network = Network() drRxPackets = network.getReceivedPackets(drTxPackets, delay, jitter, packetLoss) s.exportData(logDir + "ReceivedData.txt", drRxPackets) receiver = Receiver() drRxFilteredPackets = receiver.getFilteredData(drRxPackets) s.exportData(logDir + "FilteredData.txt", drRxFilteredPackets) convergedData = s.convergeData(drRxFilteredPackets, logDir, "-", samplingInterval, interpolationType, reconstructionThreshold)[0] iData = [ [] ] * 4 cData = [ [] ] * 4
class TestSimulator(TestCase):
"""
Tests for ``Simulator`` implementation.
"""
def setUp(self):
self.sim = Simulator()
def test_update(self):
"""
Tests that the update functions returns an object of World type.
"""
self.assertIsInstance(self.sim.update(), World)
def test_get_generation(self):
"""
Tests whether get_generation returns the correct value:
- Generation should be 0 when Simulator just created;
- Generation should be 2 after 2 updates.
"""
self.assertIs(self.sim.generation, self.sim.get_generation())
self.assertEqual(self.sim.get_generation(), 0)
self.sim.update()
self.sim.update()
self.assertEqual(self.sim.get_generation(), 2)
def test_get_world(self):
"""
Tests whether the object passed when get_world() is called is of World type, and has the required dimensions.
When no argument passed to construction of Simulator, world is square shaped with size 20.
"""
self.assertIs(self.sim.world, self.sim.get_world())
self.assertEqual(self.sim.get_world().width, 20)
self.assertEqual(self.sim.get_world().height, 20)
def test_set_world(self):
"""
Tests functionality of set_world function.
"""
world = World(10)
self.sim.set_world(world)
self.assertIsInstance(self.sim.get_world(), World)
self.assertIs(self.sim.get_world(), world)
def test_cell_survive(self):
# minder dan 2 levende cellen = dood
self.assertEqual(self.sim.check_cell_survive((2,3,5, 7, 8),[0, 0, 0, 0, 0, 0, 0, 0]), 0)
self.assertEqual(self.sim.check_cell_survive((2,3,5, 7, 8),[0, 1, 0, 0, 0, 0, 0, 0]), 0)
# 2 of 3 levende cellen = levend
self.assertEqual(self.sim.check_cell_survive((2,3,5, 7, 8),[0, 0, 0, 1, 0, 1, 0, 0]), 1)
self.assertEqual(self.sim.check_cell_survive((2,3,5, 7, 8),[0, 0, 0, 1, 1, 1, 0, 0]), 1)
# meer dan 3 levende cellen = dood
self.assertEqual(self.sim.check_cell_survive([0, 1, 1, 0, 1, 1, 0, 1]), 0)
def get_rule_set(self):
self.assertEqual(self.sim.get_rule_set("B358/S237"), (2,3,5, 7, 8))
self.assertEqual(self.sim.get_ruleset("B3/S23"), (2, 3))
self.assertEqual(self.sim.get_ruleset("B/S"), ())
dataRoot = "/Users/fstakem/Data/Movements_5_1_08/" root = "/Users/fstakem/Research/PhD/2010_Research/OptimalFiltering/" logDir = root + "code/log/" outputDir = root + "code/output/" movement = "Stacking" inputFile = inputFile = dataRoot + movement + "/Simulation" + str(1) + "/positionLog.txt" # Parameters for all algorithms samplingInterval = 10 numPoints = 131072 # Importing the raw data print "Importing data..." importer = Importer() rawInputData = importer.getInputData(inputFile, samplingInterval) s.exportData(logDir + "RawInputData.txt", rawInputData) # Filtering input data print "Filtering data..." samplingFreq = int(1e3/samplingInterval) taps = 80 bands = [0.0, 10, 11, 50.0] weights = [1, 0] coefficients = scipy.signal.remez(taps, bands, weights, Hz=samplingFreq) gain = 1.0 / sum(coefficients) filteredInputData = s.filterData(rawInputData, logDir, "cc", samplingInterval, coefficients)[0] filteredInputData = s.amplifyData(filteredInputData, gain) s.exportData(logDir + "FilteredInputData.txt", filteredInputData) # FFT the data print "Analyzing the data..."
# start server
def bore():
print("creating..")
Constants.simulator = Simulator()
startClient()
log.startLogging(sys.stdout)
factory = WebSocketServerFactory(u"ws://127.0.0.1:50050")
factory.protocol = MyServerProtocol
reactor.listenTCP(50050, factory)
reactor.run()
# p.join()
def startClient():
server_address = 'localhost'
client_socket = socket.socket()
port = 7555
client_socket.connect(('localhost', port))
print('Connected to %s on port %s' % (server_address, port))
Constants.chat_client = client_socket
if __name__ == '__main__':
# bore()
Constants.simulator = Simulator()
Constants.simulator.start()
#startClient()
Constants.simulator.loop()
# sim = Simulator()
# sim.loop()
''' Created on 13 Mar 2013 @author: thomas ''' import datetime as dt import Simulator as s if __name__ == '__main__': symbols = ["AAPL", "GOOG", "XOM", "GLD"] startdate = dt.datetime(2011, 1, 1) enddate = dt.datetime(2011, 12, 31) allocation = [0.4, 0.0, 0.2, 0.4] result = s.simulate(startdate, enddate, symbols, allocation) print 'Sharpe ratio: %.11f' % (result[2]) print 'Volatility %.13f' % (result[0]) print 'Average Daily Return %.15f' % (result[1]) print 'Cumulatative return %.11f' % (result[-1])
from Visualisation import *
from Simulator import *
import time
# Configuratie
VISUALISATION = True
if __name__ == "__main__":
w = World(110)
sim = Simulator(w, 'B3/S23/A5', age=True)
if VISUALISATION:
vis = Visualisation(sim)
else:
while True:
# Create new world and print to screen
print(sim.update())
# slow down simulation
time.sleep(0.5)
# Training neural network.
print("Training network")
trainer = BackpropTrainer(
net, dataset=sequenceDataSet, learningrate=0.01, lrdecay=1, momentum=0, weightdecay=0, verbose=True
)
if validationTraining:
trainer.trainUntilConvergence(verbose=True, maxEpochs=100, validationProportion=0.2)
else:
for i in range(trainingTimes):
trainer.train()
if not i % 10:
print("Iteration: " + str(i) + " out of " + str(trainingTimes))
print("Training finished")
"""
Trained network is saved here.
"""
if saveNetwork:
pickle.dump(net, open(networkFilename, "wb"))
# testNetwork(net)
if doFaceTest:
Simulator.testFace(enviroment, tests, speedPreferences, distPreferences, updateTime, robotHeight, net)
outputStats.append([])
for convergenceTime in convergenceTimes:
outputData[-1].append([])
outputStats[-1].append([])
# Simulate the transmission of the data
#------------------------------------------------------------------------------
startTimeTotal = time.time()
transmittedData = []
for inputFile in inputFiles:
simNumber = inputFile.split('/')[-2][-1]
print "Simulating the transmission for simulation: " + str(simNumber)
data = s.transmitData(inputFile, logDir, predictionInterval,
samplingInterval, heartbeat, drThreshold,
delay, jitter, packetLoss)
snapData = s.snapReconstructData(data[5],
logDir,
simNumber,
samplingInterval)[0]
filteredData = s.filterData(snapData,
logDir,
simNumber,
samplingInterval,
coefficients)[0]
filteredData = s.amplifyData(filteredData, gain)
data.append(snapData)
data.append(filteredData)
transmittedData.append(data)
input_asm_ptr.close()
for i_trc in range(len(input_trc_list)):
input_trc_list_ptr[i_trc].close()
# print(GlobalVar.allcontents_asm)
Architecture.parseConfig()
# Cache.parseConfig()
# VLC.parseConfig()
# Architecture.checkConfig()
# Cache.checkConfig()
# VLC.checkConfig()
#################################################################
u_simulator = Simulator()
u_simulator.simulate()
GlobalVar.outputptr.close()
# for i in range(0, 100000):
# U_Cache.accessCache(random.randint((256*16)*500,(256*16)*512))
# U_Cache.accessCache(1)
# U_Cache.accessCache(12)
# U_Cache.accessCache(14)
# U_Cache.accessCache(16)
# U_Cache.accessCache(10)
# U_Cache.accessCache(16*256-1)
# U_Cache.printInfo(-1)
help='Run on the simulator.',
action='store_true')
parser.add_argument('--hw',
help='Run on the hardware.',
action='store_true')
args = parser.parse_args()
if (args.sim and args.hw) or (not args.sim and not args.hw):
print("Please use --sim or --hw argument.")
exit(1)
if args.sim:
# A bit of explaining here is needed, because I want to overwrite the GUI with our custom controller.
# You don't want the simulator to make the GUI for you. So the GUI bool is set to False.
simulator = Simulator.Simulator(False)
Interface = SimulatorInterface.SimulatorInterface
# ======================== SIMULATOR DEFINTIONS (SOFTWARE INTERFACE) ========================
# Create effector objects
pumpA = Interface.Effector(
simulator._Simulator__plant._effectors['pumpA'])
pumpB = Interface.Effector(
simulator._Simulator__plant._effectors['pumpB'])
valveA = Interface.Effector(
simulator._Simulator__plant._effectors['valveA'])
valveB = Interface.Effector(
simulator._Simulator__plant._effectors['valveB'])
heater = Interface.Effector(
simulator._Simulator__plant._effectors['heater'])
def feasible(self, position):
A = sim.State_Space_mats(Gp_n, Gp_d, *position)[0]
return sim.stable(A[0])
from Filters.RockFilter import RockFilter
discount = 0.9
numLocs = 2
numRocks = 2
rockLocs = [0, 0, 1, 1]
robotX, robotY = 0, 1
'''
numLocs = 7
numRocks = 8
rockLocs = [2, 0, 0, 1, 3, 1, 6, 3, 2, 4, 3, 4, 5, 5, 1, 6]
robotX, robotY = 0, 3
'''
rockQuality = [0.5] * numRocks
rockSampled = [0] * numRocks
initial_state = RockState(numLocs, numRocks, rockLocs, rockQuality, rockSampled, robotX, robotY)
goal_state = initial_state
operator_d = {'amn': {'verbose': 'Moving north'},
'ams': {'verbose': 'Moving south'},
'ame': {'verbose': 'Moving east'},
'amw': {'verbose': 'Moving west'},
'as': {'verbose': 'Sampling'},
'ac': {'verbose': 'Checking rock %d'}}
sim = Simulator(operator_d, RockPlanner(discount), RockFilter(), RockWorld())
sim.run_sim(initial_state, goal_state, verbose=True, slow=True)
rawInstructions = Serialization.loadInstructionsFromFile(routesFile)
# rawInstructions is a dict
rawInstructions[308567953]
s = configL
routes = InstructionParser.ConvertRawInstructions(s.projection, rawInstructions)
date = dates[0]
flights = s.flights[date]
airports = s.airports
airspace = s.airspace[date]
print "Simulating " + str(date)
weather = None
results = Simulator.simulateFlights(s.simulationParameters,
airports,
airspace,
weather,
flights[1048:],
routes)
# specify which flight you want to optimize
k = 1048
for flightEntry, costParameters in flights[k:(k+1)]:
print flightEntry
instruction = routes[flightEntry.Id]
(flightParams, flightState) = FlightEntry.generateParametersAndState(
airports, flightEntry)
airportEnvironment = None
#airportEnvironment = airports[flightEntry.ArrivalAirport][1] # TODO check the snd
fullCoreFunctions = SimulationTypes.SimulationCoreFunctions(
delay = 100 jitter = 40 packetLoss = 0 reconThresholds = range(20,510, 100) jumpThreshold =0.001 spacing = 1 # Output results errors = [] deltaInput = [] deltaSnap = [] deltaConverge = [] # Simulate the transmission simulationData = sim.simulateTransmission(inputFile, logDir, predictionInterval, samplingInterval, heartbeat, drThreshold, delay, jitter, packetLoss) inputData = simulationData[0] deltaInput = sim.findDistanceBetweenSamples(inputData, jumpThreshold, spacing) for reconThreshold in reconThresholds: convergeTxData = sim.simulateLinearConvergence(simulationData[4], logDir, "_ex1", samplingInterval, interpolationType, reconThreshold) snapRxData = sim.simulateSnapRecon(simulationData[4], logDir, "_ex1", samplingInterval) errors.append( sim.findDistanceError(inputData, convergeTxData[0]) ) deltaSnap.append( sim.findDistanceBetweenSamples(snapRxData, jumpThreshold, spacing) ) deltaConverge.append( sim.findDistanceBetweenSamples(convergeTxData, jumpThreshold, spacing) ) # Prepare the data for plotting temp = [] for error in errors:
def test_Agents():
prompt = "Please input which Step you'd like to test (0 through 5)\n"
choice = input(prompt).strip()
#Test cases for Step 0
if choice == "0":
#Testing general output
for i in range(1000):
assert 0 == agents.rock_strategy(), "rock_strategy is incorrect"
assert 1 == agents.paper_strategy(), "paper_strategy is incorrect"
assert 2 == agents.scissors_strategy(
), "scissors_strategy is incorrect"
assert 0 <= agents.simple_strategy(
) <= 2, "simple_strategy is incorrect"
#Testing simulator runs
assert Simulator.simulator(
agents.rock_strategy,
agents.paper_strategy,
simulation_count=1000,
silent=True) == (0, 1, 0), "Simulation failed. Error in strategies"
assert Simulator.simulator(
agents.paper_strategy,
agents.rock_strategy,
simulation_count=1000,
silent=True) == (1, 0, 0), "Simulation failed. Error in strategies"
assert Simulator.simulator(
agents.scissors_strategy,
agents.rock_strategy,
simulation_count=1000,
silent=True) == (0, 1, 0), "Simulation failed. Error in strategies"
assert Simulator.simulator(
agents.rock_strategy,
agents.scissors_strategy,
simulation_count=1000,
silent=True) == (1, 0, 0), "Simulation failed. Error in strategies"
assert Simulator.simulator(
agents.paper_strategy,
agents.scissors_strategy,
simulation_count=1000,
silent=True) == (0, 1, 0), "Simulation failed. Error in strategies"
assert Simulator.simulator(
agents.scissors_strategy,
agents.paper_strategy,
simulation_count=1000,
silent=True) == (1, 0, 0), "Simulation failed. Error in strategies"
assert (
Simulator.simulator(agents.rock_strategy,
agents.rock_strategy,
simulation_count=1000,
silent=True) == Simulator.simulator(
agents.paper_strategy,
agents.paper_strategy,
simulation_count=1000,
silent=True) == Simulator.simulator(
agents.scissors_strategy,
agents.scissors_strategy,
simulation_count=1000,
silent=True) == (0, 0, 1)
), "Simulation failed -- when run against each other, the strategies did not completely tie"
#Simple strategy should always win 1/3, lose 1/3, and tie 1/3 -- no matter the complexity of its opponent
sr = [
round(x, 2) for x in Simulator.simulator(
agents.simple_strategy, agents.rock_strategy, silent=True)
]
sp = [
round(x, 2) for x in Simulator.simulator(
agents.simple_strategy, agents.paper_strategy, silent=True)
]
ss = [
round(x, 2) for x in Simulator.simulator(
agents.simple_strategy, agents.scissors_strategy, silent=True)
]
assert sr == sp == ss and sr[0] == sr[1] == sr[
2] == .33, "Simulation failed. Error in strategies"
print("Passed all tests -- Step 0 complete")
#"One test I definitely want to do for agents is creating a smart strategy that specifically can trash a reflexive_strategy that ALWAYS picks a move "
if choice == "1":
always_rock = agents.biased_strategy(1, 0)
always_paper = agents.biased_strategy(1, 1)
always_scissors = agents.biased_strategy(1, 2)
assert Simulator.simulator(
agents.rock_strategy,
always_rock,
simulation_count=1000,
silent=True
) == (
0, 0, 1
), "Simulation Failed: biased_strategy(1, 0) does not always return rock"
assert Simulator.simulator(
agents.paper_strategy,
always_paper,
simulation_count=1000,
silent=True
) == (
0, 0, 1
), "Simulation Failed: biased_strategy(1, 0) does not always return paper"
assert Simulator.simulator(
agents.scissors_strategy,
always_scissors,
simulation_count=1000,
silent=True
) == (
0, 0, 1
), "Simulation Failed: biased_strategy(1, 0) does not always return scissors"
never_rock = agents.biased_strategy(0, 0)
never_paper = agents.biased_strategy(0, 1)
never_scissors = agents.biased_strategy(0, 2)
never_rock_results = [never_rock for i in range(1000)]
never_paper_results = [never_paper for i in range(1000)]
never_scissors_results = [never_scissors for i in range(1000)]
assert 0 not in never_rock_results, "Error: Invalid value generation for biased_strategy(0, 0)"
assert 1 not in never_paper_results, "Error: Invalid value generation for biased_strategy(0, 1)"
assert 2 not in never_scissors_results, "Error: Invalid value generation for biased_strategy(0, 2)"
print("Passed all tests -- Step 1 complete")
if choice == "2":
simple = agents.triple_biased_strategy(1 / 3, 1 / 3, 1 / 3)
simple_test = simulator(simple_strategy,
simple,
simulation_count=100000,
silent=True)
assert simple_test[0] >= 0.32 and simple_test[
0] <= 0.34 and simple_test[1] >= 0.32 and simple_test[
1] <= 0.34 and simple_test[2] >= 0.32 and simple_test[
2] <= 0.34, "Error"
chance = [i / 1000 for i in range(1000)]
#Maybe make a function to do this to efficiently assign paper_chance and scissors_chance to i?
for i in chance:
rock_chance = i
paper_chance = round((1 - i) / 2, 3)
scissors_chance = paper_chance
strat = triple_biased_strategy(rock_chance, paper_chance,
scissors_chance)
results = [strat() for _ in range(1000)]
rock_results = len([i for i in results if i == 0])
paper_results = len([i for i in results if i == 1])
scissors_results = len([i for i in results if i == 2])
assert rock_results / len(
results) >= rock_chance - 0.01 or rock_results / len(
results
) <= rock_chance + 0.01, "Check when you're returning rock"
assert paper_results / len(
results) >= paper_chance - 0.01 or paper_results / len(
results
) <= paper_chance + 0.01, "Check when you're returning paper"
assert scissors_results / len(
results
) >= scissors_chance - 0.01 or scissors_results / len(
results
) <= scissors_chance + 0.01, "Check when you're returing scissors"
#Try to incorporate History object
print("Passed all tests -- Step 2 complete")
if choice == "3":
strat = agents.deterministic_strategy()
deterministic_order = [0, 1, 2, 1, 0]
simple_test_results = []
for _ in range(len(deterministic_order)):
simple_test_results.append(strat())
assert simple_test_results == deterministic_order, "Failed simple test"
for _ in range(10000):
random_test_results = []
strategy = agents.deterministic_strategy()
turns = random.randint(1, 1000)
for _ in range(turns):
random_test_results.append(strategy())
answer = deterministic_order * (turns // len(deterministic_order))
for i in range(turns - len(answer)):
answer.append(deterministic_order[i])
assert answer == random_test_results, "Deterministic strategy does not match expected output"
print("Passed all tests -- Step 3 complete")
if choice == "4":
agents.history = History.History(agents.rock_strategy,
agents.reflexive_strategy)
assert round(
Simulator.simulator(agents.rock_strategy,
agents.reflexive_strategy,
history_storage=agents.history,
simulation_count=1000,
silent=True)[1]) == 1
agents.history = History.History(agents.paper_strategy,
agents.reflexive_strategy)
assert round(
Simulator.simulator(agents.paper_strategy,
agents.reflexive_strategy,
history_storage=agents.history,
simulation_count=1000,
silent=True)[1]) == 1
agents.history = History.History(agents.scissors_strategy,
agents.reflexive_strategy)
assert round(
Simulator.simulator(agents.scissors_strategy,
agents.reflexive_strategy,
history_storage=agents.history,
simulation_count=1000,
silent=True)[1]) == 1
trials = 1000
wins = 0
for _ in range(trials):
#generate 3 random numbers that add up to 1
rates = np.random.random(3)
rates /= rates.sum()
#rates = (.1, .1, .8)
strategy1 = agents.triple_biased_strategy(rates[0], rates[1],
rates[2])
strategy2 = agents.reflexive_strategy
agents.history = History.History(strategy1, strategy2)
results = Simulator.simulator(strategy1,
strategy2,
history_storage=agents.history,
simulation_count=1000,
silent=True)
if results[1] > results[0]:
wins += 1
if results[0] - results[1] > 0:
assert results[0] - results[1] < 0.1
assert wins / trials > 0.9, "error"
print("Passed all tests -- Step 4 complete")
if choice == "5":
agents.history = History.History(agents.rock_strategy,
agents.predictive_strategy)
assert round(
Simulator.simulator(agents.rock_strategy,
agents.predictive_strategy,
history_storage=agents.history,
simulation_count=1000,
silent=True)[1]) == 1
agents.history = History.History(agents.paper_strategy,
agents.predictive_strategy)
assert round(
Simulator.simulator(agents.paper_strategy,
agents.predictive_strategy,
history_storage=agents.history,
simulation_count=1000,
silent=True)[1]) == 1
agents.history = History.History(agents.scissors_strategy,
agents.predictive_strategy)
assert round(
Simulator.simulator(agents.paper_strategy,
agents.predictive_strategy,
history_storage=agents.history,
simulation_count=1000,
silent=True)[1]) == 1
trials = 1000
wins = 0
for _ in range(trials):
test_length = random.randint(2, 10)
test_list = [random.randint(0, 2) for _ in range(test_length)]
deterministic = deterministic_list(test_list)
agents.history = History.History(deterministic,
agents.predictive_strategy)
result = Simulator.simulator(deterministic,
agents.predictive_strategy,
history_storage=agents.history,
simulation_count=1000,
silent=True)
print(result)
if result[0] < result[1]:
wins += 1
assert wins / trials >= 0.8, "Your strategy does not win enough"
print("Passed all tests -- Step 5 complete")
files = len(inputFiles)
for convergenceTime in convergenceTimes:
outputData.append([])
outputStats.append([])
# Simulate the transmission of the data
#------------------------------------------------------------------------------
startTimeTotal = time.time()
transmittedData = []
for inputFile in inputFiles:
simNumber = inputFile.split('/')[-2][-1]
print "Simulating the transmission for simulation: " + str(simNumber)
data = s.transmitData(inputFile, logDir, predictionInterval,
samplingInterval, heartbeat, drThreshold,
delay, jitter, packetLoss)
transmittedData.append(data)
print "Total time spent simulating the transmission: " + str(time.time() - \
startTimeTotal)
print
# Simulate the reconstruction of the data
#------------------------------------------------------------------------------
# Simulate relative snap reconstruction
startTimeCon = time.time()
print "Simulating convergence reconstruction..."
for i, convergenceTime in enumerate(convergenceTimes):
print "\t\tSimulating convergence time: " + str(convergenceTime)
startTimeConverge = time.time()
def main():
fileName = sys.argv[1]
with open(fileName, 'r') as f:
params = yaml.load(f)
simulator = Simulator.Simulator(params)
simulator.run(52)
upperTime = 26500
yMax = 0.45
yMin = 0.05
useDb = False
errorBins = 50
jumpBins = 100
plotTimeDomain = True
plotFreqDomain = False
plotError = False
plotJump = False
# Simulate the algorithms
simNumber = inputFile.split('/')[-2][-1]
data = s.transmitData(inputFile, logDir, predictionInterval,
samplingInterval, heartbeat, drThreshold,
delay, jitter, packetLoss)
rawInputData = data[0]
filteredInputData = data[1]
predictedData = data[2]
drTxPackets = data[3]
drRxPackets = data[4]
drRxFilteredPackets = data[5]
snapReconData = s.snapReconstructData(drRxFilteredPackets, logDir, simNumber, samplingInterval)[0]
closeRelSnapLimitData = s.snapLimitReconstructData(drRxFilteredPackets, logDir, simNumber, samplingInterval,
interpolationType, SnapLimitType.Relative, closeReconThreshold,
closeRelSnapLimit)[0]
closeAbSnapLimitData = s.snapLimitReconstructData(drRxFilteredPackets, logDir, simNumber, samplingInterval,
def _runSimulation(self,
parameters,
initValues,
blocks,
threads,
in_atol=1e-12,
in_rtol=1e-6):
totalThreads = threads * blocks
experiments = len(parameters)
neqn = self._speciesNumber
# compile
timer = time.time()
## print "Init Common..",
init_common_Kernel = self._completeCode.get_function("init_common")
init_common_Kernel(block=(threads, 1, 1), grid=(blocks, 1))
## print "finished in", round(time.time()-timer,4), "s"
start_time = time.time()
# output array
ret_xt = np.zeros(
[totalThreads, 1, self._resultNumber, self._speciesNumber])
# calculate sizes of work spaces
isize = 20 + self._speciesNumber
rsize = 22 + self._speciesNumber * max(16, self._speciesNumber + 9)
# local variables
t = np.zeros([totalThreads], dtype=np.float64)
jt = np.zeros([totalThreads], dtype=np.int32)
neq = np.zeros([totalThreads], dtype=np.int32)
itol = np.zeros([totalThreads], dtype=np.int32)
iopt = np.zeros([totalThreads], dtype=np.int32)
rtol = np.zeros([totalThreads], dtype=np.float64)
iout = np.zeros([totalThreads], dtype=np.int32)
tout = np.zeros([totalThreads], dtype=np.float64)
itask = np.zeros([totalThreads], dtype=np.int32)
istate = np.zeros([totalThreads], dtype=np.int32)
atol = np.zeros([totalThreads], dtype=np.float64)
liw = np.zeros([totalThreads], dtype=np.int32)
lrw = np.zeros([totalThreads], dtype=np.int32)
iwork = np.zeros([isize * totalThreads], dtype=np.int32)
rwork = np.zeros([rsize * totalThreads], dtype=np.float64)
y = np.zeros([self._speciesNumber * totalThreads], dtype=np.float64)
for i in range(totalThreads):
neq[i] = neqn
#t[i] = self._timepoints[0]
t[i] = 0
itol[i] = 1
itask[i] = 1
istate[i] = 1
iopt[i] = 0
jt[i] = 2
atol[i] = in_atol
rtol[i] = in_rtol
liw[i] = isize
lrw[i] = rsize
try:
# initial conditions
for j in range(self._speciesNumber):
# loop over species
y[i * self._speciesNumber + j] = initValues[i][j]
ret_xt[i, 0, 0, j] = initValues[i][j]
except IndexError:
pass
# allocate on device
d_t = driver.mem_alloc(t.size * t.dtype.itemsize)
d_jt = driver.mem_alloc(jt.size * jt.dtype.itemsize)
d_neq = driver.mem_alloc(neq.size * neq.dtype.itemsize)
d_liw = driver.mem_alloc(liw.size * liw.dtype.itemsize)
d_lrw = driver.mem_alloc(lrw.size * lrw.dtype.itemsize)
d_itol = driver.mem_alloc(itol.size * itol.dtype.itemsize)
d_iopt = driver.mem_alloc(iopt.size * iopt.dtype.itemsize)
d_rtol = driver.mem_alloc(rtol.size * rtol.dtype.itemsize)
d_iout = driver.mem_alloc(iout.size * iout.dtype.itemsize)
d_tout = driver.mem_alloc(tout.size * tout.dtype.itemsize)
d_itask = driver.mem_alloc(itask.size * itask.dtype.itemsize)
d_istate = driver.mem_alloc(istate.size * istate.dtype.itemsize)
d_y = driver.mem_alloc(y.size * y.dtype.itemsize)
d_atol = driver.mem_alloc(atol.size * atol.dtype.itemsize)
d_iwork = driver.mem_alloc(iwork.size * iwork.dtype.itemsize)
d_rwork = driver.mem_alloc(rwork.size * rwork.dtype.itemsize)
# copy to device
driver.memcpy_htod(d_t, t)
driver.memcpy_htod(d_jt, jt)
driver.memcpy_htod(d_neq, neq)
driver.memcpy_htod(d_liw, liw)
driver.memcpy_htod(d_lrw, lrw)
driver.memcpy_htod(d_itol, itol)
driver.memcpy_htod(d_iopt, iopt)
driver.memcpy_htod(d_rtol, rtol)
driver.memcpy_htod(d_iout, iout)
driver.memcpy_htod(d_tout, tout)
driver.memcpy_htod(d_itask, itask)
driver.memcpy_htod(d_istate, istate)
driver.memcpy_htod(d_y, y)
driver.memcpy_htod(d_atol, atol)
driver.memcpy_htod(d_iwork, iwork)
driver.memcpy_htod(d_rwork, rwork)
param = np.zeros((totalThreads, self._parameterNumber),
dtype=np.float32)
try:
for i in range(len(parameters)):
for j in range(self._parameterNumber):
param[i][j] = parameters[i][j]
except IndexError:
pass
# parameter texture
ary = sim.create_2D_array(param)
sim.copy2D_host_to_array(ary, param, self._parameterNumber * 4,
totalThreads)
self._param_tex.set_array(ary)
if self._dt <= 0:
start_time = time.time()
#for i in range(1,self._resultNumber):
for i in range(0, self._resultNumber):
for j in range(totalThreads):
tout[j] = self._timepoints[i]
driver.memcpy_htod(d_tout, tout)
self._compiledRunMethod(d_neq,
d_y,
d_t,
d_tout,
d_itol,
d_rtol,
d_atol,
d_itask,
d_istate,
d_iopt,
d_rwork,
d_lrw,
d_iwork,
d_liw,
d_jt,
block=(threads, 1, 1),
grid=(blocks, 1))
driver.memcpy_dtoh(t, d_t)
driver.memcpy_dtoh(y, d_y)
driver.memcpy_dtoh(istate, d_istate)
for j in range(totalThreads):
for k in range(self._speciesNumber):
ret_xt[j, 0, i, k] = y[j * self._speciesNumber + k]
# end of loop over time points
else:
tt = self._timepoints[0]
start_time = time.time()
#for i in range(1,self._resultNumber):
for i in range(0, self._resultNumber):
while 1:
next_time = min(tt + self._dt, self._timepoints[i])
for j in range(totalThreads):
tout[j] = next_time
driver.memcpy_htod(d_tout, tout)
self._compiledRunMethod(d_neq,
d_y,
d_t,
d_tout,
d_itol,
d_rtol,
d_atol,
d_itask,
d_istate,
d_iopt,
d_rwork,
d_lrw,
d_iwork,
d_liw,
d_jt,
block=(threads, 1, 1),
grid=(blocks, 1))
driver.memcpy_dtoh(t, d_t)
driver.memcpy_dtoh(y, d_y)
driver.memcpy_dtoh(istate, d_istate)
if np.abs(next_time - self._timepoints[i]) < 1e-5:
tt = next_time
break
tt = next_time
for j in range(totalThreads):
for k in range(self._speciesNumber):
ret_xt[j, 0, i, k] = y[j * self._speciesNumber + k]
# end of loop over time points
return ret_xt[0:experiments]
def evaluate(self, position):
obj = sim.response_gen(
tfinal, dt, Gp_n, Gp_d, SP, DT, u, *position)
return cevaluation(position, array([obj[0], obj[1], obj[2], obj[3], obj[4]]))
# Network parameters
delay = 100
jitter = 20
packetLoss = 0
# Plotting paramters
lowerTime = 18000
upperTime = 26500
yMax = 0.45
yMin = 0.05
# Simulate the algorithms
simNumber = inputFile.split('/')[-2][-1]
data = s.transmitData(inputFile, logDir, predictionInterval, samplingInterval,
heartbeat, drThreshold, delay, jitter, packetLoss)
rawInputData = data[0]
filteredInputData = data[1]
predictedData = data[2]
drTxPackets = data[3]
drRxPackets = data[4]
drRxFilteredPackets = data[5]
snapReconData = s.snapReconstructData(drRxFilteredPackets, logDir, simNumber,
samplingInterval)[0]
hydridSnapData = s.hydridSnapReconstructData(drRxFilteredPackets, logDir,
simNumber, samplingInterval,
interpolationType, snapLimitType,
reconstructionThreshold,
snapLimit)[0]
# Filesystem paramters dataRoot = "/Users/fstakem/Data/Movements_5_1_08/" root = "/Users/fstakem/Research/OptimalFiltering/" logDir = root + "code/log/" outputDir = root + "code/output/" movement = "Stacking" inputFile = dataRoot + movement + "/Simulation" + str(1) + "/positionLog.txt" samplingInterval = 10 upperBounds = 1 lowerBounds = 1 # Import data print "Importing data..." importer = Importer() inputData = importer.getInputData(inputFile, samplingInterval) t1, x1, y1, z1 = sim.splitData(inputData) # Filter parameters samplingFreq = 100 taps = 80 bands = [0.0, 10, 11, 50.0] weights = [1, 0] coefficients = scipy.signal.remez(taps, bands, weights, Hz=samplingFreq) gain = 1.0 / sum(coefficients) filteredData = sim.simulateFilterRecon(inputData, logDir, "cc", samplingInterval, coefficients)[0] sim.amplifyData(filteredData, gain) t2, x2, y2, z2 = sim.splitData(filteredData) # Plot data pylab.figure(1)
upperTime = 26500
yMax = 0.45
yMin = 0.05
# Simulate the algorithm
stepFunc = []
for i in range(0, 5001, 10):
if i < 200:
stepFunc.append(Sample(i, 0, 0, 0))
else:
stepFunc.append(Sample(i, 1, 1, 1))
predictor = DRPredictor()
predictedData = predictor.getPredictedData(stepFunc, predictionInterval,
samplingInterval)
s.exportData(logDir + "PredictionData.txt", predictedData)
transmitter = DRTransmitter(heartbeat)
drTxPackets = transmitter.getTransmittedPackets(.9, predictedData)
s.exportData(logDir + "TransmittedData.txt", drTxPackets)
network = Network()
drRxPackets = network.getReceivedPackets(drTxPackets, delay, jitter,
packetLoss)
s.exportData(logDir + "ReceivedData.txt", drRxPackets)
receiver = Receiver()
drRxFilteredPackets = receiver.getFilteredData(drRxPackets)
s.exportData(logDir + "FilteredData.txt", drRxFilteredPackets)
convergedData = s.convergeData(drRxFilteredPackets, logDir, "-",
samplingInterval, interpolationType,
reconstructionThreshold)[0]
iData = [[]] * 4
import Person import Simulator import sys if __name__ == "__main__": if len(sys.argv)<2: print "Please specify Config file." exit(-1) config = sys.argv[1] people = Person.getResponders() print "Survey initiated" for person in people: print person Simulator.take_survey(person, config) print "***************************************"
def runIt(g_C, R, width, rMiddle, P):
"""
Do a simulation, plot and save a diagnostic plot.
"""
# if rMiddle <= 10 * ureg.micrometer.to_base_units().magnitude:
# N = 512
# else:
# N = 1024
ringParams = Simulator.ParameterContainer(g_C=g_C,
g_R=2.0 * g_C,
gamma_C=gamma_C,
gamma_R=a * gamma_C,
R=R,
m=m,
charL=charL,
charT=charT)
# ringParams = Simulator.ParameterContainer(g_C=g_C, g_R=2.0*g_C,
# gamma_C=gamma_C,
# gamma_R=a*gamma_C, R=R, m=m)
params = ringParams.getGPEParams()
# params['charT'] = ringParams.charT
P0 = P * params['Pth']
# Make Grid
# grid = Simulator.Grid(ringParams.charL, max_XY=max_XY_unscaled, N=N)
# grid = Simulator.Grid(ringParams.charL, max_XY=3.0 * (rMiddle + width), N=N)
grid = Simulator.Grid(ringParams.charL,
max_XY=2.0 * (rMiddle + width),
N=N)
sigma = grid.toPixels(diffusionLength)
x, y = grid.getSpatialGrid()
x_us, y_us = grid.getSpatialGrid(scaled=False)
pump = UtilityFunctions.AnnularPumpFlat(rMiddle,
width,
P,
params['Pth'],
sigma=sigma)
# pump = UtilityFunctions.AnnularPumpGaussian(rMiddle, P, params['Pth'],
# sigma=width)
# pump = UtilityFunctions.GaussianPump(rMiddle, P, params['Pth'])
pumpFunction = pump.scaledFunction(ringParams.charL)
P0 = np.max(pumpFunction(x, y))
stabParam = (P0 / params['Pth']) / ((params['g_R'] * params['gamma_C']) /
(params['g_C'] * params['gamma_R']))
# Gaussian in the middle of the trap
psi0 = UtilityFunctions.GaussianPump(0.2*rMiddle,
0.01, 1, exponent=1.1).\
scaledFunction(ringParams.charL)
# psi0 = lambda x, y: 0.01 * pumpFunction(x, y) / P0
print("Stability parameter %f (should be > 1)" % stabParam)
dx = grid.dx_scaled
print("Numerical Stability Parameter %f (should be < 1)" %
((np.pi * dt) / dx**2))
print("P = %f" % P)
print("Pth = %f" % params['Pth'])
print("P0 = %f" % P0)
print("P0/Pth = %f" % (P0 / params['Pth']))
solver = Simulator.GPESolver(params,
dt,
grid.getSpatialGrid(),
grid.getKSquaredGrid(),
pumpFunction,
psiInitial=psi0,
gpu=True)
energyTimes, energy = solver.stepTo(T_MAX, stepsPerObservation=100)
# solver.stepTo(T_MAX, stepsPerObservation=1000)
f = diagnosticPlot(1e6 * x_us, 1e6 * y_us, solver, energyTimes, energy,
pump.scaledFunction(charL=1e-6))
f.savefig("Snoke" +
getPlotName(params, r=rMiddle, m=m, sigma=diffusionLength) +
".png",
dpi=800)
# f.savefig("testNew" + ".png", dpi=800)
plt.close(f)
