def sim_init( self ) :
""" simulation setup """
# construct the simulation blocks
sim = Simulation()
self.sim = sim
if False :
script = sample_demands( self.horizon, self.rategraph, self.roadnet )
source = ScriptSource( script )
print 'obtained %d demands' % len( source.script )
debug_input()
else :
source = RoadnetDemandSource( self.roadnet, self.rategraph )
self.source = source
source.join_sim( sim )
# policy setup
#import setiptah.roadgeometry.probability as roadprob
#roadmap = roadprob.sampleroadnet()
#U = roadprob.UniformDist( roadmap )
#samplepoint = U.sample
# instantiate the gate
gate = GatedTaxiDispatch()
gate.setScheduler( RoadmapFHKScheduler( self.roadnet ) )
self.gate = gate
# source -> gate
# fleet setup
vehicles = {}
self.vehicles = vehicles
# fleet parameters
from setiptah.roadgeometry.roadmap_paths import RoadmapPlanner
planner = RoadmapPlanner( self.roadnet )
roads = [ road for _,__,road in self.roadnet.edges(data=True) ]
road = random.choice( roads )
ORIGIN = ROAD.RoadAddress(road,0.) # just... somewhere
for i in range( self.numveh ) :
taxi = Taxi()
taxi.setPlanner( planner )
randpoint = roadprob.sampleaddress( self.roadnet, 'length' )
taxi.setLocation( randpoint )
taxi.setSpeed( 1. )
taxi.join_sim( sim )
gateIF = gate.newInterface()
gate.add( gateIF )
vehicles[taxi] = gateIF
gateIF.output.connect( taxi.appendDemands )
taxi.signalWakeup.connect( gateIF.input )
taxi.signalIdle.connect( gateIF.input )
gate.join_sim( sim )
# record number of unassigned demands
self.tape = []
def record_unassigned() :
# first, count the demands waiting in the gate
unassg = len( self.gate._demandQ ) #+ len( self.dispatch.demands )
# then, count the demands in vehicle queues (minus possibly 1 being worked on)
for veh in self.vehicles :
temp = len( veh._demandQ )
temp = max( temp, 1 ) - 1
unassg += temp
# recorder the number
self.tape.append( unassg )
recorder = UniformClock( 1. )
recorder.join_sim( sim )
recorder.output.connect( record_unassigned )
self.recorder = recorder
# report demand arrivals to several places
self.DEMANDS = []
def record_arrival( dem ) :
self.DEMANDS.append( dem )
def give_to_dispatch( dem ) :
#p, q = dem
taxidem = Taxi.Demand( *dem )
self.gate.queueDemand( taxidem )
source_out = source.source()
#source_out.connect( counting.increment )
source_out.connect( record_arrival )
source_out.connect( give_to_dispatch )
#source.source().connect( give_to_dispatch )
self.timer = data()
self.timer.last_time = sim.time
def say( dem ) :
p, q = dem
new_time = self.sim.time
elapsed = new_time - self.timer.last_time
print 'tick, %f: %s, %s' % ( elapsed, repr(p), repr(q) )
self.timer.last_time = new_time
source_out.connect( say )
def gimme( *args, **kwargs ) :
print "need a batch!!"
# creates an interface from gate to interactive dispatcher
#gate_if = gate.spawn_interface()
#self.gate_if = gate_if
#dispatch.request_batch.connect( gate.requestRelease )
#dispatch.request_batch.connect( gimme )
#gate.output.connect( dispatch.batch_arrived )
#gate_if.batch_out.connect( dispatch.batch_arrived )
def hello( *args, **kwargs ) :
print 'vehicle is ready!'
def sim_init( self ) :
""" simulation setup """
# construct the simulation blocks
sim = Simulation()
self.sim = sim
if False :
script = sample_demands( self.horizon, self.rategraph, self.roadnet )
source = ScriptSource( script )
print 'obtained %d demands' % len( source.script )
debug_input()
else :
source = RoadnetDemandSource( self.roadnet, self.rategraph )
self.source = source
source.join_sim( sim )
gate = GatedQueue() # because nearest neighbor "cheats" if the arrival rate is too high
self.gate = gate
gate.join_sim( sim )
dispatch = BatchNNeighDispatcher()
self.dispatch = dispatch
dispatch.set_environment( roadnet )
dispatch.join_sim( sim )
""" add some demands to jump-start the simulation """
preload = 0
distr = {}
for road1, road2, rate_data in normrategraph.edges_iter( data=True ) :
distr[(road1,road2)] = rate_data.get( 'rate', 0. )
bonus_demands = [ roadprob.samplepair( roadnet, distr ) for i in range(preload) ]
for p, q in bonus_demands : gate.demand_arrived( (p,q) )
""" end cheats """
vehicles = {}
self.vehicles = vehicles
for k in range( self.numveh ) :
veh = Vehicle() ; vehicles[ veh ] = None
veh.set_environment( self.distance )
veh.set_speed( self.vehspeed )
randpoint = roadprob.sampleaddress( roadnet, 'length' )
veh.set_location( randpoint )
veh.join_sim( sim )
# record number of unassigned demands
self.tape = []
def record_unassigned() :
unassg = len( self.gate._queue ) + len( self.dispatch.demands )
self.tape.append( unassg )
recorder = UniformClock( 1. )
recorder.join_sim( sim )
recorder.output.connect( record_unassigned )
self.recorder = recorder
# report demand arrivals to several places
self.DEMANDS = []
def record_arrival( dem ) :
self.DEMANDS.append( dem )
def give_to_dispatch( dem ) :
p, q = dem
loc = p
#dispatch.demand_arrived( dem, loc )
self.gate.arrival( dem )
source_out = source.source()
#source_out.connect( counting.increment )
source_out.connect( give_to_dispatch )
source_out.connect( record_arrival )
#source.source().connect( give_to_dispatch )
self.timer = data()
self.timer.last_time = sim.time
def say( dem ) :
p, q = dem
new_time = self.sim.time
elapsed = new_time - self.timer.last_time
print 'tick, %f: %s, %s' % ( elapsed, repr(p), repr(q) )
self.timer.last_time = new_time
source_out.connect( say )
def gimme( *args, **kwargs ) :
print "need a batch!!"
# creates an interface from gate to interactive dispatcher
#gate_if = gate.spawn_interface()
#self.gate_if = gate_if
dispatch.request_batch.connect( gate.requestRelease )
dispatch.request_batch.connect( gimme )
gate.output.connect( dispatch.batch_arrived )
#gate_if.batch_out.connect( dispatch.batch_arrived )
def hello( *args, **kwargs ) :
print 'vehicle is ready!'
# vehicle signal connections
for veh in vehicles :
vehconn = dispatch.spawn_interface() ; vehicles[veh] = vehconn
veh.ready.connect( vehconn.request_in )
veh.ready.connect( hello )
#veh.ready.connect( vehconn.request_in )
vehconn.demand_out.connect( veh.receive_demand )