如何跟踪simpy中有各种事件的多个对象的信息？

Question

我试图在下面构建一个模拟模型，但我有错误。 这是我的情况。 我有两个大型医院。

1. eu（eu1和eu2）

2. iu（iu1和iu2）

3. 每个大区域都有两个护理领域，并且患者从欧盟转移到IU（EU1至IU1或EU1或EU1至IU2或EU2或EU2到IU1或EU2）

4. Transporter将患者从欧盟移动到IU

5. 清洁器清洁所有床，但对护理区域并不重要。

6. 但是，已经清洁的床，床应放置每个护理区域清洁。

7. 有时，患者需要的床和将要清洁的床是不同的。 - ＆gt;我可以说这是“不匹配的情况”。 例如，如果EU1患者需要清洁EU1床，但是队列床的顶部是IU1床（或EU2或IU2，而不是EU1床）。因此，EU1患者应等到EU1床排队并清洁床。

8. 这也发生在IU患者需要IU床清洁

   时发生
9. 也许清洁床队列的顺序应稍后清洁请求
   可以改变

import simpy
import random

class Pre_Define:
    eu_beds= 10
    iu_beds= 10

class Bed():
    def __init__(self, id, request, care_area, name):
        self.id = id
        self.request = request
        self.care_area = care_area
        self.name = name
        self.pt_info = None
        self.priority = 2

