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):
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):
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')
routesSuffix = ".xml"
if options.binary:
routesSuffix = ".sbx"
for step in range(options.firstStep, options.lastStep):
btimeA = datetime.now()
print "> Executing step %s" % step
# dua-router
if options.skipFirstRouting and step == 0:
files = input_demands
else:
files = []
for demand_file in input_demands:
absPath = os.path.abspath(demand_file)
basename = os.path.basename(demand_file)
if 'alt' in basename:
basename = basename[:-12]
elif 'trips' in basename:
basename = basename[:-10]
else:
basename = basename[:basename.find(".")]
output = basename + "_%03i.rou%s" % (step, routesSuffix)
if step > 0 and not (options.skipFirstRouting and step == 1):
# output of previous step
demand_file = basename + "_%03i.rou.alt%s" % (step-1, routesSuffix)
print ">> Running router"
btime = datetime.now()
print ">>> Begin time: %s" % btime
cfgname = writeRouteConf(step, options, demand_file, output, options.routefile, initial_type)
log.flush()
call([duaBinary, "-c", cfgname], log)
if options.clean_alt and step != 0:
os.remove(demand_file)
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 == 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 == 0 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)
files.append(output)
# simulation
print ">> Running simulation"
btime = datetime.now()
print ">>> Begin time: %s" % btime
writeSUMOConf(sumoBinary, step, options, sumo_args, ",".join(files)) # 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())
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()
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')
routesSuffix = ".xml"
if options.binary:
routesSuffix = ".sbx"
for step in range(options.firstStep, options.lastStep):
btimeA = datetime.now()
print "> Executing step %s" % step
# dua-router
if options.skipFirstRouting and step == 0:
files = input_demands
else:
files = []
for demand_file in input_demands:
absPath = os.path.abspath(demand_file)
basename = os.path.basename(demand_file)
if 'alt' in basename:
basename = basename[:-12]
elif 'trips' in basename:
basename = basename[:-10]
else:
basename = basename[:basename.find(".")]
output = basename + "_%03i.rou%s" % (step, routesSuffix)
if step > 0 and not (options.skipFirstRouting and step == 1):
# output of previous step
demand_file = basename + "_%03i.rou.alt%s" % (step - 1,
routesSuffix)
print ">> Running router"
btime = datetime.now()
print ">>> Begin time: %s" % btime
cfgname = writeRouteConf(step, options, demand_file, output,
options.routefile, initial_type)
log.flush()
call([duaBinary, "-c", cfgname], log)
if options.clean_alt and step != 0:
os.remove(demand_file)
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 == 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 == 0 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)
files.append(output)
# simulation
print ">> Running simulation"
btime = datetime.now()
print ">>> Begin time: %s" % btime
writeSUMOConf(sumoBinary, step, options, sumo_args,
",".join(files)) # 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())
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):
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)
index = -1
for i in range(len(dua_args)):
if dua_args[i] == '--additional-files':
index = i
if index > -1:
dua_args[index + 1] = ','.join([
prepend_relative("..", f) for f in dua_args[index + 1].split(',')
])
sys.stdout = sumolib.TeeFile(sys.stdout, open(options.log, "w+"))
log = open(options.dualog, "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 Exception:
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(",")
elif options.flows:
input_demands = options.flows.split(",")
else:
input_demands = options.routes.split(",")
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.gzip:
routesSuffix = ".gz"
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):
current_directory = os.getcwd()
final_directory = os.path.join(current_directory, str(step))
if not os.path.exists(final_directory):
os.makedirs(final_directory)
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 = [
str(step - 1) + os.sep + 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)
log.flush()
sys.stdout.flush()
if options.SO:
if options.logit:
if step > 1:
with open(
os.path.join(
str(step - 1),
get_weightfilename(
options, step - 1, "dump")),
'r') as sumo_cur:
tree_sumo_cur = ET.parse(sumo_cur)
root_sumo_cur = tree_sumo_cur.getroot()
with open(
os.path.join(
str(step - 2),
get_weightfilename(
options, step - 2, "dump")),
'r') as sumo_prv:
tree_sumo_prv = ET.parse(sumo_prv)
root_sumo_prv = tree_sumo_prv.getroot()
for interval_cur in root_sumo_cur:
begin_cur = interval_cur.attrib.get("begin")
for interval_prv in root_sumo_prv:
begin_prv = interval_prv.attrib.get(
"begin")
for edge_cur in interval_cur.iter('edge'):
for edge_prv in interval_prv.iter(
'edge'):
if begin_cur == begin_prv and edge_cur.get(
"id") == edge_prv.get(
"id"):
if edge_cur.get(
"traveltime"
) is not None and edge_prv.get(
"traveltime"
) is not None:
veh_cur = round(
float(
edge_cur.get(
"left") +
edge_cur.get(
"arrived")), 2)
veh_prv = round(
float(
edge_prv.get(
"left") +
edge_prv.get(
"arrived")), 2)
tt_cur = round(
float(
edge_cur.get(
"traveltime")),
2)
tt_prv = round(
float(
edge_prv.get(
"traveltime")),
2)
dif_tt = abs(tt_cur -
tt_prv)
dif_veh = abs(veh_cur -
veh_prv)
if dif_veh != 0:
margin = round(
(dif_tt / dif_veh),
3)
new_tt = round(
(margin + tt_cur),
3)
edge_cur.set(
"traveltime",
str(new_tt))
tree_sumo_cur.write(
os.path.join(
str(step - 1),
get_weightfilename(options, step - 1,
"dump")))
else:
argParser.error(
"SO assignment only works with logit route choice algorithm "
"---> activate logit route choice algorithm")
call([duaBinary, "-c", cfgname], log)
if options.clean_alt and router_input not 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:
basename = get_basename(router_input)
if ((step > 0 and not options.skipFirstRouting)
or step > 1):
basename = basename[:-4]
print('basename', basename)
ecomeasure = None
if options.eco_measure:
ecomeasure = options.eco_measure
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(
str(1) + os.sep + basename +
"_001.rou.alt.xml",
".." + os.sep + basename + "_001.rou.galt.xml")
shutil.copy(
str(step) + os.sep + basename + "_001.rou.xml",
str(step) + os.sep + basename +
"_001.grou.xml")
if step == options.firstStep and not options.skipFirstRouting:
shutil.copy(
str(step) + os.sep + basename + "_000.rou.alt.xml",
".." + os.sep + basename + "_000.rou.galt.xml")
shutil.copy(
str(step) + os.sep + basename + "_000.rou.xml",
".." + os.sep + basename + "_000.grou.xml")
else:
print('step:', step)
print('get externalgawron')
dumpfile = str(step -
1) + os.sep + "dump_%03i_%s.xml" % (
step - 1, options.aggregation)
shutil.copy(
str(step - 1) + os.sep + basename +
"_00%s.rou.alt.xml" % (step - 1),
basename + "_00%s.rou.galt.xml" % (step - 1))
if (not options.skipFirstRouting) or (
options.skipFirstRouting and step > 1):
output, edgesMap = getRouteChoices(
edgesMap, dumpfile,
str(step) + os.sep + 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",
"%s%siteration_%03i.sumocfg" % (step, os.sep, step)
], log)
if options.tripinfoFilter:
filterTripinfo(step, 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(
str(step) + os.sep + get_dumpfilename(options, step, "dump"),
step, get_scale(options, step))
costmemory.write_costs(
str(step) + os.sep + get_weightfilename(options, step, "dump"))
print(">>> Updated %s edges" % costmemory.loaded())
print(">>> Decayed %s unseen edges" % costmemory.decayed())
print(">>> Error avg:%.12g mean:%.12g" %
(costmemory.avg_error(), costmemory.mean_error()))
print(">>> Absolute Error avg:%.12g mean:%.12g" %
(costmemory.avg_abs_error(), costmemory.mean_abs_error()))
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 list(zipProcesses.keys()):
if zipProcesses[s].poll() is not None:
for f in glob.glob("*_%03i*" % s):
try:
os.remove(f)
except Exception:
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(
str(step) + os.sep + "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 Exception:
print("Could not remove %s" % f, file=zipLog)
zipLog.close()
print("dua-iterate ended (duration: %s)" % (datetime.now() - starttime))
log.close()