trmg2.model

/**
  The macro "trmg2" holds the definition for the graphical flowchart of this model,
  with steps and links connecting steps.

  Put the following in immediate execution to get better error behavior:
    global flowchart_debug
    flowchart_debug = 1

**/
Macro "trmg2" (Args)
Body:
    // model = FlowChart( { StartNodes } , { EndNodes } , Description)
    model = FlowChart({"Initial Processsing"},{"Summaries"},)
    //
    // Nodes
    //
    // FlowChartNode(model,NodeName,MacroName,UI,Description)
    //
    FlowChartNode(model,"Convergence",,,)
    FlowChartNode(model,"Roadway Assignment",,,)
    FlowChartNode(model,"Initial Processsing",,,)
    FlowChartNode(model,"Generation Models",,,)
    FlowChartNode(model,"NonMotorized Models",,,)
    FlowChartNode(model,"Time of Day",,,)
    FlowChartNode(model,"Skimming",,,)
    FlowChartNode(model,"Home-based Choice Models",,,)
    FlowChartNode(model,"Non-Home-based Models",,,)
    FlowChartNode(model,"Special Market DC & MC",,,)
    FlowChartNode(model,"Hourly Roadway Assignment",,,)
    FlowChartNode(model,"Transit Assignment",,,)
    FlowChartNode(model,"Summaries",,,)
    //
    // Links
    //
    // FlowChartLink(model , FromNode , ToNode , Condition , Description , IsFeedbackLoop)
    //
    FlowChartLink(model,"Convergence","Skimming",True,,1)
    FlowChartLink(model,"Convergence","Hourly Roadway Assignment",2,,)
    FlowChartLink(model,"Roadway Assignment","Convergence",True,,)
    FlowChartLink(model,"Initial Processsing","Generation Models",True,,)
    FlowChartLink(model,"Generation Models","NonMotorized Models",True,,)
    FlowChartLink(model,"NonMotorized Models","Time of Day",True,,)
    FlowChartLink(model,"Time of Day","Skimming",True,,)
    FlowChartLink(model,"Skimming","Home-based Choice Models",True,,)
    FlowChartLink(model,"Home-based Choice Models","Non-Home-based Models",True,,)
    FlowChartLink(model,"Non-Home-based Models","Special Market DC & MC",True,,)
    FlowChartLink(model,"Special Market DC & MC","Roadway Assignment",True,,)
    FlowChartLink(model,"Hourly Roadway Assignment","Transit Assignment",True,,)
    FlowChartLink(model,"Transit Assignment","Summaries",True,,)
    Return(model)
EndMacro


Macro "Accessibility" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"Accessibility"}},
        {"Picture", "bmp\\plan_config_v3.bmp"}
    }
Data:
    InSections({"Accessibilities"})
    In({ Args.[SE] })
    In({ Args.[TAZs] })
    Out({ Args.[SE] })
EndMacro


Macro "Home-based Productions" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"Home-based Productions"}},
        {"Picture", "bmp\\planlanduse_v3.bmp"}
    }
Data:
    In({ Args.[Persons] })
    In({ Args.[ProdCalibFactors] })
    In({ Args.[ProdRates] })
    Out({ Args.[Persons] })
EndMacro


Macro "NonMotorized Choice" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"NonMotorized Choice"}},
        {"Picture", "bmp\\planwork_v3.bmp"}
    }
Data:
    In({ Args.[NMInputFolder] })
    Out({ Args.[Persons] })
    Out({ Args.[SE] })
EndMacro


Macro "Time of Day Split" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"Time of Day Split"}},
        {"Picture", "bmp\\planpeople_v3.bmp"}
    }
Data:
    In({ Args.[ResTODFactors] })
    In({ Args.[SE] })
    Out({ Args.[SE] })
EndMacro


Macro "Parking Probabilities" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"Parking Probabilities"}},
        {"Picture", "bmp\\planmodesplit_v3.bmp"}
    }
