如何模拟允许等到下一个过程解决？

Question

＆lt;这是简短的场景＆gt; 患者到达ED（急诊科）。当患者到达ED时，他们首先从护士那里获得分类。分类后，将为患者分配一张ED床，但是如果患者没有干净的床，他们必须等到脏床。 （当患者出院或进入IU时（住院单位）时，发生脏床。系统应给出清洁顺序。 第二是，如果没有脏床，这意味着现在正在清洁肮脏的床或等到病人出院或去IU（发生脏床的情况）。由医生治疗。检查医生后，患者要么去IU或出院。当患者去IU时，如果在IU中有一张干净的床，则立即将ED床退回，但是如果没有，则必须继续在ED床上等待。 而且，如果患者从医院出院，则将退还ED床，但不会立即进行清洁。（在发出清洁命令之前，将其弄脏）根据要求清洁脏床，然后分配给新来的患者。无论如何，我现在很难实施程序的一部分是，分配ED床的部分并未按照我的意图实施。

因此，我的要点是

1. 患者应清理ED床。
2. 如果没有清洁床，请病人等到可用的床。 （等待患者将继续等待，但是其他患者的过程将继续。）
3. 当患者离开ED时，患者使用的床仍然很脏，但是如果有清洁新患者的要求，则脏床应清洁。

我添加了“ bed_mgmt”课程来解决这个问题，但我做不到。请给我一些指导方针。

import simpy
import random

class Pre_Define:
    warmup_period = 1440
    sim_duration = 14400
    number_of_runs = 3
    n_edbed = 77

class Patients:
    def __init__(self, p_id):
        self.id = p_id
        self.bed_name = ""
        self.admission_decision = ""
    def admin_decision(self):
        admin_decision_prob = random.uniform(0, 1)
        if admin_decision_prob <= 0.7:
            self.admission_decision = "DIS"
        else:
            self.admission_decision = "IU"

class Bed_Mgmt:
    def __init__(self, env):
        self.env = env
        
    def check_q(self, Pt_id, pt_ed_q, bed_clean, bed_dirty, bed_cleaner): #, pt_ed_q, pt_ed_q, dirty_bed_q
        if pt_ed_q != [] and bed_clean != []:
            Patients.bed_name = bed_clean.get()
            Pt_id = pt_ed_q.get()
        elif pt_ed_q != [] and bed_clean == [] and bed_dirty != []:
            get_dirty_bed_name = bed_dirty.get() 
            with bed_cleaner.request() as req:
                yield req
                yield self.env.timeout(50)
                Patients.bed_name = get_dirty_bed_name
        else: # self.pt_ed_q != [] and self.clean_bed_q == [] and self.dirty_bed_q == []:
            pass  # generate patient

