def __init__(self, manager):
super(Simulation, self).__init__()
self.manager = manager
self.running = True
self.state = Simulation.init
self.prevstate = None
# Set starting system time [milliseconds]
self.syst = 0.0
# Benchmark time and timespan [seconds]
self.bencht = 0.0
self.benchdt = -1.0
# Starting simulation time [seconds]
self.simt = 0.0
# Simulation timestep [seconds]
self.simdt = settings.simdt
# Simulation timestep multiplier: run sim at n x speed
self.dtmult = 1.0
# Simulated clock time
self.deltclock = 0.0
self.simtclock = self.simt
# System timestep [milliseconds]
self.sysdt = int(self.simdt / self.dtmult * 1000)
# Flag indicating running at fixed rate or fast time
self.ffmode = False
self.ffstop = None
# If available, name of the currently running scenario
self.scenname = 'Untitled'
# Simulation objects
self.navdb = Navdatabase('global')
self.screenio = ScreenIO(self, manager)
self.traf = Traffic(self.navdb)
self.birds = Birds()
self.cdbirds = Conflict_Detection_Birds(self.traf, self.birds)
# Additional modules
self.metric = Metric()
self.beastfeed = Modesbeast(self.traf)
# Initialize the stack module once
stack.init(self, self.traf, self.birds, self.screenio)
def __init__(self, gui, navdb):
super(Simulation, self).__init__()
print 'Initializing multi-threaded simulation'
self.mode = Simulation.init
self.samplecount = 0
self.sysdt = 1000 / self.sys_rate
# Set starting system time [milliseconds]
self.syst = 0.0
# Starting simulation time [seconds]
self.simt = 0.0
# Flag indicating running at fixed rate or fast time
self.ffmode = False
self.ffstop = None
# Simulation objects
self.screenio = ScreenIO(self)
self.traf = Traffic(navdb)
self.stack = Commandstack(self, self.traf, self.screenio)
self.telnet_in = StackTelnetServer(self.stack)
self.navdb = navdb
# Metrics
self.metric = None
# self.metric = Metric()
self.beastfeed = Modesbeast(self.stack, self.traf)
def __init__(self, manager):
super(Simulation, self).__init__()
self.manager = manager
self.running = True
self.state = Simulation.init
self.prevstate = None
# Set starting system time [milliseconds]
self.syst = 0.0
# Benchmark time and timespan [seconds]
self.bencht = 0.0
self.benchdt = -1.0
# Starting simulation time [seconds]
self.simt = 0.0
# Simulation timestep [seconds]
self.simdt = settings.simdt
# Simulation timestep multiplier: run sim at n x speed
self.dtmult = 1.0
# Simulated clock time
self.deltclock = 0.0
self.simtclock = self.simt
# System timestep [milliseconds]
self.sysdt = int(self.simdt / self.dtmult * 1000)
# Flag indicating running at fixed rate or fast time
self.ffmode = False
self.ffstop = None
# Simulation objects
self.navdb = Navdatabase('global')
self.screenio = ScreenIO(self, manager)
self.traf = Traffic(self.navdb)
# Additional modules
self.metric = Metric()
self.beastfeed = Modesbeast(self.traf)
# Initialize the stack module once
stack.init(self, self.traf, self.screenio)
def __init__(self, manager):
super(Simulation, self).__init__()
self.manager = manager
self.running = True
self.state = Simulation.init
self.prevstate = None
# Set starting system time [milliseconds]
self.syst = 0.0
# Benchmark time and timespan [seconds]
self.bencht = 0.0
self.benchdt = -1.0
# Starting simulation time [seconds]
self.simt = 0.0
# Simulation timestep [seconds]
self.simdt = settings.simdt
# Simulation timestep multiplier: run sim at n x speed
self.dtmult = 1.0
# System timestep [milliseconds]
self.sysdt = int(self.simdt / self.dtmult * 1000)
# Flag indicating running at fixed rate or fast time
self.ffmode = False
self.ffstop = None
# If available, name of the currently running scenario
self.scenname = 'Untitled'
# Create datalog instance
self.datalog = Datalog(self)
# Simulation objects
self.navdb = Navdatabase('global')
self.screenio = ScreenIO(self, manager)
self.traf = Traffic(self.navdb)
self.stack = Commandstack(self, self.traf, self.screenio)
# Additional modules
self.metric = Metric()
self.beastfeed = Modesbeast(self.stack, self.traf)
def __init__(self, gui, navdb):
super(Simulation, self).__init__()
self.mode = Simulation.init
self.samplecount = 0
self.sysdt = 1000 / self.sys_rate
# Simulation objects
self.screenio = ScreenIO(self)
self.traf = Traffic(navdb)
self.navdb = navdb
# Metrics
self.metric = None
# self.metric = Metric()
# Stack ties it all together
self.stack = Commandstack(self, self.traf, self.screenio)
print 'Initializing multi-threaded simulation'
def __init__(self, gui, navdb):
# simmode
self.mode = self.init
self.simt = 0.0 # Runtime
self.tprev = 0.0
self.syst0 = 0.0
self.dt = 0.0
self.syst = 0.0 # system time
# Directories
self.datadir = "./data/"
self.dts = []
# Fixed dt mode for fast forward
self.ffmode = False # Default FF off
self.fixdt = 0.1 # Default time step
self.ffstop = -1. # Indefinitely
# Simulation objects
# Simulation objects
self.navdb = Navdatabase('global')
self.screenio = ScreenIO(self, manager)
self.traf = Traffic(self.navdb)
self.birds = Birds()
self.cdbirds = Conflict_Detection_Birds(self.traf, self.birds)
self.metric = Metric()
self.stack = stack.init(self, self.traf, self.birds, self.screenio)
# Additional modules
self.beastfeed = Modesbeast(self.traf)
self.telnet_in = StackTelnetServer()
# Initialize the stack module once
stack.init(self, self.traf, gui.scr)
class Simulation(QObject):
# simulation modes
init, op, hold, end = range(4)
# =========================================================================
# Functions
# =========================================================================
def __init__(self, manager):
super(Simulation, self).__init__()
self.manager = manager
self.running = True
self.state = Simulation.init
self.prevstate = None
# Set starting system time [milliseconds]
self.syst = 0.0
# Benchmark time and timespan [seconds]
self.bencht = 0.0
self.benchdt = -1.0
# Starting simulation time [seconds]
self.simt = 0.0
# Simulation timestep [seconds]
self.simdt = settings.simdt
# Simulation timestep multiplier: run sim at n x speed
self.dtmult = 1.0
# Simulated clock time
self.deltclock = 0.0
self.simtclock = self.simt
# System timestep [milliseconds]
self.sysdt = int(self.simdt / self.dtmult * 1000)
# Flag indicating running at fixed rate or fast time
self.ffmode = False
self.ffstop = None
# Simulation objects
self.navdb = Navdatabase('global')
self.screenio = ScreenIO(self, manager)
self.traf = Traffic(self.navdb)
# Additional modules
self.metric = Metric()
self.beastfeed = Modesbeast(self.traf)
# Initialize the stack module once
stack.init(self, self.traf, self.screenio)
def doWork(self):
self.syst = int(time.time() * 1000.0)
self.fixdt = self.simdt
# Open scenario file automatically
if '--node' in sys.argv:
stack.openfile(str(var_name)+'.scn')
else:
stack.openfile('scenariotest.scn')
while self.running:
# Stop simulation automatically
if self.simt > 40E3:
self.stop()
# Datalog pre-update (communicate current sim time to loggers)
datalog.preupdate(self.simt)
# Update screen logic
self.screenio.update()
# Update the Mode-S beast parsing
self.beastfeed.update()
# Simulation starts as soon as there is traffic, or pending commands
if self.state == Simulation.init:
if self.traf.ntraf > 0 or len(stack.get_scendata()[0]) > 0:
self.start()
if self.benchdt > 0.0:
self.fastforward(self.benchdt)
self.bencht = time.time()
if self.state == Simulation.op:
stack.checkfile(self.simt)
# Always update stack
stack.process(self, self.traf, self.screenio)
if self.state == Simulation.op:
self.traf.update(self.simt, self.simdt)
# Update metrics
self.metric.update(self)
# Update loggers
datalog.postupdate()
# Update time for the next timestep
self.simt += self.simdt
# Update clock
self.simtclock = (self.deltclock + self.simt) % onedayinsec
# Process Qt events
self.manager.processEvents()
# When running at a fixed rate, or when in hold/init, increment system time with sysdt and calculate remainder to sleep
if not self.ffmode or not self.state == Simulation.op:
self.syst += self.sysdt
remainder = self.syst - int(1000.0 * time.time())
if remainder > 0:
QThread.msleep(remainder)
elif self.ffstop is not None and self.simt >= self.ffstop:
if self.benchdt > 0.0:
self.screenio.echo('Benchmark complete: %d samples in %.3f seconds.' % (self.screenio.samplecount, time.time() - self.bencht))
self.benchdt = -1.0
self.pause()
else:
self.start()
# Inform main of our state change
if not self.state == self.prevstate:
self.sendState()
self.prevstate = self.state
def stop(self):
self.state = Simulation.end
datalog.reset()
def start(self):
if self.ffmode:
self.syst = int(time.time() * 1000.0)
self.ffmode = True # Always run in fastforward mode
self.state = Simulation.op
def pause(self):
self.state = Simulation.hold
def reset(self):
self.simt = 0.0
self.deltclock = 0.0
self.simtclock = self.simt
self.state = Simulation.init
self.ffmode = False
self.traf.reset(self.navdb)
stack.reset()
datalog.reset()
areafilter.reset()
self.screenio.reset()
def quit(self):
self.running = False
def setDt(self, dt):
self.simdt = abs(dt)
self.sysdt = int(self.simdt / self.dtmult * 1000)
def setDtMultiplier(self, mult):
self.dtmult = mult
self.sysdt = int(self.simdt / self.dtmult * 1000)
def setFixdt(self, flag, nsec=None):
if flag:
self.fastforward(nsec)
else:
self.start()
def fastforward(self, nsec=None):
self.ffmode = True
if nsec is not None:
self.ffstop = self.simt + nsec
else:
self.ffstop = None
def benchmark(self, fname='IC', dt=300.0):
stack.ic(self.screenio, self, fname)
self.bencht = 0.0 # Start time will be set at next sim cycle
self.benchdt = dt
def sendState(self):
self.manager.sendEvent(SimStateEvent(self.state))
def addNodes(self, count):
self.manager.addNodes(count)
def batch(self, filename):
# The contents of the scenario file are meant as a batch list: send to manager and clear stack
result = stack.openfile(filename)
scentime, scencmd = stack.get_scendata()
if result is True:
self.manager.sendEvent(BatchEvent(scentime, scencmd))
self.reset()
return result
def event(self, event):
# Keep track of event processing
event_processed = False
if event.type() == StackTextEventType:
# We received a single stack command. Add it to the existing stack
stack.stack(event.cmdtext)
event_processed = True
elif event.type() == BatchEventType:
# We are in a batch simulation, and received an entire scenario. Assign it to the stack.
self.reset()
stack.set_scendata(event.scentime, event.scencmd)
self.start()
event_processed = True
elif event.type() == SimQuitEventType:
# BlueSky is quitting
self.quit()
else:
# This is either an unknown event or a gui event.
event_processed = self.screenio.event(event)
return event_processed
def setclock(self, txt=""):
""" Set simulated clock time offset"""
if txt == "":
pass # avoid error message, just give time
elif txt.upper() == "RUN":
self.deltclock = 0.0
self.simtclock = self.simt
elif txt.upper() == "REAL":
tclock = time.localtime()
self.simtclock = tclock.tm_hour * 3600. + tclock.tm_min * 60. + tclock.tm_sec
self.deltclock = self.simtclock - self.simt
elif txt.upper() == "UTC":
utclock = time.gmtime()
self.simtclock = utclock.tm_hour * 3600. + utclock.tm_min * 60. + utclock.tm_sec
self.deltclock = self.simtclock - self.simt
elif txt.replace(":", "").replace(".", "").isdigit():
self.simtclock = txt2tim(txt)
self.deltclock = self.simtclock - self.simt
else:
return False, "Time syntax error"
return True, "Time is now " + tim2txt(self.simtclock)
class Simulation(QObject):
# =========================================================================
# Settings
# =========================================================================
# Simulation timestep [seconds]
simdt = settings.simdt
# Simulation loop update rate [Hz]
sys_rate = settings.sim_update_rate
# simulation modes
init, op, hold, end = range(4)
# =========================================================================
# Functions
# =========================================================================
def __init__(self, gui, navdb):
super(Simulation, self).__init__()
print 'Initializing multi-threaded simulation'
self.mode = Simulation.init
self.samplecount = 0
self.sysdt = 1000 / self.sys_rate
# Set starting system time [milliseconds]
self.syst = 0.0
# Starting simulation time [seconds]
self.simt = 0.0
# Flag indicating running at fixed rate or fast time
self.ffmode = False
self.ffstop = None
# Simulation objects
self.screenio = ScreenIO(self)
self.traf = Traffic(navdb)
self.stack = Commandstack(self, self.traf, self.screenio)
self.telnet_in = StackTelnetServer(self.stack)
self.navdb = navdb
# Metrics
self.metric = None
# self.metric = Metric()
self.beastfeed = Modesbeast(self.stack, self.traf)
#self.scenfile='scenariotest.scn'
def moveToThread(self, target_thread):
self.screenio.moveToThread(target_thread)
self.telnet_in.moveToThread(target_thread)
#self.beastfeed.moveToThread(target_thread)
super(Simulation, self).moveToThread(target_thread)
def doWork(self):
# Start the telnet input server for stack commands
self.telnet_in.start()
self.syst = int(time.time() * 1000.0)
self.fixdt = self.simdt
self.fastforward() #Alexander. Always run simulations in fast-time
if len(sys.argv)>1: #Alexander
self.stack.openfile(str(sys.argv[1]) + '.scn') #Alexander. Open .scn file automatically
while not self.mode == Simulation.end:
# Timing bookkeeping
self.samplecount += 1
# Update the Mode-S beast parsing
self.beastfeed.update()
# TODO: what to do with init
if self.mode == Simulation.init:
self.mode = Simulation.op
if self.mode == Simulation.op:
self.stack.checkfile(self.simt)
# Always update stack
self.stack.process(self, self.traf, self.screenio)
if self.mode == Simulation.op:
self.traf.update(self.simt, self.simdt)
# Update metrics
if self.metric is not None:
self.metric.update(self, self.traf)
# Update time for the next timestep
self.simt += self.simdt
if self.simt>50E3 and len(sys.argv)>1: #Alexander. Stop simulation if simt larger than 50000 s.
self.stop()
# Process Qt events
QCoreApplication.processEvents()
# When running at a fixed rate, increment system time with sysdt and calculate remainder to sleep
if not self.ffmode:
self.syst += self.sysdt
remainder = self.syst - int(1000.0 * time.time())
if remainder > 0:
QThread.msleep(remainder)
elif self.ffstop is not None and self.simt >= self.ffstop:
self.start()
def stop(self):
self.mode = Simulation.end
self.screenio.postQuit()
def start(self):
if self.ffmode:
self.syst = int(time.time() * 1000.0)
self.ffmode = False
self.mode = self.op
def pause(self):
self.mode = self.hold
def reset(self):
self.simt = 0.0
self.mode = self.init
self.traf.reset(self.navdb)
def fastforward(self, nsec=None):
self.ffmode = True
if nsec is not None:
self.ffstop = self.simt + nsec
else:
self.ffstop = None
def datafeed(self, flag):
if flag == "ON":
self.beastfeed.connectToHost(settings.modeS_host,
settings.modeS_port)
if flag == "OFF":
self.beastfeed.disconnectFromHost()
class Simulation(QObject):
# simulation modes
init, op, hold, end = range(4)
# =========================================================================
# Functions
# =========================================================================
def __init__(self, manager):
super(Simulation, self).__init__()
self.manager = manager
self.running = True
self.state = Simulation.init
self.prevstate = None
# Set starting system time [milliseconds]
self.syst = 0.0
# Benchmark time and timespan [seconds]
self.bencht = 0.0
self.benchdt = -1.0
# Starting simulation time [seconds]
self.simt = 0.0
# Simulation timestep [seconds]
self.simdt = settings.simdt
# Simulation timestep multiplier: run sim at n x speed
self.dtmult = 1.0
# System timestep [milliseconds]
self.sysdt = int(self.simdt / self.dtmult * 1000)
# Flag indicating running at fixed rate or fast time
self.ffmode = False
self.ffstop = None
# If available, name of the currently running scenario
self.scenname = 'Untitled'
# Create datalog instance
self.datalog = Datalog(self)
# Simulation objects
self.navdb = Navdatabase('global')
self.screenio = ScreenIO(self, manager)
self.traf = Traffic(self.navdb)
self.stack = Commandstack(self, self.traf, self.screenio)
# Additional modules
self.metric = Metric()
self.beastfeed = Modesbeast(self.stack, self.traf)
def doWork(self):
self.syst = int(time.time() * 1000.0)
self.fixdt = self.simdt
while self.running:
# Update screen logic
self.screenio.update()
# Update the Mode-S beast parsing
self.beastfeed.update()
# Simulation starts as soon as there is traffic, or pending commands
if self.state == Simulation.init:
if self.traf.ntraf > 0 or len(self.stack.scencmd) > 0:
self.start()
if self.benchdt > 0.0:
self.fastforward(self.benchdt)
self.bencht = time.time()
if self.state == Simulation.op:
self.stack.checkfile(self.simt)
# Always update stack
self.stack.process(self, self.traf, self.screenio)
if self.state == Simulation.op:
self.traf.update(self.simt, self.simdt)
# Update metrics
self.metric.update(self)
# Update log
self.datalog.update(self)
# Update time for the next timestep
self.simt += self.simdt
# Process Qt events
self.manager.processEvents()
# When running at a fixed rate, or when in hold/init, increment system time with sysdt and calculate remainder to sleep
if not self.ffmode or not self.state == Simulation.op:
self.syst += self.sysdt
remainder = self.syst - int(1000.0 * time.time())
if remainder > 0:
QThread.msleep(remainder)
elif self.ffstop is not None and self.simt >= self.ffstop:
if self.benchdt > 0.0:
self.screenio.echo('Benchmark complete: %d samples in %.3f seconds.' % (self.screenio.samplecount, time.time() - self.bencht))
self.benchdt = -1.0
self.pause()
else:
self.start()
# Inform main of our state change
if not self.state == self.prevstate:
self.sendState()
self.prevstate = self.state
def stop(self):
self.state = Simulation.end
self.datalog.save()
def start(self):
if self.ffmode:
self.syst = int(time.time() * 1000.0)
self.ffmode = False
self.state = Simulation.op
def pause(self):
self.state = Simulation.hold
def reset(self):
self.simt = 0.0
self.state = Simulation.init
self.ffmode = False
self.scenname = 'Untitled'
self.traf.reset(self.navdb)
self.stack.reset()
self.screenio.reset()
def quit(self):
self.running = False
def setDt(self, dt):
self.simdt = abs(dt)
self.sysdt = int(self.simdt / self.dtmult * 1000)
def setDtMultiplier(self, mult):
self.dtmult = mult
self.sysdt = int(self.simdt / self.dtmult * 1000)
def setFixdt(self, flag, nsec=None):
if flag:
self.fastforward(nsec)
else:
self.start()
def fastforward(self, nsec=None):
self.ffmode = True
if nsec is not None:
self.ffstop = self.simt + nsec
else:
self.ffstop = None
def benchmark(self, fname='IC', dt=300.0):
self.stack.ic(self.screenio, self, fname)
self.bencht = 0.0 # Start time will be set at next sim cycle
self.benchdt = dt
def scenarioInit(self, name):
self.screenio.echo('Starting scenario ' + name)
self.scenname = name
def sendState(self):
self.manager.sendEvent(SimStateEvent(self.state))
def addNodes(self, count):
self.manager.addNodes(count)
def batch(self, filename):
# The contents of the scenario file are meant as a batch list: send to manager and clear stack
self.stack.openfile(filename)
self.manager.sendEvent(BatchEvent(self.stack.scentime, self.stack.scencmd))
self.reset()
def event(self, event):
# Keep track of event processing
event_processed = False
if event.type() == StackTextEventType:
# We received a single stack command. Add it to the existing stack
self.stack.stack(event.cmdtext)
event_processed = True
elif event.type() == BatchEventType:
# We are in a batch simulation, and received an entire scenario. Assign it to the stack.
self.reset()
self.stack.scentime = event.scentime
self.stack.scencmd = event.scencmd
self.start()
event_processed = True
elif event.type() == SimQuitEventType:
# BlueSky is quitting
self.quit()
else:
# This is either an unknown event or a gui event.
event_processed = self.screenio.event(event)
return event_processed
class Simulation(QObject):
# simulation modes
init, op, hold, end = range(4)
# =========================================================================
# Functions
# =========================================================================
def __init__(self, manager):
super(Simulation, self).__init__()
self.manager = manager
self.running = True
self.state = Simulation.init
self.prevstate = None
# Set starting system time [milliseconds]
self.syst = 0.0
# Benchmark time and timespan [seconds]
self.bencht = 0.0
self.benchdt = -1.0
# Starting simulation time [seconds]
self.simt = 0.0
# Simulation timestep [seconds]
self.simdt = settings.simdt
# Simulation timestep multiplier: run sim at n x speed
self.dtmult = 1.0
# Simulated clock time
self.deltclock = 0.0
self.simtclock = self.simt
# System timestep [milliseconds]
self.sysdt = int(self.simdt / self.dtmult * 1000)
# Flag indicating running at fixed rate or fast time
self.ffmode = False
self.ffstop = None
# Simulation objects
self.navdb = Navdatabase('global')
self.screenio = ScreenIO(self, manager)
self.traf = Traffic(self.navdb)
# Additional modules
self.metric = Metric()
self.beastfeed = Modesbeast(self.traf)
# Initialize the stack module once
stack.init(self, self.traf, self.screenio)
def doWork(self):
self.syst = int(time.time() * 1000.0)
self.fixdt = self.simdt
while self.running:
# Datalog pre-update (communicate current sim time to loggers)
datalog.preupdate(self.simt)
# Update screen logic
self.screenio.update()
# Update the Mode-S beast parsing
self.beastfeed.update()
# Simulation starts as soon as there is traffic, or pending commands
if self.state == Simulation.init:
if self.traf.ntraf > 0 or len(stack.get_scendata()[0]) > 0:
self.start()
if self.benchdt > 0.0:
self.fastforward(self.benchdt)
self.bencht = time.time()
if self.state == Simulation.op:
stack.checkfile(self.simt)
# Always update stack
stack.process(self, self.traf, self.screenio)
if self.state == Simulation.op:
self.traf.update(self.simt, self.simdt)
# Update metrics
self.metric.update(self)
# Update loggers
datalog.postupdate()
# Update time for the next timestep
self.simt += self.simdt
# Update clock
self.simtclock = (self.deltclock + self.simt) % onedayinsec
# Process Qt events
self.manager.processEvents()
# When running at a fixed rate, or when in hold/init, increment system time with sysdt and calculate remainder to sleep
if not self.ffmode or not self.state == Simulation.op:
self.syst += self.sysdt
remainder = self.syst - int(1000.0 * time.time())
if remainder > 0:
QThread.msleep(remainder)
elif self.ffstop is not None and self.simt >= self.ffstop:
if self.benchdt > 0.0:
self.screenio.echo(
'Benchmark complete: %d samples in %.3f seconds.' %
(self.screenio.samplecount, time.time() - self.bencht))
self.benchdt = -1.0
self.pause()
else:
self.start()
# Inform main of our state change
if not self.state == self.prevstate:
self.sendState()
self.prevstate = self.state
def stop(self):
self.state = Simulation.end
datalog.reset()
def start(self):
if self.ffmode:
self.syst = int(time.time() * 1000.0)
self.ffmode = False
self.state = Simulation.op
def pause(self):
self.state = Simulation.hold
def reset(self):
self.simt = 0.0
self.deltclock = 0.0
self.simtclock = self.simt
self.state = Simulation.init
self.ffmode = False
self.traf.reset(self.navdb)
stack.reset()
datalog.reset()
areafilter.reset()
self.screenio.reset()
def quit(self):
self.running = False
def setDt(self, dt):
self.simdt = abs(dt)
self.sysdt = int(self.simdt / self.dtmult * 1000)
def setDtMultiplier(self, mult):
self.dtmult = mult
self.sysdt = int(self.simdt / self.dtmult * 1000)
def setFixdt(self, flag, nsec=None):
if flag:
self.fastforward(nsec)
else:
self.start()
def fastforward(self, nsec=None):
self.ffmode = True
if nsec is not None:
self.ffstop = self.simt + nsec
else:
self.ffstop = None
def benchmark(self, fname='IC', dt=300.0):
stack.ic(self.screenio, self, fname)
self.bencht = 0.0 # Start time will be set at next sim cycle
self.benchdt = dt
def sendState(self):
self.manager.sendEvent(SimStateEvent(self.state))
def addNodes(self, count):
self.manager.addNodes(count)
def batch(self, filename):
# The contents of the scenario file are meant as a batch list: send to manager and clear stack
result = stack.openfile(filename)
scentime, scencmd = stack.get_scendata()
if result is True:
self.manager.sendEvent(BatchEvent(scentime, scencmd))
self.reset()
return result
def event(self, event):
# Keep track of event processing
event_processed = False
if event.type() == StackTextEventType:
# We received a single stack command. Add it to the existing stack
stack.stack(event.cmdtext)
event_processed = True
elif event.type() == BatchEventType:
# We are in a batch simulation, and received an entire scenario. Assign it to the stack.
self.reset()
stack.set_scendata(event.scentime, event.scencmd)
self.start()
event_processed = True
elif event.type() == SimQuitEventType:
# BlueSky is quitting
self.quit()
else:
# This is either an unknown event or a gui event.
event_processed = self.screenio.event(event)
return event_processed
def setclock(self, txt=""):
""" Set simulated clock time offset"""
if txt == "":
pass # avoid error message, just give time
elif txt.upper() == "RUN":
self.deltclock = 0.0
self.simtclock = self.simt
elif txt.upper() == "REAL":
tclock = time.localtime()
self.simtclock = tclock.tm_hour * 3600. + tclock.tm_min * 60. + tclock.tm_sec
self.deltclock = self.simtclock - self.simt
elif txt.upper() == "UTC":
utclock = time.gmtime()
self.simtclock = utclock.tm_hour * 3600. + utclock.tm_min * 60. + utclock.tm_sec
self.deltclock = self.simtclock - self.simt
elif txt.replace(":", "").replace(".", "").isdigit():
self.simtclock = txt2tim(txt)
self.deltclock = self.simtclock - self.simt
else:
return False, "Time syntax error"
return True, "Time is now " + tim2txt(self.simtclock)
class Simulation(QObject):
# =========================================================================
# Settings
# =========================================================================
# Simulation timestep [seconds]
simdt = settings.simdt
# Simulation loop update rate [Hz]
sys_rate = settings.sim_update_rate
# Flag indicating running at fixed rate or fast time
run_fixed = True
# simulation modes
init, op, hold, end = range(4)
# =========================================================================
# Functions
# =========================================================================
def __init__(self, gui, navdb):
super(Simulation, self).__init__()
self.mode = Simulation.init
self.samplecount = 0
self.sysdt = 1000 / self.sys_rate
# Simulation objects
self.screenio = ScreenIO(self)
self.traf = Traffic(navdb)
self.navdb = navdb
# Metrics
self.metric = None
# self.metric = Metric()
# Stack ties it all together
self.stack = Commandstack(self, self.traf, self.screenio)
print 'Initializing multi-threaded simulation'
def moveToThread(self, target_thread):
self.screenio.moveToThread(target_thread)
super(Simulation, self).moveToThread(target_thread)
def doWork(self):
# Set starting system time [milliseconds]
self.syst = int(time.time() * 1000.0)
# Set starting simulation time [seconds]
self.simt = 0.0
while not self.mode == Simulation.end:
# Timing bookkeeping
self.samplecount += 1
# TODO: what to do with init
if self.mode == Simulation.init:
self.mode = Simulation.op
if self.mode == Simulation.op:
self.stack.checkfile(self.simt)
# Always update stack
self.stack.process(self, self.traf, self.screenio)
if self.mode == Simulation.op:
self.traf.update(self.simt, self.simdt)
# Update metrics
if self.metric is not None:
self.metric.update(self, self.traf)
# Update time for the next timestep
self.simt += self.simdt
# Process Qt events
QCoreApplication.processEvents()
# When running at a fixed rate, increment system time with sysdt and calculate remainder to sleep
if self.run_fixed:
self.syst += self.sysdt
remainder = self.syst - int(1000.0 * time.time())
if remainder > 0:
QThread.msleep(remainder)
def stop(self):
self.mode = Simulation.end
# TODO: Communicate quit signal to main thread
def start(self):
self.mode = Simulation.op
def pause(self):
self.mode = Simulation.hold
def reset(self):
self.simt = 0.0
self.mode = Simulation.init
self.traf.reset(self.navdb)