Data:
    In({ Args.[ParkMCCoeffs] })
    Out({ Args.[Parking DC Prob Matrix] })
    Out({ Args.[Parking DC Util Matrix] })
    Out({ Args.[Parking Logsums Table] })
EndMacro


Macro "Mode Probabilities" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"Mode Probabilities"}},
        {"Picture", "bmp\\planmodesplit_v3.bmp"}
    }
EndMacro


Macro "Destination Probabilities" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"Destination Probabilities"}},
        {"Picture", "bmp\\planmodesplit_v3.bmp"}
    }
Data:
    In({ Args.[ResDCAttrRates] })
    In({ Args.[ResDCSizeCoeffs] })
EndMacro


Macro "Aggregation to Zones" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"Aggregation to Zones"}},
        {"Picture", "bmp\\planpeople_v3.bmp"}
    }
Data:
    In({ Args.[Persons] })
    Out({ Args.[SE] })
EndMacro


Macro "Create Assignment Matrices" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"Create Assignment Matrices"}},
        {"Picture", "bmp\\planassigncar_v3.bmp"}
    }
EndMacro


Macro "Pre Assignment" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"Pre Assignment"}},
        {"Picture", "bmp\\planassigncar_v3.bmp"}
    }
EndMacro


Macro "AM Assignment" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"AM Roadway Assignment"}},
        {"Picture", "bmp\\planassigncar_v3.bmp"}
    }
EndMacro


Macro "MD Assignment" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"MD Roadway Assignment"}},
        {"Picture", "bmp\\planassigncar_v3.bmp"}
    }
EndMacro


Macro "trmg2.Pins" (Args)
Body:
   // Do not modify the following line:
   Positions = null
   Return(Positions)
EndMacro


Macro "PM Assignment" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"PM Roadway Assignment"}},
        {"Picture", "bmp\\planassigncar_v3.bmp"}
    }
EndMacro


Macro "NT Assignment" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"NT Roadway Assignment"}},
        {"Picture", "bmp\\planassigncar_v3.bmp"}
    }
EndMacro


Macro "Post Assignment" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"Post Assignment"}},
        {"Picture", "bmp\\planassigncar_v3.bmp"}
    }
EndMacro


Macro "Convergence" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"Shape", "Decision"}
    }
Body:
    
    iter = Args.FeedbackIteration
    max_iters = Args.FeedbackIterations
    target_prmse = Args.FeedbackConvergence

    mr = CreateObject("Model.Runtime")
    periods = mr.RunCode("Get Unconverged Periods", Args)

    // Add any periods that converged to the list of converged periods
    for period in periods do
        prmse = Args.(period + "_PRMSE")
        if prmse <= target_prmse or iter >= max_iters 
            then Args.converged_periods = Args.converged_periods + {period}
    end
    
    // Feedback is done when all periods have converged or hit max iters
    converged = 0
    if Args.periods.length = Args.converged_periods.length then converged = 1
    if converged = 0 then Args.FeedbackIteration = iter + 1
    Return(converged + 1)
EndMacro


Macro "Link.Convergence.Transit Assignm" (Args,Result)
    Attributes = {
        {"Run_Condition", "Result = 2"}
    }
EndMacro


Macro "Roadway Assignment" (Args,Result)
    Attributes = {
        {"Description", "Stage 5"},
        {"Picture", "bmp\\planassigncar_v3.bmp"}
    }
