Моделирование методом Монте-Карло: основные изменения параметров распределения во время моделирования в зависимости от условий

Это решение может обрабатывать более 2 машин. Когда машина ломается, она отправляет сообщение всем другим машинам, уведомляя их о поломке. Машина также отправляет уведомление, когда она исправлена. Каждая машина отслеживает, сколько машин сломано, и ускоряет производство, если 1 или более машин сломаны. Время до отказа (ttf) также ускорено. когда ставки меняются, ход выполнения текущей части учитывается при расчете нового времени окончания. Прерывание используется как для запуска сбоя, так и для сброса, когда незавершенная работа будет завершена. также ознакомьтесь с примером механического цеха в документации. У меня не хватило времени, чтобы поработать над этим, так что это может быть не идеально

"""
Machine shop example where machines change their
production rate and break down rates in response
to other machines breaking down or getting fixed

If one machine breaks down, the remaining machines 
will speed up until all machines are fixed

speeding up the production rate also speeds up the
time till failure ttf

rates can change in the middle of making a part

Programmmer: Michael R. Gibbs
"""

import simpy
import random

class Machine():
    """
    Machine that makes parts.
    Machine breaks down at ramdom time
    The machine has a normal mode, and a fast mode

    Machine speeds up when it receives a message that
    another machine has broken down and slows back down
    when it receives messages that all broken machines are fixed
    
    env:    simulation environment
    id:     name of the machine
    rate:   number of parts per time unit (normal mode)
    fast_rate:  number of parts per time unit (fast mode)
    ttf_gen:    zero param func to generate ttf (normal mode)
    fast_ttf_gen:   zero param func to generate ttf (fast mode)
    """

    def __init__(self, env, id, rate, fast_rate, ttf_gen, fast_ttf_gen):

        self.id = id
        self.env = env
        self.rate = rate
        self.fast_rate = fast_rate
        self.ttf_gen = ttf_gen
        self.fast_ttf_gen = fast_ttf_gen
        self.broken = False
        self.fast_mode = False
        self.remaining_time = 0
        self.current_rate = self.rate

        self.mach_list = []
        self.broke_cnt = 0

        # start the part making, an the count down till failure
        self.make_parts_proc = self.env.process(self.make_parts())
        self.breakdown_proc = self.env.process(self.gen_breakdown())

    def make_parts(self):
        """
        Main loop to manufacture parts

        interupts are used to trigger updates
        when rates change and when breakdowns occure
        """

        while True:

            if self.remaining_time <= 0:
                # starting a new part
                print(f'{self.env.now:.2f}: mach: {self.id} has started a part')
                
                # need to store times so other methods can upate
                # the procesing state
                self.total_part_time = 1 / self.current_rate
                self.remaining_time = self.total_part_time 

            while self.remaining_time > 0:
                # need to loop incase get inturrupted 
                # while in the middle of making a part

                try:
                    self.part_start_time = self.env.now # used to track progress
                    yield self.env.timeout(self.remaining_time)

                    # got here without being interupted, done with part
                    self.remaining_time = 0

                except simpy.Interrupt:
                    # can get inturpted because processing rate changed
                    # or a breakdown has happend
                    # if rate changed, we are using the inturput to update 
                    # the processing timeout
                                            
                    if self.broken:
                        # processing is interuped, fix machine

                        # update processing progress
                        self.remaining_time -= (self.env.now - self.part_start_time)
                        
                        print(f'{self.env.now:.2f}: mach: {self.id} has broken down')
                        
                        # notify other machines that this machine has broke
                        for m in self.mach_list:
                            m.someone_broke(self)

                        # time out for fixing
                        yield self.env.timeout(5)

                        # notify other machines that this machine is fixed
                        for m in self.mach_list:
                            m.someone_fixed(self)
                        
                        print(f'{self.env.now:.2f}: mach: {self.id} has been fixed')

                        # start a new breakdown count down
                        self.breakdown_proc = self.env.process(self.gen_breakdown())
                        self.broken = False

            print(f'{self.env.now:.2f}: mach: {self.id} has finish a part')

    def gen_breakdown(self):
        """
            counts down to failure and uses
            a interrupt to stop processing
            and start repairs

            using class properties instead of local
            variables so other methods can update
            the countdown state of ttf
        """

        if not self.broken:
            # get breakdown based on current fast mode
            if self.fast_mode:
                self.total_ttf = self.fast_ttf_gen()
            else:
                self.total_ttf = self.ttf_gen()

            self.remaining_ttf = self.total_ttf

            while self.remaining_ttf > 0:
                self.ttf_start = self.env.now
                print(f'{self.env.now:.2f}: mach: {self.id} has {self.remaining_ttf} till breakdown')
                try:
                    yield self.env.timeout(self.remaining_ttf)

                    # failure has orrured
                    self.broken = True
                    self.make_parts_proc.interrupt()
                    self.remaining_ttf = 0

                except simpy.Interrupt:
                    # the state has been updated
                    # the timeout has been interupted
                    # so it can be restarted with new state
                    print(f'{self.env.now:.2f}: mach: {self.id} updating ttf {self.remaining_ttf}')
        print(f'{self.env.now:.2f}: mach: {self.id} ttf gen exit')

    def someone_broke(self, mach):
        """
        Another machine is notifing this machine that it has broken
        and this machine needs to change to fast mode, if not already
        in fast mode
        """

        self.broke_cnt += 1
        
        print(f'{self.env.now:.2f}: mach: {self.id} received mess that mach: {mach.id} has broke, broke cnt: {self.broke_cnt}')
    
        if not self.fast_mode:
            self.fast_mode = True

            # update the ttf based on the fast mode ttf func
            # keep the same progress so if we were 90% of of the 
            # old ttf, then set things so we are still 90% of new ttf

            # update with the last bit of progress
            self.remaining_ttf -= self.env.now - self.ttf_start
            per_ttf_left = (self.remaining_ttf/self.total_ttf)

            # update based on fast ttf
            self.total_ttf = self.fast_ttf_gen() 
            self.remaining_ttf = per_ttf_left * self.total_ttf
            if self.remaining_ttf <= 0:
                # special case when notification happens at same time as breakdown
                self.remaining_ttf = 0.001
                
            # update the part processing state

            # update the last bit of processing progress
            self.remaining_time -= self.env.now - self.part_start_time

            # update state based on new processing fast rate
            # like ttf keep the same perenct of progress
            self.current_rate = self.fast_rate
            old_total = self.total_part_time
            self.total_part_time = 1 / self.current_rate
            per_left = self.remaining_time / old_total
            self.remaining_time = self.total_part_time * per_left

            if not self.broken:
                # if broken nothing to interrupt
                # new states will used when machine
                # is fixed and processing starts up again
                self.breakdown_proc.interrupt()
                self.make_parts_proc.interrupt()


                
    def someone_fixed(self, mach):
        """
        Another machine is notifing this machine that it has been fixed
        and this machine needs to change to normal mode, if there are
        no more broken machines
        """

        self.broke_cnt -= 1

        print(f'{self.env.now:.2f}: mach: {self.id} received mess that mach: {mach.id} is fixed, broke cnt: {self.broke_cnt}')
        
        # only change if all machines are fixed and broke cnt is 0
        if self.broke_cnt <= 0:
            self.broke_cnt = 0

            if self.fast_mode:
                self.fast_mode = False

            # update the ttf based on the normal mode ttf func
            # keep the same progress so if we were 90% of of the 
            # old ttf, then set things so we are still 90% of new ttf

            # update with the last bit of progress
            self.remaining_ttf -= self.env.now - self.ttf_start
            per_ttf_left = (self.remaining_ttf/self.total_ttf)

            self.total_ttf = self.ttf_gen()
            self.remaining_ttf = per_ttf_left * self.total_ttf

            if self.remaining_ttf <= 0:
                # special case when notifcation happens at breakdown time
                self.remaining_ttf = 0.001
                
            # update state based on new processing normal rate
            # like ttf keep the same perenct of progress
            self.remaining_time -= self.env.now - self.part_start_time
            self.current_rate = self.rate
            old_total = self.total_part_time
            self.total_part_time = 1 / self.current_rate
            per_left = self.remaining_time / old_total
            self.remaining_time = self.total_part_time * per_left

            if not self.broken:
                # if broken nothing to interrupt
                # new states will be used when machine
                # is fixed and processing starts up again
               self.breakdown_proc.interrupt()
               self.make_parts_proc.interrupt()



    def set_mach_list(self, mach_list):
        """
        set the list of machines to be notified if this machine
        breaks down, or is fixed
        """
        self.mach_list = mach_list 

# ttf generator function
#
# by wrapping a dist in a lambda I 
# created create a 0 param function
# that I can pass to the Machine class
# To change the dist I just need to 
# update the lambda, no hard codeing 
# of dist func parameters in the Machine
# class code
ttf = lambda : random.randint(8,10)
fast_ttf = lambda: random.randint(5,7)

# create sim
env = simpy.Environment()

mach_list = []
machines_cnt = 2 # can be more then 2 
for i in range(1, machines_cnt + 1):
    m = Machine(env, i, 5, 8, ttf, fast_ttf)
    mach_list.append(m)

# build list of machines to notify
# when a machine breaks or gets fixed
for m in mach_list:
    # filter out the current machine
    # don't want to send to self
    other_m = mach_list.copy()
    other_m.remove(m)

    m.set_mach_list(other_m)

env.run(until = 50)

print("end of simulation")