Python -Simpy 4.0.1-环境中多种输入

Question

我一直在研究一个问题，我必须在一个simpy 4.0.1计划中模拟患者，该计划具有多种患者（例如“ A”，“ B”和“ C”）。患者根据numpy.random.partential（） 和“占用床”（simpy Resources）在中心基于numpy.random.landom.lognormal（）< /代码>。每种患者类型都有不同的值以控制此抽样。这是一个简单的FIFO过程，无需优先考虑，患者只是以不同的速度到达。

我尝试的第一种方法是为每个类别的患者创建3个过程，然后让小调子处理他们的一代：

import simpy
from numpy.random import exponential, lognormal

counter = 0
total_beds = 5
run_length = 10

mean_iat_a, mean_iat_b, mean_iat_c = 1.0, 2.0, 3.0
normal_mean_a, normal_mean_b, normal_mean_c = 4.0, 5.0, 6.0
normal_stdev_a, normal_stdev_b, normal_stdev_c = 7.0, 8.0, 9.0


class Patient:
    def __init__(self, pid, ptype):
        self.pid = pid
        self.ptype = ptype
        self.time_arrived = None
        self.time_admitted = None
        self.time_discharged = None

def generate_arrivals(env, ptype):
    while True:
        global counter
        counter += 1
        patient = Patient(counter, ptype)
        env.process(perform_treatment(env, patient))
        # sample arrivals
        if patient.ptype == 'A':
            interarival_time = exponential(scale=mean_iat_a)
        elif patient.ptype == 'B':
            interarival_time = exponential(scale=mean_iat_b)
        else:
            interarival_time = exponential(scale=mean_iat_c)
        yield env.timeout(interarival_time)


def perform_treatment(env, patient):
    patient.time_arrived = env.now
    print(f'Patient {patient.pid} - {patient.ptype} - arrived at {patient.time_arrived}')
    with beds.request() as req:
        yield req
        patient.time_admitted = env.now
        print(f'Patient {patient.pid} - {patient.ptype} - admitted at {patient.time_admitted}')
        # sample duration of stay
        if patient.ptype == 'A':
            stay_duration = lognormal(mean=normal_mean_a, sigma=normal_stdev_a)
        elif patient.ptype == 'B':
            stay_duration = lognormal(mean=normal_mean_b, sigma=normal_stdev_b)
        else:
            stay_duration = lognormal(mean=normal_mean_c, sigma=normal_stdev_c)
        yield env.timeout(stay_duration)
        patient.time_discharged = env.now
        print(f'Patient {patient.pid} - {patient.ptype} - discharged at {patient.time_discharged}')


env = simpy.Environment()
beds = simpy.Resource(env, capacity=total_beds)
env.process(generate_arrivals(env, 'A'))
env.process(generate_arrivals(env, 'B'))
env.process(generate_arrivals(env, 'C'))
env.run(until=run_length)

这种方法的问题是，在各自过程开始时都有每个类别的患者（它总是创造患者1，2＆amp;在时间= 0的每个类别中的3个），这并不反映现实世界的情况：

Patient 1 - A - arrived at 0
Patient 2 - B - arrived at 0
Patient 3 - C - arrived at 0
Patient 1 - A - admitted at 0
Patient 2 - B - admitted at 0
Patient 3 - C - admitted at 0
Patient 1 - A - discharged at 0.04165029350880402
Patient 4 - A - arrived at 0.6503311494436321
Patient 4 - A - admitted at 0.6503311494436321
Patient 4 - A - discharged at 0.6626671650563922
Patient 5 - B - arrived at 0.6868621026906724
.
.
etc

到目前为止，我一直在玩：用于使用

1. 特定类别的常数
2. 通过numpy.random.multinomial（）具有同样概率的单个过程，可以随机确定哪种患者的生成。

import simpy
from numpy.random import exponential, lognormal, multinomial


counter = 0
total_beds = 5
run_length = 10
ptypes = ['A', 'B', 'C']
probvals = [1.0 / len(ptypes) for _ in ptypes]


class Patient:
    def __init__(self, pid, ptype):
        self.pid = pid
        self.ptype = ptype
        self.time_arrived = None
        self.time_admitted = None
        self.time_discharged = None


class TypeA(Patient):
    def __init__(self, pid, ptype):
        super().__init__(pid, ptype)
        self.mean_iat = 1.0
        self.normal_mean = 4.0
        self.normal_stdev = 7.0


class TypeB(Patient):
    def __init__(self, pid, ptype):
        super().__init__(pid, ptype)
        self.mean_iat = 2.0
        self.normal_mean = 5.0
        self.normal_stdev = 8.0


class TypeC(Patient):
    def __init__(self, pid, ptype):
        super().__init__(pid, ptype)
        self.mean_iat = 3.0
        self.normal_mean = 6.0
        self.normal_stdev = 9.0


def generate_arrivals(env):
    while True:
        global counter
        counter += 1
        ptype = ptypes[multinomial(n=1, pvals=probvals).argmax()]
        
        # From here is where I'm stuck

        # Can't understand how to drive the correct object instantiation
        # to replace the if-elif-else from the previous example
        patient = Patient(counter, ptype)

        # Not sure of the logic from here on out
        env.process(perform_treatment(env, patient))
        interarival_time = exponential(scale=patient.mean_iat)
        yield env.timeout(interarival_time)


def perform_treatment(env, patient):
    patient.time_arrived = env.now
    print(f'Patient {patient.pid} - {patient.ptype} - arrived at {patient.time_arrived}')
    with beds.request() as req:
        yield req
        patient.time_admitted = env.now
        print(f'Patient {patient.pid} - {patient.ptype} - admitted at {patient.time_admitted}')
        
        # Again, how do I replace the if-elif-else from the previous example
        stay_duration = lognormal(mean=patient.normal_mean, sigma=patient.normal_stdev)
        yield env.timeout(stay_duration)
        patient.time_discharged = env.now
        print(f'Patient {patient.pid} - {patient.ptype} - discharged at {patient.time_discharged}')


env = simpy.Environment()
beds = simpy.Resource(env, capacity=total_beds)
env.process(generate_arrivals(env))
env.run(until=run_length)

但是，我似乎不明白如何使用Simpy进行操作。对我的方法或其他想法的任何意见都将不胜感激！

注意：我知道使用numpy.random.multinomial（）一次仅会产生一种患者，但这可能完全是一个不同的问题。

Answer 1

在您的第一个代码中，您可以移动Gen患者代码吗？您可以将超时移至循环的顶部吗？当然，这意味着您不会在时间

0开始在每个过程开始之前启动的每个过程。过程。我想到每个过程及其自己的线程。因此，当您的程序致电Env.Run。它抓住了您的一个过程，创建患者，然后在收益率上等待。超时（），然后抓住第二个过程，仍处于时间0，并创建一个患者并以产量的暂停。 ect ... ect ...在短时间内不会在一个过程中移动，直到达到产量为止。这有帮助吗？ -
迈克尔
11小时前删除
当该过程中的第一行是收益and Env.TimeOut（）直到超时完成并更新时间之前，什么都不会发生。它具有调度的效果