Body:
    model = FlowChart({"Create Assignment Matrices"},{"Post Assignment"},"Group steps")
    //
    // Nodes
    //
    // FlowChartNode(model,NodeName,MacroName,UI,Description)
    //
    FlowChartNode(model,"Create Assignment Matrices",,,)
    FlowChartNode(model,"Pre Assignment",,,)
    FlowChartNode(model,"AM Assignment",,,)
    FlowChartNode(model,"MD Assignment",,,)
    FlowChartNode(model,"PM Assignment",,,)
    FlowChartNode(model,"NT Assignment",,,)
    FlowChartNode(model,"Post Assignment",,,)
    //
    // Links
    //
    // FlowChartLink(model , FromNode , ToNode , Condition , Description , IsFeedbackLoop)
    //
    FlowChartLink(model,"Create Assignment Matrices","Pre Assignment",True,,)
    FlowChartLink(model,"Pre Assignment","AM Assignment",True,,)
    FlowChartLink(model,"Pre Assignment","MD Assignment",True,,)
    FlowChartLink(model,"Pre Assignment","PM Assignment",True,,)
    FlowChartLink(model,"Pre Assignment","NT Assignment",True,,)
    FlowChartLink(model,"AM Assignment","Post Assignment",True,,)
    FlowChartLink(model,"MD Assignment","Post Assignment",True,,)
    FlowChartLink(model,"PM Assignment","Post Assignment",True,,)
    FlowChartLink(model,"NT Assignment","Post Assignment",True,,)
    Return(model)
EndMacro


Macro "Area Type" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"Area Type"}},
        {"Picture", "bmp\\plan_config_v3.bmp"}
    }
Data:
    In({ Args.[AreaTypes] })
    In({ Args.[SE] })
    Out({ Args.[SE] })
EndMacro


Macro "Capacities" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"Capacities"}},
        {"Picture", "bmp\\plan_config_v3.bmp"}
    }
Data:
    In({ Args.[Capacity] })
    In({ Args.[CapacityFactors] })
    In({ Args.[Links] })
    Out({ Args.[Links] })
EndMacro


Macro "Speeds & Tolls" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"Speeds & Tolls"}},
        {"Picture", "bmp\\plan_config_v3.bmp"}
    }
Data:
    In({ Args.[CCSpeeds] })
    In({ Args.[SpeedFactors] })
    In({ Args.[TransponderRatioAuto] })
    In({ Args.[TransponderRatioMUT] })
    In({ Args.[TransponderRatioSUT] })
EndMacro


Macro "Network Creation" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"Network Creation"}},
        {"Picture", "bmp\\plan_config_v3.bmp"}
    }
Data:
    Out({ Args.[Network Folder] })
EndMacro


Macro "Create Initial Output Files" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"Create Initial Output Files"}},
        {"Picture", "bmp\\plan_config_v3.bmp"}
    }
Data:
    In({ Args.[Input Links] })
    In({ Args.[Input Routes] })
    In({ Args.[Input SE] })
    In({ Args.[Input TAZs] })
    Out({ Args.[Links] })
    Out({ Args.[Routes] })
    Out({ Args.[SE] })
    Out({ Args.[TAZs] })
EndMacro


Macro "Disaggregate Curves" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"Disaggregate Curves"}},
        {"Picture", "bmp\\plan_config_v3.bmp"}
    }
Data:
    In({ Args.[IncomeCurves] })
    In({ Args.[RegionalMedianIncome] })
    In({ Args.[SizeCurves] })
    In({ Args.[WorkerCurves] })
    Out({ Args.[SEDMarginals] })
EndMacro


Macro "IPU Synthesis" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"IPU Synthesis"}},
        {"Picture", "bmp\\plan_config_v3.bmp"}
    }
Data:
    In({ Args.[PUMS HH Seed] })
    In({ Args.[PUMS Person Seed] })
    Out({ Args.[Households] })
    Out({ Args.[Persons] })
EndMacro


Macro "Auto Ownership" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"Auto Ownership"}},
        {"Picture", "bmp\\plan_config_v3.bmp"}
    }
Data:
    In({ Args.[AOCoeffs] })
    Out({ Args.[Persons] })
EndMacro


Macro "Population Synthesis" (Args,Result)
    Attributes = {
        {"Description", "Stage 1"},
        {"Picture", "bmp\\plan_config_v3.bmp"}
    }