class Model:
    def __init__(self, run_number):
        self.env = simpy.Environment()
        self.pt_ed_q = simpy.Store(self.env )
        self.pt_counter = 0
        self.tg = simpy.Resource(self.env, capacity = 4)
        self.physician = simpy.Resource(self.env, capacity = 4)
        self.bed_clean = simpy.Store(self.env, capacity = Pre_Define.n_edbed)
        self.bed_dirty = simpy.Store(self.env, capacity = Pre_Define.n_edbed)
        self.IU_bed = simpy.Resource(self.env, capacity = 50)   
        self.bed_cleaner = simpy.Resource(self.env, capacity = 2)
        self.run_number = run_number
        
    def generate_beds(self):
        for i in range(Pre_Define.n_edbed):
            yield self.env.timeout(0)
            yield self.bed_clean.put(f'bed{i}')
        print(self.bed_clean.items)
       
    def generate_pt_arrivals(self):
        while True:
            self.pt_counter += 1
            pt = Patients(self.pt_counter)
            yield self.env.timeout(1/7)
            self.env.process(self.ED_Process(pt))
            #self.pt_ed_q.put(pt.id)

    def Process(self, Patients, Bed_Mgmt):
        with self.tg.request() as req:
            yield req
            triage_service_time = random.expovariate(1.0/18)
            yield self.env.timeout(triage_service_time)
        
        yield self.pt_ed_q.put(Patients.id)
        pt_id = yield self.pt_ed_q.get()
        Bed_Mgmt.check_q(pt_id, self.pt_ed_q, self.bed_clean, self.bed_dirty, self.bed_cleaner)

        with self.physician.request() as req:
            yield req
            yield self.env.timeout(10)
            Patients.admin_decision()
            
        if Patients.admission_decision == "DIS":
            with self.IU_bed.request() as req:
                yield req
                Bed_Mgmt.check_q(pt_id, self.pt_ed_q, self.bed_clean, self.bed_dirty, self.bed_cleaner)
                yield self.env.timeout(600)
                get_dirty_bed_name = Patients.bed_name
                yield self.bed_dirty.put(get_dirty_bed_name)
        else:
            get_dirty_bed_name = Patients.bed_name
            Bed_Mgmt.check_q(pt_id, self.pt_ed_q, self.bed_clean, self.bed_dirty, self.bed_cleaner)
            yield self.bed_dirty.put(get_dirty_bed_name)

    def run(self):
        self.env.process(self.generate_pt_arrivals())
        self.env.process(self.generate_beds())
        self.env.run(until = Pre_Define.warmup_period + Pre_Define.sim_duration)

for run in range(Pre_Define.number_of_runs):
    run_model = Model(run)
    run_model.run()
    print()

Answer 1

因此，这清除了一些事情。您会在日志开始时看到，分类后立即获得SA床，因为队列中有床。 a木头的末端您会看到患者没有床，直到清洁器完成清洁床，显示干净的床队列是空的。关于simpy的好处之一。存储是管理您的请求，因此您不需要检查队列是否为空。另外， https://realpython.com/ 是学习python的好网站。

import simpy
import random

class Pre_Define:
    warmup_period = 1440
    sim_duration = 14400
    number_of_runs = 1 #3
    n_edbed = 77

class Patients:
    def __init__(self, p_id):
        self.id = p_id
        self.bed_name = ""
        self.admission_decision = ""

    def admin_decision(self):
        admin_decision_prob = random.uniform(0, 1)
        if admin_decision_prob <= 0.7:
            self.admission_decision = "DIS"
        else:
            self.dmission_decision = "IU"

        return self.admission_decision

    

# class Bed_Mgmt:
#     def __init__(self, env):
#         self.env = env
        
#     def check_q(self, Pt_id, pt_ed_q, bed_clean, bed_dirty, bed_cleaner): #, pt_ed_q, pt_ed_q, dirty_bed_q
#         if pt_ed_q != [] and bed_clean != []:
#             Patients.bed_name = bed_clean.get()
#             Pt_id = pt_ed_q.get()
#         elif pt_ed_q != [] and bed_clean == [] and bed_dirty != []:
#             get_dirty_bed_name = bed_dirty.get() 
#             with bed_cleaner.request() as req:
#                 yield req
#                 yield self.env.timeout(50)
#                 Patients.bed_name = get_dirty_bed_name
#         else: # self.pt_ed_q != [] and self.clean_bed_q == [] and self.dirty_bed_q == []:
#             pass  # generate patient

