Imported from artubss/SKILLS-CLAUDE-CODE (skills/skills/scientific/simpy/SKILL.md). Install upstream with npx skills add artubss/SKILLS-CLAUDE-CODE --skill simpy. Copyright stays with the author.

SimPy - Simulação de Eventos Discretos

Visão Geral

SimPy é um framework de simulação de eventos discretos baseado em processos, construído sobre Python padrão. Use SimPy para modelar sistemas onde entidades (clientes, veículos, pacotes, etc.) interagem entre si e competem por recursos compartilhados (servidores, máquinas, largura de banda, etc.) ao longo do tempo.

Capacidades principais:

Modelagem de processos usando funções geradoras Python
Gerenciamento de recursos compartilhados (servidores, contêineres, stores)
Agendamento e sincronização orientados a eventos
Simulações em tempo real sincronizadas com tempo de parede
Monitoramento abrangente e coleta de dados

Quando Usar Essa Habilidade

Use a habilidade SimPy quando:

Modelar sistemas de eventos discretos - Sistemas onde eventos ocorrem em intervalos irregulares
Contenção de recursos - Entidades competem por recursos limitados (servidores, máquinas, pessoal)
Análise de filas - Estudar linhas de espera, tempos de serviço e throughput
Otimização de processos - Analisar processos de manufatura, logística ou serviços
Simulação de rede - Roteamento de pacotes, alocação de banda, análise de latência
Planejamento de capacidade - Determinar níveis ótimos de recursos para desempenho desejado
Validação de sistema - Testar comportamento do sistema antes da implementação

Não adequado para:

Simulações contínuas com passos de tempo fixos (considere resolvedores ODE do SciPy)
Processos independentes sem compartilhamento de recursos
Otimização matemática pura (considere SciPy optimize)

Início Rápido

Estrutura Básica de Simulação

import simpy

def process(env, name):
    """A simple process that waits and prints."""
    print(f'{name} starting at {env.now}')
    yield env.timeout(5)
    print(f'{name} finishing at {env.now}')

# Create environment
env = simpy.Environment()

# Start processes
env.process(process(env, 'Process 1'))
env.process(process(env, 'Process 2'))

# Run simulation
env.run(until=10)

Padrão de Uso de Recurso

import simpy

def customer(env, name, resource):
    """Customer requests resource, uses it, then releases."""
    with resource.request() as req:
        yield req  # Wait for resource
        print(f'{name} got resource at {env.now}')
        yield env.timeout(3)  # Use resource
        print(f'{name} released resource at {env.now}')

env = simpy.Environment()
server = simpy.Resource(env, capacity=1)

env.process(customer(env, 'Customer 1', server))
env.process(customer(env, 'Customer 2', server))
env.run()

Conceitos Principais

1. Environment

O ambiente de simulação gerencia o tempo e agenda eventos.

import simpy

# Standard environment (runs as fast as possible)
env = simpy.Environment(initial_time=0)

# Real-time environment (synchronized with wall-clock)
import simpy.rt
env_rt = simpy.rt.RealtimeEnvironment(factor=1.0)

# Run simulation
env.run(until=100)  # Run until time 100
env.run()  # Run until no events remain

2. Processos

Processos são definidos usando funções geradoras Python (funções com instruções yield).

def my_process(env, param1, param2):
    """Process that yields events to pause execution."""
    print(f'Starting at {env.now}')

    # Wait for time to pass
    yield env.timeout(5)

    print(f'Resumed at {env.now}')

    # Wait for another event
    yield env.timeout(3)

    print(f'Done at {env.now}')
    return 'result'

# Start the process
env.process(my_process(env, 'value1', 'value2'))

3. Eventos

Eventos são o mecanismo fundamental para sincronização de processos. Processos fazem yield de eventos e retomam quando esses eventos são acionados.

Tipos de eventos comuns:

env.timeout(delay) - Aguardar passagem de tempo
resource.request() - Solicitar um recurso
env.event() - Criar um evento personalizado
env.process(func()) - Processo como um evento
event1 & event2 - Aguardar todos os eventos (AllOf)
event1 | event2 - Aguardar qualquer evento (AnyOf)

Recursos

SimPy fornece vários tipos de recursos para cenários diferentes. Para detalhes abrangentes, consulte references/resources.md.

Resumo de Tipos de Recursos

Tipo de Recurso	Caso de Uso
Resource	Capacidade limitada (servidores, máquinas)
PriorityResource	Fila baseada em prioridade
PreemptiveResource	Alta prioridade pode interromper baixa prioridade
Container	Materiais em massa (combustível, água)
Store	Armazenamento de objetos Python (FIFO)
FilterStore	Recuperação seletiva de itens
PriorityStore	Itens ordenados por prioridade

Referência Rápida

import simpy

env = simpy.Environment()

# Basic resource (e.g., servers)
resource = simpy.Resource(env, capacity=2)

# Priority resource
priority_resource = simpy.PriorityResource(env, capacity=1)

# Container (e.g., fuel tank)
fuel_tank = simpy.Container(env, capacity=100, init=50)