class Patients:
    def __init__(self, p_id):
        self.id = p_id
        self.request = None
        self.edbed_info = None
        self.iubed_info = None
        self.care_area = None
        self.admission_decision = ""
        self.priority = 2
    def admin_decision(self):
        admin_decision_prob = random.uniform(0, 1)
        if admin_decision_prob <= 0.3:
            self.admission_decision = "DIS"
        elif admin_decision_prob > 0.3 and admin_decision_prob <= 0.6:
            self.admission_decision = "IU1"
        elif admin_decision_prob > 0.6:
            self.admission_decision = "IU2"
        return self.admission_decision
    
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_cleaner = simpy.Resource(self.env, capacity = 7)
        self.bed_transporter = simpy.Resource(self.env, capacity = 5)
        
        self.iu1_bed_clean = simpy.Store(self.env, capacity = 5)
        self.iu2_bed_clean = simpy.Store(self.env, capacity = 5)
        self.eu1_bed_clean = simpy.Store(self.env, capacity = 5)
        self.eu2_bed_clean = simpy.Store(self.env, capacity = 5)
        
        self.iu1_bed_dirty = simpy.Store(self.env, capacity = 5)
        self.iu2_bed_dirty = simpy.Store(self.env, capacity = 5)
        self.eu1_bed_dirty = simpy.Store(self.env, capacity = 5)
        self.eu2_bed_dirty = simpy.Store(self.env, capacity = 5)
        
        self.clean_request_q = simpy.Store(self.env, capacity = Pre_Define.eu_beds+Pre_Define.iu_beds)
        
        self.bed_dirty = simpy.Store(self.env)
        self.clean_request = simpy.Store(self.env)
        self.pt_q = simpy.PriorityStore(self.env)
        
    def generate_beds(self):
        self.eu1_bed_clean.items = [Bed(i+1, "EU", "EU1", f'EU1bed_{i}') for i in range(Pre_Define.eu_beds)]
        self.eu2_bed_clean.items = [Bed(i+1, "EU", "EU2", f'EU2bed_{i}') for i in range(Pre_Define.eu_beds)]
        self.iu1_bed_clean.items = [Bed(i+1, "IU", "IU1", f'IU1bed_{i}') for i in range(Pre_Define.iu_beds)]
        self.iu2_bed_clean.items = [Bed(i+1, "IU", "IU2", f'IU2bed_{i}') for i in range(Pre_Define.iu_beds)]

    def generate_pt_arrivals(self):
        while True:
            self.pt_counter += 1
            pt = Patients(self.pt_counter)
            carearea_prob = random.uniform(0, 1)
            if carearea_prob <= 0.5:
                pt.care_area = "EU1"
                pt.request = "EU"
            else:
                pt.care_area = "EU2"
                pt.request = "EU"
            yield self.env.timeout(5)
            self.env.process(self.ed_process(pt))

    def clean_beds_process(self, cleaner_id):
        while True:
            bed = yield self.clean_request_q.get()
            print(f'{self.env.now:.2f} Case chedk!! patient {bed.pt_info.id} request bed {bed.pt_info.request} bed in queue {bed.request}')
            # This is the matched case, patient request bed and the first queue in being cleaned bed 
            if (bed.pt_info.request == 'EU' and bed.request == 'EU') or (bed.pt_info.request == 'IU' and bed.request == 'IU'):
                print(f'{self.env.now:.2f} Matched case patient {bed.pt_info.id} get matched bed {bed.pt_info.request} = {bed.request}')
                with self.bed_cleaner.request() as bedreq:
                    yield bedreq
                    if bed.care_area == 'EU1':
                        yield self.eu1_bed_clean.put(bed)
                    elif bed.care_area == 'EU2':
                        yield self.eu2_bed_clean.put(bed)
                    elif bed.care_area == 'IU1':
                        yield self.iu1_bed_clean.put(bed)
                    else:
                        yield self.iu2_bed_clean.put(bed)
            # This is the NOT matched case, so just clean the the first in queue bed and the patient should wait until matching the bed
            else:
                print(f'{self.env.now:.2f} NOT matched case patient {bed.pt_info.id} get matched bed {bed.pt_info.request} != {bed.request}')
                with self.bed_cleaner.request() as bedreq:
                    yield bedreq
                    if bed.care_area == 'EU1':
                        yield self.eu1_bed_clean.put(bed)
                        continue
                    elif bed.care_area == 'EU2':
                        yield self.eu2_bed_clean.put(bed)
                        continue
                    if bed.care_area == 'IU1':
                        yield self.iu1_bed_clean.put(bed)
                        continue
                    else:
                        yield self.iu2_bed_clean.put(bed)
                        continue

    def ed_process(self, pt):
        with self.tg.request() as req:
            yield req
            yield self.env.timeout(15)
        print(f'{self.env.now:.2f} patient {pt.id} has been triaged {pt.care_area}')
        #yield self.pt_q.put(pt)
        #pt = yield self.pt_q.get()
        
        # EU1 case
        if pt.care_area == 'EU1':
            # The case: clean EU bed
            if self.eu1_bed_clean.items != []:
                edbed = yield self.eu1_bed_clean.get()
                # Copy pt info when comparing pt care area and bed care area at "clean_beds_process" function
                edbed.pt_info = pt
                pt.edbed_info = edbed
            # The case: don't have clean EU bed, but have dirty EU bed
            elif self.eu1_bed_dirty.items != []:
                edbed = yield self.eu1_bed_dirty.get()
                edbed.pt_info = pt
                yield self.clean_request_q.put(edbed)
                edbed = yield self.eu1_bed_clean.get()
                edbed.pt_info = pt
                pt.edbed_info = edbed
            # The case: don't have not only clean EU beds, but also dirty EU beds, so we should wait until any EU dirty bed come to list
            else:
                pass # I don't know what I have to do!!!

        # EU2 case    
        elif pt.care_area == 'EU2':
            if self.eu2_bed_clean.items != []:
                edbed = yield self.eu2_bed_clean.get()
                edbed.pt_info = pt
                pt.edbed_info = edbed
            elif self.eu2_bed_dirty.items != []:
                edbed = yield self.eu2_bed_dirty.get()
                edbed.pt_info = pt
                yield self.clean_request_q.put(edbed)
                edbed = yield self.eu2_bed_clean.get()
                edbed.pt_info = pt
                pt.edbed_info = edbed
                # The case: don't have not only clean EU beds, but also dirty EU beds, so we should wait until any EU dirty bed come to list
            else:
                pass # I don't know what I have to do!!!

        with self.physician.request() as req:
            yield req
            yield self.env.timeout(25)
            pt.admin_decision()
            
        # IU1 case
        print(f'{self.env.now:.2f} patient {pt.id} IU case {pt.admission_decision}')
        if pt.admission_decision == "IU1":
            pt.request = "IU"
            # The case that already clean IU beds available
            if self.iu1_bed_clean.items != []:
                iubed = yield self.iu1_bed_clean.get()
                # Copy pt info when comparing pt care area and bed care area
                iubed.pt_info = pt
                pt.iubed_info = iubed
                print(f'{self.env.now:.2f} patient {pt.id} get IU1 bed {iubed.id} direct')
            # The case don't have clean IU beds, so request one of them is cleaned
            elif self.iu1_bed_dirty.items != []:
                iubed = yield self.iu1_bed_dirty.get()
                # Copy pt info when comparing pt care area and bed care area
                iubed.pt_info = pt
                yield self.clean_request_q.put(iubed)
                iubed = yield self.iu1_bed_clean.get()
                iubed.pt_info = pt
                pt.iubed_info = iubed
                print(f'{self.env.now:.2f} patient {pt.id} get IU1 bed {iubed.id} after cleaning')
            # The case don't have not only clean IU beds, but also dirty IU beds, so we should wait until IU dirty bed come to list
            else:
                pass # I don't know what I have to do!!!

            # The case EU bed return base on the care area
            if pt.care_area == 'EU1':
                print(f'{self.env.now:.2f} patient {pt.id} return edbed {pt.edbed_info.id}')
                yield self.eu1_bed_dirty.put(pt.edbed_info)
            else:
                print(f'{self.env.now:.2f} patient {pt.id} return edbed {pt.edbed_info.id}')
                yield self.eu2_bed_dirty.put(pt.edbed_info)
                
            # After waiting bed transporter for moving from EU and IU
            with self.bed_transporter.request() as transreq:
                yield transreq
                
            # After using IU bed, return, put the iubed dirty queue list by care area
            yield self.env.timeout(30)
            if iubed.care_area == 'IU1':
                print(f'{self.env.now:.2f} patient {pt.id} return iubed {pt.edbed_info.id}')
                yield self.iu1_bed_dirty.put(pt.iubed_info)
            else:
                print(f'{self.env.now:.2f} patient {pt.id} return iubed {pt.edbed_info.id}')
                yield self.iu2_bed_dirty.put(pt.iubed_info)
        # IU2 case    
        elif pt.admission_decision == "IU2":
            pt.request = "IU"
            if self.iu2_bed_clean.items != []:
                iubed = yield self.iu2_bed_clean.get()
                # Copy pt info when comparing pt care area and bed care area
                iubed.pt_info = pt
                pt.iubed_info = iubed
                print(f'{self.env.now:.2f} patient {pt.id} get IU2 bed {iubed.id} direct')
            # The case don't have clean IU beds, so request one of them is cleaned
            elif self.iu2_bed_dirty.items != []:
                iubed = yield self.iu2_bed_dirty.get()
                # Copy pt info when comparing pt care area and bed care area
                iubed.pt_info = pt
                yield self.clean_request_q.put(iubed)
                iubed = yield self.iu2_bed_clean.get()
                iubed.pt_info = pt
                pt.iubed_info = iubed
                print(f'{self.env.now:.2f} patient {pt.id} get IU2 bed {iubed.id} after cleaning')
            # The case don't have not only clean IU beds, but also dirty IU beds, so we should wait until IU dirty bed come to list
            else:
                pass # I don't know what I have to do!!!
                
            if pt.care_area == 'EU1':
                yield self.eu1_bed_dirty.put(pt.edbed_info)
            else:
                yield self.eu2_bed_dirty.put(pt.edbed_info)
            # After waiting bed transporter for moving from EU and IU
            with self.bed_transporter.request() as transreq:
                yield transreq
            # After using IU bed, return, put the iubed dirty queue list
            yield self.env.timeout(30)
            if iubed.care_area == 'IU1':
                print(f'{self.env.now:.2f} patient {pt.id} return iubed {pt.edbed_info.id}')
                yield self.iu1_bed_dirty.put(pt.iubed_info)
            else:
                print(f'{self.env.now:.2f} patient {pt.id} return iubed {pt.edbed_info.id}')
                yield self.iu2_bed_dirty.put(pt.iubed_info)
        
        # Discharge case don't need IU bed, just discharge! and return EU bed
        else:
            # Return EU bed and put the eubed dirty queue list
            if pt.care_area == 'EU1':
                print(f'{self.env.now:.2f} patient {pt.id} return edbed {pt.edbed_info.id}')
                yield self.eu1_bed_dirty.put(pt.edbed_info)
            else:
                print(f'{self.env.now:.2f} patient {pt.id} return edbed {pt.edbed_info.id}')
                yield self.eu2_bed_dirty.put(pt.edbed_info)

    def run(self):
        self.env.process(self.generate_pt_arrivals())
        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 = 300)

run_model = Model(0)
run_model.run()

我稍后实现了该方案，但有一个错误。

attributeError：“ nontype”对象没有属性“ id”，

我认为这是因为没有监控病人和床信息。 请给我一些解决这个问题的意见或想法。 谢谢您的时间和工作。