def testShouldGoBackDown(self):
elevator = Elevator()
elevator.currentFloor = 4
elevator.doorsOpen = True
elevator.closeDoors()
self.assertEqual(elevator.nextFloor, 0)
self.assertEqual(elevator.direction, -1)
def __init__(self, elevators=8, verbose=False):
self._elevators = []
self._verbose = verbose
for i in range(1, elevators + 1):
self._elevators.append(Elevator(i, verbose=self._verbose))
def __init__(self, id, num_floors):
self.id = id
self.order_timeout_secs = 60
self.ips = {self.id: self.own_ip()}
self.elevators = {id: Elevator()}
self.hub_down = dict() # KEY: floor, id VALUE: boolean
self.hub_up = dict()
self.cab = dict() # KEY: floor, id VALUE: boolean
self.cab[0] = False
self.hub_up[0] = False
self.cab[num_floors - 1] = False
self.hub_down[num_floors - 1] = False
for floor in range(1, num_floors - 1):
self.cab[floor] = False
self.hub_up[floor] = False
self.hub_down[floor] = False
self._sockets_init()
launch_thr(self.receive_hub_order)
launch_thr(self.receive_state)
time.sleep(0.5)
launch_thr(self.send_state)
def __init__(self, numberOfPeople, numOfFloors, numOfElevators):
self.numberOfPeople = numberOfPeople
self.numberOfFloors = numOfFloors
self.floors = {}
self.elevators = []
i = 0
peopleInFloor = int(numberOfPeople / numOfFloors)
"""need to fix"""
# peopleInFloor = int(numberOfPeople / numOfFloors)
# if peopleInFloor < 1:
# while floorNum < numOfFloors + 1:
# randPerson = random.randint(0, 1)
# if i < numberOfPeople:
# if randPerson == 1:
# self.floors[floorNum] = Floor(floorNum, randPerson, numOfFloors)
# floorNum = floorNum + 1
# i = i + 1
# else:
# self.floors[floorNum] = Floor(floorNum, randPerson, numOfFloors)
# floorNum = floorNum + 1
for floorNum in range(1, numOfFloors + 1):
self.floors[floorNum] = Floor(floorNum, peopleInFloor, numOfFloors)
for i in range(0, numOfElevators):
self.elevators.append(Elevator(i, numOfFloors))
def __init__(self,MaxCustomer,Speed,BoardTime):
''' 初始化
@type MaxCustomer: int
@param MaxCustomer: 每部电梯最大顾客数
@type Speed: int
@param Speed: 电梯运行速度 Speed秒/层
@type BoardTime: int
@param BoardTime: 顾客上下电梯耗时
'''
self.AllElevator = []
# 电梯基本信息
AvaliableFloorTable = {
'E0' : range(1,41),
'E1' : range(1,41),
'E2' : [1] + range(25,41),
'E3' : [1] + range(25,41),
'E4' : range(1,26),
'E5' : range(1,26),
'E6' : [1] + range(2,41,2),
'E7' : [1] + range(2,41,2),
'E8' : range(1,41,2),
'E9' : range(1,41,2)
}
ElevatorNum = len(AvaliableFloorTable)
# 产生电梯
for tag,floor in AvaliableFloorTable.items():
newElevator = Elevator(tag,floor,MaxCustomer,random.choice(floor),Speed,BoardTime)
self.AllElevator.append(newElevator)
#print newElevator
self.AllElevator.sort(cmp = lambda x,y: cmp(x.Tag, y.Tag))
def __init__(self, name, FLOOR_COUNT, elevator_count):
self.name = name
self.FLOOR_COUNT = FLOOR_COUNT
self.elevator_count = elevator_count
self.elevators = []
self.calls_for_elevator = []
for i in range(0, self.elevator_count):
self.elevators.append(Elevator(self, i, 1))
def testPickupInRightOrder(self):
elevator = Elevator(speed=0.5)
elevator.handleRequest(floor=8)
elevator.handleRequest(floor=4)
time.sleep(1)
elevator.handleRequest(floor=1)
self.assertEqual(elevator.direction, 1)
self.assertEqual(elevator.nextFloor, 4)
def __init__(self, communicator, dispatcher=False):
self.communicator = communicator
self.orderList = [[0 for x in range(NO_FLOORS)] for x in range(2)] # direction is one dimension, no. floors the other
self.peerList = {} # store peer objects, with IP as key
self.dispatcher = dispatcher
self.id = self.getMyIP()
self.status = ""
self.elevator = Elevator() # this object should handle the interface with the driver and keep track of elevator state
def reset_elevator():
global elevator
p = elevator.p
elevator = Elevator(scheduler=schedule_list[schedule_var.get()](),
floors=floors,
p=p,
capacity=2,
initial_count=0,
pressing_up=pressing_list[pressing_var.get()])
def __init__(self, elevators_count):
if elevators_count <= 0:
raise Exception("elevators count must be greater than 0")
self.elevators_count = elevators_count
self.elevators = {} # dictionary of elevators and their state
# populate elevators
for i in range(self.elevators_count):
self.elevators[i] = Elevator(i)
# keep instance of factory for building requests
self._request_factory = GoToFloorRequestFactory()
def _generateGiantSpike(self):
self.giantSpike = giantSpike()
self.giantSpikeList = pygame.sprite.Group()
self.giantSpikeList.add(self.giantSpike)
self.giantSpikePlat = Elevator('elevator')
self.giantSpikePlat.speed = 0
self.giantSpikePlat.rect.x, self.giantSpikePlat.rect.y = self.giantSpike.rect.x + 10, self.giantSpike.rect.y - 5
self.giantSpike.plat = self.giantSpikePlat
self.elevatorList.add(self.giantSpikePlat)
self.chainGroup = pygame.sprite.Group()
self.chainGroup.add(self.giantSpike.chain)
def __init__(self, N, K, p, q, r, t_u):
self.N = N # number of floors
self.K = K # number of elevators
self.p = p # probability person arrives at a given time step
self.q = q # probability person arrives at first floor
self.r = r # probability person wants to get down at first floor
self.t_u = t_u # one time unit
self.elev = Elevator(N, K)
self.total_cost = 0
self.total_people_served = 0
self.people_in_sys = []
def __init__(self, number_of_elevator, number_of_floor):
self.elevators = [
Elevator(i, number_of_floor) for i in range(number_of_elevator)
]
self.floors = number_of_floor
# people start from certain floor that have a elevator come for them
self.people_from_floors = [[Queue(), Queue()]
for i in range(number_of_floor + 1)]
# people cannot get elevators come to them
self.waitlist = Queue()
def __init__(self, num_floors, num_elevators):
self.floors = num_floors
self.num_elevators = num_elevators
self.elevators = []
self.pending_targets = {}
self.new_floor_calls = []
self.new_elevator_calls = []
for i in range(num_elevators):
self.elevators.append(Elevator(i, self.floors))
self.pending_targets[i] = []
self.control_loop = threading.Thread(target=self.state_loop,
args=(True, ))
self.control_loop.start()
self.input_loop()
def __init__(self, communicator, dispatcher=False):
self.communicator = communicator
self.orderList = [[0 for x in range(NO_FLOORS)] for x in range(2)] # direction is one dimension, no. floors the other
self.peerList = {} # store peer objects, with IP as key
self.dispatcher = dispatcher
self.id = self.getMyIP()
self.status = ""
self.peers = []
# ugly hack to give the messageHandler the controller instance.
self.communicator.messageHandler.setController(self)
# this object should handle the interface with the driver and keep track of elevator state
self.elevator = Elevator(self)
def main(): # #Genereate test cases, uncomment the next line to generate input files with random requests # generate_pseudo_input(building_floors, customer_total_number, end_time, input_file_path) # Read the input file and get all the customer data all_data = get_pseudo_input(input_file_path) # Initialize the elevator my_elevator = Elevator(starting_floor, max_capacity,max_speed,actions_log_file_path) # Initialize the simulator my_simulator = Simulator(building_floors,my_elevator) # Operate the simulator my_simulator.operate(all_data, requests_log_file_path)
def __init__(self, total_elevator_num, height, max_people):
self.target = 0
self.total_elevator_num = total_elevator_num
self.max_people_in_floor = max_people
#each elevator has max capacity of 10
self.elevators = []
for idx in range(total_elevator_num):
self.elevators.append(Elevator(idx, 10, height))
self.height = height
self.people_in_floors = []
self.floor_button = []
for idx in range(height):
self.people_in_floors.append([])
self.floor_button.append(Switch())
def __init__(self):
self.num_customers = self.get_user_int("How many customers? ",1,24)
self.num_floors = self.get_user_int("How many floors? ", 1, 100)
self.customers = self.gather_customers()
print("Gathered ", self.num_customers, "customers for", self.num_floors,"floors.")
self.elevator = Elevator(self.num_floors, DefaultStrategy)
for c in self.customers:
self.elevator.add_customer(c)
print("Customers in elevator:")
for c in self.elevator.customers:
print(str(c))
self.elevator.start()
def main():
currentIndex = 0
time_tick = 0
cumulative_time = 0
#reads from jsonfile
with open('testcases/elevator_practice1.json') as json_data:
jsonFile = json.load(json_data)
#intializing floor and elevators
numFloors = jsonFile["floors"]
numElevators = jsonFile["elevators"]
floorList = []
elevatorList = []
drawGui = DrawElevator(numFloors, numElevators)
drawGui.initialDraw()
for i in range(numFloors):
floorList.append(Floor(i))
for i in range(numElevators):
elevatorList.append(Elevator(5, numFloors))
while time_tick < 1000:
#stores the data locally from the json object
if time_tick == jsonFile["events"][currentIndex]["time"]:
startFloor = jsonFile["events"][currentIndex]["start"]
endFloor = jsonFile["events"][currentIndex]["end"]
#populates the floor class
new_person = Person(time_tick, startFloor, endFloor)
floorList[startFloor].appendPerson(new_person)
currentIndex += 1
#updates the elevator class
for elevator in elevatorList:
floorList = elevator.update(floorList)
drawGui.update(elevatorList, floorList)
time_tick += 1
time.sleep(0.1)
def __init__(self, elvNum):
self.__elevatorList = [Elevator() for i in range(elvNum)]
def addElevator(self):
self.__elevatorList.append(Elevator())
# 当 self.Status == 'InElevator'时才能调用
# 确认到达请求楼层
assert self.Status == 'InElevator'
# 因为存在电梯时间先加1，人时间后加1的问题，所以这里人的楼层不可能等于电梯的楼层。
self.NowFloor = elevator.NowFloor
self.Status = 'Landing'
# 此时的时间控制和Elevator相同
self.TimeRemain = elevator.BoardTime
self.Elevator = elevator
#print '%s LandingNotify %s' % (self,elevator)
def GetNowStatus(self):
''' 获得当前顾客状态
@rtype: tuple
@return: 当前状态,(ID,Status,NowFloor,DestFloor,LaunchNum,InRequestTime)
'''
return (self.ID, self.Status, self.NowFloor, self.DestFloor,
self.LaunchNum, self.InRequestTime)
if __name__ == '__main__':
from Elevator import Elevator
eve = Elevator('E0', range(1, 41), 10, InitFloor=1, Speed=2, BoardTime=2)
cust = Customer(1, 5)
cust.AddTimer(1)
cust.AddTimer(2)
cust.AddTimer(3)
def reset_elevator():
global elevator
p = elevator.p
elevator = Elevator(scheduler=schedule_list[schedule_var.get()](),
floors=floors,
p=p,
capacity=2,
initial_count=0,
pressing_up=pressing_list[pressing_var.get()])
if __name__ == '__main__':
elevator = Elevator(scheduler=MinMaxScheduler(),
floors=floors,
p=1 / 20,
capacity=2,
initial_count=0)
master = Tk()
master.resizable = False
master.title("Elevator")
master.bind("<Configure>", window_event)
master.protocol("WM_DELETE_WINDOW", window_event2)
canvas = Canvas(master, width=canvas_width, height=canvas_height)
canvas.pack(expand=YES, fill=BOTH)
schedule_var = StringVar(master)
pressing_var = StringVar(master)
button0 = Button(master, text="Reset", fg='black', command=reset_elevator)
elevators = []
riders = []
random.seed(RANDOM_SEED)
pygame.init()
size = width, height = 1000, 800
screen = pygame.display.set_mode(size)
display = pygame.display
image = pygame.image
event = pygame.event
# Creating Elevators
for ele in range(NUM_OF_ELEVATORS):
new_ele = Elevator("E-" + str(ele), env)
elevators.append(new_ele)
# Creating Riders
for rid in range(NUM_OF_RIDERS):
rider = Rider(chr(65 + rid), env)
riders.append(rider)
matrix = Building(elevators, riders, env, screen, display, image, event)
for rider in riders:
env.process(rider.run())
for elevator in elevators:
env.process(elevator.run())
env.process(matrix.run())
def __init__(self, total_floors):
self.elevator_obj = Elevator()
self.max_floor_number = total_floors
def __init__(self,
manager=ElevatorManager.NaiveManager,
debug_mode=False,
verbose=True,
sim_len=120,
sim_pace=None,
time_resolution=0.5,
logfile=None,
seed=1,
n_floors=3,
n_elevators=2,
capacity=4,
speed=1,
open_time=2,
arrival_pace=1 / 10,
p_between=0.1,
p_up=0.45,
size=1.5,
delay=3):
# Note: default time unit is seconds.
self.debug = debug_mode
self.verbose = verbose
## Simulation world
# conf
self.sim_len = sim_len
sim_pace = sim_pace # visualization's fast-forward; None for no visualization
self.time_resolution = np.inf if sim_pace is None else time_resolution
self.logfile = logfile
self.seed = seed
# init
self.sim_time = 0
self.real_time = None
self.logger = None
# stats init
self.useless_opens = 0
self.blocked_entrances = 0
self.moves_without_open = 0
## Elevators
# conf
self.n_floors = n_floors
self.n_elevators = n_elevators
el_capacity = capacity
el_speed = speed # floors per second. Note: acceleration is neglected
el_open_time = open_time # = time to open = time to close
# init
self.el_next_event_time = [np.inf for _ in range(self.n_elevators)]
self.el = [
Elevator(i, self.n_floors, el_capacity, el_speed, el_open_time)
for i in range(self.n_elevators)
]
self.sim_plot = SimPlotter(self.n_floors, self.n_elevators, sim_pace) \
if sim_pace is not None else None
## Passengers
# conf
self.arrivals_pace = arrival_pace # arrivals per second
self.p_go_between = p_between
self.p_go_up = p_up
self.p_go_down = 1 - (self.p_go_between + self.p_go_up)
self.arrival_size = size # mean number of passengers per arrival
self.delay = delay # mean delay on passengers entrance
# init
self.scenario = []
self.future_arrivals = []
self.waiting_passengers = []
self.moving_passengers = [[] for _ in range(self.n_elevators)]
self.completed_passengers = []
## Manager
self.manager_info = manager.version_info()
self.manager = manager(self.n_floors, self.el, el_capacity, el_speed,
el_open_time, self.arrivals_pace, self.p_go_up,
self.p_go_down, self.p_go_between,
self.arrival_size, self.delay)
def p0_simulator():
user = '******'
problem = 2
count = 4
isend = False
ret = start(user, problem, count)
token = ret['token']
print('Token for %s is %s' % (user, token))
elevators = [0, 0, 0, 0]
for i in range(4):
elevators[i] = Elevator(i, 1, [], "STOPPED")
elevators[i].updateStatus(ret['elevators'][i])
while not isend:
ev_stat = ['', '', '', '']
ret = oncalls(token)
calls = []
command = [-1, -1, -1, -1]
# 콜 업데이트
for cl in ret['calls']:
calls.append(
Call(cl['id'], cl['timestamp'], cl['start'], cl['end']))
# 1순위 : 내리기
for i, ev in enumerate(elevators):
byebye = ev.exitablePassengers() # 이 층에서 내릴 승객들의 id
if byebye:
if ev.status == "UPWARD" or ev.status == "DOWNWARD": # 안 멈췄으면 멈추고
command[i] = ev.stop()
ev_stat[ev.id] = 'stop to exit'
elif ev.status == "STOPPED": # 멈췄으면 문 열고
command[i] = ev.open()
ev_stat[ev.id] = 'open to exit'
elif ev.status == "OPENED": # 열었으면 내려주기
command[i] = ev.exit(byebye)
ev_stat[ev.id] = 'bye, ' + ', '.join(map(str,
byebye)) + '!'
# 2순위 : 태우기
for i, ev in enumerate(elevators):
quota = ev.quota
comein = []
for call in calls:
if quota == maxquota: break
if call.start == ev.floor:
comein.append(call.id)
calls.remove(call)
quota += 1
if comein:
if command[i] == -1:
if ev.status == "UPWARD" or ev.status == "DOWNWARD": # 올라가거나 내려가다가 태울 애가 생기면 멈추기
command[i] = ev.stop()
ev_stat[ev.id] = 'stop to enter'
elif ev.status == "STOPPED": # 멈춘 상태면 태우기 위해 열기
command[i] = ev.open()
ev_stat[ev.id] = 'open to enter'
elif ev.status == "OPENED": # 열렸으면 태우기
command[i] = ev.enter(comein)
ev_stat[ev.id] = 'come in, ' + ', '.join(
map(str, comein)) + '!'
# 3순위 : 문 닫거나 올라가거나 내려가기
for i, ev in enumerate(elevators):
if command[i] == -1: # 아직 명령을 수행하지 않은 엘리베이터만
if ev.status == "OPENED":
command[i] = ev.close()
ev_stat[ev.id] = 'close to move'
else:
if ev.direction == "upward" and ev.floor != height: # 그냥 올라가면 됨
command[i] = ev.up()
ev_stat[ev.id] = 'go up'
elif ev.direction == "downward" and ev.floor != 1: # 그냥 내려가면 됨
command[i] = ev.down()
ev_stat[ev.id] = 'go down'
elif ev.direction == "upward" and ev.floor == height: # 올라가다가 꼭대기 도착한 경우
ev.direction = "stop_maxheight"
command[i] = ev.stop()
ev_stat[ev.id] = 'top of building'
elif ev.direction == "stop_maxheight" and ev.floor == height: # 꼭대기에서 멈춰 있는 경우
ev.direction = "downward"
command[i] = ev.down()
ev_stat[ev.id] = 'go down'
elif ev.direction == "downward" and ev.floor == 1: # 내려가다가 1층 도착한 경우
ev.direction = "stop_minheight"
command[i] = ev.stop()
ev_stat[ev.id] = '1th floor'
elif ev.direction == "stop_minheight" and ev.floor == 1: # 1층에서 멈춰 있는 경우
ev.direction = "upward"
command[i] = ev.up()
ev_stat[ev.id] = 'go up'
# ===== 진행상황 표시용 =====
for i in range(4):
print(i, ev_stat[i])
print()
for i in range(height, 0, -1):
tmp = []
for call in calls:
if call.start == i:
tmp.append(call.id)
print('floor', i, ':', end=' ')
for t in tmp:
print(t, end=' ')
for ev in elevators:
if ev.floor == i:
print(' [' + str(ev.id) + ')', end=' ')
for person in ev.passengers:
print(person.id, end=', ')
print(']', end=' ')
print()
print()
# ====================
print(command)
print('\n', '======================================', '\n')
# 4순위 : action 실행, 엘리베이터 상태 업데이트
ret = action(token, command)
for i in range(4):
elevators[i].updateStatus(ret['elevators'][i])
# 5순위 : isend 체크
isend = ret['is_end']
def __init__(self, allpassengers):
if allpassengers is None:
raise Exception("Passengers cannot be None")
self.elevator = Elevator(self)
self.allPassengers = allpassengers
import time
from Elevator import Elevator
el = Elevator.Elevator(1)
el.start()
print(el.distance_request("U", 3))
el.push_button_floor(3)
el.push_button_floor(4)
el.push_button_floor(6)
el.assing_request("D", 10)
time.sleep(3)
el.assing_request("D", 2)
from Person import Person from Elevator import Elevator e = Elevator(6) p = Person(1, 4) p1 = Person(3, 5) e.add_people_to_floor(4, 1) e.floor_change_up() e.floor_change_up() e.remove_people_from_ele(2) e.floor_change_down() e.floor_change_down() print(e.get_ele_list()) print(e.get_total_time())
