Example #1
0
    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)
Example #2
0
    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
Example #3
0
    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
Example #4
0
    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
Example #5
0
    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
Example #6
0
    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
Example #7
0
    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)
Example #8
0
    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)
Example #9
0
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())
Example #10
0
    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
Example #12
0
    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'],
Example #13
0
 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
Example #14
0
 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)
Example #15
0
def basic_environment():
    return Environment()