def step(self) -> None: """Process the next event after enough real-time has passed for the event to happen. The delay is scaled according to the real-time :attr:`factor`. With :attr:`strict` mode enabled, a :exc:`RuntimeError` will be raised, if the event is processed too slowly. """ evt_time = self.peek() if evt_time is Infinity: raise EmptySchedule() real_time = self.real_start + (evt_time - self.env_start) * self.factor if self.strict and monotonic() - real_time > self.factor: # Events scheduled for time *t* may take just up to *t+1* # for their computation, before an error is raised. delta = monotonic() - real_time raise RuntimeError( f'Simulation too slow for real time ({delta:.3f}s).') # Sleep in a loop to fix inaccuracies of windows (see # http://stackoverflow.com/a/15967564 for details) and to ignore # interrupts. while True: delta = real_time - monotonic() if delta <= 0: break sleep(delta) Environment.step(self)
def __init__(self, initial_time=0, factor=1.0, strict=True): Environment.__init__(self, initial_time) self.env_start = initial_time self.real_start = time() self._factor = factor self._strict = strict
def __init__(self, initial_time=0, factor=1.0, strict=True): Environment.__init__(self, initial_time) self.env_start = initial_time self.real_start = time() self.factor = factor """Scaling factor of the real-time.""" self.strict = strict """Running mode of the environment. :meth:`step()` will raise a
def __init__( self, initial_time: SimTime = 0, factor: float = 1.0, strict: bool = True, ): Environment.__init__(self, initial_time) self.env_start = initial_time self.real_start = monotonic() self._factor = factor self._strict = strict
def step(self): """Waits until enough real-time has passed for the next event to happen. The delay is scaled according to the real-time :attr:`factor`. If the events of a time step are processed too slowly for the given :attr:`factor` and if :attr:`strict` is enabled, a :exc:`RuntimeError` is raised. """ evt_time = self.peek() if evt_time is Infinity: raise EmptySchedule() sim_delta = evt_time - self.env_start real_delta = time() - self.real_start delay = sim_delta * self.factor - real_delta if delay > 0: sleep(delay) elif self.strict and -delay > self.factor: # Events scheduled for time *t* may take just up to *t+1* # for their computation, before an error is raised. raise RuntimeError('Simulation too slow for real time (%.3fs).' % -delay) return Environment.step(self)
def step(self): """Waits until enough real-time has passed for the next event to happen. The delay is scaled according to the real-time :attr:`factor`. If the events of a time step are processed too slowly for the given :attr:`factor` and if :attr:`strict` is enabled, a :exc:`RuntimeError` is raised. """ evt_time = self.peek() if evt_time is Infinity: raise EmptySchedule() sim_delta = evt_time - self.env_start real_delta = time() - self.real_start delay = sim_delta * self.factor - real_delta if delay > 0: sleep(delay) elif self.strict and -delay > self.factor: # Events scheduled for time *t* may take just up to *t+1* # for their computation, before an error is raised. raise RuntimeError( 'Simulation too slow for real time (%.3fs).' % -delay) return Environment.step(self)
def start_delayed(env: Environment, generator: ProcessGenerator, delay: SimTime) -> Process: """Return a helper process that starts another process for *generator* after a certain *delay*. :meth:`~simpy.core.Environment.process()` starts a process at the current simulation time. This helper allows you to start a process after a delay of *delay* simulation time units:: >>> from simpy import Environment >>> from simpy.util import start_delayed >>> def my_process(env, x): ... print(f'{env.now}, {x}') ... yield env.timeout(1) ... >>> env = Environment() >>> proc = start_delayed(env, my_process(env, 3), 5) >>> env.run() 5, 3 Raise a :exc:`ValueError` if ``delay <= 0``. """ if delay <= 0: raise ValueError(f'delay(={delay}) must be > 0.') def starter() -> Generator[Event, None, Process]: yield env.timeout(delay) proc = env.process(generator) return proc return env.process(starter())
def step(self): """Process the next event after enough real-time has passed for the event to happen. The delay is scaled according to the real-time :attr:`factor`. With :attr:`strict` mode enabled, a :exc:`RuntimeError` will be raised, if the event is processed too slowly. """ evt_time = self.peek() if evt_time is Infinity: raise EmptySchedule() real_time = self.real_start + (evt_time - self.env_start) * self.factor if self.strict and time() - real_time > self.factor: # Events scheduled for time *t* may take just up to *t+1* # for their computation, before an error is raised. raise RuntimeError('Simulation too slow for real time (%.3fs).' % ( time() - real_time)) # Sleep in a loop to fix inaccuracies of windows (see # http://stackoverflow.com/a/15967564 for details) and to ignore # interrupts. while True: delta = real_time - time() if delta <= 0: break sleep(delta) return Environment.step(self)
def main(commuters=10, sim_max_time=700, train_capacity=800): env = Environment() data=[] train = Train(train_capacity, env) train.start_monitor(data) station_objs = convert_to_station_obj(TUBELINES['Jubilee'], env) train.initialise(station_objs.values()) commuters, stats = initialise_commuters( commuters, station_objs, env ) env.process(train.run()) for station in station_objs.itervalues(): env.process(station.train_arrives(train)) for commuter in commuters: env.process(commuter.request_train_space(train)) env.run(until=sim_max_time) print '****DATA*****', data
start_overall = time.time() for sim_name, runs, years, pop_cls, entries in SCENARIOS: g = nx.read_gpickle(join('data', 'islands.gpickle')) # type: nx.DiGraph num_agents = 1 save_path = join(SAVE_FOLDER, sim_name) if not exists(save_path): os.mkdir(save_path) for sim_number in xrange(runs): logger.info('Running Simulation #%d', sim_number) start_sim = time.time() # pops = [env.process(population(env, i, islands, START_ISLAND, 1, 1)) for i in xrange(num_agents)] env = Environment() env.rainfall = max(1, np.random.normal(RAINFALL, RAINFALL_SD)) islands = {} to_del = [node for node, data in g.nodes_iter(data=True) if data['area'] < ISLAND_SIZE_CUTOFF_DEG2] g.remove_nodes_from(to_del) islands = {node: Island( env=env, id=node, area=data['area'], perimeter=data['perimeter'], can_see={ n: { 'ab': d['area'], 'ba': g[n][node]['area'],
def __init__(self, loop=None): Environment.__init__(self, time.time()) self.loop = loop if loop is not None else asyncio.get_event_loop() self._event_task = None
def schedule(self, event, priority=NORMAL, delay=0): # Resume run() if necessary. if self._event_task is not None: self._event_task.set_result() self._event_task = None return Environment.schedule(self, event, priority, delay)
def basic_environment(): return Environment()