# Store (e.g., warehouse)
warehouse = simpy.Store(env, capacity=10)

Padrões de Simulação Comuns

Padrão 1: Fila Cliente-Servidor

import simpy
import random

def customer(env, name, server):
    arrival = env.now
    with server.request() as req:
        yield req
        wait = env.now - arrival
        print(f'{name} waited {wait:.2f}, served at {env.now}')
        yield env.timeout(random.uniform(2, 4))

def customer_generator(env, server):
    i = 0
    while True:
        yield env.timeout(random.uniform(1, 3))
        i += 1
        env.process(customer(env, f'Customer {i}', server))

env = simpy.Environment()
server = simpy.Resource(env, capacity=2)
env.process(customer_generator(env, server))
env.run(until=20)

Padrão 2: Produtor-Consumidor

import simpy

def producer(env, store):
    item_id = 0
    while True:
        yield env.timeout(2)
        item = f'Item {item_id}'
        yield store.put(item)
        print(f'Produced {item} at {env.now}')
        item_id += 1

def consumer(env, store):
    while True:
        item = yield store.get()
        print(f'Consumed {item} at {env.now}')
        yield env.timeout(3)

env = simpy.Environment()
store = simpy.Store(env, capacity=10)
env.process(producer(env, store))
env.process(consumer(env, store))
env.run(until=20)

Padrão 3: Execução de Tarefas em Paralelo

import simpy

def task(env, name, duration):
    print(f'{name} starting at {env.now}')
    yield env.timeout(duration)
    print(f'{name} done at {env.now}')
    return f'{name} result'

def coordinator(env):
    # Start tasks in parallel
    task1 = env.process(task(env, 'Task 1', 5))
    task2 = env.process(task(env, 'Task 2', 3))
    task3 = env.process(task(env, 'Task 3', 4))

    # Wait for all to complete
    results = yield task1 & task2 & task3
    print(f'All done at {env.now}')

env = simpy.Environment()
env.process(coordinator(env))
env.run()

Guia de Workflow

Passo 1: Defina o Sistema

Identifique:

Entidades: O que se move pelo sistema? (clientes, peças, pacotes)
Recursos: Quais são as restrições? (servidores, máquinas, banda)
Processos: Quais são as atividades? (chegada, serviço, partida)
Métricas: O que medir? (tempos de espera, utilização, throughput)

Passo 2: Implemente Funções de Processo

Crie funções geradoras para cada tipo de processo:

def entity_process(env, name, resources, parameters):
    # Arrival logic
    arrival_time = env.now

    # Request resources
    with resource.request() as req:
        yield req

        # Service logic
        service_time = calculate_service_time(parameters)
        yield env.timeout(service_time)

    # Departure logic
    collect_statistics(env.now - arrival_time)

Passo 3: Configure Monitoramento

Use utilitários de monitoramento para coletar dados. Consulte references/monitoring.md para técnicas abrangentes.

from scripts.resource_monitor import ResourceMonitor

# Create and monitor resource
resource = simpy.Resource(env, capacity=2)
monitor = ResourceMonitor(env, resource, "Server")

# After simulation
monitor.report()

Passo 4: Execute e Analise

# Run simulation
env.run(until=simulation_time)

# Generate reports
monitor.report()
stats.report()

# Export data for further analysis
monitor.export_csv('results.csv')

Recursos Avançados

Interação de Processos

Processos podem interagir através de eventos, yields de processos e interrupções. Consulte references/process-interaction.md para padrões detalhados.

Mecanismos principais:

Sinalização de eventos: Eventos compartilhados para coordenação
Yields de processo: Aguardar conclusão de outros processos
Interrupções: Retomar processos forcadamente para preempção

Simulações em Tempo Real

Sincronize a simulação com o tempo de parede para aplicações hardware-in-the-loop ou interativas. Consulte references/real-time.md.

import simpy.rt

env = simpy.rt.RealtimeEnvironment(factor=1.0)  # 1:1 time mapping
# factor=0.5 means 1 sim unit = 0.5 seconds (2x faster)

Monitoramento Abrangente

Monitore processos, recursos e eventos. Consulte references/monitoring.md para técnicas incluindo:

Rastreamento de variáveis de estado
Monkey-patching de recursos
Rastreamento de eventos
Coleta estatística

Scripts e Templates

basic_simulation_template.py

Template completo para construir simulações de fila com:

Parâmetros configuráveis
Coleta de estatísticas
Geração de clientes
Uso de recursos
Geração de relatórios

Uso:

from scripts.basic_simulation_template import SimulationConfig, run_simulation

config = SimulationConfig()
config.num_resources = 2
config.sim_time = 100
stats = run_simulation(config)
stats.report()

resource_monitor.py

Utilitários de monitoramento reutilizáveis:

ResourceMonitor - Rastrear recurso único
MultiResourceMonitor - Monitorar múltiplos recursos
ContainerMonitor - Rastrear níveis de contêiner
Cálculo automático de estatísticas
Funcionalidade de exportação CSV