def __init__(self,
origNode,
destNode,
depTime,
trainList,
transferStation=None):
assert( (origNode is not None) and (destNode is not None) and (depTime is not None) ),\
"%s (%.2f) to %s" % (origNode, depTime, destNode)
#recover or resample faulty gate IDs
if origNode not in Parameter.rocktGateIDSetIn:
if origNode in Parameter.rocktGateIDCorrectionDict.keys():
origNode = Parameter.rocktGateIDCorrectionDict[origNode]
elif origNode in Parameter.utrechtCorruptedGateIDs:
origNode = weightedChoice(Parameter.utrechtGateFrequencyDict)
if origNode in Parameter.rocktInGateResampleDict.keys():
sampleGateDict = Parameter.rocktInGateResampleDict[origNode]
origNode = weightedChoice(sampleGateDict)
assert (
origNode
in Parameter.rocktGateIDSetIn), "origNode (%s) invalid" % origNode
#recover or resample faulty gate IDs
if destNode not in Parameter.rocktGateIDSetOut:
if destNode in Parameter.rocktGateIDCorrectionDict.keys():
destNode = Parameter.rocktGateIDCorrectionDict[destNode]
elif destNode in Parameter.utrechtCorruptedGateIDs:
destNode = weightedChoice(Parameter.utrechtGateFrequencyDict)
assert (
destNode
in Parameter.rocktGateIDSetOut), "destNode (%s) invalid" % destNode
self.origNode = 'G' + str(origNode) #append NS gate node names by G
self.destNode = 'G' + str(destNode) #append NS gate node names by G
self.depTime = float(depTime) #check if departure time is numeric
assert (depTime >= 0), "negative depTime not allowed (%s)" % depTime
self.transferStation = transferStation
if isinstance(trainList, int):
self.trainList = list()
self.trainList.append(trainList)
elif isinstance(trainList, list):
self.trainList = trainList
else:
print("Warning: Could not read trainList.")
def assignVehicle(self, boardLinkID, trainName, trainDict,
streamIDDictRev):
#dictionary containing for each vehID an assignment probability
vehIDAssgFrac = self.getBoardAssgFrac(boardLinkID, trainName,
trainDict, streamIDDictRev)
return weightedChoice(vehIDAssgFrac)
def getLinkList(self, origLinkID, destLinkID, pedNet, popMemory):
#discrete choice approach
linkList = list()
origNode = pedNet.getLinkDestNode(origLinkID)
destNode = pedNet.getLinkOrigNode(destLinkID)
#if (origNode,destNode) not in popMemory.odPathDict:
#shortestNodeList = pedNet.getShortestPath(origNode,destNode)
#print("OD pair (%s,%s) is not connected. Shortest path: %s" % (origNode,destNode,shortestNodeList))
pathSet = popMemory.odPathDict[origNode, destNode]
#at least one path must exist
assert (len(pathSet) > 0)
if (len(pathSet) == 1):
pathID = next(iter(pathSet))
else:
pathIDUtilDict = dict()
for curPathID in pathSet:
pathIDUtilDict[
curPathID] = self.personalMemory.getExpPathUtility(
curPathID)
pathID = weightedChoice(pathIDUtilDict, normalize=True)
if self.chosenPathID is None:
self.chosenPathID = pathID
else:
raise Exception(
"Error: Only a single choice per pedestrian allowed for learning. \
The pathSet %s contains more than one element." %
str(pathSet))
nodeList = popMemory.pathDict[pathID]
#shortest route from downstream node of origLink to upstream node of destLink
#nodeList = pedNet.getShortestPath(origNode,destNode)
for linkNum in range(0, len(nodeList) - 1):
upNode = nodeList[linkNum]
downNode = nodeList[linkNum + 1]
linkID = pedNet.getLinkID(upNode, downNode)
linkList.append(linkID)
#add destLinkID to linkList
linkList.append(destLinkID)
return linkList
def propagate(self, simEnv, pedNet, transSys, popMemory):
curActNumber = 0
curEpisodeID = None
#curEpisodeStartTime = 0
curEpisodeUtility = 0
self.totalTravelUtility = 0
self.totalWalkUtility = 0
self.totalWaitUtility = 0
self.totalRideUtility = 0
self.totalPenalty = 0 #for missed trains, or chance to miss train
while (curActNumber < len(self.activitySequence)):
curActivity = self.activitySequence[curActNumber]
actType = curActivity.actType
param = curActivity.param
#episodes: choosePathAndWalk + waitAndBoard, choosePathAndWalk + Exit, rideAndAlight
if ('init' == actType):
#delay pedestrian by his departure time
yield simEnv.timeout(param['depTime'])
timeDep = simEnv.now
#initialize pedestrian on desired link
linkID = param['linkID']
#get area of origin link
origArea = pedNet.getAreaFromLinkID(linkID)
self.resReqEvent = origArea.getResReqEvent()
#try to get slot on area and update current link
yield self.resReqEvent
self.curLinkID = linkID
#no delay between planned and actual initialization time
timeAdmitted = simEnv.now
if (timeAdmitted > timeDep):
delayStr = "Late initialization by %.1f on link (%s,%s), admitted at %.1f instead of %.1f"\
% (timeAdmitted-timeDep, pedNet.streamIDDict[self.curLinkID], timeAdmitted, timeDep)
print(delayStr)
elif ('choosePathAndWalk' == actType):
assert ('linkIDSet' in param)
destLinkIDSet = param['linkIDSet']
#set of all feasible paths to any of the destLinkIDs
pathIDset = set()
origNode = pedNet.getLinkOrigNode(self.curLinkID)
for destLinkID in destLinkIDSet:
destNode = pedNet.getLinkDestNode(destLinkID)
curPathIDSet = popMemory.getPathSet(
origNode, destNode, pedNet)
pathIDset.update(curPathIDSet)
#at least one path must exist
assert (len(pathIDset) > 0)
#dictionary of logsum of utility of all decision paths that are compatible with a given path ID
pathIDUtilDict = dict()
#previous episode: update choice set for correct computation of logsum
if len(self.episodeIDList) > 0:
updateChoiceTree = True
prevEpisode = self.personalMemory.episodeDict[
self.episodeIDList[-1]]
else:
updateChoiceTree = False
#simple path choice model that neglects correlation/overlap
#reasonable approximation for paid areas with unique path between any OD (no path choice would be even needed)
for pathID in pathIDset:
pathIDUtilDict[
pathID] = self.personalMemory.getPathPotential(
curActNumber, pathID)
if updateChoiceTree:
#probability of availability of a path is always one
prevEpisode.nextEpisodeDict[(curActNumber, pathID)] = 1
chosenPathID = weightedChoice(pathIDUtilDict, normalize=True)
curEpisodeID = (curActNumber, chosenPathID)
self.episodeIDList.append(curEpisodeID)
self.personalMemory.initializeEpisode(curEpisodeID)
#curEpisodeStartTime = simEnv.now
curEpisodeUtility = 0
timeLinkAdmission = simEnv.now #register time at which pedestrian has been admitted to current link
linkList = popMemory.getLinkList(chosenPathID, pedNet)
if not linkList:
#if linkList is empty, transfer on same boarding area
#change pedestrian from alighting to boarding link
alightLinkName = pedNet.streamIDDict[self.curLinkID]
boardLinkName = alightLinkName[::-1]
boardLinkID = pedNet.streamIDDictRev[boardLinkName]
linkList = [boardLinkID]
assert (linkList), "linkList must not be empty"
for nextLinkID in linkList:
curAreaID = pedNet.getAreaIDFromLinkID(self.curLinkID)
curArea = pedNet.getArea(curAreaID)
curArea.resource.updateCost(
) #required for pedestrians alighting from train
nextAreaID = pedNet.getAreaIDFromLinkID(nextLinkID)
#if changing area, need to book slot in new area and release old
if (curAreaID != nextAreaID):
nextArea = pedNet.getArea(nextAreaID)
#get interface
interfaceID = pedNet.getInterfaceID(
curAreaID, nextAreaID)
if interfaceID is not None:
interface = pedNet.getInterface(interfaceID)
#get wait time needed to enforce flow capacity at interface
interfaceWaitTime = interface.getWaitTime(simEnv)
#wait at interface, while remaining registered on current area
yield simEnv.timeout(interfaceWaitTime)
elif Parameter.showWarnings:
pedNet.interfaceDebugSet.add(
"No interface between areas %s and %s available."
% (curAreaID, nextAreaID))
#once interface passed, prepare accessing of area
nextAreaResReqEvent = nextArea.getResReqEvent()
#try to get slot on area, release previous area, and update area request handler
yield nextAreaResReqEvent
curArea.getRelease(self.resReqEvent)
self.resReqEvent = nextAreaResReqEvent
#add walking cost to travel cost of episode
if simEnv.now != timeLinkAdmission:
curArea.resource.updateCost()
walkingCost = curArea.getWalkingCost(
timeLinkAdmission, simEnv.now)
curEpisodeUtility -= walkingCost
#register time of admittance to new link
timeLinkAdmission = simEnv.now
#update link
self.curLinkID = nextLinkID
if Parameter.textOutput or self.param.isFinalInstance:
self.logEntry(pedNet, transSys, simEnv)
#book pedestrian during walking
yield simEnv.timeout(self.getStreamTravelTime(pedNet))
#generate time stamp in cumulative area travel cost and add cost for last link traversal
curArea = pedNet.getArea(
pedNet.getAreaIDFromLinkID(self.curLinkID))
curArea.resource.updateCost()
walkingCost = curArea.getWalkingCost(timeLinkAdmission,
simEnv.now)
curEpisodeUtility -= walkingCost
self.totalWalkUtility += curEpisodeUtility
elif ('waitAndBoard' == actType):
trainName = param['trainID']
train = transSys.trainDict[trainName]
assert(self.curLinkID in pedNet.boardingLinkPlatformDict.keys()), \
"link %s %s not a boarding link, pedestrian awaiting train %s may have got lost at time %.2f. \nLogBook of affected traveler:\n%s\nActivity Sequence:\n%s" % \
(self.curLinkID, pedNet.streamIDDict[self.curLinkID], trainName, simEnv.now, ''.join('{}: {}\n'.format(*logEntry) for logEntry in self.logBook), "".join("{}: {}\n".format(k, v) for k, v in self.activitySequence.items()) )
curPlatformName = pedNet.boardingLinkPlatformDict[
self.curLinkID]
curAreaID = pedNet.getAreaIDFromLinkID(self.curLinkID)
curArea = pedNet.getArea(curAreaID)
timePlatformArrival = simEnv.now
#if train already departed
if (train.getDepartureEvent(curPlatformName).processed):
#print('Missed my train. Will leave the simulation.')
#penalize missing the train with a high travel cost
curEpisodeUtility -= Parameter.costMissedTrain
self.totalPenalty -= Parameter.costMissedTrain
#increase walking speed multiplier
self.personalMemory.speedMultiplier = min(
self.personalMemory.speedMultiplier *
Parameter.speedMultiplierIncrease,
Parameter.maxSpeedMultiplier)
#add entry in log book
self.logBook.append(
[simEnv.now, "Missed train. Leaving simulation."])
if Parameter.showWarnings and self.personalMemory.speedMultiplier == Parameter.maxSpeedMultiplier:
print(
"Missed train %s: Reached platform %s %.1fs late, train left at %.1f. (Using maximum speed multiplier %.1f)."
%
(trainName, curPlatformName, timePlatformArrival -
train.getDepTimeForPlatform(curPlatformName),
train.getDepTimeForPlatform(curPlatformName),
self.personalMemory.speedMultiplier))
#leave simulation
curArea.getRelease(self.resReqEvent)
simEnv.exit()
else:
yield train.getArrivalEvent(curPlatformName)
platform = pedNet.platformDict[curPlatformName]
#add available set of vehicles to choice set of current episode
curEpisode = self.personalMemory.episodeDict[
self.episodeIDList[-1]]
vehIDAssgFrac = platform.getBoardAssgFrac(self.curLinkID, trainName,\
transSys.trainDict, pedNet.streamIDDictRev)
#Availability of car given by assignment probability (no active choice!)
for vehID, vehChoiceProb in vehIDAssgFrac.items():
curEpisode.nextEpisodeDict[(curActNumber + 1,
vehID)] = vehChoiceProb
#on lateral platform sectors, train cars may not cover full sector length
#given a uniform distribution along a sector represented by a boarding link, service probability given by
trainServiceProbability = platform.boardLinkServiceProbability[
trainName][self.curLinkID]
#penalty due to limited service (requiring walking) approximated by transfer penalty
penaltyNoLocalTrainService = (
1 - trainServiceProbability) * Parameter.penaltyTrans
#penalize additional walking
curEpisodeUtility -= penaltyNoLocalTrainService
self.totalPenalty -= penaltyNoLocalTrainService
#get train vehicle from boarding link (weighted random choice)
trainVehID = platform.assignVehicle(
self.curLinkID, trainName, transSys.trainDict,
pedNet.streamIDDictRev)
#weightedChoice(platform.linkVehAssg[train.numVehicles,self.curLinkID])
trainVehicle = train.vehicleDict[trainVehID]
#once train has arrived, queue up to board
with trainVehicle.requestBoarding(
) as boardReq: #generate request event
#wait for access
yield boardReq
#check out from area
curArea.getRelease(self.resReqEvent)
self.curLinkID = None
self.ridingTrainName = param['trainID']
self.curVehID = trainVehID
#waiting cost
#account for waiting cost except if pedestrian arrived before simulation started
if not timePlatformArrival < self.param.dateStartSec:
waitingCost = curArea.getWaitingCost(
timePlatformArrival, simEnv.now)
curEpisodeUtility -= waitingCost
self.totalWaitUtility -= waitingCost
#transfer cost: can be applied upfront as number of transfers is known in advance
#curEpisodeUtility -= Parameter.penaltyTrans
#block door while boarding
boardingTime = trainVehicle.boardServTime()
yield simEnv.timeout(boardingTime)
#consider boarding time in travel cost (probably negligible)
boardWaitCost = boardingTime * Parameter.betaIVTZero #assume boarding time waited as IVT
curEpisodeUtility -= boardWaitCost
self.totalWaitUtility -= boardWaitCost
#increment passenger count
trainVehicle.cabin.passengerLoad += 1
if self.auxiliaryPassenger:
trainVehicle.cabin.loadAuxiliaryPassengers += 1
else:
trainVehicle.cabin.loadTrackedPassengers += 1
if Parameter.textOutput or self.param.isFinalInstance:
self.logEntry(pedNet, transSys, simEnv)
self.personalMemory.memorizeEpisode(curEpisodeID,
curEpisodeUtility)
self.totalTravelUtility += curEpisodeUtility
elif ('rideAndAlight' == actType):
assert (self.ridingTrainName is not None
and self.curVehID is not None)
train = transSys.trainDict[self.ridingTrainName]
trainVehicle = train.vehicleDict[self.curVehID]
curEpisodeID = (curActNumber, self.curVehID)
self.personalMemory.initializeEpisode(curEpisodeID)
self.episodeIDList.append(curEpisodeID)
#curEpisodeStartTime = simEnv.now
curEpisodeUtility = 0
timeRideStart = simEnv.now
#cabin request and train arrival event
self.seatReqEvent = trainVehicle.cabin.request()
arrEvent = train.getArrivalEvent(param['platformName'])
assert(arrEvent.processed is False), \
"Train %s should not have arrived yet on %s at %.2f. Passenger details: %s." %\
(self.ridingTrainName, param['platformName'], simEnv.now, self.activitySequence)
#wait for free cabin or train arrival
nextEvent = yield self.seatReqEvent | arrEvent
#if no space available until arrival
if arrEvent in nextEvent:
timeTrainArrival = simEnv.now
#manually compute standing cost
trainVehicle.cabin.updateCost()
ridingCost = trainVehicle.getRidingCostStanding(
timeRideStart, timeTrainArrival)
curEpisodeUtility -= ridingCost
#if a seating space is available
else:
timeSeated = simEnv.now
self.seated = True
ridingCost = trainVehicle.getRidingCostStanding(
timeRideStart, timeSeated)
curEpisodeUtility -= ridingCost
if Parameter.textOutput or self.param.isFinalInstance:
self.logEntry(pedNet, transSys, simEnv)
#wait for vehicle to arrive
yield arrEvent
timeTrainArrival = simEnv.now
#charge travel cost during seated part
trainVehicle.cabin.updateCost()
ridingCost = trainVehicle.getRidingCostSeated(
timeSeated, timeTrainArrival)
curEpisodeUtility -= ridingCost
#once arrived, leave cabin or revoke cabin request event
trainVehicle.cabin.release(self.seatReqEvent)
self.seated = False
if Parameter.textOutput or self.param.isFinalInstance:
self.logEntry(pedNet, transSys, simEnv)
#get alighting link
#alightLinkID = self.getAlightingLinkID(param['platformName'],transSys,pedNet) #obsolete
alightingPlatformName = param['platformName']
alightingPlatform = pedNet.platformDict[alightingPlatformName]
alightLinkID = alightingPlatform.assignAlightLink(self.ridingTrainName, \
transSys.trainDict, self.curVehID, pedNet.streamIDDictRev)
alightAreaID = pedNet.getAreaIDFromLinkID(alightLinkID)
alightArea = pedNet.getArea(alightAreaID)
alightAreaResReqEvent = alightArea.getResReqEvent()
#once train has arrived, queue up to alight
with trainVehicle.requestAlighting(
) as alightReq: #generate request event
yield alightReq #wait for access
alightingTime = trainVehicle.alightServTime()
yield simEnv.timeout(
alightingTime) #block door while boarding
#once able to use door, request space on area
yield alightAreaResReqEvent
self.ridingTrainName = None
self.curVehID = None
self.resReqEvent = alightAreaResReqEvent
#decrement passenger count
assert (trainVehicle.cabin.passengerLoad > 0)
trainVehicle.cabin.passengerLoad -= 1
if self.auxiliaryPassenger:
trainVehicle.cabin.loadAuxiliaryPassengers -= 1
else:
trainVehicle.cabin.loadTrackedPassengers -= 1
#update link
self.curLinkID = alightLinkID
#charge travel cost during alighting, requiring updating of cost
trainVehicle.cabin.updateCost()
timeOnPlatform = simEnv.now
ridingCost = trainVehicle.getRidingCostStanding(
timeTrainArrival, timeOnPlatform)
curEpisodeUtility -= ridingCost
self.personalMemory.memorizeEpisode(curEpisodeID,
curEpisodeUtility)
self.totalTravelUtility += curEpisodeUtility
self.totalRideUtility += curEpisodeUtility
elif ('exit' == actType):
#release current area
curAreaID = pedNet.getAreaIDFromLinkID(self.curLinkID)
curArea = pedNet.getArea(curAreaID)
curArea.getRelease(self.resReqEvent)
#set current link to None
self.curLinkID = None
#memorize episode and update travel cost
self.personalMemory.memorizeEpisode(curEpisodeID,
curEpisodeUtility)
self.totalTravelUtility += curEpisodeUtility
#display pedestrian state (debugging)
if Parameter.textOutput or self.param.isFinalInstance:
self.logEntry(pedNet, transSys, simEnv)
else:
raise KeyError('unknown actType ' + actType)
curActNumber += 1
simEnv.exit()
def synthesizeTwoLegTravelers(self, trentoTrains):
for overstapperFilePath in Parameter.overstapperFiles:
overstapperRawDataFiltered = self.loadOverstapperData(
overstapperFilePath, trentoTrains)
for _, overstapperEntry in overstapperRawDataFiltered.iterrows():
stationID = overstapperEntry["stationID"]
feedingTrainNumber = overstapperEntry["feedingTrain"]
connectingTrainNumber = overstapperEntry["connectingTrain"]
arrTimeFeedingTrainRaw = overstapperEntry[
"arrTimeFeedingTrain"]
numTravelers = overstapperEntry["numTravelers"]
transferStation = Parameter.stationNameDict[stationID]
feedingTrainModeled = False
connectingTrainModeled = False
#feeding train in trento train dict if served by at least one relevant platform
if feedingTrainNumber in trentoTrains.trainDict.keys():
trentoFeedingTrain = trentoTrains.trainDict[
feedingTrainNumber]
#check if train served by modeled platform in current station
if transferStation in trentoFeedingTrain.stationNameSequence:
assert (
feedingTrainNumber in self.trainDict
), "Train %s unknown in ROCKT InUit data." % feedingTrainNumber
feedingTrain = self.trainDict[feedingTrainNumber]
feedingTrainModeled = True
#connecting train in trento train dict if served by at least one relevant platform
if connectingTrainNumber in trentoTrains.trainDict.keys():
trentoConnectingTrain = trentoTrains.trainDict[
connectingTrainNumber]
#consider connecting train only if also served by modeled platform in current station
if transferStation in trentoConnectingTrain.stationNameSequence:
assert (
connectingTrainNumber in self.trainDict
), "Train %s unknown in ROCKT InUit data." % connectingTrainNumber
connectingTrain = self.trainDict[connectingTrainNumber]
connectingTrainModeled = True
#both trains served on modeled platform
if (feedingTrainModeled and connectingTrainModeled):
#synthesize individual travelers
while (numTravelers > random()):
numTravelers -= 1
#draw origin node and time
origTime, origNode, origStation = feedingTrain.sampleOriginStationAndEntranceGate(
transferStation)
#draw destination node
destNode, destStation = connectingTrain.sampleDestinationStationAndExitGate(
transferStation)
curTraveler = RocktTraveler(
origNode, destNode, origTime,
[feedingTrainNumber, connectingTrainNumber])
curTraveler.setTransferStation(transferStation)
self.travelerSet.add(curTraveler)
#add two travelers to OD table for validation
feedingTrain.addSynthesizedPassenger(
origStation, transferStation)
connectingTrain.addSynthesizedPassenger(
transferStation, destStation)
#only feeding train served by modeled platform:
#consider as incoming passenger (instead of transfer)
elif feedingTrainModeled:
#synthesize individual travelers
while (numTravelers > random()):
numTravelers -= 1
#draw origin node and time
origTime, origNode, origStation = feedingTrain.sampleOriginStationAndEntranceGate(
transferStation)
##draw exit gate in transfer station which becomes final destination
#destNode = feedingTrain.chooseExitGate(transferStation)
#destNode set to virtual transfer desk asking as gate
destNode = weightedChoice(
Parameter.transferGate[transferStation])
curTraveler = RocktTraveler(origNode, destNode,
origTime,
feedingTrainNumber)
self.travelerSet.add(curTraveler)
#add traveler to OD table for validation
feedingTrain.addSynthesizedPassenger(
origStation, transferStation)
#only connecting train served by modeled platform:
#consider as outgoing passenger (instead of transfer)
elif connectingTrainModeled:
arrTimeFeedingTrain = datetime.strptime(
arrTimeFeedingTrainRaw, '%Y-%m-%dT%H:%M:%S')
origTime = (arrTimeFeedingTrain -
self.midnightCaseStudy).total_seconds()
assert (origTime > 0)
#synthesize individual travelers
while (numTravelers > random()):
numTravelers -= 1
##draw entrance gate
#origNode = connectingTrain.chooseEntranceGate(transferStation)
origNode = weightedChoice(
Parameter.transferGate[transferStation])
#draw destination station and node
destNode, destStation = connectingTrain.sampleDestinationStationAndExitGate(
transferStation)
curTraveler = RocktTraveler(origNode, destNode,
origTime,
connectingTrainNumber)
self.travelerSet.add(curTraveler)
#add traveler to OD table for validation
connectingTrain.addSynthesizedPassenger(
transferStation, destStation)
#neither feeding nor connecting train served by modeled platform:
else:
#discard concerned passengers
continue
# def checkConsisteny(self, trentoTrains):
#
# print("\nConsistency Check:")
#
# boardInTrainStationDict = dict()
# alightOutTrainStationDict = dict()
#
# boardTransferTrainStationDict = dict()
# alightTransferTrainStationDict = dict()
#
# boardAuxiliaryTrainStationDict = dict()
# alightAuxiliaryTrainStationDict = dict()
#
# gateValidationDict = {'61001':'AsdZ-Minerva', '61002':'AsdZ-Minerva', '61003':'AsdZ-Minerva'}
#
# gateValidationFlow = dict()
#
#
# for traveler in self.travelerSet:
#
# origNode = traveler.origNode[1:]
# destNode = traveler.destNode[1:]
#
# depTime = traveler.depTime
#
# trainList = traveler.trainList
# transferStation = traveler.transferStation
#
# origTrain = trainList[0]
# destTrain = trainList[-1]
#
# if origNode in gateValidationDict.keys():
#
# validationGroup = gateValidationDict[origNode]
#
# if validationGroup not in gateValidationFlow:
# gateValidationFlow[validationGroup] = dict()
#
# if depTime not in gateValidationFlow[validationGroup].keys():
# gateValidationFlow[validationGroup][depTime] = 0
#
# gateValidationFlow[validationGroup][depTime] += 1
#
#
# if origTrain not in boardInTrainStationDict.keys():
# boardInTrainStationDict[origTrain] = dict()
# boardAuxiliaryTrainStationDict[origTrain] = dict()
#
# boardInStationDict = boardInTrainStationDict[origTrain]
# boardAuxiliaryStationDict = boardAuxiliaryTrainStationDict[origTrain]
#
# auxiliary = False
#
# if origNode == 'up':
# origStation = 'upstream'
# elif origNode[0:5] == 'Trans':
# auxiliary = True
# statNameRaw = origNode[5:]
#
# if statNameRaw in Parameter.stationNameDict.values():
# origStation=statNameRaw
# else:
# assert(statNameRaw[:-1] == 'Utrecht'), "invalid station name: %s" % statNameRaw[:-1]
# origStation = 'Utrecht'
#
# elif int(origNode[0:3]) in Parameter.stationNameDict.keys():
# origStation = Parameter.stationNameDict[ int(origNode[0:3]) ]
#
# elif int(origNode[0:2]) in Parameter.stationNameDict.keys():
# origStation = Parameter.stationNameDict[ int(origNode[0:2]) ]
#
# else:
# print("Could not identify origin station (%s)" % origNode)
#
#
# if origStation not in boardInStationDict:
# boardInStationDict[origStation] = 0
# boardAuxiliaryStationDict[origStation] = 0
#
# if auxiliary == False:
# boardInStationDict[origStation] += 1
# else:
# boardAuxiliaryStationDict[origStation] += 1
#
# if destTrain not in alightOutTrainStationDict.keys():
# alightOutTrainStationDict[destTrain] = dict()
# alightAuxiliaryTrainStationDict[destTrain] = dict()
#
# alightOutStationDict = alightOutTrainStationDict[destTrain]
# alightAuxiliaryStationDict = alightAuxiliaryTrainStationDict[destTrain]
#
# auxiliary=False
#
# if destNode == 'down':
# destStation = 'downstream'
# elif destNode[0:5] == 'Trans':
# auxiliary = True
# statNameRaw = destNode[5:]
#
# if statNameRaw in Parameter.stationNameDict.values():
# destStation=statNameRaw
# else:
# assert(statNameRaw[:-1] == 'Utrecht'), "invalid station name: %s" % statNameRaw[:-1]
# destStation = 'Utrecht'
# elif int(destNode[0:3]) in Parameter.stationNameDict.keys():
# destStation = Parameter.stationNameDict[ int(destNode[0:3]) ]
#
# elif int(destNode[0:2]) in Parameter.stationNameDict.keys():
# destStation = Parameter.stationNameDict[ int(destNode[0:2]) ]
#
# else:
# print("Could not identify destination station (%s)" % destNode)
#
#
# if destStation not in alightOutStationDict:
# alightOutStationDict[destStation] = 0
# alightAuxiliaryStationDict[destStation] = 0
#
# if auxiliary == False:
# alightOutStationDict[destStation] += 1
# else:
# alightAuxiliaryStationDict[destStation] += 1
#
# if transferStation is not None:
# assert(len(trainList) == 2)
#
# if origTrain not in alightTransferTrainStationDict:
# alightTransferTrainStationDict[origTrain] = dict()
#
# alightTransferStationDict = alightTransferTrainStationDict[origTrain]
#
# if transferStation not in alightTransferStationDict.keys():
# alightTransferStationDict[transferStation] = 0
#
# alightTransferStationDict[transferStation] += 1
#
#
# if destTrain not in boardTransferTrainStationDict:
# boardTransferTrainStationDict[destTrain] = dict()
#
# boardTransferStationDict = boardTransferTrainStationDict[destTrain]
#
# if transferStation not in boardTransferStationDict.keys():
# boardTransferStationDict[transferStation] = 0
#
# boardTransferStationDict[transferStation] += 1
#
# self.consistencyProtocol = dict()
#
# for trainNumber, train in self.trainDict.items():
#
# curStr = "%d (boardOut/alightIn/boardTrans/alightTrans):" % trainNumber
#
# for stationName in Parameter.stationNameDict.values():
# curStr += " %s: " % stationName
#
# compare boardings
# if stationName in train.boardOutgoing.keys():
# boardOutRaw = train.boardOutgoing[stationName]
#
# if trainNumber in boardInTrainStationDict.keys() and stationName in boardInTrainStationDict[trainNumber].keys():
# boardOutSynth = boardInTrainStationDict[trainNumber][stationName]
# else:
# boardOutSynth = 0
#
# curStr += "%+.1f%% (%d instead of %.1f) / " % ((boardOutSynth/boardOutRaw-1)*100,boardOutSynth,boardOutRaw)
#
# compare alightings
# if stationName in train.alightIncoming.keys():
# alightInRaw = train.alightIncoming[stationName]
#
# if trainNumber in alightOutTrainStationDict.keys() and stationName in alightOutTrainStationDict[trainNumber].keys():
# alightInSynth = alightOutTrainStationDict[trainNumber][stationName]
# else:
# alightInSynth = 0
#
# curStr += "%+.1f%% (%d instead of %.1f) / " % ((alightInSynth/alightInRaw-1)*100,alightInSynth,alightInRaw)
#
# compare transfer boardings
# if stationName in train.boardTransfer.keys():
# boardTransferRaw = train.boardTransfer[stationName]
#
# boardTransferSynth = 0
#
# if trainNumber in boardTransferTrainStationDict.keys() and stationName in boardTransferTrainStationDict[trainNumber].keys():
# boardTransferSynth += boardTransferTrainStationDict[trainNumber][stationName]
#
# if trainNumber in boardAuxiliaryTrainStationDict.keys() and stationName in boardAuxiliaryTrainStationDict[trainNumber].keys():
# boardTransferSynth += boardAuxiliaryTrainStationDict[trainNumber][stationName]
#
# curStr += "%+.1f%% (%d instead of %.1f) / " % ((boardTransferSynth/boardTransferRaw-1)*100,boardTransferSynth,boardTransferRaw)
#
# compare transfer alightings
# if stationName in train.alightTransfer.keys():
# alightTransferRaw = train.alightTransfer[stationName]
#
# alightTransferSynth = 0
#
# if trainNumber in alightTransferTrainStationDict.keys() and stationName in alightTransferTrainStationDict[trainNumber].keys():
# alightTransferSynth += alightTransferTrainStationDict[trainNumber][stationName]
#
# if trainNumber in alightAuxiliaryTrainStationDict.keys() and stationName in alightAuxiliaryTrainStationDict[trainNumber].keys():
# alightTransferSynth += alightAuxiliaryTrainStationDict[trainNumber][stationName]
#
# curStr += "%+.1f%% (%d instead of %.1f)" % ((alightTransferSynth/alightTransferRaw-1)*100,alightTransferSynth,alightTransferRaw)
#
# self.consistencyProtocol[trainNumber] = curStr
#
# print(self.consistencyProtocol)
#
# for validatorName, validatorFlowDict in gateValidationFlow.items():
#
# print("checking gate in-flow at %s [paused]" % validatorName)
#
# timeStamps,flowObs = zip(*( sorted( validatorFlowDict.items() ) ))
#
# cumFlow = np.cumsum(flowObs)
#
# plotting cumulative flow
# figCum, axCum = plt.subplots()
#
# plt.ylabel('cumulative flow')
# plt.title(validatorName)
#
# plt.step(timeStamps, cumFlow, where='post', label='synthesizedDemand', color='blue')
#
# plt.legend()
#
# plt.show()
def assignAlightLink(self, trainName, trainDict, vehID, streamIDDictRev):
#dictionary of alighting links and corresponding assignment probabilities
alightLinkAssgFrac = self.getAlightAssgFrac(trainName, trainDict,
vehID, streamIDDictRev)
return weightedChoice(alightLinkAssgFrac)