Body:
    // model = FlowChart( { StartNodes } , { EndNodes } , Description)
    model = FlowChart({"Disaggregate Curves"},{"Auto Ownership"},"Group steps")
    //
    // Nodes
    //
    // FlowChartNode(model,NodeName,MacroName,UI,Description)
    //
    FlowChartNode(model,"Disaggregate Curves",,,)
    FlowChartNode(model,"IPU Synthesis",,,)
    FlowChartNode(model,"Auto Ownership",,,)
    //
    // Links
    //
    // FlowChartLink(model , FromNode , ToNode , Condition , Description , IsFeedbackLoop)
    //
    FlowChartLink(model,"Disaggregate Curves","IPU Synthesis",True,,)
    FlowChartLink(model,"IPU Synthesis","Auto Ownership",True,,)
    Return(model)
EndMacro


Macro "Network Calculators" (Args,Result)
    Attributes = {
        {"Description", "Stage 1"},
        {"Picture", "bmp\\plan_config_v3.bmp"}
    }
Body:
    // model = FlowChart( { StartNodes } , { EndNodes } , Description)
    model = FlowChart({"Area Type"},{"Network Creation"},"Group steps")
    //
    // Nodes
    //
    // FlowChartNode(model,NodeName,MacroName,UI,Description)
    //
    FlowChartNode(model,"Area Type",,,)
    FlowChartNode(model,"Capacities",,,)
    FlowChartNode(model,"Speeds & Tolls",,,)
    FlowChartNode(model,"Network Creation",,,)
    //
    // Links
    //
    // FlowChartLink(model , FromNode , ToNode , Condition , Description , IsFeedbackLoop)
    //
    FlowChartLink(model,"Area Type","Capacities",True,,)
    FlowChartLink(model,"Capacities","Speeds & Tolls",True,,)
    FlowChartLink(model,"Speeds & Tolls","Network Creation",True,,)
    Return(model)
EndMacro


Macro "Initial Processsing" (Args,Result)
    Attributes = {
        {"Description", "Stage 1"},
        {"Picture", "bmp\\plan_config_v3.bmp"}
    }
Body:
    // model = FlowChart( { StartNodes } , { EndNodes } , Description)
    model = FlowChart({"Create Initial Output Files"},{"Population Synthesis"},"Group steps")
    //
    // Nodes
    //
    // FlowChartNode(model,NodeName,MacroName,UI,Description)
    //
    FlowChartNode(model,"Accessibility",,,)
    FlowChartNode(model,"Population Synthesis",,,)
    FlowChartNode(model,"Create Initial Output Files",,,)
    FlowChartNode(model,"Network Calculators",,,)
    //
    // Links
    //
    // FlowChartLink(model , FromNode , ToNode , Condition , Description , IsFeedbackLoop)
    //
    FlowChartLink(model,"Accessibility","Population Synthesis",True,,)
    FlowChartLink(model,"Create Initial Output Files","Network Calculators",True,,)
    FlowChartLink(model,"Network Calculators","Accessibility",True,,)
    Return(model)
EndMacro


Macro "Airport" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"Airport"}},
        {"Picture", "bmp\\planlanduse_v3.bmp"}
    }
EndMacro


Macro "Externals" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"Externals"}},
        {"Picture", "bmp\\planlanduse_v3.bmp"}
    }
EndMacro


Macro "Commercial Vehicles" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"Commercial Vehicles"}},
        {"Picture", "bmp\\planlanduse_v3.bmp"}
    }
Data:
    In({ Args.[CV TOD Rates] })
    In({ Args.[CV Trip Rates] })
    Out({ Args.[SE] })
EndMacro


Macro "Special Markets Generation" (Args,Result)
    Attributes = {
        {"Description", "Stage 1"},
        {"Picture", "bmp\\planlanduse_v3.bmp"}
    }
Body:
    // model = FlowChart( { StartNodes } , { EndNodes } , Description)
    stage = FlowChart({"Airport"},{"Commercial Vehicles"},"Group steps")
    //
    // Nodes
    //
    // FlowChartNode(model,NodeName,MacroName,UI,Description)
    //
    FlowChartNode(stage,"Airport",,,)
    FlowChartNode(stage,"Externals",,,)
    FlowChartNode(stage,"Commercial Vehicles",,,)
    FlowChartNode(stage,"University",,,)
    //
    // Links
    //
    // FlowChartLink(model , FromNode , ToNode , Condition , Description , IsFeedbackLoop)
    //
    FlowChartLink(stage,"Externals","Commercial Vehicles",True,,)
    FlowChartLink(stage,"Airport","University",True,,)
    FlowChartLink(stage,"University","Externals",True,,)
    Return(stage)
