Untitled
unknown
plain_text
2 years ago
21 kB
3
Indexable
import simpy
import random
import matplotlib.pyplot as plt
#tempi di riordino
t_raw_1= random.normalvariate(5*8,0.5)
t_raw_2 = random.normalvariate(5*8,0.5)
t_cc_1 = random.normalvariate(random.randint(16, 32),1)
t_cc_2 = random.normalvariate(random.randint(16, 32),1)
t_sep = random.normalvariate(random.randint(16, 32),0.3)
t_cases = random.normalvariate(4*8,0.5)
t_electrolyte_tank = random.normalvariate(8,0.5)
#unità prodotte per ciclo
n_raw_1= 10
n_raw_2 = 10
n_cc_1 = 150
n_cc_2 = 150
n_sep = 50
n_cases = 500
n_electrolyte_tank = 4
#critical stock
raw_1_critical_stock = (t_raw_1*n_raw_1)*2
raw_2_critical_stock = (t_raw_2*n_raw_2)*2
cc_1_critical_stock = (t_cc_1*n_cc_1)*2
cc_2_critical_stock = (t_cc_2*n_cc_2)*2
sep_critical_stock = (t_sep*n_sep)*2
cases_critical_stock = (t_cases*n_cases)*2
electrolyte_tank_critical_stock = (t_electrolyte_tank*n_electrolyte_tank)*2
#quantità di riordino
r_raw_1= raw_1_critical_stock*10
r_raw_2= raw_2_critical_stock*10
r_cc_1= cc_1_critical_stock*10
r_cc_2= cc_2_critical_stock*10
r_sep= sep_critical_stock*10
r_cases= cases_critical_stock*10
r_electrolyte_tank= electrolyte_tank_critical_stock*10
#tempo di ricarica in risorsa formation machine
ch_m=3
ch_dev=0.3
charge_time = random.gauss(ch_m, ch_dev)
#distribuzione probabilità scarti
mean_g = 1
dev_g = 0.01
quality_std = dev_g*2
#liste controlli debug
raw_1_level=[]
raw_2_level=[]
tank_1_level=[]
tank_2_level=[]
cc_1_level=[]
cc_2_level=[]
roll_1_level=[]
roll_2_level=[]
sep_level=[]
jelly_level=[]
cases_level=[]
open_cells_level=[]
electrolyte_tank_level=[]
final_cells_level=[]
dispatch_level=[]
counter = []
reject_level = []
control=[]
#----------------------------------PROCESSI -----------------------------------
def ink (env, gigafactory, line): #INK MIXING PROCESS, prende dai raw, processa e immette nel serbatoio di ink
if line == 1:
while True:
yield gigafactory.raw_1.get(n_raw_1)
raw_1_level.append(gigafactory.raw_1.level)
yield env.timeout(3)
yield gigafactory.tank_1.put(5)
tank_1_level.append(gigafactory.tank_1.level)
else:
while True:
yield gigafactory.raw_2.get(n_raw_2)
raw_2_level.append(gigafactory.raw_2.level)
yield env.timeout(3)
yield gigafactory.tank_2.put(5)
tank_2_level.append(gigafactory.tank_2.level)
def roll_prep (env, gigafactory, line): #prende dal serbatoio di ink e dal cc, processa e immette nel roll intermedio
if line == 1:
while True:
yield gigafactory.tank_1.get(1)
tank_1_level.append(gigafactory.tank_1.level)
yield gigafactory.cc_1.get(n_cc_1)
cc_1_level.append(gigafactory.cc_1.level)
yield env.timeout(2)
yield gigafactory.roll_1.put(150)
roll_1_level.append(gigafactory.roll_1.level)
else:
while True:
yield gigafactory.tank_2.get(1)
tank_2_level.append(gigafactory.tank_2.level)
yield gigafactory.cc_2.get(n_cc_2)
cc_2_level.append(gigafactory.cc_2.level)
yield env.timeout(2)
yield gigafactory.roll_2.put(150)
roll_2_level.append(gigafactory.roll_2.level)
def jelly_prep (env, gigafactory): #prende dai roll intermedi e dal separatore, unisce e put in jelly
while True:
yield gigafactory.roll_1.get(50)
roll_1_level.append(gigafactory.roll_1.level)
yield gigafactory.roll_2.get(50)
roll_2_level.append(gigafactory.roll_2.level)
yield gigafactory.sep.get(n_sep)
sep_level.append(gigafactory.sep.level)
yield env.timeout(5)
yield gigafactory.jelly.put(200)
jelly_level.append(gigafactory.jelly.level)
def open_cells_prep (env, gigafactory): #prende dai jelly e dai case, unisce e put in cells
while True:
yield gigafactory.jelly.get(500)
jelly_level.append(gigafactory.jelly.level)
yield gigafactory.cases.get(n_cases)
cases_level.append(gigafactory.cases.level)
yield env.timeout(1)
yield gigafactory.open_cells.put(500)
open_cells_level.append(gigafactory.open_cells.level)
def final_cells_prep (env, gigafactory): #prende dalle celle non finite open e dal serbatoio elettrolita, unisce e put in cells finale
while True:
yield gigafactory.open_cells.get(400)
open_cells_level.append(gigafactory.open_cells.level)
yield gigafactory.electrolyte_tank.get(n_electrolyte_tank)
electrolyte_tank_level.append(gigafactory.electrolyte_tank.level)
yield env.timeout(1)
yield gigafactory.final_cells.put(400)
final_cells_level.append(gigafactory.final_cells.level)
def formation_charger(env, gigafactory, formation_machine_res, charge_time): # genera i processi di ricarica delle celle in formation machine
while True:
if gigafactory.final_cells.level>10:
for i in range(gigafactory.final_cells.level):
env.process(formation_machine(env, gigafactory, formation_machine_res, charge_time))
#print(formation_machine_res.count)
yield gigafactory.final_cells.get(gigafactory.final_cells.level)
final_cells_level.append(gigafactory.final_cells.level)
else:
yield env.timeout(1)
def formation_machine (env, gigafactory, formation_machine_res, charge_time): #ritira dalle celle pronte e le mette in carica nel formation machine
with formation_machine_res.request() as req:
yield req
yield env.timeout(charge_time)
yield gigafactory.dispatch.put(1)
counter.append(formation_machine_res.count)
dispatch_level.append(gigafactory.dispatch.level)
def quality_check (env, gigafactory):
while True:
yield env.timeout(0.05)
x=random.gauss(mean_g, dev_g)
control.append(x)
if (x<(mean_g-quality_std)) or (x>(mean_g+quality_std)):
yield gigafactory.dispatch.get(1)
yield gigafactory.reject.put(1)
reject_level.append(gigafactory.reject.level)
class Gigafactory:
def __init__(self,
env,
#materie prime
raw_capacity,
init_raw,
#ink tank
tank_capacity,
init_tank,
#current collectors
cc_capacity,
init_cc,
#roll intermedio magzzino
roll_capacity,
init_roll,
#separatore
sep_capacity,
init_sep,
#jelly roll
jelly_capacity,
init_jelly,
#cases
cases_capacity,
init_cases,
#magazzino celle non completate
open_cells_capacity,
init_open_cells,
#electrolyte tank
electrolyte_capacity,
init_electrolyte,
#magazzino celle complete
final_cells_capacity,
init_final_cells,
#formed cells
formed_cells_capacity,
init_formed_cells,
#dispatch
dispatch_capacity,
init_dispatch,
#scarti
reject_capacity,
init_reject
):
self.env = env
#container delle materie prime per ink, con capacità e init uguali
self.raw_1 = simpy.Container(env, capacity=raw_capacity, init=init_raw)
self.raw_2 = simpy.Container(env, capacity=raw_capacity, init=init_raw)
self.raw_control_1 = env.process(self.raw_stock_control(env, 1)) #controllo per riordino materie prime linea 1
self.raw_control_2 = env.process(self.raw_stock_control(env, 2)) #controllo per riordino materie prime linea 2
#serbatoi di ink
self.tank_1 = simpy.Container(env, capacity=tank_capacity, init=init_tank)
self.tank_2 = simpy.Container(env, capacity=tank_capacity, init=init_tank)
#current collectors magazzino
self.cc_1 = simpy.Container(env, capacity=cc_capacity, init=init_cc)
self.cc_2 = simpy.Container(env, capacity=cc_capacity, init=init_cc)
self.cc_control_1 = env.process(self.cc_stock_control(env, 1)) #controllo per riordino collettori linea 1
self.cc_control_2 = env.process(self.cc_stock_control(env, 2)) #controllo per riordino collettori linea 2
#roll intermedio magzzino
self.roll_1 = simpy.Container(env, capacity=roll_capacity, init=init_roll)
self.roll_2 = simpy.Container(env, capacity=roll_capacity, init=init_roll)
# --------------------------------------------------------------------------------
#separatore magazzino
self.sep = simpy.Container(env, capacity=sep_capacity, init=init_sep)
self.sep_control = env.process(self.sep_stock_control(env)) #controllo per riordino separatore
#jelly rolls magazzino
self.jelly = simpy.Container(env, capacity=jelly_capacity, init=init_jelly)
#cases magazzino
self.cases = simpy.Container(env, capacity=cases_capacity, init=init_cases)
self.cases_control = env.process(self.cases_stock_control(env)) #controllo per riordino cases
# ...............................................................................
#magazzino celle aperte
self.open_cells = simpy.Container(env, capacity=open_cells_capacity, init=init_open_cells)
#electrolyte tank
self.electrolyte_tank = simpy.Container(env, capacity=electrolyte_capacity, init=init_electrolyte)
self.electrolyte_control = env.process(self.electrolyte_stock_control(env)) #controllo per riordino cases
#magazzino celle finite
self.final_cells = simpy.Container(env, capacity=final_cells_capacity, init=init_final_cells)
# --------------------------------------------------------------------------------
#formed cells container
self.formed_cells = simpy.Container(env, capacity=formed_cells_capacity, init=init_formed_cells)
# -----------------------------------------------------------------------------------
#dispatch
self.dispatch = simpy.Container(env, capacity=dispatch_capacity, init=init_dispatch)
#scarti
self.reject = simpy.Container(env, capacity=reject_capacity, init=init_reject)
#----------------------------------FINE CONTAINER ---------------------------------
#----------------------------------INIZIO CONTROLLI FORNITORI -----------------------------------
def raw_stock_control (self, env, line):
yield env.timeout(0)
if line == 1:
while True:
if self.raw_1.level <= raw_1_critical_stock:
print("Riordino materie prime linea 1")
yield env.timeout(1)
yield self.raw_1.put(r_raw_1)
print("Nuovo livello materie prime linea 1: %d" %self.raw_1.level)
yield env.timeout(t_raw_1)
else:
yield env.timeout(1)
else:
while True:
if self.raw_2.level <= raw_2_critical_stock:
print("Riordino materie prime linea 2")
yield env.timeout(1)
yield self.raw_2.put(r_raw_2)
print("Nuovo livello materie prime linea 2: %d" %self.raw_2.level)
yield env.timeout(t_raw_2)
else:
yield env.timeout(1)
# ---------------------------------------------------------------------------------------------------------------------
def cc_stock_control (self, env, line):
yield env.timeout(0)
if line == 1:
while True:
if self.cc_1.level <= cc_1_critical_stock:
print("Riordino collettore linea 1")
yield env.timeout(1)
yield self.cc_1.put(r_cc_1)
print("Nuovo livello collettore linea 1: %d" %self.cc_1.level)
yield env.timeout(t_cc_1)
else:
yield env.timeout(1)
else:
while True:
if self.cc_2.level <= cc_2_critical_stock:
print("Riordino collettore linea 2")
yield env.timeout(1)
yield self.cc_2.put(r_cc_2)
print("Nuovo livello collettore linea 2: %d" %self.cc_2.level)
yield env.timeout(t_cc_2)
else:
yield env.timeout(1)
#-------------------------------------------------------------------------------------------------------------------
def sep_stock_control (self, env):
yield env.timeout(0)
while True:
if self.sep.level <= sep_critical_stock:
print("Riordino separatore")
yield env.timeout(1)
yield self.sep.put(r_sep)
print("Nuovo livello separatore: %d" %self.sep.level)
yield env.timeout(t_sep)
else:
yield env.timeout(1)
#-------------------------------------------------------------------------------------------------------------------
def cases_stock_control (self, env):
yield env.timeout(0)
while True:
if self.cases.level <= cases_critical_stock:
print("Riordino cases")
yield env.timeout(1)
yield self.sep.put(r_cases)
print("Nuovo livello cases: %d" %self.cases.level)
yield env.timeout(t_cases)
else:
yield env.timeout(1)
#-------------------------------------------------------------------------------------------------------------------
def electrolyte_stock_control (self, env):
yield env.timeout(0)
while True:
if self.electrolyte_tank.level <= electrolyte_tank_critical_stock:
print("Riordino Elettrolita")
yield env.timeout(1)
yield self.electrolyte_tank.put(r_electrolyte_tank)
print("Nuovo livello elettrolita: %d" %self.electrolyte_tank.level)
yield env.timeout(t_electrolyte_tank)
else:
yield env.timeout(1)
#-------------------------------------------------------------------------------------------------------------------
env = simpy.Environment()
formation_machine_res = simpy.Resource(env, capacity = 25)
gigafactory = Gigafactory(
env,
#materie prime
raw_capacity= r_raw_1*1.5,
init_raw= r_raw_1*0.5,
#ink tank
tank_capacity= 50,
init_tank= 0,
#current collectors
cc_capacity= r_cc_1*1.5,
init_cc= r_cc_1*0.5,
#roll intermedio magzzino
roll_capacity=500,
init_roll=0,
#separatore
sep_capacity= r_sep*1.5,
init_sep= r_sep*0.5,
#jelly roll
jelly_capacity=10000,
init_jelly=0,
#cases
cases_capacity= r_cases*1.5,
init_cases= r_cases*0.5,
#magazzino celle
open_cells_capacity=10000,
init_open_cells=0,
#electrolyte tank
electrolyte_capacity= r_electrolyte_tank*1.5,
init_electrolyte= r_electrolyte_tank*0.5,
#magazzino celle complete
final_cells_capacity=10000,
init_final_cells= 0,
#formed cells
formed_cells_capacity=10000,
init_formed_cells=0,
#dispatch
dispatch_capacity=500000,
init_dispatch=0,
#scarti
reject_capacity=500000,
init_reject=0
)
print("----------------------LIVELLI INIZIALI--------------------------")
print("Livello raw materials 1")
print(gigafactory.raw_1.level)
print("Livello raw materials 2")
print(gigafactory.raw_2.level)
print("Litri di ink 1")
print(gigafactory.tank_1.level)
print("Litri di ink 2")
print(gigafactory.tank_2.level)
print("Metri di current collector 1")
print(gigafactory.cc_1.level)
print("Metri di current collector 2")
print(gigafactory.cc_2.level)
print("Metri di roll 1")
print(gigafactory.roll_1.level)
print("Metri di roll 2")
print(gigafactory.roll_2.level)
print("Metri di separatore")
print(gigafactory.sep.level)
print("Numero di jelly rolls")
print(gigafactory.jelly.level)
print("Numero di cases")
print(gigafactory.cases.level)
print("Celle non complete")
print(gigafactory.open_cells.level)
print("Livello elettrolita")
print(gigafactory.electrolyte_tank.level)
print("Celle pronte per formation machine")
print(gigafactory.final_cells.level)
print("Celle prodotte")
print(gigafactory.dispatch.level)
print("Celle scartate")
print(gigafactory.reject.level)
#-------------------------------SIMULAZIONE---------------------------------
#linea 1
ink_mixing_process_1 = env.process(ink(env, gigafactory,1))
roll_prep_1 = env.process(roll_prep(env, gigafactory,1))
#linea 2
ink_mixing_process_2 = env.process(ink(env, gigafactory,2))
roll_prep_2 = env.process(roll_prep(env, gigafactory,2))
#jelly
jelly_prep = env.process(jelly_prep(env, gigafactory))
#cella aperta
open_cells_prep = env.process(open_cells_prep(env, gigafactory))
#cella finita
final_cells_prep = env.process(final_cells_prep(env, gigafactory))
#formation
formation = env.process(formation_charger(env, gigafactory, formation_machine_res, charge_time))
#quality
quality = env.process(quality_check (env, gigafactory))
t_sim=5*8*4*12
env.run(until=t_sim)
kpi_throughput = gigafactory.dispatch.level/t_sim
print("----------------------LIVELLI FINALI--------------------------")
print("Livello raw materials 1")
print(gigafactory.raw_1.level)
print("Livello raw materials 2")
print(gigafactory.raw_2.level)
print("Litri di ink 1")
print(gigafactory.tank_1.level)
print("Litri di ink 2")
print(gigafactory.tank_2.level)
print("Metri di current collector 1")
print(gigafactory.cc_1.level)
print("Metri di current collector 2")
print(gigafactory.cc_2.level)
print("Metri di roll 1")
print(gigafactory.roll_1.level)
print("Metri di roll 2")
print(gigafactory.roll_2.level)
print("Metri di separatore")
print(gigafactory.sep.level)
print("Numero di jelly rolls")
print(gigafactory.jelly.level)
print("Numero di cases")
print(gigafactory.cases.level)
print("Celle non complete")
print(gigafactory.open_cells.level)
print("Livello elettrolita")
print(gigafactory.electrolyte_tank.level)
print("Celle pronte per formation machine")
print(gigafactory.final_cells.level)
print("Celle prodotte")
print(gigafactory.dispatch.level)
print("Celle scartate")
print(gigafactory.reject.level)
fig, ax = plt.subplots()
# plot the data and customize
#ax.plot(raw_1_level, label = "raw 1")
#ax.plot(raw_2_level, label = "raw 2")
#ax.plot(tank_1_level, label = "tank 1")
#ax.plot(tank_2_level, label = "tank 2")
#ax.plot(cc_1_level, label = "cc 1")
#ax.plot(cc_2_level, label = "cc 2")
#ax.plot(roll_1_level, label = "roll 1")
#ax.plot(roll_2_level, label = "roll 2")
#ax.plot(sep_level, label = "sep")
#ax.plot(jelly_level, label = "jelly")
#ax.plot(cases_level, label = "cases")
#ax.plot(open_cells_level, label = "open cells")
#ax.plot(electrolyte_tank_level, label = "electrolyte")
#ax.plot(final_cells_level, label = "celle pre-formation")
ax.plot(dispatch_level, label = "celle prodotte")
#ax.plot(counter, label = "counter")
#ax.plot(reject_level, label = "reject")
plt.legend(ncol=1, loc="upper right")
# save and show the plot
fig.savefig('raw1_plot.png')
plt.show()
print("KPI")
print(kpi_throughput)Editor is loading...