class XTMFMatrixCalculator(_m.Tool()):
#---Parameters---
Scenario = _m.Attribute(_m.InstanceType)
xtmf_ScenarioNumber = _m.Attribute(str)
xtmf_expression = _m.Attribute(str)
xtmf_result = _m.Attribute(str)
def __init__(self):
self.Scenario = _MODELLER.scenario
def __call__(self, xtmf_ScenarioNumber, xtmf_expression, xtmf_result):
self.Scenario = _MODELLER.emmebank.scenario(xtmf_ScenarioNumber)
if (self.Scenario is None):
raise Exception("Scenario %s was not found!" % xtmf_ScenarioNumber)
self.expression = xtmf_expression
self.result = xtmf_result
spec = self.matrix_calculator_spec()
report = matrixCalculator(spec, self.Scenario)
return ""
def matrix_calculator_spec(self):
spec = {
"result": self.result,
"expression": self.expression,
"type": "MATRIX_CALCULATION"
}
return spec
def GetToolParameterTypes(self, tool):
# get the names of the parameters
parameterNames = inspect.getargspec(tool.__call__)[0][1:]
ret = []
for param in parameterNames:
try:
paramVar = eval("tool.__class__." + str(param))
except:
_m.logbook_write("A parameter with the name '" + param + "' does not exist in the executing EMME tool! Make sure that the EMME tool defines this attribute as a class variable.")
self.SendParameterError("A parameter with the name '" + param + "' does not exist in the executing EMME tool! Make sure that the EMME tool defines this attribute as a class variable.")
return None
typeOfParam = paramVar.type
if typeOfParam == _m.Attribute(float).type:
ret.append("float")
elif typeOfParam == _m.Attribute(int).type:
ret.append("int")
elif typeOfParam == _m.Attribute(str).type:
ret.append("string")
elif typeOfParam == _m.Attribute(bool).type:
ret.append("bool")
else:
_m.logbook_write(param + " uses a type unsupported by the ModellerBridge '" + str(typeOfParam) + "'!")
self.SendParameterError(param + " uses a type unsupported by the ModellerBridge '" + str(typeOfParam) + "'!")
return None
return ret
class CopyScenario(_m.Tool()):
version = '0.0.1'
xtmf_JSON = _m.Attribute(str)
xtmf_logbook_level = _m.Attribute(str)
def page(self):
pb = _m.ToolPageBuilder(self,
title="Copy Scenario",
runnable=False,
description="Cannot be called from Modeller.",
branding_text="XTMF")
return pb.render()
def run(self):
pass
def __call__(self, xtmf_JSON, xtmf_logbook_level):
logbook = _m.logbook_level()
if xtmf_logbook_level == "NONE":
_m.logbook_level(_m.LogbookLevel.NONE)
parameters = json.loads(xtmf_JSON)
FromScenario = parameters['from_scenario']
ToScenario = parameters['to_scenario']
CopyStrategy = parameters['copy_strategy']
try:
self._execute(FromScenario, ToScenario, CopyStrategy)
except Exception, e:
raise Exception(_traceback.format_exc(e))
class RunMacro(_m.Tool()):
ScenarioNumber = _m.Attribute(int)
MacroFile = _m.Attribute(str)
Args = _m.Attribute(str)
def page(self):
pb = _m.ToolPageBuilder(self,
title="Run a macro",
runnable=False,
description="Cannot be called from Modeller.",
branding_text="XTMF")
return pb.render()
def run(self):
pass
def __call__(self, ScenarioNumber, MacroFile, Args):
try:
# Get the run macro tool
tool = None
try:
tool = _m.Modeller().tool('inro.emme.standard.prompt.run_macro'
) #Emme 3.4.2 namespace
except Exception, e:
tool = _m.Modeller().tool(
'inro.emme.prompt.run_macro') #Emme 4.0.3 namespace
tool(macro_name=MacroFile,
macro_arguments=Args,
scenario=ScenarioNumber)
except Exception, e:
raise Exception(_traceback.format_exc(e))
class CopyScenario(_m.Tool()):
version = '0.0.1'
batch_file = _m.Attribute(str)
scenario_number = _m.Attribute(int)
def page(self):
pb = _m.ToolPageBuilder(self,
title="Import VDF Batch File",
runnable=False,
description="Cannot be called from Modeller.",
branding_text="XTMF")
return pb.render()
def run(self):
pass
def __call__(self, batch_file, scenario_number):
try:
project = _MODELLER.emmebank
scenario = project.scenario(str(scenario_number))
process(transaction_file=batch_file,
scenario=scenario,
throw_on_error=True)
except Exception as e:
raise Exception(_traceback.format_exc())
class AddNodeWeights(_m.Tool()):
version = '0.1.0'
tool_run_msg = ""
report_html = ""
Scenario = _m.Attribute(_m.InstanceType)
MassAttribute = _m.Attribute(_m.InstanceType)
def __init__(self):
self.Scenario = _MODELLER.scenario
self._tracker = _util.ProgressTracker(5)
def page(self):
pb = _tmgTPB.TmgToolPageBuilder(
self,
title="Add Node Weights v%s" % self.version,
description="Adds node weights to existing network nodes \
for use in centroid generation. Higher weights are \
more likely to be connected to centroid connectors in CCGEN.\
<br><br>The node weights are assigned as follows: \
<br> <ul style=\"list-style-type:none\">\
<li><b>1</b>: default value \
<li><b>2</b>: nodes at intersections with transit stop(s) \
<li><b>3</b>: mid-block nodes without any transit stops \
<li><b>4</b>: mid-block nodes with transit stop(s) \
<li><b>5</b>: dead-end nodes without any transit stops \
<li><b>6</b>: dead-end nodes with transit stop(s)</ul>\
",
branding_text="- TMG Toolbox")
if self.tool_run_msg != "": # to display messages in the page
pb.tool_run_status(self.tool_run_msg_status)
pb.add_select_scenario(tool_attribute_name="Scenario",
title="Select Scenario",
allow_none=False)
pb.add_select_attribute(
tool_attribute_name="MassAttribute",
filter='NODE',
allow_none=True,
title="Node weight attribute",
note="Attribute which node weights will be stored in.")
return pb.render()
@_m.method(return_type=unicode)
def tool_run_msg_status(self):
return self.tool_run_msg
def run(self):
self.tool_run_msg = ""
'''Run is called from Modeller.'''
try:
self._execute()
except Exception, e:
self.tool_run_msg = _m.PageBuilder.format_exception(
e, _traceback.format_exc(e))
raise
class ImportCordonCounts(_m.Tool()):
version = '1.0.0'
tool_run_msg = ""
number_of_tasks = 1
Scenario = _m.Attribute(_m.InstanceType)
CordonTruthTable = _m.Attribute(str)
def __init__(self):
#---Init internal variables
self.TRACKER = _util.ProgressTracker(self.number_of_tasks) #init the ProgressTracker
#---Set the defaults of parameters used by Modeller
self.Scenario = _mm.scenario #Default is primary scenario
def page(self):
pb = _tmgTPB.TmgToolPageBuilder(self, title="Populate Cordon Count Data v%s" %self.version,
description="Loads the cordon count results from a file for the \
purpose of validating traffic assignment. An extra attribute \
is created that stores the cordon counts on the relevant links.\
The difference in assigned volumes and counts can be visualized\
using the Link Layer in Desktop. (Bar Value = Volau - @cord).",
branding_text="- TMG Toolbox")
if self.tool_run_msg != "": # to display messages in the page
pb.tool_run_status(self.tool_run_msg_status)
pb.add_select_scenario(tool_attribute_name='Scenario',
title='Scenario',
allow_none=False)
pb.add_header("CORDON DATA FILE")
pb.add_select_file(tool_attribute_name='CordonTruthTable',
window_type='file', file_filter='*.csv',
title="Cordon Count File",
note="Requires three columns:\
<ul><li>countpost_id</li>\
<li>link id (form of inode-jnode)</li>\
<li>cordon_count</li></ul>")
return pb.render()
def __call__(self, Scen, TruthTable):
self.tool_run_msg = ""
self.TRACKER.reset()
self.Scenario = Scen
self.CordonTruthTable = TruthTable
try:
self._Execute()
except Exception, e:
self.tool_run_msg = _m.PageBuilder.format_exception(
e, _traceback.format_exc(e))
raise
self.tool_run_msg = _m.PageBuilder.format_info("Done.")
class ReverseTransitLines(_m.Tool()):
version = '1.0.0'
tool_run_msg = ""
number_of_tasks = 1 # For progress reporting, enter the integer number of tasks here
#---PARAMETERS
Scenario = _m.Attribute(_m.InstanceType) # common variable or parameter
LineSelectorExpression = _m.Attribute(str)
def __init__(self):
#---Init internal variables
self.TRACKER = _util.ProgressTracker(self.number_of_tasks) #init the ProgressTracker
#---Set the defaults of parameters used by Modeller
self.Scenario = _MODELLER.scenario #Default is primary scenario
self.LineSelectorExpression = 'mode=r'
##########################################################################################################
#---
#---MODELLER INTERACE METHODS
def page(self):
pb = _tmgTPB.TmgToolPageBuilder(self, title="Reverse Transit Lines v%s" %self.version,
description="Reverses the itineraries of a subset of transit lines. It will \
try to preserve the line ID of the original line by appending or \
modifying the final character. Reports to the Logbook which new lines \
are reversed copies of which other lines.",
branding_text="- TMG Toolbox")
if self.tool_run_msg != "": # to display messages in the page
pb.tool_run_status(self.tool_run_msg_status)
pb.add_select_scenario(tool_attribute_name='Scenario',
title='Scenario:',
allow_none=False)
pb.add_text_box(tool_attribute_name= 'LineSelectorExpression',
size=100, multi_line= True,
title= "Line selector expression",
note= "Write a network calculator expression to select lines to reverse.")
return pb.render()
def run(self):
self.tool_run_msg = ""
self.TRACKER.reset()
try:
self._Execute()
except Exception, e:
self.tool_run_msg = _m.PageBuilder.format_exception(
e, _traceback.format_exc(e))
raise
self.tool_run_msg = _m.PageBuilder.format_info("Done.")
class ReturnBoardingsAndWAW(_m.Tool()):
version = '0.1.1'
tool_run_msg = ""
number_of_tasks = 1 # For progress reporting, enter the integer number of tasks here
# Tool Input Parameters
# Only those parameters necessary for Modeller and/or XTMF to dock with
# need to be placed here. Internal parameters (such as lists and dicts)
# get initialized during construction (__init__)
xtmf_ScenarioNumber = _m.Attribute(int) # parameter used by XTMF only
xtmf_LineAggregationFile = _m.Attribute(str)
xtmf_ExportWAW = _m.Attribute(bool)
NumberOfProcessors = _m.Attribute(int)
def __init__(self):
#---Init internal variables
self.TRACKER = _util.ProgressTracker(
self.number_of_tasks) #init the ProgressTracker
self.NumberOfProcessors = cpu_count()
def page(self):
pb = _m.ToolPageBuilder(self,
title="Return Boardings",
description="Cannot be called from Modeller.",
runnable=False,
branding_text="XTMF")
return pb.render()
##########################################################################################################
def __call__(self, xtmf_ScenarioNumber, xtmf_LineAggregationFile,
xtmf_ExportWAW):
_m.logbook_write("Extracting boarding results")
#---1 Set up scenario
scenario = _m.Modeller().emmebank.scenario(xtmf_ScenarioNumber)
if (scenario == None):
raise Exception("Scenario %s was not found!" % xtmf_ScenarioNumber)
if not scenario.has_transit_results:
raise Exception(
"Scenario %s does not have transit assignment results" %
xtmf_ScenarioNumber)
self.xtmf_LineAggregationFile = xtmf_LineAggregationFile
self.xtmf_ExportWAW = xtmf_ExportWAW
try:
return self._Execute(scenario)
except Exception, e:
msg = str(e) + "\n" + _traceback.format_exc(e)
raise Exception(msg)
class ExportCountStationLocation(_m.Tool()):
version = '0.1.1'
tool_run_msg = ""
number_of_tasks = 1
Scenario = _m.Attribute(_m.InstanceType)
CordonExportFile = _m.Attribute(str)
def __init__(self):
#---Init internal variables
self.TRACKER = _util.ProgressTracker(
self.number_of_tasks) #init the ProgressTracker
#---Set the defaults of parameters used by Modeller
self.Scenario = _mm.scenario #Default is primary scenario
def page(self):
pb = _tmgTPB.TmgToolPageBuilder(
self,
title="Export Count Station-Link Correspondence File v%s" %
self.version,
description="Exports a link and countpost correspondence file.\
Contained witin, is the link on which each countpost is found.\
Assumes that count stations are defined by '@stn1'.",
branding_text="- TMG Toolbox")
if self.tool_run_msg != "": # to display messages in the page
pb.tool_run_status(self.tool_run_msg_status)
pb.add_header("EXPORT CORDON DATA FILE")
pb.add_select_file(tool_attribute_name='CordonExportFile',
window_type='save_file',
file_filter='*.csv',
title="Cordon Count File",
note="Select Export Location:\
<ul><li>countpost_id</li>\
<li>link id (inode-jnode)</li>\
</ul>")
return pb.render()
def __call__(self, Scen, TruthTable):
self.tool_run_msg = ""
self.TRACKER.reset()
self.Scenario = Scen
self.CordonTruthTable = TruthTable
try:
self._Execute()
except Exception, e:
self.tool_run_msg = _m.PageBuilder.format_exception(
e, _traceback.format_exc(e))
raise
self.tool_run_msg = _m.PageBuilder.format_info("Done.")
class ShptoEmmeMap(_m.Tool()):
version = '0.0.1'
tool_run_msg = ""
number_of_tasks = 1
#Tool Parameters
ShpFileName = _m.Attribute(str)
MappingFileName = _m.Attribute(str)
def __init__(self):
#---Init internal variables
self.TRACKER = _util.ProgressTracker(
self.number_of_tasks) #init the ProgressTracker
def page(self):
pb = _tmgTPB.TmgToolPageBuilder(
self,
title="GTFS Stops to Emme Node File v%s" % self.version,
description=
"Takes a shapefile and creates a mapping file that shows \
the node in the EMME network which it corresponds to. \
EXPERIMENTAL",
branding_text="- TMG Toolbox")
if self.tool_run_msg != "": # to display messages in the page
pb.tool_run_status(self.tool_run_msg_status)
pb.add_select_file(tool_attribute_name="ShpFileName",
window_type='file',
file_filter="*.shp",
title="stops.shp file")
pb.add_select_file(tool_attribute_name="MappingFileName",
window_type='save_file',
title="Map file to export")
'''pb.add_select_file(tool_attribute_name="MappingfileName",
window_type='save_file',
title="Map file to export")'''
return pb.render()
def __call__(self, StopFileName, MappingFileName):
self.StopsFileName = StopFileName
self.MappingFileName = MappingFileName
self.tool_run_msg = ""
self.TRACKER.reset()
try:
self._Execute()
except Exception, e:
self.tool_run_msg = _m.PageBuilder.format_exception(
e, _traceback.format_exc(e))
raise
self.tool_run_msg = _m.PageBuilder.format_info("Done.")
class NodeEMMEmap(_m.Tool()):
version = '0.0.1'
tool_run_msg = ""
number_of_tasks = 1
#Tool Parameters
FileName = _m.Attribute(str)
MappingFileName = _m.Attribute(str)
def __init__(self):
#---Init internal variables
self.TRACKER = _util.ProgressTracker(
self.number_of_tasks) #init the ProgressTracker
def page(self):
pb = _tmgTPB.TmgToolPageBuilder(
self,
title="GTFS Stops to Emme Node File v%s" % self.version,
description=
"Takes the <b>stops.txt</b> file and creates a mapping file that shows \
the node in the EMME network which it corresponds to.",
branding_text="- TMG Toolbox")
if self.tool_run_msg != "": # to display messages in the page
pb.tool_run_status(self.tool_run_msg_status)
pb.add_select_file(
tool_attribute_name="FileName",
window_type='file',
file_filter="*.txt *.shp",
title=
"The shp or stops.txt file that contains the stops information. Please note that the stops.txt file format should \
follow GTFS rules. The shp files also needs to contain the DBF field 'StopID'"
)
pb.add_select_file(tool_attribute_name="MappingFileName",
window_type='save_file',
title="Map file to export in csv format")
'''pb.add_select_file(tool_attribute_name="MappingfileName",
window_type='save_file',
title="Map file to export")'''
return pb.render()
def run(self):
self.tool_run_msg = ""
self.TRACKER.reset()
try:
self._Execute()
except Exception, e:
self.tool_run_msg = _m.PageBuilder.format_exception(
e, _traceback.format_exc(e))
raise
self.tool_run_msg = _m.PageBuilder.format_info("Done")
class BKRCastExportAllAttributes(_modeller.Tool()):
'''
'''
version = "1.0" # this is the version
default_path = ""
tool_run_message = ""
scenarios_list = _modeller.Attribute(_modeller.ListType)
sola_specs_box = _modeller.Attribute(_modeller.StringType)
def page(self):
pb = _modeller.ToolPageBuilder(
self,
title="BKRCast Network Interface",
description="SOLA Assignment on Multiple Scenarios",
branding_text=
"Modeling and Analysis Group -- City of Bellevue Transportation")
pb.add_select_scenario("scenarios_list", title="Select scenarios")
pb.add_sola_traffic_assignment_spec("sola_specs_box",
title="Select specs")
if self.tool_run_message != "":
pb.tool_run_status(self.tool_run_msg_status)
return pb.render()
@_modeller.method(return_type=_modeller.UnicodeType)
def tool_run_msg_status(self):
return self.tool_run_message
@property
def current_scenario(self):
return _modeller.Modeller().desktop.data_explorer(
).primary_scenario.core_scenario
@property
def current_emmebank(self):
return self.current_scenario.emmebank
def set_primary_scenario(self, scenarioID):
'''set the scenario identified by scenarioID to the primary scenario.
'''
scenario = self.current_emmebank.scenario(scenarioID)
_modeller.Modeller().desktop.data_explorer().replace_primary_scenario(
scenario)
def run(self):
self.tool_run_message = ""
try:
self.__call__()
run_message = "All attributes exported"
self.tool_run_message += _modeller.PageBuilder.format_info(
run_message)
except Exception, e:
self.tool_run_message += _modeller.PageBuilder.format_exception(
e, _traceback.format_exc(e))
class CheckScenarioFunctions(_m.Tool()):
version = '0.0.1'
tool_run_msg = ""
number_of_tasks = 1 # For progress reporting, enter the integer number of tasks here
# Tool Input Parameters
# Only those parameters neccessary for Modeller and/or XTMF to dock with
# need to be placed here. Internal parameters (such as lists and dicts)
# get intitialized during construction (__init__)
xtmf_ScenarioNumber = _m.Attribute(int) # parameter used by XTMF only
Scenario = _m.Attribute(_m.InstanceType) # common variable or parameter
def __init__(self):
#---Init internal variables
self.TRACKER = _util.ProgressTracker(
self.number_of_tasks) #init the ProgressTracker
#---Set the defaults of parameters used by Modeller
self.Scenario = _MODELLER.scenario #Default is primary scenario
def page(self):
pb = _tmgTPB.TmgToolPageBuilder(
self,
title="Check Scenario Functions v%s" % self.version,
description=
"Loads a scenario and checks that all referenced functions \
(link VDF, transit segment TTF, and turn TPF) are defined in the \
emmebank. It will raise an error listing all missing functions.",
branding_text="- TMG Toolbox")
if self.tool_run_msg != "": # to display messages in the page
pb.tool_run_status(self.tool_run_msg_status)
pb.add_select_scenario(tool_attribute_name='Scenario',
title='Scenario:',
allow_none=False)
return pb.render()
##########################################################################################################
def run(self):
self.tool_run_msg = ""
self.TRACKER.reset()
try:
self._Execute()
except Exception, e:
self.tool_run_msg = _m.PageBuilder.format_exception(
e, _traceback.format_exc(e))
raise
self.tool_run_msg = _m.PageBuilder.format_info("Run complete.")
class ConvertVDFs(_m.Tool()):
version = '0.2.0'
tool_run_msg = ""
#---Special instance types
scenario = _m.Attribute(_m.InstanceType) #
makeChangesPermanent = _m.Attribute(bool) #
def __init__(self):
self.networkCalculator = _m.Modeller().tool(
"inro.emme.network_calculation.network_calculator")
def page(self):
pb = _m.ToolPageBuilder(
self,
title="Convert VDFs v%s" % self.version,
description=
"Converts link classification types (stored as VDF ids) from \
DMG2001 to NCS11.",
branding_text="- TMG Toolbox")
if self.tool_run_msg != "": # to display messages in the page
pb.tool_run_status(self.tool_run_msg_status)
pb.add_select_scenario(tool_attribute_name="scenario",
title="Select a scenario",
allow_none=False)
pb.add_checkbox(
tool_attribute_name="makeChangesPermanent",
title="Make changes permanent?",
note=
"If unchecked, new VDF values will be stored in link extra attribute '@vdf'."
)
return pb.render()
##########################################################################################################
def run(self):
self.tool_run_msg = ""
if self.makeChangesPermanent == None: # Fix the checkbox problem
self.makeChangesPermanent = False
try:
self._execute()
except Exception, e:
self.tool_run_msg = _m.PageBuilder.format_exception(
e, _traceback.format_exc(e))
raise
self.tool_run_msg = _m.PageBuilder.format_info("Tool complete.")
class ExtractSelectLineMatrix(_m.Tool()):
version = '0.2.0'
tool_run_msg = ""
number_of_tasks = 1 # For progress reporting, enter the integer number of tasks here
#---Variable definitions
xtmf_ScenarioNumber = _m.Attribute(int)
xtmf_MatrixResultNumber = _m.Attribute(int)
MatrixResultId = _m.Attribute(str)
Scenario = _m.Attribute(_m.InstanceType)
def __init__(self):
#---Init internal variables
self.TRACKER = _util.ProgressTracker(
self.number_of_tasks) #init the ProgressTracker
#---Set the defaults of parameters used by Modeller
self.Scenario = _MODELLER.scenario #Default is primary scenario
def page(self):
pb = _tmgTPB.TmgToolPageBuilder(
self,
title="Extract Select Line Matrix",
description="Extracts a select-line matrix for transit lines flagged\
by <b>@lflag</b>.",
branding_text="- TMG Toolbox")
if self.tool_run_msg != "": # to display messages in the page
pb.tool_run_status(self.tool_run_msg_status)
pb.add_select_scenario(tool_attribute_name='Scenario',
title='Scenario:',
allow_none=False)
pb.add_select_new_matrix(tool_attribute_name='MatrixResultId',
overwrite_existing=True,
title="Result Matrix")
return pb.render()
def run(self):
self.tool_run_msg = ""
try:
self._execute()
except Exception, e:
self.tool_run_msg = _m.PageBuilder.format_exception(
e, _traceback.format_exc(e))
raise
self.tool_run_msg = _m.PageBuilder.format_info(
"Analysis complete. Results stored in matrix %s." %
self.MatrixResultId)
class AdjacentNodes(_m.Tool()):
north_angle = _m.Attribute(float)
export_file = _m.Attribute(unicode)
scenario = _m.Attribute(_m.InstanceType)
tool_run_msg = ""
def __init__(self):
self.north_angle = 90
def page(self):
pb = _m.ToolPageBuilder(
self,
title="List adjacent nodes",
description=
"Exports the nodes specified by a selection expression to "
"a text file, with a list of the adjacent nodes "
"sorted North South East and West.<br>"
"Note: can only export nodes with four or less adjacent nodes.",
branding_text="INRO - Emme")
if self.tool_run_msg != "":
pb.tool_run_status(self.tool_run_msg_status)
pb.add_text_box(
"north_angle",
size=10,
title="North Angle:",
note=
"Angle which is North, counterclockwise relative to the horizontal axis."
)
pb.add_select_file("export_file",
window_type="save_file",
start_path=os.path.dirname(
_m.Modeller().desktop.project_file_name()),
title="Export file:")
if not self.scenario:
self.scenario = _m.Modeller().desktop.data_explorer().\
primary_scenario.core_scenario
pb.add_select_scenario("scenario", title="Scenario:")
return pb.render()
def run(self):
self.tool_run_msg = ""
try:
self(self.north_angle, self.export_file, self.scenario)
self.tool_run_msg = _m.PageBuilder.format_info("Tool completed.")
except Exception, e:
self.tool_run_msg += _m.PageBuilder.format_exception(
e, _traceback.format_exc(e))
raise
class ExportGtfsStopsAsShapefile(_m.Tool()):
version = '0.0.1'
tool_run_msg = ""
number_of_tasks = 1 # For progress reporting, enter the integer number of tasks here
# Tool Input Parameters
# Only those parameters neccessary for Modeller and/or XTMF to dock with
# need to be placed here. Internal parameters (such as lists and dicts)
# get intitialized during construction (__init__)
GtfsFolderName = _m.Attribute(str)
ShapefileName = _m.Attribute(str)
def __init__(self):
#---Init internal variables
self.TRACKER = _util.ProgressTracker(self.number_of_tasks) #init the ProgressTracker
def page(self):
pb = _tmgTPB.TmgToolPageBuilder(self, title="Export GTFS Stops As Shapefile v%s" %self.version,
description="Converts the <b>stops.txt</b> file to a shapefile, flagging which \
modes it serves as well.",
branding_text="- TMG Toolbox")
if self.tool_run_msg != "": # to display messages in the page
pb.tool_run_status(self.tool_run_msg_status)
pb.add_select_file(tool_attribute_name="GtfsFolderName",
window_type='directory',
title="GTFS Folder")
pb.add_select_file(tool_attribute_name="ShapefileName",
window_type='save_file',
title="Shapefile to export")
return pb.render()
##########################################################################################################
def run(self):
self.tool_run_msg = ""
self.TRACKER.reset()
try:
self._Execute()
except Exception, e:
self.tool_run_msg = _m.PageBuilder.format_exception(
e, _traceback.format_exc(e))
raise
self.tool_run_msg = _m.PageBuilder.format_info("Done")
class ExportMatrix(_m.Tool()):
MatrixId = _m.Attribute(int)
Filename = _m.Attribute(str)
ScenarioNumber = _m.Attribute(int)
def __init__(self):
self._tracker = _util.ProgressTracker(1)
def page(self):
pb = _m.ToolPageBuilder(self,
title="Export a matrix",
runnable=False,
description="Cannot be called from Modeller.",
branding_text="XTMF")
return pb.render()
def __call__(self, MatrixId, Filename, ScenarioNumber):
with _m.logbook_trace("Exporting matrix %s to XTMF" % MatrixId):
scenario = _m.Modeller().emmebank.scenario(ScenarioNumber)
if (scenario is None):
raise Exception("Scenario %s was not found!" % ScenarioNumber)
try:
tool = None
try:
tool = _m.Modeller().tool(
'inro.emme.standard.data.matrix.export_matrices')
except Exception as e:
tool = _m.Modeller().tool(
'inro.emme.data.matrix.export_matrices')
mtx = _m.Modeller().emmebank.matrix("mf%s" % MatrixId)
if mtx is None:
raise Exception("No matrix found with id '%s'" % MatrixId)
self._tracker.runTool(
tool,
export_file=Filename,
field_separator=' ',
matrices=[mtx],
full_matrix_line_format="ONE_ENTRY_PER_LINE",
export_format="PROMPT_DATA_FORMAT",
scenario=scenario,
skip_default_values=False)
except Exception as e:
raise Exception(_traceback.format_exc(e))
@_m.method(return_type=_m.TupleType)
def percent_completed(self):
return self._tracker.getProgress()
class ImportBoardingPenalties(_m.Tool()):
BoardingsFile = _m.Attribute(str)
Scenario = _m.Attribute(_m.InstanceType)
ScenarioNumber = _m.Attribute(int)
def __init__(self):
try:
self.netCalcTool = _m.Modeller().tool(
"inro.emme.standard.network_calculation.network_calculator")
except Exception, e:
self.netCalcTool = _m.Modeller().tool(
"inro.emme.network_calculation.network_calculator")
class CalculateStationFrequency(_m.Tool()):
Scenario = _m.Attribute(_m.InstanceType)
ScenarioId = _m.Attribute(str)
Mode = _m.Attribute(str)
ModeType = _m.Attribute(_m.InstanceType)
FileName = _m.Attribute(str)
tool_run_msg = ""
def page(self):
pb = _m.ToolPageBuilder(
self,
title="CalculateStationFrequency",
description=
"Calculates the number of transit vehicles passing by station centroids.",
branding_text="- TMG Toolbox")
if self.tool_run_msg != "": # to display messages in the page
pb.tool_run_status(self.tool_run_msg_status)
pb.add_select_scenario(tool_attribute_name="Scenario",
title="Select scenario",
allow_none=False)
pb.add_select_mode(
tool_attribute_name="ModeType",
title="Select mode",
filter=["TRANSIT"],
note="Select a mode with station centroids (e.g., subway)",
allow_none=False)
pb.add_select_file(tool_attribute_name="FileName",
window_type="save_file",
file_filter="*.txt",
start_path="C:/",
title="Save file",
note="Select a text file to save.")
#_m.Modeller().desktop.project_file_name()
return pb.render()
def run(self):
self.tool_run_msg = ""
try:
s = self(self.Scenario.id, self.ModeType.id, self.FileName)
self.tool_run_msg = _m.PageBuilder.format_info(s)
except Exception, e:
self.tool_run_msg = _m.PageBuilder.format_exception(
e, _traceback.format_exc(e))
raise
class DeleteMatrix(_m.Tool()):
version = '0.0.1'
Scenario = _m.Attribute(int)
def page(self):
pb = _m.ToolPageBuilder(self,
title="Delete Matrix",
runnable=False,
description="Cannot be called from Modeller.",
branding_text="XTMF")
return pb.render()
def run(self):
pass
def __call__(self, Scenario):
try:
self._execute(Scenario)
except Exception as e:
raise Exception(_traceback.format_exc())
def _execute(self, Scenario):
project = _MODELLER.emmebank
scenario = project.scenario(str(Scenario))
if scenario is None:
print "A delete was requested for scenario " + str(
Scenario) + " but the scenario does not exist."
return
if scenario.delete_protected == True:
scenario.delete_protected = False
project.delete_scenario(scenario.id)
class CheckConnectorSpeeds(_m.Tool()):
Scenario = _m.Attribute(_m.InstanceType)
tool_run_msg = ""
@_m.method(return_type=unicode)
def tool_run_msg_status(self):
return self.tool_run_msg
def page(self):
pb = _m.ToolPageBuilder(
self,
title="Check connector speeds",
description=
"Checks that all connectors are set to 40 km/hr as per NCS11.<br><br>\
Reports any errors in the logbook.",
branding_text="- TMG Toolbox")
if self.tool_run_msg != "": # to display messages in the page
pb.tool_run_status(self.tool_run_msg_status)
pb.add_select_scenario(tool_attribute_name="Scenario",
title="Select scenario",
allow_none=False)
return pb.render()
def run(self):
self.tool_run_msg = ""
try:
self()
except Exception, e:
self.tool_run_msg = _m.PageBuilder.format_exception(
e, _traceback.format_exc(e))
raise
class CheckLinkLanes(_m.Tool()):
Scenario = _m.Attribute(_m.InstanceType)
tool_run_msg = ""
@_m.method(return_type=unicode)
def tool_run_msg_status(self):
return self.tool_run_msg
def page(self):
pb = _m.ToolPageBuilder(
self,
title="Check Link lanes",
description=
"Checks that special link type (centroid connectors, transit-only links) \
meet NCS11 requirements.<br><br> Reports any errors in the logbook.",
branding_text="- TMG Toolbox")
if self.tool_run_msg != "": # to display messages in the page
pb.tool_run_status(self.tool_run_msg_status)
pb.add_select_scenario(tool_attribute_name="Scenario",
title="Select scenario",
allow_none=False)
return pb.render()
def run(self):
self.tool_run_msg = ""
try:
self()
except Exception, e:
self.tool_run_msg = _m.PageBuilder.format_exception(
e, _traceback.format_exc(e))
raise
class ExportNetworkPackage(_m.Tool()):
version = '1.2.1'
tool_run_msg = ""
number_of_tasks = 11 # For progress reporting, enter the integer number of tasks here
xtmf_JSON = _m.Attribute(str)
xtmf_logbook_level = _m.Attribute(str)
def __init__(self):
# Init internal variables
self.TRACKER = _util.ProgressTracker(
self.number_of_tasks) # init the ProgressTracker
# Set the defaults of parameters used by Modeller
self.Scenario = _MODELLER.scenario # Default is primary scenario
self.ExportMetadata = ""
def page(self):
return ""
def __call__(self, xtmf_JSON, xtmf_logbook_level):
logbook = _m.logbook_level()
if xtmf_logbook_level == "NONE":
_m.logbook_level(_m.LogbookLevel.NONE)
# xtmf_ScenarioNumber, ExportFile, xtmf_AttributeIdString
parameters = json.loads(xtmf_JSON)
self.ExportFile = parameters["export_file"]
self.Scenario = _m.Modeller().emmebank.scenario(
parameters["scenario_number"])
if self.Scenario is None:
raise Exception("Scenario %s was not found!" % xtmf_ScenarioNumber)
xtmf_AttributeIdString = parameters["extra_attributes"]
if xtmf_AttributeIdString.lower() == 'all':
self.ExportAllFlag = True # if true, self.AttributeIdsToExport gets set in execute
else:
cells = xtmf_AttributeIdString.split(',')
self.AttributeIdsToExport = [
str(c.strip()) for c in cells if c.strip()
] # Clean out null values
try:
self._execute()
except Exception, e:
msg = str(e) + "\n" + _traceback.format_exc(e)
raise Exception(msg)
finally:
class BKRCastExportNetwork(_modeller.Tool()):
'''
this tool is to populate AM, MD and PM peak hour network and their associated network
input files in EMME punch file format.
Files will be produced:
base network file, link shape file, turn file, and transit lines for AM, MD, PM and NI.
1.1.0: populate vdf functions for four TOD.
1.1.1: populate sc_headway.csv
1.1.2: remove future bike links with modes == "wk" and @biketype == 0
'''
version = "1.1.2" # this is the version
default_path = ""
tool_run_message = ""
outputFolder = _modeller.Attribute(_modeller.InstanceType)
def page(self):
pb = _modeller.ToolPageBuilder(
self,
title="BKRCast Network Interface",
description="Populate networks from master network",
branding_text=
"Modeling and Analysis Group -- City of Bellevue Transportation")
pb.add_select_file("outputFolder",
"directory",
"",
self.default_path,
title="Select the directory for output files")
if self.tool_run_message != "":
pb.tool_run_status(self.tool_run_msg_status)
return pb.render()
@_modeller.method(return_type=_modeller.UnicodeType)
def tool_run_msg_status(self):
return self.tool_run_message
@property
def current_scenario(self):
return _modeller.Modeller().desktop.data_explorer(
).primary_scenario.core_scenario
@property
def current_emmebank(self):
return self.current_scenario.emmebank
def run(self):
self.tool_run_message = ""
try:
self.__call__()
run_message = "Network exported"
self.tool_run_message += _modeller.PageBuilder.format_info(
run_message)
except Exception, e:
self.tool_run_message += _modeller.PageBuilder.format_exception(
e, _traceback.format_exc(e))
class ConvertVehicles(_m.Tool()):
version = '0.1.2'
tool_run_msg = ""
#---Variable definitions
ScenarioNumber = _m.Attribute(int)
#---Special instance types
scenario = _m.Attribute(_m.InstanceType) #
def page(self):
pb = _m.ToolPageBuilder(
self,
title="Convert Vehicles v%s" % self.version,
description="Converts vehicle definitions and properties \
according to NCS11 definitions.",
branding_text="- TMG Toolbox")
if self.tool_run_msg != "": # to display messages in the page
pb.tool_run_status(self.tool_run_msg_status)
pb.add_select_scenario(tool_attribute_name="scenario",
title="Select scenario",
allow_none=False)
return pb.render()
##########################################################################################################
def run(self):
self.tool_run_msg = ""
'''Run is called from Modeller.'''
self.isRunningFromXTMF = False
try:
self._execute()
except Exception, e:
self.tool_run_msg = _m.PageBuilder.format_exception(
e, _traceback.format_exc(e))
raise
self.tool_run_msg = _m.PageBuilder.format_info("Run complete.")
class CopyScenario(_m.Tool()):
version = '0.0.1'
FromScenario = _m.Attribute(int)
ToScenario = _m.Attribute(int)
CopyStrategy = _m.Attribute(bool)
def page(self):
pb = _m.ToolPageBuilder(self,
title="Copy Scenario",
runnable=False,
description="Cannot be called from Modeller.",
branding_text="XTMF")
return pb.render()
def run(self):
pass
def __call__(self, FromScenario, ToScenario, CopyStrategy):
try:
self._execute(FromScenario, ToScenario, CopyStrategy)
except Exception as e:
raise Exception(_traceback.format_exc(e))
def _execute(self, FromScenario, ToScenario, CopyStrategy):
if FromScenario == ToScenario:
print "A copy was requested to from scenario " + str(FromScenario) + " to " + str(ToScenario) \
+ ". This was not executed."
return
project = _MODELLER.emmebank
original = project.scenario(str(FromScenario))
if original is None:
raise Exception("The base scenario '"+str(FromScenario)+"' does not exist in order to copy to scenario '" \
+ str(ToScenario)+"'!")
dest = project.scenario(str(ToScenario))
if dest is not None:
project.delete_scenario(dest.id)
if CopyStrategy == True:
project.copy_scenario(original.id, str(ToScenario), True, True,
True)
else:
project.copy_scenario(original.id, str(ToScenario), True, False,
True)
class Calculate_fitness(_m.Tool()):
version = '1.0.0'
tool_run_msg = ""
number_of_tasks = 1
EMME2TTS_file = _m.Attribute(str)
Obs_paths_file = _m.Attribute(str)
EMME_paths_file = _m.Attribute(str)
fitness_csv_file = _m.Attribute(str)
beta = _m.Attribute(float)
def __init__(self):
#---Init internal variables
self.TRACKER = _util.ProgressTracker(
self.number_of_tasks) #init the ProgressTracker
#---Set the defaults of parameters used by Modeller
self.Scenario = _MODELLER.scenario #Default is primary scenario
def page(self):
pb = _m.ToolPageBuilder(self,
title="Calculate Fitness",
description="Cannot be called from Modeller.",
runnable=False,
branding_text="XTMF")
return pb.render()
def __call__(self, EMME2TTS_file, Obs_paths_file, EMME_paths_file,
fitness_csv_file, beta):
print "Calculating Fitness"
#EMME2TTS = convert_id("2011_Emme2TTS_Line.csv")
#ObservedPaths = read_obs_paths("TripDataObsAM.csv")
#EMMEpath_details = read_EMME_paths("pathDetails", EMME2TTS)
EMME2TTS = convert_id(EMME2TTS_file)
ObservedPaths = read_obs_paths(Obs_paths_file)
EMMEpath_details = read_EMME_paths(EMME_paths_file, EMME2TTS)
calculate_fitness(EMMEpath_details, ObservedPaths, fitness_csv_file,
beta)
def _Execute(EMME_paths_file, Obs_paths_file, EMME2TTSfile, beta):
self.TRACKER.completeTask()
class MoveNetowrks(_m.Tool()):
Scenarios = _m.Attribute(_m.ListType)
tool_run_msg = ""
def page(self):
pb = _m.ToolPageBuilder(self, title="Move Networks",
description="Moves selected networks up by 4,000,000 meters; essentially \
adding a 7th digit to the y-coordinate to make the projection \
compatible with UTM-17N.<br>\
<br><b>This tool is irreversible. Make sure to copy your \
scenarios prior to running!</b>",
branding_text="- TMG Toolbox")
if self.tool_run_msg != "": # to display messages in the page
pb.tool_run_status(self.tool_run_msg_status)
pb.add_select_scenario(tool_attribute_name="Scenarios",
title="Select scenarios",
allow_none=False)
return pb.render()
def run(self):
self.tool_run_msg = ""
try:
with _m.logbook_trace(name="Move Networks",
attributes=self._getAtts()):
calculator = None
try:
calculator = _m.Modeller().tool("inro.emme.network_calculation.network_calculator")
except Exception, e:
calculator = _m.Modeller().tool("inro.emme.standard.network_calculation.network_calculator")
spec = {
"result": "yi",
"expression": "yi + 4000000",
"aggregation": None,
"selections": {
"node": "all"
},
"type": "NETWORK_CALCULATION"
}
for scenario in self.Scenarios:
_m.logbook_write("Changing scenario %s" %scenario.id)
calculator(spec, scenario=scenario)
self.tool_run_msg = _m.PageBuilder.format_info("Tool complete.")
except Exception, e:
self.tool_run_msg = _m.PageBuilder.format_exception(
e, _traceback.format_exc(e))
raise