EndMacro


Macro "Generation Models" (Args,Result)
    Attributes = {
        {"Description", "Stage 1"},
        {"Picture", "bmp\\planlanduse_v3.bmp"}
    }
Body:
    // model = FlowChart( { StartNodes } , { EndNodes } , Description)
    model = FlowChart({"Home-based Productions"},{"Special Markets Generation"},"Group steps")
    //
    // Nodes
    //
    // FlowChartNode(model,NodeName,MacroName,UI,Description)
    //
    FlowChartNode(model,"Home-based Productions",,,)
    FlowChartNode(model,"Special Markets Generation",,,)
    //
    // Links
    //
    // FlowChartLink(model , FromNode , ToNode , Condition , Description , IsFeedbackLoop)
    //
    FlowChartLink(model,"Home-based Productions","Special Markets Generation",True,,)
    Return(model)
EndMacro


Macro "NM Distribution" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"NM Distribution"}},
        {"Picture", "bmp\\planwork_v3.bmp"}
    }
Data:
    In({ Args.[NMInputFolder] })
EndMacro


Macro "NM Time-of-Day" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"NM Time-of-Day"}},
        {"Picture", "bmp\\planwork_v3.bmp"}
    }
EndMacro


Macro "NonMotorized Models" (Args,Result)
    Attributes = {
        {"Description", "Stage 1"},
        {"Picture", "bmp\\planwork_v3.bmp"}
    }
Body:
    // model = FlowChart( { StartNodes } , { EndNodes } , Description)
    model = FlowChart({"NonMotorized Choice"},{"NM Time-of-Day"},"Group steps")
    //
    // Nodes
    //
    // FlowChartNode(model,NodeName,MacroName,UI,Description)
    //
    FlowChartNode(model,"NonMotorized Choice",,,)
    FlowChartNode(model,"NM Distribution",,,)
    FlowChartNode(model,"NM Time-of-Day",,,)
    //
    // Links
    //
    // FlowChartLink(model , FromNode , ToNode , Condition , Description , IsFeedbackLoop)
    //
    FlowChartLink(model,"NonMotorized Choice","NM Distribution",True,,)
    FlowChartLink(model,"NM Distribution","NM Time-of-Day",True,,)
    Return(model)
EndMacro


Macro "Time of Day" (Args,Result)
    Attributes = {
        {"Description", "Stage 1"},
        {"Picture", "bmp\\planpeople_v3.bmp"}
    }
Body:
    // model = FlowChart( { StartNodes } , { EndNodes } , Description)
    model = FlowChart({"Aggregation to Zones"},{"Time of Day Split"},"Group steps")
    //
    // Nodes
    //
    // FlowChartNode(model,NodeName,MacroName,UI,Description)
    //
    FlowChartNode(model,"Time of Day Split",,,)
    FlowChartNode(model,"Aggregation to Zones",,,)
    //
    // Links
    //
    // FlowChartLink(model , FromNode , ToNode , Condition , Description , IsFeedbackLoop)
    //
    FlowChartLink(model,"Aggregation to Zones","Time of Day Split",True,,)
    Return(model)
EndMacro


Macro "Roadway Skims" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"Roadway Skims"}},
        {"Picture", "bmp/planskim_v3.bmp"}
    }
Data:
    In({ Args.[Network Folder] })
EndMacro


Macro "Transit Skims" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"Transit Skims"}},
        {"Picture", "bmp/planskim_v3.bmp"}
    }
Data:
    In({ Args.[Network Folder] })
    In({ Args.[TransModeTable] })
EndMacro


Macro "Skimming" (Args,Result)
    Attributes = {
        {"Description", "Stage 1"},
        {"Picture", "bmp/planskim_v3.bmp"}
    }
