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)