class Model:
    def __init__(self, run_number):
        self.env = simpy.Environment()
        self.pt_ed_q = simpy.Store(self.env )
        self.pt_counter = 0
        self.tg = simpy.Resource(self.env, capacity = 4)
        self.physician = simpy.Resource(self.env, capacity = 4)
        self.bed_clean = simpy.Store(self.env)
        self.bed_dirty = simpy.Store(self.env)
        self.IU_bed = simpy.Resource(self.env, capacity = 50)   
        # self.bed_cleaner = simpy.Resource(self.env, capacity = 2)
        self.run_number = run_number
        
    def generate_beds(self):
        for i in range(Pre_Define.n_edbed):
            yield self.env.timeout(0)
            yield self.bed_clean.put(f'bed{i}')
        print(self.bed_clean.items)
       
    def generate_pt_arrivals(self):
        while True:
            self.pt_counter += 1
            pt = Patients(self.pt_counter)
            #yield self.env.timeout(1/7)
            yield self.env.timeout(5)
            self.env.process(self.ed_process(pt))
            #self.pt_ed_q.put(pt.id)

    def clean_beds_process(self, cleaner_id):
        """
            contious process for cleaning beds
            feeds off of the dirty bed queue
            if the queue is empty, will wait 
            until a bed is added to the queue.
            Clean beds are returned to the clean bed queue

            This process is the cleaner.  
            It one instance of th process is started for each cleaner
        """

        while True:

            # wait untile there is a bed in the dirty bead queue
            bed = yield self.bed_dirty.get()

            print(f'{self.env.now:.2f}  cleaner {cleaner_id} has started to clean bed {bed}')

            # clean bed
            yield self.env.timeout(50)

            print(f'{self.env.now:.2f}  cleaner {cleaner_id} has finish cleaning bed {bed}')

            # put bed in clean bed queue, loop to wait for next dirty bead
            yield self.bed_clean.put(bed)


    def ed_process(self, pt):
        # process for treating a patient

        print(f'{self.env.now:.2f}  patient  {pt.id} has arrived')
        with self.tg.request() as req:
            yield req
            triage_service_time = random.expovariate(1.0/18)
            yield self.env.timeout(triage_service_time)
        
        print(f'{self.env.now:.2f}  patient  {pt.id} has been triaged')
        
        # yield self.pt_ed_q.put(Patients.id)
        # pt_id = yield self.pt_ed_q.get()
        # Bed_Mgmt.check_q(pt_id, self.pt_ed_q, self.bed_clean, self.bed_dirty, self.bed_cleaner)

        bed = yield self.bed_clean.get()
        pt.bed_name = bed
        print(f'{self.env.now:.2f}  patient {pt.id} has a clean EU bed {bed}')

        with self.physician.request() as req:
            yield req
            yield self.env.timeout(10)
            pt.admin_decision()

            print(f'{self.env.now:.2f}  patient {pt.id} has admission descesion of  {pt.admission_decision}')
            
        if pt.admission_decision == "DIS":
            with self.IU_bed.request() as req:
                yield req
                # Bed_Mgmt.check_q(pt_id, self.pt_ed_q, self.bed_clean, self.bed_dirty, self.bed_cleaner)
                
                # have IU bed can give up EU bed
                dirty_bed_name = pt.bed_name
                yield self.bed_dirty.put(dirty_bed_name)

                print(f'{self.env.now:.2f}  patient {pt.id} moved to IU giving up bed {dirty_bed_name}')

                # time until IU bed becomes becone available 
                yield self.env.timeout(600)
                print(f'{self.env.now:.2f}  IU bed is available')
        else:
            # patient leaves EU
            dirty_bed_name = pt.bed_name
            #Bed_Mgmt.check_q(pt_id, self.pt_ed_q, self.bed_clean, self.bed_dirty, self.bed_cleaner)
            yield self.bed_dirty.put(dirty_bed_name)

            print(f'{self.env.now:.2f}  patient {pt.id} left EU giving up bed {dirty_bed_name}')


    def run(self):
        self.env.process(self.generate_pt_arrivals())
        self.env.process(self.generate_beds())

        # creating and starting two cleaners
        for i in range(2):
            self.env.process(self.clean_beds_process(i+1))
        
        #self.env.run(until = Pre_Define.warmup_period + Pre_Define.sim_duration)
        self.env.run(until = 650)

for run in range(Pre_Define.number_of_runs):
    run_model = Model(run)
    run_model.run()
    print()