Simpy：使用 Simpy 进行 RMFS 模拟
Simpy: An RMFS simulation with Simpy
我有一个项目，我正在尝试用 simpy 模拟一个 RMFS 仓库。我真的很感激任何人都可以帮助我，因为我是 simpy 的新手并且卡住了，我不知道如何建模。我尝试了不同的代码，但其中 none 可以正常工作。这是我的假设：
1- 仓库是一个网格，每个单元格包含许多数量的 1 种物品（物品 1、2、3，...）。类似于所附照片。它有一个独特的地址
2- 订单在预定义的时间内到达（例如 2 分钟的均匀分布）
3- 然后将订单分配给一个机器人（我们有 10 个机器人）去取回订单。需要3分钟
4- 然后机器人将订单送到工作站进行下一步（比如从机器人那里挑选订单并打包）。这将需要 2 分钟。
5- 然后机器人去把订单放回去并等待下一个订单。
试一试，我建模的过程是
基本流程：
订单到了，
订单获取机器人（如果所有机器人都在使用中，请排队等候），
订单获取单元格（如果单元格已被其他订单占用，请等待），
从单元格中选择，
放回手机，
发布机器人
因此，与其让单元格成为一个资源池（这需要一个匹配函数来获得所需的单元格），每个单元格都有自己的容量为 1 的资源池。我用它来排队请求单元格和所有单元格都在字典中以便于访问
事后看来，我认为如果我在抓住机器人之前让订单抓住单元，我可以获得更好的吞吐量。
"""
modes a robot warehouse where robots get pulls a cell
and brings it to a picker who picks stuff from the cell,
then returns the cell back to the warehouse
basic process:
order arrives
order gets a robot (wait in a queue if all robots are in use)
order gets cell (wait if cell has been seized by another order)
pick from cell
put cell back
release robot
programmer: Michael R. Gibbs
"""
import simpy
import random
class Order():
"""
Order to be fulfilled
has unique id for tracking
and the cell id to pull
"""
# class var used to gen unique ids
next_id = 1
def __init__(self, cell):
"""
initalizes a order with a unique id and a cell to pull
"""
# set unique id
self.id = Order.next_id
Order.next_id += 1
# set cell to pull
self.cell = cell
class Cell():
"""
Cell that robots retrieve so pickers can pick
A cell can only be seized by one robot at a time
so each cell has its own request queue implemented
with a simple resouce. Could have put all the cells in
one matching store, but I think this is more effecient
as the matching can be slow with big queues
"""
def __init__(self, env, id):
"""
Initializes a cell with a id, and a request/resouce queue
"""
self.id = id
self.env = env
# used to queue requests for the cell
self.resQueue = simpy.Resource(env, capacity=1)
# request that currently holds the cell's resource
self.request = None
def seize(self):
"""
gets in queue and waits to seize cell
"""
request = self.resQueue.request() # Generate a request event
yield request
# save the request that has the cell so can release latter
self.request = request
return self
def release(self):
"""
releases the cell so other robots can seize it
"""
yield self.resQueue.release(self.request)
self.request = None
def gen_orders(env, cellMap, robots):
"""
Generates orders at a random distrubution
and kicks off the fill order process for the order
"""
while True:
# time between arrivals
yield env.timeout(random.uniform(0,2))
# create order and assign cell
cell = random.randint(1,len(cellMap))
order = Order(cell)
print(env.now, f'Order {order.id} has been created')
# start process to fulfill the order
# do not use yield here, just drop and go to next order
env.process(fill_order(order,cellMap, robots))
def fill_order(order, cellMap, robots):
"""
the order filling process
this process gets created for each order
"""
# get a robot
print(env.now, f'order {order.id} waits for robot')
with robots.request() as req:
yield req
print(env.now, f'order {order.id} has a robot')
# get the cell
print(env.now, f'order {order.id} waits for cell {order.cell}')
cell = cellMap[order.cell]
yield env.process(cell.seize())
print(env.now, f'order {order.id} has seized cell {order.cell}')
# pull the cell
yield env.timeout(3)
print(env.now, f'order {order.id} has pulled cell {order.cell}')
# pick
yield env.timeout(2)
print(env.now, f'order {order.id} has picked')
# return cell
yield env.timeout(3)
env.process(cell.release())
print(env.now, f'order {order.id} has return cell {order.cell}')
# release robot
print(env.now, f'order {order.id} has released a robot')
# start building the sim
env = simpy.Environment()
# made only 10 cells so orders are more likely to compete for a cell
cellMap = {id:Cell(env,id) for id in range(1,10)}
robots = simpy.Resource(env,capacity=10)
# start generating orders, which also kicks off the processing for each order
env.process(gen_orders(env, cellMap, robots))
env.run(100)
这是针对 6*9 仓库的代码更新。我还给它加了一个升降机构。我感谢您对我们如何改进和优化它的评论。以及如何向其中添加报告。
"""
modes a robot warehouse where robots get pulls a cell
and brings it to a picker who picks stuff from the cell,
then returns the cell back to the warehouse
basic process:
order arrives
order gets a robot (wait in a queue if all robots are in use)
order gets cell (wait if cell has been seized by another order)
pick from cell
put cell back
release robot
programmer: Michael R. Gibbs
"""
import simpy
import random
random.seed(0)
NUM_ROBOTS = 10
NUM_PICKERS = 1
NUM_GANTRY = 2
EXT_CELLS = [1,2,3,4,5,6,7,12,13,18,19,24,25,30,31,36,37,42,43,48,49,50,51,52,53,54]
INT_CELLS = [8,9,10,11,14,15,16,17,20,21,22,23,26,27,28,29,32,33,34,35,38,39,40,41,44,45,46,47]
class Order():
"""
Order to be fulfilled
has unique id for tracking
and the cell id to pull
"""
# class var used to gen unique ids
next_id = 1
def __init__(self, cell):
"""
initalizes a order with a unique id and a cell to pull
"""
# set unique id
self.id = Order.next_id
Order.next_id += 1
# set cell to pull
self.cell = cell
class Cell():
"""
Cell that robots retrieve so pickers can pick
A cell can only be seized by one robot at a time
so each cell has its own request queue implemented
with a simple resource.
"""
def __init__(self, env, id):
"""
Initializes a cell with a id, and a request/resource queue
"""
self.id = id
self.env = env
# used to queue requests for the cell
self.resQueue = simpy.Resource(env, capacity=1)
# request that currently holds the cell's resource
self.request = None
def seize(self):
"""
gets in queue and waits to seize cell
"""
request = self.resQueue.request() # Generate a request event
yield request
# save the request that has the cell so can release latter
self.request = request
return self
def release(self):
"""
releases the cell so other robots can seize it
"""
yield self.resQueue.release(self.request)
self.request = None
def gen_orders(env, cellMap, robots):
"""
Generates orders at a random distribution
and kicks off the fill order process for the order
"""
while True:
# time between arrivals
yield env.timeout(random.expovariate(1.0/1.5))
# create order and assign cell
cell = random.randint(1, len(cellMap))
order = Order(cell)
print('{:.2f} Order {} received for item in cell #{}'.format(env.now, order.id,order.cell))
# start process to fulfill the order
# do not use yield here, just drop and go to next order
if cell in EXT_CELLS:
env.process(fill_order(order, cellMap, robots, pickers))
else:
env.process(fill_order_internal(order, cellMap, robots, pickers,gantry))
def fill_order(order, cellMap, robots, pickers):
"""
the order filling process
this process gets created for each order
"""
#indicate cell status
print(format(env.now,'.2f'), f'order {order.id} cell {order.cell} is an external cell')
# get a robot
print('{:.2f} order {} waits for robot'.format(env.now,order.id))
with robots.request() as req:
yield req
print('{:.2f} order {} assigned to robot# {}'.format(env.now, order.id, robots.count))
# get the cell
print(format(env.now, '.2f'), f'order {order.id} waits for cell {order.cell}')
cell = cellMap[order.cell]
yield env.process(cell.seize())
print(format(env.now, '.2f'), f'order {order.id} has seized cell {order.cell}')
# pull the cell
yield env.timeout(3)
print(format(env.now,'.2f'), f'order {order.id} has pulled cell {order.cell} by robot#{robots.count}')
# pick
with pickers.request() as picker_req:
yield picker_req
yield env.timeout(random.triangular(0.5,1.2,1.8))
print(format(env.now,'.2f'), f'order {order.id} has picked')
# return cell
yield env.timeout(3)
env.process(cell.release())
print(format(env.now,'.2f'), f'order {order.id} has return cell {order.cell} by robot# {robots.count}')
# release robot
print('{:.2f} order {} has released a robot'.format(env.now,order.id))
def fill_order_internal(order, cellMap, robots, pickers,gantry):
"""
the order filling process for internal cells
this process gets created for each order
"""
#indicate cell status
print(format(env.now,'.2f'), f'order {order.id} cell {order.cell} is an internal cell')
# get a robot
print('{:.2f} order {} waits for robot and gantry'.format(env.now,order.id))
with robots.request() as req:
yield req
print('{:.2f} order {} assigned to robot# {}'.format(env.now, order.id, robots.count))
# get the cell
print(format(env.now, '.2f'), f'order {order.id} waits for cell {order.cell}')
cell = cellMap[order.cell]
yield env.process(cell.seize())
print(format(env.now, '.2f'), f'order {order.id} has seized cell {order.cell}')
# get the gantry
with gantry.request() as req_gantry:
yield req_gantry
print('{:.2f} order {} assigned to gantry# {}'.format(env.now, order.id, gantry.count))
#lift obstacle cells
yield env.timeout(2)
print(format(env.now, '.2f'), f'order {order.id} has lifted obstacles of cell {order.cell} by gantry{gantry.count}')
# pull the cell
yield env.timeout(3)
print(format(env.now,'.2f'), f'order {order.id} has pulled cell {order.cell} by robot#{robots.count}')
# pick
with pickers.request() as picker_req:
yield picker_req
yield env.timeout(random.triangular(0.5,1.2,1.8))
print(format(env.now, '.2f'), f'order {order.id} has picked')
# get the gantry
with gantry.request() as req_gantry:
yield req_gantry
print('at {:.2f} order {} assigned to gantry# {}'.format(env.now, order.id, gantry.count))
# lift obstacle cells for return
yield env.timeout(2)
print(format(env.now, '.2f'), f'order {order.id} has lifted obstacles of cell {order.cell} by gantry{gantry.count}')
# return cell
yield env.timeout(3)
env.process(cell.release())
print(format(env.now,'.2f'), f'order {order.id} has return cell {order.cell} by robot# {robots.count}')
# release robot
print('at {:.2f} order {} has released a robot'.format(env.now,order.id))
# start building the sim
env = simpy.Environment()
# 54 cells for a 6*9 Warehouse
cellMap = {id: Cell(env, id) for id in range(1, 55)}
#print(cellMap)
robots = simpy.Resource(env, capacity= NUM_ROBOTS)
pickers = simpy.Resource(env, capacity= NUM_PICKERS)
gantry = simpy.Resource(env, capacity= NUM_GANTRY)
# start generating orders, which also kicks off the processing for each order
env.process(gen_orders(env, cellMap, robots))
env.run(100)
我有一个项目，我正在尝试用 simpy 模拟一个 RMFS 仓库。我真的很感激任何人都可以帮助我，因为我是 simpy 的新手并且卡住了，我不知道如何建模。我尝试了不同的代码，但其中 none 可以正常工作。这是我的假设： 1- 仓库是一个网格，每个单元格包含许多数量的 1 种物品（物品 1、2、3，...）。类似于所附照片。它有一个独特的地址 2- 订单在预定义的时间内到达（例如 2 分钟的均匀分布） 3- 然后将订单分配给一个机器人（我们有 10 个机器人）去取回订单。需要3分钟 4- 然后机器人将订单送到工作站进行下一步（比如从机器人那里挑选订单并打包）。这将需要 2 分钟。 5- 然后机器人去把订单放回去并等待下一个订单。
试一试，我建模的过程是
基本流程：
订单到了，
订单获取机器人（如果所有机器人都在使用中，请排队等候），
订单获取单元格（如果单元格已被其他订单占用，请等待），
从单元格中选择，
放回手机，
发布机器人
因此，与其让单元格成为一个资源池（这需要一个匹配函数来获得所需的单元格），每个单元格都有自己的容量为 1 的资源池。我用它来排队请求单元格和所有单元格都在字典中以便于访问
事后看来，我认为如果我在抓住机器人之前让订单抓住单元，我可以获得更好的吞吐量。
"""
modes a robot warehouse where robots get pulls a cell
and brings it to a picker who picks stuff from the cell,
then returns the cell back to the warehouse
basic process:
order arrives
order gets a robot (wait in a queue if all robots are in use)
order gets cell (wait if cell has been seized by another order)
pick from cell
put cell back
release robot
programmer: Michael R. Gibbs
"""
import simpy
import random
class Order():
"""
Order to be fulfilled
has unique id for tracking
and the cell id to pull
"""
# class var used to gen unique ids
next_id = 1
def __init__(self, cell):
"""
initalizes a order with a unique id and a cell to pull
"""
# set unique id
self.id = Order.next_id
Order.next_id += 1
# set cell to pull
self.cell = cell
class Cell():
"""
Cell that robots retrieve so pickers can pick
A cell can only be seized by one robot at a time
so each cell has its own request queue implemented
with a simple resouce. Could have put all the cells in
one matching store, but I think this is more effecient
as the matching can be slow with big queues
"""
def __init__(self, env, id):
"""
Initializes a cell with a id, and a request/resouce queue
"""
self.id = id
self.env = env
# used to queue requests for the cell
self.resQueue = simpy.Resource(env, capacity=1)
# request that currently holds the cell's resource
self.request = None
def seize(self):
"""
gets in queue and waits to seize cell
"""
request = self.resQueue.request() # Generate a request event
yield request
# save the request that has the cell so can release latter
self.request = request
return self
def release(self):
"""
releases the cell so other robots can seize it
"""
yield self.resQueue.release(self.request)
self.request = None
def gen_orders(env, cellMap, robots):
"""
Generates orders at a random distrubution
and kicks off the fill order process for the order
"""
while True:
# time between arrivals
yield env.timeout(random.uniform(0,2))
# create order and assign cell
cell = random.randint(1,len(cellMap))
order = Order(cell)
print(env.now, f'Order {order.id} has been created')
# start process to fulfill the order
# do not use yield here, just drop and go to next order
env.process(fill_order(order,cellMap, robots))
def fill_order(order, cellMap, robots):
"""
the order filling process
this process gets created for each order
"""
# get a robot
print(env.now, f'order {order.id} waits for robot')
with robots.request() as req:
yield req
print(env.now, f'order {order.id} has a robot')
# get the cell
print(env.now, f'order {order.id} waits for cell {order.cell}')
cell = cellMap[order.cell]
yield env.process(cell.seize())
print(env.now, f'order {order.id} has seized cell {order.cell}')
# pull the cell
yield env.timeout(3)
print(env.now, f'order {order.id} has pulled cell {order.cell}')
# pick
yield env.timeout(2)
print(env.now, f'order {order.id} has picked')
# return cell
yield env.timeout(3)
env.process(cell.release())
print(env.now, f'order {order.id} has return cell {order.cell}')
# release robot
print(env.now, f'order {order.id} has released a robot')
# start building the sim
env = simpy.Environment()
# made only 10 cells so orders are more likely to compete for a cell
cellMap = {id:Cell(env,id) for id in range(1,10)}
robots = simpy.Resource(env,capacity=10)
# start generating orders, which also kicks off the processing for each order
env.process(gen_orders(env, cellMap, robots))
env.run(100)
这是针对 6*9 仓库的代码更新。我还给它加了一个升降机构。我感谢您对我们如何改进和优化它的评论。以及如何向其中添加报告。
"""
modes a robot warehouse where robots get pulls a cell
and brings it to a picker who picks stuff from the cell,
then returns the cell back to the warehouse
basic process:
order arrives
order gets a robot (wait in a queue if all robots are in use)
order gets cell (wait if cell has been seized by another order)
pick from cell
put cell back
release robot
programmer: Michael R. Gibbs
"""
import simpy
import random
random.seed(0)
NUM_ROBOTS = 10
NUM_PICKERS = 1
NUM_GANTRY = 2
EXT_CELLS = [1,2,3,4,5,6,7,12,13,18,19,24,25,30,31,36,37,42,43,48,49,50,51,52,53,54]
INT_CELLS = [8,9,10,11,14,15,16,17,20,21,22,23,26,27,28,29,32,33,34,35,38,39,40,41,44,45,46,47]
class Order():
"""
Order to be fulfilled
has unique id for tracking
and the cell id to pull
"""
# class var used to gen unique ids
next_id = 1
def __init__(self, cell):
"""
initalizes a order with a unique id and a cell to pull
"""
# set unique id
self.id = Order.next_id
Order.next_id += 1
# set cell to pull
self.cell = cell
class Cell():
"""
Cell that robots retrieve so pickers can pick
A cell can only be seized by one robot at a time
so each cell has its own request queue implemented
with a simple resource.
"""
def __init__(self, env, id):
"""
Initializes a cell with a id, and a request/resource queue
"""
self.id = id
self.env = env
# used to queue requests for the cell
self.resQueue = simpy.Resource(env, capacity=1)
# request that currently holds the cell's resource
self.request = None
def seize(self):
"""
gets in queue and waits to seize cell
"""
request = self.resQueue.request() # Generate a request event
yield request
# save the request that has the cell so can release latter
self.request = request
return self
def release(self):
"""
releases the cell so other robots can seize it
"""
yield self.resQueue.release(self.request)
self.request = None
def gen_orders(env, cellMap, robots):
"""
Generates orders at a random distribution
and kicks off the fill order process for the order
"""
while True:
# time between arrivals
yield env.timeout(random.expovariate(1.0/1.5))
# create order and assign cell
cell = random.randint(1, len(cellMap))
order = Order(cell)
print('{:.2f} Order {} received for item in cell #{}'.format(env.now, order.id,order.cell))
# start process to fulfill the order
# do not use yield here, just drop and go to next order
if cell in EXT_CELLS:
env.process(fill_order(order, cellMap, robots, pickers))
else:
env.process(fill_order_internal(order, cellMap, robots, pickers,gantry))
def fill_order(order, cellMap, robots, pickers):
"""
the order filling process
this process gets created for each order
"""
#indicate cell status
print(format(env.now,'.2f'), f'order {order.id} cell {order.cell} is an external cell')
# get a robot
print('{:.2f} order {} waits for robot'.format(env.now,order.id))
with robots.request() as req:
yield req
print('{:.2f} order {} assigned to robot# {}'.format(env.now, order.id, robots.count))
# get the cell
print(format(env.now, '.2f'), f'order {order.id} waits for cell {order.cell}')
cell = cellMap[order.cell]
yield env.process(cell.seize())
print(format(env.now, '.2f'), f'order {order.id} has seized cell {order.cell}')
# pull the cell
yield env.timeout(3)
print(format(env.now,'.2f'), f'order {order.id} has pulled cell {order.cell} by robot#{robots.count}')
# pick
with pickers.request() as picker_req:
yield picker_req
yield env.timeout(random.triangular(0.5,1.2,1.8))
print(format(env.now,'.2f'), f'order {order.id} has picked')
# return cell
yield env.timeout(3)
env.process(cell.release())
print(format(env.now,'.2f'), f'order {order.id} has return cell {order.cell} by robot# {robots.count}')
# release robot
print('{:.2f} order {} has released a robot'.format(env.now,order.id))
def fill_order_internal(order, cellMap, robots, pickers,gantry):
"""
the order filling process for internal cells
this process gets created for each order
"""
#indicate cell status
print(format(env.now,'.2f'), f'order {order.id} cell {order.cell} is an internal cell')
# get a robot
print('{:.2f} order {} waits for robot and gantry'.format(env.now,order.id))
with robots.request() as req:
yield req
print('{:.2f} order {} assigned to robot# {}'.format(env.now, order.id, robots.count))
# get the cell
print(format(env.now, '.2f'), f'order {order.id} waits for cell {order.cell}')
cell = cellMap[order.cell]
yield env.process(cell.seize())
print(format(env.now, '.2f'), f'order {order.id} has seized cell {order.cell}')
# get the gantry
with gantry.request() as req_gantry:
yield req_gantry
print('{:.2f} order {} assigned to gantry# {}'.format(env.now, order.id, gantry.count))
#lift obstacle cells
yield env.timeout(2)
print(format(env.now, '.2f'), f'order {order.id} has lifted obstacles of cell {order.cell} by gantry{gantry.count}')
# pull the cell
yield env.timeout(3)
print(format(env.now,'.2f'), f'order {order.id} has pulled cell {order.cell} by robot#{robots.count}')
# pick
with pickers.request() as picker_req:
yield picker_req
yield env.timeout(random.triangular(0.5,1.2,1.8))
print(format(env.now, '.2f'), f'order {order.id} has picked')
# get the gantry
with gantry.request() as req_gantry:
yield req_gantry
print('at {:.2f} order {} assigned to gantry# {}'.format(env.now, order.id, gantry.count))
# lift obstacle cells for return
yield env.timeout(2)
print(format(env.now, '.2f'), f'order {order.id} has lifted obstacles of cell {order.cell} by gantry{gantry.count}')
# return cell
yield env.timeout(3)
env.process(cell.release())
print(format(env.now,'.2f'), f'order {order.id} has return cell {order.cell} by robot# {robots.count}')
# release robot
print('at {:.2f} order {} has released a robot'.format(env.now,order.id))
# start building the sim
env = simpy.Environment()
# 54 cells for a 6*9 Warehouse
cellMap = {id: Cell(env, id) for id in range(1, 55)}
#print(cellMap)
robots = simpy.Resource(env, capacity= NUM_ROBOTS)
pickers = simpy.Resource(env, capacity= NUM_PICKERS)
gantry = simpy.Resource(env, capacity= NUM_GANTRY)
# start generating orders, which also kicks off the processing for each order
env.process(gen_orders(env, cellMap, robots))
env.run(100)