Body:
    // model = FlowChart( { StartNodes } , { EndNodes } , Description)
    model = FlowChart({"Roadway Skims"},{"Transit Skims"},"Group steps")
    //
    // Nodes
    //
    // FlowChartNode(model,NodeName,MacroName,UI,Description)
    //
    FlowChartNode(model,"Roadway Skims",,,)
    FlowChartNode(model,"Transit Skims",,,)
    //
    // Links
    //
    // FlowChartLink(model , FromNode , ToNode , Condition , Description , IsFeedbackLoop)
    //
    FlowChartLink(model,"Roadway Skims","Transit Skims",True,,)
    Return(model)
EndMacro


Macro "Application of Probabilities" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"Application of Probabilities"}},
        {"Picture", "bmp/planmodesplit_v3.bmp"}
    }
EndMacro


Macro "Home-based Choice Models" (Args,Result)
    Attributes = {
        {"Description", "Stage 1"},
        {"Picture", "bmp/planmodesplit_v3.bmp"}
    }
Body:
    // model = FlowChart( { StartNodes } , { EndNodes } , Description)
    model = FlowChart({"Parking Probabilities"},{"Application of Probabilities"},"Group steps")
    //
    // Nodes
    //
    // FlowChartNode(model,NodeName,MacroName,UI,Description)
    //
    FlowChartNode(model,"Parking Probabilities",,,)
    FlowChartNode(model,"Mode Probabilities",,,)
    FlowChartNode(model,"Destination Probabilities",,,)
    FlowChartNode(model,"Application of Probabilities",,,)
    //
    // Links
    //
    // FlowChartLink(model , FromNode , ToNode , Condition , Description , IsFeedbackLoop)
    //
    FlowChartLink(model,"Parking Probabilities","Mode Probabilities",True,,)
    FlowChartLink(model,"Mode Probabilities","Destination Probabilities",True,,)
    FlowChartLink(model,"Destination Probabilities","Application of Probabilities",True,,)
    Return(model)
EndMacro


Macro "NHB Generation by Mode" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"NHB Generation by Mode"}},
        {"Picture", "bmp/plantour_v3.bmp"}
    }
Data:
    In({ Args.[NHBTODFacs] })
    Out({ Args.[SE] })
EndMacro


Macro "NHB Destination Choice" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"NHB Destination Choice"}},
        {"Picture", "bmp/plantour_v3.bmp"}
    }
Data:
    In({ Args.[NHBDCSizeCoeffs] })
    In({ Args.[NHBHOV3OccFactors] })
    In({ Args.[NHBOtherShares] })
EndMacro


Macro "Non-Home-based Models" (Args,Result)
    Attributes = {
        {"Description", "Stage 1"},
        {"Picture", "bmp/plantour_v3.bmp"}
    }
Body:
    // model = FlowChart( { StartNodes } , { EndNodes } , Description)
    model = FlowChart({"NHB Generation by Mode"},{"NHB Destination Choice"},"Group steps")
    //
    // Nodes
    //
    // FlowChartNode(model,NodeName,MacroName,UI,Description)
    //
    FlowChartNode(model,"NHB Generation by Mode",,,)
    FlowChartNode(model,"NHB Destination Choice",,,)
    //
    // Links
    //
    // FlowChartLink(model , FromNode , ToNode , Condition , Description , IsFeedbackLoop)
    //
    FlowChartLink(model,"NHB Generation by Mode","NHB Destination Choice",True,,)
    Return(model)
EndMacro


Macro "Airport MC" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"Airport MC"}},
        {"Picture", "bmp/planmodesplit_v3.bmp"}
    }
EndMacro


Macro "Commercial Vehicles DC" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"Commercial Vehicles DC"}},
        {"Picture", "bmp/planmodesplit_v3.bmp"}
    }
EndMacro


Macro "Special Market DC & MC" (Args,Result)
    Attributes = {
        {"Description", "Stage 1"},
        {"Picture", "bmp/planmodesplit_v3.bmp"}
    }
