def main(args=None):
argParser = initOptions()
options = argParser.parse_args(args=args)
if not options.net:
argParser.error("Option --net-file is mandatory")
if (not options.trips and not options.routes
and not options.flows) or (options.trips and options.routes):
argParser.error(
"Either --trips, --flows, or --routes have to be given!")
duaBinary = sumolib.checkBinary("duarouter", options.path)
sumoBinary = sumolib.checkBinary("sumo", options.path)
if options.addweights and options.weightmemory:
argParser.error(
"Options --addweights and --weight-memory are mutually exclusive.")
# make sure BOTH binaries are callable before we start
try:
subprocess.call(duaBinary, stdout=subprocess.PIPE)
except OSError:
sys.exit(
"Error: Could not locate duarouter (%s).\nMake sure its on the search path or set environment variable DUAROUTER_BINARY\n"
% duaBinary)
try:
subprocess.call(sumoBinary, stdout=subprocess.PIPE)
except OSError:
sys.exit(
"Error: Could not locate sumo (%s).\nMake sure its on the search path or set environment variable SUMO_BINARY\n"
% sumoBinary)
sumo_args = assign_remaining_args(sumoBinary, 'sumo',
options.remaining_args)
dua_args = assign_remaining_args(duaBinary, 'duarouter',
options.remaining_args)
sys.stdout = sumolib.TeeFile(sys.stdout, open("stdout.log", "w+"))
log = open("dua.log", "w+")
if options.zip:
if options.clean_alt:
sys.exit(
"Error: Please use either --zip or --clean-alt but not both.")
try:
subprocess.call("7z", stdout=open(os.devnull, 'wb'))
except:
sys.exit(
"Error: Could not locate 7z, please make sure its on the search path."
)
zipProcesses = {}
zipLog = open("7zip.log", "w+")
starttime = datetime.now()
if options.trips:
input_demands = options.trips.split(",")
initial_type = "trip"
elif options.flows:
input_demands = options.flows.split(",")
initial_type = "flow"
else:
input_demands = options.routes.split(",")
initial_type = "route"
if options.externalgawron:
# avoid dependency on numpy for normal duaIterate
from routeChoices import getRouteChoices, calFirstRouteProbs
print('use externalgawron')
edgesMap = {}
if options.weightmemory:
costmemory = CostMemory('traveltime',
pessimism=options.pessimism,
network_file=options.net)
routesSuffix = ".xml"
if options.binary:
routesSuffix = ".sbx"
if options.costmodifier != 'None':
pyPath = os.path.abspath(os.path.dirname(sys.argv[0]))
sys.path.append(
os.path.join(pyPath, "..", "..", "..", "..", "..", "tools",
"kkwSim"))
from kkwCostModifier import costModifier
print('Use the cost modifier for KKW simulation')
if options.weightmemory and options.firstStep != 0:
# load previous dump files when continuing a run
print(">> Reassembling cost-memory from previous iteration steps")
for step in range(0, options.firstStep):
dumpfile = get_dumpfilename(options, step, "dump")
print(">>> Loading %s" % dumpfile)
costmemory.load_costs(dumpfile, step, get_scale(options, step))
avgTT = sumolib.miscutils.Statistics()
for step in range(options.firstStep, options.lastStep):
btimeA = datetime.now()
print("> Executing step %s" % step)
router_demands = input_demands
simulation_demands = input_demands
# demand files have regular names based on the basename and the step
if not (options.skipFirstRouting and step == 0):
simulation_demands = [
get_basename(f) + "_%03i.rou%s" % (step, routesSuffix)
for f in input_demands
]
if not ((options.skipFirstRouting and step == 1) or step == 0):
router_demands = [
get_basename(f) + "_%03i.rou.alt%s" % (step - 1, routesSuffix)
for f in input_demands
]
if not (options.skipFirstRouting and step == options.firstStep):
# call duarouter
for router_input, output in zip(router_demands,
simulation_demands):
print(">> Running router on %s" % router_input)
btime = datetime.now()
print(">>> Begin time: %s" % btime)
cfgname = writeRouteConf(duaBinary, step, options, dua_args,
router_input, output,
options.routefile, initial_type)
log.flush()
sys.stdout.flush()
call([duaBinary, "-c", cfgname], log)
if options.clean_alt and not router_input in input_demands:
os.remove(router_input)
etime = datetime.now()
print(">>> End time: %s" % etime)
print(">>> Duration: %s" % (etime - btime))
print("<<")
# use the external gawron
if options.externalgawron:
ecomeasure = None
if options.ecomeasure:
ecomeasure = options.ecomeasure
if step == options.firstStep + 1 and options.skipFirstRouting:
if options.caloldprob:
calFirstRouteProbs(
"dump_000_%s.xml" % (options.aggregation),
basename + "_001.rou.alt.xml",
options.addweights, ecomeasure)
else:
shutil.copy(basename + "_001.rou.alt.xml",
basename + "_001.rou.galt.xml")
shutil.copy(basename + "_001.rou.xml",
basename + "_001.grou.xml")
if step == options.firstStep and not options.skipFirstRouting:
shutil.copy(basename + "_000.rou.alt.xml",
basename + "_000.rou.galt.xml")
shutil.copy(basename + "_000.rou.xml",
basename + "_000.grou.xml")
else:
print('step:', step)
print('get externalgawron')
dumpfile = "dump_%03i_%s.xml" % (step - 1,
options.aggregation)
if (not options.skipFirstRouting) or (
options.skipFirstRouting and step > 1):
output, edgesMap = getRouteChoices(
edgesMap, dumpfile,
basename + "_%03i.rou.alt.xml" % step,
options.net, options.addweights, options.gA,
options.gBeta, step, ecomeasure)
# simulation
print(">> Running simulation")
btime = datetime.now()
print(">>> Begin time: %s" % btime)
writeSUMOConf(sumoBinary, step, options, sumo_args,
",".join(simulation_demands)) # todo: change 'grou.xml'
log.flush()
sys.stdout.flush()
call([sumoBinary, "-c", "iteration_%03i.sumocfg" % step], log)
if options.tripinfoFilter:
filterTripinfo(step, set(options.tripinfoFilter.split(",")))
etime = datetime.now()
print(">>> End time: %s" % etime)
print(">>> Duration: %s" % (etime - btime))
print("<<")
if options.weightmemory:
print(">> Smoothing edge weights")
costmemory.load_costs(get_dumpfilename(options, step, "dump"),
step, get_scale(options, step))
costmemory.write_costs(get_weightfilename(options, step, "dump"))
print(">>> Updated %s edges" % costmemory.loaded())
print(">>> Decayed %s unseen edges" % costmemory.decayed())
print(">>> Error avg:%s mean:%s" %
(costmemory.avg_error(), costmemory.mean_error()))
print(">>> Absolute Error avg:%s mean:%s" %
(costmemory.avg_abs_error(), costmemory.mean_abs_error()))
if options.costmodifier != 'None':
currentDir = os.getcwd()
costModifier(get_weightfilename(options, step, "dump"), step,
"dump", options.aggregation, currentDir,
options.costmodifier, 'dua-iterate')
if options.zip and step - options.firstStep > 1:
# this is a little hackish since we zip and remove all files by glob, which may have undesired side effects
# also note that the 7z file does not have an "_" before the
# iteration number in order to be not picked up by the remove
for s in zipProcesses.keys():
if zipProcesses[s].poll() is not None:
for f in glob.glob("*_%03i*" % s):
try:
os.remove(f)
except:
print("Could not remove %s" % f, file=zipLog)
del zipProcesses[s]
zipStep = step - 2
zipProcesses[zipStep] = subprocess.Popen(
["7z", "a", "iteration%03i.7z" % zipStep] +
glob.glob("*_%03i*" % zipStep),
stdout=zipLog,
stderr=zipLog)
converged = False
if options.convDev:
sum = 0.
count = 0
for t in sumolib.output.parse_fast("tripinfo_%03i.xml" % step,
'tripinfo', ['duration']):
sum += float(t.duration)
count += 1
avgTT.add(sum / count)
relStdDev = avgTT.relStdDev(options.convIt)
print(
"< relative travel time deviation in the last %s steps: %.05f"
% (min(avgTT.count(), options.convIt), relStdDev))
if avgTT.count() >= options.convIt and relStdDev < options.convDev:
converged = True
print("< Step %s ended (duration: %s)" %
(step, datetime.now() - btimeA))
print("------------------\n")
log.flush()
sys.stdout.flush()
if converged:
break
if options.zip:
for s in zipProcesses.keys():
zipProcesses[s].wait()
for f in glob.glob("*_%03i*" % s):
try:
os.remove(f)
except:
print("Could not remove %s" % f, file=zipLog)
zipLog.close()
print("dua-iterate ended (duration: %s)" % (datetime.now() - starttime))
log.close()
sumoBinary = sumolib.checkBinary(sumo, options.path)
if options.costmodifier != 'None':
pyPath = os.path.abspath(os.path.dirname(sys.argv[0]))
sys.path.append(
os.path.join(pyPath, "..", "..", "..", "..", "..", "tools", "kkwSim"))
from kkwCostModifier import costModifier
print('use the cost modifier')
log = open("one_shot-log.txt", "w")
starttime = datetime.now()
for step in options.frequencies.split(","):
step = int(step)
print("> Running simulation with update frequency %s" % step)
btime = datetime.now()
print(">> Begin time %s" % btime)
if options.costmodifier != 'None':
currentDir = os.getcwd()
print(options.costmodifier)
outputfile = '%s_weights_%s.xml' % (options.costmodifier, step)
costModifier(outputfile, step, "dump", options.aggregation,
currentDir, options.costmodifier, 'one-shot')
writeSUMOConf(step, options, options.trips)
call([sumoBinary, "-c", "one_shot_%s.sumocfg" % step], log)
etime = datetime.now()
print(">> End time %s" % etime)
print("< Step %s ended (duration: %s)" % (step, etime - btime))
print("------------------\n")
print("one-shot ended (duration: %s)" % (datetime.now() - starttime))
log.close()
def main(args=None):
argParser = initOptions()
options = argParser.parse_args(args=args)
if not options.net:
argParser.error("Option --net-file is mandatory")
if (not options.trips and not options.routes and not options.flows) or (options.trips and options.routes):
argParser.error(
"Either --trips, --flows, or --routes have to be given!")
duaBinary = sumolib.checkBinary("duarouter", options.path)
sumoBinary = sumolib.checkBinary("sumo", options.path)
if options.addweights and options.weightmemory:
argParser.error(
"Options --addweights and --weight-memory are mutually exclusive.")
# make sure BOTH binaries are callable before we start
try:
subprocess.call(duaBinary, stdout=subprocess.PIPE)
except OSError:
sys.exit(
"Error: Could not locate duarouter (%s).\nMake sure its on the search path or set environment variable DUAROUTER_BINARY\n" % duaBinary)
try:
subprocess.call(sumoBinary, stdout=subprocess.PIPE)
except OSError:
sys.exit(
"Error: Could not locate sumo (%s).\nMake sure its on the search path or set environment variable SUMO_BINARY\n" % sumoBinary)
sumo_args = assign_remaining_args(
sumoBinary, 'sumo', options.remaining_args)
dua_args = assign_remaining_args(
duaBinary, 'duarouter', options.remaining_args)
sys.stdout = sumolib.TeeFile(sys.stdout, open("stdout.log", "w+"))
log = open("dua.log", "w+")
if options.zip:
if options.clean_alt:
sys.exit(
"Error: Please use either --zip or --clean-alt but not both.")
try:
subprocess.call("7z", stdout=open(os.devnull, 'wb'))
except:
sys.exit(
"Error: Could not locate 7z, please make sure its on the search path.")
zipProcesses = {}
zipLog = open("7zip.log", "w+")
starttime = datetime.now()
if options.trips:
input_demands = options.trips.split(",")
initial_type = "trip"
elif options.flows:
input_demands = options.flows.split(",")
initial_type = "flow"
else:
input_demands = options.routes.split(",")
initial_type = "route"
if options.externalgawron:
# avoid dependency on numpy for normal duaIterate
from routeChoices import getRouteChoices, calFirstRouteProbs
print('use externalgawron')
edgesMap = {}
if options.weightmemory:
costmemory = CostMemory('traveltime', pessimism=options.pessimism, network_file=options.net
)
routesSuffix = ".xml"
if options.binary:
routesSuffix = ".sbx"
if options.costmodifier != 'None':
pyPath = os.path.abspath(os.path.dirname(sys.argv[0]))
sys.path.append(
os.path.join(pyPath, "..", "..", "..", "..", "..", "tools", "kkwSim"))
from kkwCostModifier import costModifier
print('Use the cost modifier for KKW simulation')
if options.weightmemory and options.firstStep != 0:
# load previous dump files when continuing a run
print(">> Reassembling cost-memory from previous iteration steps")
for step in range(0, options.firstStep):
dumpfile = get_dumpfilename(options, step, "dump")
print(">>> Loading %s" % dumpfile)
costmemory.load_costs(dumpfile, step, get_scale(options, step))
avgTT = sumolib.miscutils.Statistics()
for step in range(options.firstStep, options.lastStep):
btimeA = datetime.now()
print("> Executing step %s" % step)
router_demands = input_demands
simulation_demands = input_demands
# demand files have regular names based on the basename and the step
if not (options.skipFirstRouting and step == 0):
simulation_demands = [
get_basename(f) + "_%03i.rou%s" % (step, routesSuffix) for f in input_demands]
if not ((options.skipFirstRouting and step == 1) or step == 0):
router_demands = [get_basename(
f) + "_%03i.rou.alt%s" % (step - 1, routesSuffix) for f in input_demands]
if not (options.skipFirstRouting and step == options.firstStep):
# call duarouter
for router_input, output in zip(router_demands, simulation_demands):
print(">> Running router on %s" % router_input)
btime = datetime.now()
print(">>> Begin time: %s" % btime)
cfgname = writeRouteConf(duaBinary, step, options, dua_args, router_input,
output, options.routefile, initial_type)
log.flush()
sys.stdout.flush()
call([duaBinary, "-c", cfgname], log)
if options.clean_alt and not router_input in input_demands:
os.remove(router_input)
etime = datetime.now()
print(">>> End time: %s" % etime)
print(">>> Duration: %s" % (etime - btime))
print("<<")
# use the external gawron
if options.externalgawron:
ecomeasure = None
if options.ecomeasure:
ecomeasure = options.ecomeasure
if step == options.firstStep + 1 and options.skipFirstRouting:
if options.caloldprob:
calFirstRouteProbs("dump_000_%s.xml" % (
options.aggregation), basename + "_001.rou.alt.xml", options.addweights, ecomeasure)
else:
shutil.copy(
basename + "_001.rou.alt.xml", basename + "_001.rou.galt.xml")
shutil.copy(
basename + "_001.rou.xml", basename + "_001.grou.xml")
if step == options.firstStep and not options.skipFirstRouting:
shutil.copy(
basename + "_000.rou.alt.xml", basename + "_000.rou.galt.xml")
shutil.copy(
basename + "_000.rou.xml", basename + "_000.grou.xml")
else:
print('step:', step)
print('get externalgawron')
dumpfile = "dump_%03i_%s.xml" % (
step - 1, options.aggregation)
if (not options.skipFirstRouting) or (options.skipFirstRouting and step > 1):
output, edgesMap = getRouteChoices(
edgesMap, dumpfile, basename + "_%03i.rou.alt.xml" % step, options.net, options.addweights, options.gA, options.gBeta, step, ecomeasure)
# simulation
print(">> Running simulation")
btime = datetime.now()
print(">>> Begin time: %s" % btime)
writeSUMOConf(sumoBinary, step, options, sumo_args,
",".join(simulation_demands)) # todo: change 'grou.xml'
log.flush()
sys.stdout.flush()
call([sumoBinary, "-c", "iteration_%03i.sumocfg" % step], log)
if options.tripinfoFilter:
filterTripinfo(step, set(options.tripinfoFilter.split(",")))
etime = datetime.now()
print(">>> End time: %s" % etime)
print(">>> Duration: %s" % (etime - btime))
print("<<")
if options.weightmemory:
print(">> Smoothing edge weights")
costmemory.load_costs(
get_dumpfilename(options, step, "dump"), step, get_scale(options, step))
costmemory.write_costs(get_weightfilename(options, step, "dump"))
print(">>> Updated %s edges" % costmemory.loaded())
print(">>> Decayed %s unseen edges" % costmemory.decayed())
print(">>> Error avg:%s mean:%s" %
(costmemory.avg_error(), costmemory.mean_error()))
print(">>> Absolute Error avg:%s mean:%s" %
(costmemory.avg_abs_error(), costmemory.mean_abs_error()))
if options.costmodifier != 'None':
currentDir = os.getcwd()
costModifier(get_weightfilename(options, step, "dump"), step, "dump",
options.aggregation, currentDir, options.costmodifier, 'dua-iterate')
if options.zip and step - options.firstStep > 1:
# this is a little hackish since we zip and remove all files by glob, which may have undesired side effects
# also note that the 7z file does not have an "_" before the
# iteration number in order to be not picked up by the remove
for s in zipProcesses.keys():
if zipProcesses[s].poll() is not None:
for f in glob.glob("*_%03i*" % s):
try:
os.remove(f)
except:
print("Could not remove %s" % f, file=zipLog)
del zipProcesses[s]
zipStep = step - 2
zipProcesses[zipStep] = subprocess.Popen(
["7z", "a", "iteration%03i.7z" % zipStep] + glob.glob("*_%03i*" % zipStep), stdout=zipLog, stderr=zipLog)
converged = False
if options.convDev:
sum = 0.
count = 0
for t in sumolib.output.parse_fast("tripinfo_%03i.xml" % step, 'tripinfo', ['duration']):
sum += float(t.duration)
count += 1
avgTT.add(sum / count)
relStdDev = avgTT.relStdDev(options.convIt)
print("< relative travel time deviation in the last %s steps: %.05f" % (
min(avgTT.count(), options.convIt), relStdDev))
if avgTT.count() >= options.convIt and relStdDev < options.convDev:
converged = True
print("< Step %s ended (duration: %s)" %
(step, datetime.now() - btimeA))
print("------------------\n")
log.flush()
sys.stdout.flush()
if converged:
break
if options.zip:
for s in zipProcesses.keys():
zipProcesses[s].wait()
for f in glob.glob("*_%03i*" % s):
try:
os.remove(f)
except:
print("Could not remove %s" % f, file=zipLog)
zipLog.close()
print("dua-iterate ended (duration: %s)" % (datetime.now() - starttime))
log.close()
def main(args=None):
optParser = initOptions()
options, remaining_args = optParser.parse_args(args=args)
if not options.net:
optParser.error("Option --net-file is mandatory")
if (not options.trips and not options.routes
and not options.flows) or (options.trips and options.routes):
optParser.error(
"Either --trips, --flows, or --routes have to be given!")
duaBinary = os.environ.get("DUAROUTER_BINARY",
os.path.join(options.path, "duarouter"))
if options.mesosim:
sumoBinary = os.environ.get("SUMO_BINARY",
os.path.join(options.path, "meso"))
else:
sumoBinary = os.environ.get("SUMO_BINARY",
os.path.join(options.path, "sumo"))
if options.addweights and options.weightmemory:
optParser.error(
"Options --addweights and --weight-memory are mutually exclusive.")
# make sure BOTH binaries are callable before we start
try:
subprocess.call(duaBinary, stdout=subprocess.PIPE)
except OSError:
sys.exit(
"Error: Could not locate duarouter (%s).\nMake sure its on the search path or set environment variable DUAROUTER_BINARY\n"
% duaBinary)
try:
subprocess.call(sumoBinary, stdout=subprocess.PIPE)
except OSError:
sys.exit(
"Error: Could not locate sumo (%s).\nMake sure its on the search path or set environment variable SUMO_BINARY\n"
% sumoBinary)
sumo_args = assign_remaining_args(sumoBinary, 'sumo', remaining_args)
log = open("dua-log.txt", "w+")
starttime = datetime.now()
if options.trips:
input_demands = options.trips.split(",")
initial_type = "trip"
elif options.flows:
input_demands = options.flows.split(",")
initial_type = "flow"
else:
input_demands = options.routes.split(",")
initial_type = "route"
if options.externalgawron:
# avoid dependency on numpy for normal duaIterate
from routeChoices import getRouteChoices, calFirstRouteProbs
print('use externalgawron')
edgesMap = {}
if options.weightmemory:
costmemory = CostMemory('traveltime',
pessimism=options.pessimism,
network_file=options.net)
routesSuffix = ".xml"
if options.binary:
routesSuffix = ".sbx"
if options.costmodifier != 'None':
pyPath = os.path.abspath(os.path.dirname(sys.argv[0]))
sys.path.append(
os.path.join(pyPath, "..", "..", "..", "..", "..", "tools",
"kkwSim"))
from kkwCostModifier import costModifier
print('Use the cost modifier for KKW simulation')
if options.weightmemory and options.firstStep != 0:
# load previous dump files when continuing a run
print(">> Reassembling cost-memory from previous iteration steps")
for step in range(0, options.firstStep):
dumpfile = get_dumpfilename(options, step, "dump")
print(">>> Loading %s" % dumpfile)
costmemory.load_costs(dumpfile, step, get_scale(options, step))
for step in range(options.firstStep, options.lastStep):
btimeA = datetime.now()
print("> Executing step %s" % step)
router_demands = input_demands
simulation_demands = input_demands
# demand files have regular names based on the basename and the step
if not (options.skipFirstRouting and step == 0):
simulation_demands = [
get_basename(f) + "_%03i.rou%s" % (step, routesSuffix)
for f in input_demands
]
if not ((options.skipFirstRouting and step == 1) or step == 0):
router_demands = [
get_basename(f) + "_%03i.rou.alt%s" % (step - 1, routesSuffix)
for f in input_demands
]
if not (options.skipFirstRouting and step == options.firstStep):
# call duarouter
for router_input, output in zip(router_demands,
simulation_demands):
print(">> Running router on %s" % router_input)
btime = datetime.now()
print(">>> Begin time: %s" % btime)
cfgname = writeRouteConf(step, options, router_input, output,
options.routefile, initial_type)
log.flush()
call([duaBinary, "-c", cfgname], log)
if options.clean_alt and not router_input in input_demands:
os.remove(router_input)
etime = datetime.now()
print(">>> End time: %s" % etime)
print(">>> Duration: %s" % (etime - btime))
print("<<")
# use the external gawron
if options.externalgawron:
ecomeasure = None
if options.ecomeasure:
ecomeasure = options.ecomeasure
if step == options.firstStep + 1 and options.skipFirstRouting:
if options.caloldprob:
calFirstRouteProbs(
"dump_000_%s.xml" % (options.aggregation),
basename + "_001.rou.alt.xml",
options.addweights, ecomeasure)
else:
shutil.copy(basename + "_001.rou.alt.xml",
basename + "_001.rou.galt.xml")
shutil.copy(basename + "_001.rou.xml",
basename + "_001.grou.xml")
if step == options.firstStep and not options.skipFirstRouting:
shutil.copy(basename + "_000.rou.alt.xml",
basename + "_000.rou.galt.xml")
shutil.copy(basename + "_000.rou.xml",
basename + "_000.grou.xml")
else:
print('step:', step)
print('get externalgawron')
dumpfile = "dump_%03i_%s.xml" % (step - 1,
options.aggregation)
if (not options.skipFirstRouting) or (
options.skipFirstRouting and step > 1):
output, edgesMap = getRouteChoices(
edgesMap, dumpfile,
basename + "_%03i.rou.alt.xml" % step,
options.net, options.addweights, options.gA,
options.gBeta, step, ecomeasure)
# simulation
print(">> Running simulation")
btime = datetime.now()
print(">>> Begin time: %s" % btime)
writeSUMOConf(sumoBinary, step, options, sumo_args,
",".join(simulation_demands)) # todo: change 'grou.xml'
log.flush()
call([sumoBinary, "-c", "iteration_%03i.sumocfg" % step], log)
if options.tripinfoFilter:
filterTripinfo(step, set(options.tripinfoFilter.split(",")))
etime = datetime.now()
print(">>> End time: %s" % etime)
print(">>> Duration: %s" % (etime - btime))
print("<<")
if options.weightmemory:
print(">> Smoothing edge weights")
costmemory.load_costs(get_dumpfilename(options, step, "dump"),
step, get_scale(options, step))
costmemory.write_costs(get_weightfilename(options, step, "dump"))
print(">>> Updated %s edges" % costmemory.loaded())
print(">>> Decayed %s unseen edges" % costmemory.decayed())
print(">>> Error avg:%s mean:%s" %
(costmemory.avg_error(), costmemory.mean_error()))
print(">>> Absolute Error avg:%s mean:%s" %
(costmemory.avg_abs_error(), costmemory.mean_abs_error()))
if options.costmodifier != 'None':
currentDir = os.getcwd()
costModifier(get_weightfilename(options, step, "dump"), step,
"dump", options.aggregation, currentDir,
options.costmodifier, 'dua-iterate')
print("< Step %s ended (duration: %s)" %
(step, datetime.now() - btimeA))
print("------------------\n")
log.flush()
print("dua-iterate ended (duration: %s)" % (datetime.now() - starttime))
log.close()
def main(args=None):
optParser = initOptions()
options, remaining_args = optParser.parse_args(args=args)
if not options.net:
optParser.error("Option --net-file is mandatory")
if (not options.trips and not options.routes and not options.flows) or (options.trips and options.routes):
optParser.error("Either --trips, --flows, or --routes have to be given!")
duaBinary = os.environ.get("DUAROUTER_BINARY", os.path.join(options.path, "duarouter"))
if options.mesosim:
sumoBinary = os.environ.get("SUMO_BINARY", os.path.join(options.path, "meso"))
else:
sumoBinary = os.environ.get("SUMO_BINARY", os.path.join(options.path, "sumo"))
if options.addweights and options.weightmemory:
optParser.error("Options --addweights and --weight-memory are mutually exclusive.")
# make sure BOTH binaries are callable before we start
try:
subprocess.call(duaBinary, stdout=subprocess.PIPE)
except OSError:
sys.exit("Error: Could not locate duarouter (%s).\nMake sure its on the search path or set environment variable DUAROUTER_BINARY\n" % duaBinary)
try:
subprocess.call(sumoBinary, stdout=subprocess.PIPE)
except OSError:
sys.exit("Error: Could not locate sumo (%s).\nMake sure its on the search path or set environment variable SUMO_BINARY\n" % sumoBinary)
sumo_args = assign_remaining_args(sumoBinary, 'sumo', remaining_args)
log = open("dua-log.txt", "w+")
starttime = datetime.now()
if options.trips:
input_demands = options.trips.split(",")
initial_type = "trip"
elif options.flows:
input_demands = options.flows.split(",")
initial_type = "flow"
else:
input_demands = options.routes.split(",")
initial_type = "route"
if options.externalgawron:
# avoid dependency on numpy for normal duaIterate
from routeChoices import getRouteChoices, calFirstRouteProbs
print('use externalgawron')
edgesMap = {}
if options.weightmemory:
costmemory = CostMemory('traveltime'
,pessimism=options.pessimism
,network_file=options.net
)
routesSuffix = ".xml"
if options.binary:
routesSuffix = ".sbx"
if options.costmodifier != 'None':
pyPath = os.path.abspath(os.path.dirname(sys.argv[0]))
sys.path.append(os.path.join(pyPath, "..", "..", "..", "..","..", "tools", "kkwSim"))
from kkwCostModifier import costModifier
print('Use the cost modifier for KKW simulation')
if options.weightmemory and options.firstStep != 0:
# load previous dump files when continuing a run
print(">> Reassembling cost-memory from previous iteration steps")
for step in range(0, options.firstStep):
dumpfile = get_dumpfilename(options, step,"dump")
print(">>> Loading %s" % dumpfile)
costmemory.load_costs(dumpfile, step, get_scale(options, step))
for step in range(options.firstStep, options.lastStep):
btimeA = datetime.now()
print("> Executing step %s" % step)
router_demands = input_demands
simulation_demands = input_demands
# demand files have regular names based on the basename and the step
if not (options.skipFirstRouting and step == 0):
simulation_demands = [get_basename(f) + "_%03i.rou%s" % (step, routesSuffix) for f in input_demands]
if not ((options.skipFirstRouting and step == 1) or step == 0):
router_demands = [get_basename(f) + "_%03i.rou.alt%s" % (step-1, routesSuffix) for f in input_demands]
if not (options.skipFirstRouting and step == options.firstStep):
# call duarouter
for router_input, output in zip(router_demands, simulation_demands):
print(">> Running router on %s" % router_input)
btime = datetime.now()
print(">>> Begin time: %s" % btime)
cfgname = writeRouteConf(step, options, router_input, output, options.routefile, initial_type)
log.flush()
call([duaBinary, "-c", cfgname], log)
if options.clean_alt and not router_input in input_demands:
os.remove(router_input)
etime = datetime.now()
print(">>> End time: %s" % etime)
print(">>> Duration: %s" % (etime-btime))
print("<<")
# use the external gawron
if options.externalgawron:
ecomeasure = None
if options.ecomeasure:
ecomeasure = options.ecomeasure
if step == options.firstStep + 1 and options.skipFirstRouting:
if options.caloldprob:
calFirstRouteProbs("dump_000_%s.xml" % (options.aggregation), basename + "_001.rou.alt.xml",options.addweights,ecomeasure)
else:
shutil.copy(basename + "_001.rou.alt.xml", basename + "_001.rou.galt.xml")
shutil.copy(basename + "_001.rou.xml", basename + "_001.grou.xml")
if step == options.firstStep and not options.skipFirstRouting:
shutil.copy(basename + "_000.rou.alt.xml", basename + "_000.rou.galt.xml")
shutil.copy(basename + "_000.rou.xml", basename + "_000.grou.xml")
else:
print('step:', step)
print('get externalgawron')
dumpfile = "dump_%03i_%s.xml" % (step-1, options.aggregation)
if (not options.skipFirstRouting) or (options.skipFirstRouting and step > 1):
output, edgesMap = getRouteChoices(edgesMap,dumpfile,basename + "_%03i.rou.alt.xml" % step,options.net,options.addweights, options.gA, options.gBeta,step,ecomeasure)
# simulation
print(">> Running simulation")
btime = datetime.now()
print(">>> Begin time: %s" % btime)
writeSUMOConf(sumoBinary, step, options, sumo_args,
",".join(simulation_demands)) # todo: change 'grou.xml'
log.flush()
call([sumoBinary, "-c", "iteration_%03i.sumocfg" % step], log)
if options.tripinfoFilter:
filterTripinfo(step, set(options.tripinfoFilter.split(",")))
etime = datetime.now()
print(">>> End time: %s" % etime)
print(">>> Duration: %s" % (etime-btime))
print("<<")
if options.weightmemory:
print(">> Smoothing edge weights")
costmemory.load_costs(
get_dumpfilename(options, step,"dump"), step, get_scale(options, step))
costmemory.write_costs(get_weightfilename(options, step, "dump"))
print(">>> Updated %s edges" % costmemory.loaded())
print(">>> Decayed %s unseen edges" % costmemory.decayed())
print(">>> Error avg:%s mean:%s" % (costmemory.avg_error(), costmemory.mean_error()))
print(">>> Absolute Error avg:%s mean:%s" % (costmemory.avg_abs_error(), costmemory.mean_abs_error()))
if options.costmodifier != 'None':
currentDir = os.getcwd()
costModifier(get_weightfilename(options, step, "dump"), step, "dump", options.aggregation, currentDir, options.costmodifier, 'dua-iterate')
print("< Step %s ended (duration: %s)" % (step, datetime.now() - btimeA))
print("------------------\n")
log.flush()
print("dua-iterate ended (duration: %s)" % (datetime.now() - starttime))
log.close()
