1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213

# -*- coding: utf-8 -*-

import simpy
import numpy


# 機具
class Machine(object):
    # 建構機具物件
    def __init__(self, sim_environment, 
                 machine_definition, item_definition):
        
        self.sim_environment = sim_environment
        self.machine_definition = machine_definition
        self.item_definition = item_definition
        
        # 將機具視為有限資源
        resource_capacity = len(machine_definition.keys())
        self.machine_resource = simpy.Resource(sim_environment, 
                                               capacity=resource_capacity)
        
    # 機具資源
    def getResource(self):
        return self.machine_resource

    # 隨機指派機具
    def findMachine(self):
        name_machine = 'M-%02d' % numpy.random.randint(
            len(self.machine_definition.keys()))
        _machine = self.machine_definition[name_machine]
            
        return name_machine
            
    # 當機具收到待修物件時
    def service(self, name_machine, name_item):
        # 進場時間
        time_start = self.sim_environment.now
        
        machine = self.machine_definition[name_machine]
        item = self.item_definition[name_item]
        
        machine['busy'] = True

        # 機具處理時間 = 機具單位處理時間 * 物件損壞程度
        working_time = machine['time'] * item['damage']
        yield self.sim_environment.timeout(working_time)

        # 機具處理後紀錄
        machine['busy'] = False
        
        machine['history'].append({
            'item': name_item, 
            'start': time_start, 
            'end': self.sim_environment.now })


# 物件
class Item(object):
    def __init__(self, sim_environment, 
                 machine_definition, item_definition, 
                 machine):
        
        self.sim_environment = sim_environment
        self.machine_definition = machine_definition
        self.item_definition = item_definition
        self.machine = machine

    # 當物件需要待修時
    def service(self, name_item):
        item = self.item_definition[name_item]

        # 物件請求機具資源成功
        with self.machine.getResource().request() as request:
            yield request

            # 物件開始處理時間
            time_start = self.sim_environment.now
            
            # 隨機指派機具服務
            name_machine = self.machine.findMachine()
            if name_machine is None:
                # 機具沒空處理物件
                item['history'].append({
                    'machine': '',
                    'start': self.sim_environment.now, 
                    'end': self.sim_environment.now })
            else:
                # 觸發機具服務
                yield self.sim_environment.process(
                    self.machine.service(name_machine, name_item))
        
                # 物件處理結束時間
                item['broken'] = False
                
                item['history'].append({
                    'machine': name_machine,
                    'start': time_start, 
                    'end': self.sim_environment.now })


# 模擬
class Simulation(object):
    # 建構物件
    def __init__(self, simulation_cycle, 
                 num_machine=4, num_item=16, 
                 event_interval=8):
        
        self.simulation_cycle = simulation_cycle
        self.event_interval = event_interval
        
        # 依據模擬週期，重設亂數因子
        numpy.random.seed(numpy.random.randint(simulation_cycle) + 1)
    
        # 隨機產生機具參數，至少有 4 ~ 7 部可供服務
        self.machine_definition = {}
        for i in range(0, numpy.random.randint(num_machine) + num_machine):
            self.machine_definition['M-%02d' % i] = {
                'time': 10 * numpy.random.rand() + 0.1,
                'busy': False,
                'history': []
                }
        
        # 隨機產生物件參數，至少有 16 ~ 35 部可供服務
        self.item_definition = {}
        for i in range(0, numpy.random.randint(num_item) + num_item):
            self.item_definition['I-%02d' % i] = {
                'damage': numpy.random.rand() + 0.1,
                'broken': False,
                'history': []
                }

        # 模擬環境
        self.sim_environment = simpy.Environment()

        # 初始機具
        self.machine = Machine(self.sim_environment, 
                               self.machine_definition, self.item_definition)
        # 初始物件
        self.item = Item(self.sim_environment, 
                         self.machine_definition, self.item_definition, 
                         self.machine)

    # 待修物件
    def __run__(self):
        while True:
            # 隨機產生待修物件，至少要等候 8 ~ 15 個
            _event_interval = numpy.random.randint(self.event_interval) + self.event_interval
            
            # 物件等候處理所需之間隔時間
            yield self.sim_environment.timeout(_event_interval)
            
            name_item = 'I-%02d' % numpy.random.randint(len(self.item_definition.keys()))
            item = self.item_definition[name_item]
            item['broken'] = True
            
            # 觸發機具處理新物件
            self.sim_environment.process(self.item.service(name_item))
        
    # 模擬進入點
    def service(self):
        # 設置模擬程序
        self.sim_environment.process(self.__run__())
        
        # 啟動模擬
        self.sim_environment.run(until=self.simulation_cycle)

        # 輸出結果
        self.result()

    # 輸出結果
    def result(self):
        # 輸出機具服務
        with open('M.dat', 'w') as fM:
            for machine in self.machine_definition:
                _machine = self.machine_definition[machine]
                
                _history = _machine['history']        
                for _work in _history:
                    fM.write(
                        '%s\t%6.2f\t%s\t%6.2f\t%6.2f\t%6.2f\n' % (
                            machine, _machine['time'], _work['item'], 
                            _work['start'], _work['end'],
                            _work['end'] - _work['start'])
                         )
            
        # 輸出物件維修
        with open('I.dat', 'w') as fI:
            for item in self.item_definition:
                _item = self.item_definition[item]
                
                _history = _item['history']
                for _work in _history:
                    fI.write(
                        '%s\t%6.2f\t%s\t%6.2f\t%6.2f\t%6.2f\n' % (
                            item, _item['damage'], _work['machine'], 
                            _work['start'], _work['end'], 
                            _work['end'] - _work['start'])
                         )


# 主程式
if __name__ == '__main__':
    # m 個物件指派 n 台機具維修
    # 物件隨機等候發生故障
    # 機具隨機被指派維修物件
    
    simulation = Simulation(
        simulation_cycle=500, 
        num_machine=4, num_item=16, 
        event_interval=8)
    
    simulation.service()