Body:
    // model = FlowChart( { StartNodes } , { EndNodes } , Description)
    stage = FlowChart({"Airport MC"},{"Commercial Vehicles DC"},"Group steps")
    //
    // Nodes
    //
    // FlowChartNode(model,NodeName,MacroName,UI,Description)
    //
    FlowChartNode(stage,"Airport MC",,,)
    FlowChartNode(stage,"Commercial Vehicles DC",,,)
    FlowChartNode(stage,"University DC & MC",,,)
    //
    // Links
    //
    // FlowChartLink(model , FromNode , ToNode , Condition , Description , IsFeedbackLoop)
    //
    FlowChartLink(stage,"Airport MC","University DC & MC",True,,)
    FlowChartLink(stage,"University DC & MC","Commercial Vehicles DC",True,,)
    Return(stage)
EndMacro


Macro "Create Transit Matrices" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"Create Transit Matrices"}},
        {"Picture", "bmp/planassignbus_v3.bmp"}
    }
EndMacro


Macro "Run Transit Assignment" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"Run Transit Assignment"}},
        {"Picture", "bmp/planassignbus_v3.bmp"}
    }
EndMacro


Macro "Hourly Roadway Assignment" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"Peak Hour Roadway Assignment"}},
        {"Picture", "bmp\\planassigncar_v3.bmp"}
    }
EndMacro


Macro "Transit Assignment" (Args,Result)
    Attributes = {
        {"Description", "Stage 1"},
        {"Picture", "bmp/planassignbus_v3.bmp"}
    }
Body:
    // model = FlowChart( { StartNodes } , { EndNodes } , Description)
    model = FlowChart({"Create Transit Matrices"},{"Run Transit Assignment"},"Group steps")
    //
    // Nodes
    //
    // FlowChartNode(model,NodeName,MacroName,UI,Description)
    //
    FlowChartNode(model,"Create Transit Matrices",,,)
    FlowChartNode(model,"Run Transit Assignment",,,)
    //
    // Links
    //
    // FlowChartLink(model , FromNode , ToNode , Condition , Description , IsFeedbackLoop)
    //
    FlowChartLink(model,"Create Transit Matrices","Run Transit Assignment",True,,)
    Return(model)
EndMacro


Macro "Maps" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"Maps"}},
        {"Picture", "bmp\\planmatrix_v3.bmp"}
    }
EndMacro


Macro "Calibration Reports" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"Calibration Reports"}},
        {"Picture", "bmp\\planmatrix_v3.bmp"}
    }
EndMacro


Macro "Other Reports" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"Other Reports"}},
        {"Picture", "bmp\\planmatrix_v3.bmp"}
    }
EndMacro


Macro "Summaries" (Args,Result)
    Attributes = {
        {"Description", "Stage 1"},
        {"Picture", "bmp\\planmatrix_v3.bmp"}
    }
Data:
    Out({ Args.[Summary Folder] })
Body:
    // model = FlowChart( { StartNodes } , { EndNodes } , Description)
    model = FlowChart({"Maps"},{"Other Reports"},"Group steps")
    //
    // Nodes
    //
    // FlowChartNode(model,NodeName,MacroName,UI,Description)
    //
    FlowChartNode(model,"Maps",,,)
    FlowChartNode(model,"Calibration Reports",,,)
    FlowChartNode(model,"Other Reports",,,)
    //
    // Links
    //
    // FlowChartLink(model , FromNode , ToNode , Condition , Description , IsFeedbackLoop)
    //
    FlowChartLink(model,"Maps","Calibration Reports",True,,)
    FlowChartLink(model,"Calibration Reports","Other Reports",True,,)
    Return(model)
EndMacro


Macro "University DC & MC" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"University DC & MC"}},
        {"Picture", "bmp/planmodesplit_v3.bmp"}
    }
EndMacro


Macro "University" (Args,Result)
    Attributes = {
        {"Class", {"GISDK"}},
        {"MacroNames", {"University"}},
        {"Picture", "bmp\\planlanduse_v3.bmp"}
    }
EndMacro