org.matsim.contrib.dvrp.run.DvrpConfigGroup Java Examples

static Controler createController(AmodeusConfigGroup avConfigGroup) {
    Config config = ConfigUtils.createConfig(avConfigGroup, new DvrpConfigGroup());
    Scenario scenario = TestScenarioGenerator.generateWithAVLegs(config);

    PlanCalcScoreConfigGroup.ModeParams modeParams = config.planCalcScore().getOrCreateModeParams(AmodeusModeConfig.DEFAULT_MODE);
    modeParams.setMonetaryDistanceRate(0.0);
    modeParams.setMarginalUtilityOfTraveling(8.86);
    modeParams.setConstant(0.0);

    Controler controler = new Controler(scenario);
    controler.addOverridingModule(new DvrpModule());
    controler.addOverridingModule(new AmodeusModule());
    controler.addOverridingQSimModule(new AmodeusQSimModule());

    controler.configureQSimComponents(AmodeusQSimModule.activateModes(avConfigGroup));

    return controler;
}
 

public static void run(String configFile, boolean otfvis, int lastIteration) {
	// load config
	Config config = ConfigUtils.loadConfig(configFile, new MultiModeTaxiConfigGroup(), new DvrpConfigGroup(),
			new OTFVisConfigGroup());
	config.controler().setLastIteration(lastIteration);

	TaxiControlerCreator.createControler(config, otfvis).run();
}
 

public static void main(String[] args) {

		Config config = ConfigUtils.loadConfig("scenarios/cottbus/drtconfig_stopbased.xml",
				new MultiModeDrtConfigGroup(), new DvrpConfigGroup(),
                new OTFVisConfigGroup(), new DrtFaresConfigGroup());
        run(config, false);
    }
 

public static void main(String[] args) {

		Config config = ConfigUtils.loadConfig(COTTBUS_DOOR2DOOR_CONFIG, new MultiModeDrtConfigGroup(),
				new DvrpConfigGroup(),
				new OTFVisConfigGroup(), new DrtFaresConfigGroup());
		run(config, false);
	}
 

@Test
public void testAmodeusDrt() {
    Config config = ConfigUtils.createConfig(new MultiModeDrtConfigGroup(), new DvrpConfigGroup(), new AmodeusConfigGroup());
    Scenario scenario = TestScenarioGenerator.generateWithAVLegs(config);
    run(config, scenario, true);

    // Currently, Amodeus does not know where to put the auto-generated ScenarioOptions file.
    // We can make this a config option for AmodeusConfigGroup.
    FileUtils.deleteQuietly(new File("AmodeusOptions.properties"));
}
 

@Override
public void simulate() throws Exception {
    // change dispatcher
    Config config = ConfigUtils.loadConfig(scenarioOptions.getSimulationConfigName(), new DvrpConfigGroup(), new AmodeusConfigGroup());
    AmodeusConfigGroup.get(config).getModes().values()//
            .iterator().next().getDispatcherConfig().setType("TShareDispatcher");
    new ConfigWriter(config).write(scenarioOptions.getSimulationConfigName());
    super.simulate();
}
 

@Test
public void testStuckScoring() {
    AmodeusConfigGroup avConfigGroup = new AmodeusConfigGroup();

    AmodeusModeConfig operatorConfig = new AmodeusModeConfig(AmodeusModeConfig.DEFAULT_MODE);
    operatorConfig.getGeneratorConfig().setNumberOfVehicles(0);
    avConfigGroup.addMode(operatorConfig);

    AmodeusScoringConfig scoringParams = operatorConfig.getScoringParameters(null);
    scoringParams.setMarginalUtilityOfWaitingTime(-0.84);

    Config config = ConfigUtils.createConfig(avConfigGroup, new DvrpConfigGroup());
    Scenario scenario = TestScenarioGenerator.generateWithAVLegs(config);
    config.planCalcScore().getOrCreateModeParams(AmodeusModeConfig.DEFAULT_MODE); // Refactor av

    Controler controler = new Controler(scenario);
    controler.addOverridingModule(new DvrpModule());
    controler.addOverridingModule(new AmodeusModule());
    controler.addOverridingQSimModule(new AmodeusQSimModule());

    controler.configureQSimComponents(AmodeusQSimModule.activateModes(avConfigGroup));

    controler.run();

    for (Person person : scenario.getPopulation().getPersons().values()) {
        Assert.assertEquals(-1000.0, person.getSelectedPlan().getScore(), 1e-6);
    }
}
 

@Test
public void testMultiOD() {
    AmodeusConfigGroup avConfigGroup = new AmodeusConfigGroup();

    AmodeusModeConfig operatorConfig = new AmodeusModeConfig(AmodeusModeConfig.DEFAULT_MODE);
    operatorConfig.getDispatcherConfig().setType(MultiODHeuristic.TYPE);
    operatorConfig.getGeneratorConfig().setNumberOfVehicles(100);
    operatorConfig.getPricingConfig().setPricePerKm(0.48);
    operatorConfig.getPricingConfig().setSpatialBillingInterval(1000.0);
    avConfigGroup.addMode(operatorConfig);

    AmodeusScoringConfig scoringParams = operatorConfig.getScoringParameters(null);
    scoringParams.setMarginalUtilityOfWaitingTime(-0.84);

    Config config = ConfigUtils.createConfig(avConfigGroup, new DvrpConfigGroup());
    Scenario scenario = TestScenarioGenerator.generateWithAVLegs(config);

    PlanCalcScoreConfigGroup.ModeParams modeParams = config.planCalcScore().getOrCreateModeParams(AmodeusModeConfig.DEFAULT_MODE); // Refactor av
    modeParams.setMonetaryDistanceRate(0.0);
    modeParams.setMarginalUtilityOfTraveling(8.86);
    modeParams.setConstant(0.0);

    Controler controler = new Controler(scenario);
    controler.addOverridingModule(new DvrpModule());
    controler.addOverridingModule(new AmodeusModule());
    controler.addOverridingQSimModule(new AmodeusQSimModule());

    controler.configureQSimComponents(AmodeusQSimModule.activateModes(avConfigGroup));

    TestScenarioAnalyzer analyzer = new TestScenarioAnalyzer();
    controler.addOverridingModule(analyzer);

    controler.run();

    Assert.assertEquals(0, analyzer.numberOfDepartures - analyzer.numberOfArrivals);
}
 

@Test
public void testBasicSetup() {
    // CONFIG PART

    Config config = ConfigUtils.createConfig(new DvrpConfigGroup(), new AmodeusConfigGroup());

    // Add Amodeus mode
    AmodeusModeConfig modeConfig = new AmodeusModeConfig("av");
    modeConfig.getDispatcherConfig().setType("GlobalBipartiteMatchingDispatcher");
    AmodeusConfigGroup.get(config).addMode(modeConfig);

    config.planCalcScore().getOrCreateModeParams("av");

    // DVRP adjustments
    config.qsim().setSimStarttimeInterpretation(StarttimeInterpretation.onlyUseStarttime);

    // SCENARIO PART

    // Generates a scenario with "av" legs
    Scenario scenario = TestScenarioGenerator.generateWithAVLegs(config);

    // CONTROLLER PART
    Controler controller = new Controler(scenario);

    controller.addOverridingModule(new DvrpModule());
    controller.addOverridingModule(new AmodeusModule());

    controller.addOverridingQSimModule(new AmodeusQSimModule());
    controller.configureQSimComponents(AmodeusQSimModule.activateModes(AmodeusConfigGroup.get(controller.getConfig())));

    // Some analysis listener for testing
    TestScenarioAnalyzer analyzer = new TestScenarioAnalyzer();
    controller.addOverridingModule(analyzer);

    controller.run();

    Assert.assertEquals(0, analyzer.numberOfDepartures - analyzer.numberOfArrivals);
    Assert.assertEquals(100, analyzer.numberOfDepartures);
}
 

/** runs a simulation run using input data from Amodeus.properties, av.xml and MATSim config.xml
 * 
 * @throws MalformedURLException
 * @throws Exception */

public void simulate(StringSocket stringSocket, int numReqTot, //
        File workingDirectory) throws MalformedURLException, Exception {
    Static.setup();
    /** working directory and options */
    scenarioOptions = new ScenarioOptions(workingDirectory, ScenarioOptionsBase.getDefault());

    /** set to true in order to make server wait for at least 1 client, for
     * instance viewer client, for fals the ScenarioServer starts the simulation
     * immediately */
    boolean waitForClients = scenarioOptions.getBoolean("waitForClients");
    configFile = new File(scenarioOptions.getSimulationConfigName());
    /** geographic information */
    LocationSpec locationSpec = scenarioOptions.getLocationSpec();
    referenceFrame = locationSpec.referenceFrame();

    /** open server port for clients to connect to */
    SimulationServer.INSTANCE.startAcceptingNonBlocking();
    SimulationServer.INSTANCE.setWaitForClients(waitForClients);

    /** load MATSim configs - including av.xml configurations, load routing packages */
    GlobalAssert.that(configFile.exists());
    DvrpConfigGroup dvrpConfigGroup = new DvrpConfigGroup();
    dvrpConfigGroup.setTravelTimeEstimationAlpha(0.05);
    Config config = ConfigUtils.loadConfig(configFile.toString(), new AmodeusConfigGroup(), dvrpConfigGroup);
    config.planCalcScore().addActivityParams(new ActivityParams("activity"));
    // TODO @Sebastian fix this to meaningful values, remove, or add comment
    // this was added because there are sometimes problems, is there a more elegant option?
    for (ActivityParams activityParams : config.planCalcScore().getActivityParams()) {
        activityParams.setTypicalDuration(3600.0);
    }

    /** load MATSim scenario for simulation */
    Scenario scenario = ScenarioUtils.loadScenario(config);
    AddCoordinatesToActivities.run(scenario);
    network = scenario.getNetwork();
    Population population = scenario.getPopulation();
    GlobalAssert.that(Objects.nonNull(network));
    GlobalAssert.that(Objects.nonNull(population));

    Objects.requireNonNull(network);
    MatsimAmodeusDatabase db = MatsimAmodeusDatabase.initialize(network, referenceFrame);
    Controler controller = new Controler(scenario);
    AmodeusConfigurator.configureController(controller, db, scenarioOptions);

    /** try to load link speed data and use for speed adaption in network */
    try {
        File linkSpeedDataFile = new File(scenarioOptions.getLinkSpeedDataName());
        System.out.println(linkSpeedDataFile.toString());
        LinkSpeedDataContainer lsData = LinkSpeedUtils.loadLinkSpeedData(linkSpeedDataFile);
        controller.addOverridingQSimModule(new TrafficDataModule(lsData));
    } catch (Exception exception) {
        System.err.println("Unable to load linkspeed data, freeflow speeds will be used in the simulation.");
        exception.printStackTrace();
    }

    controller.addOverridingModule(new SocketModule(stringSocket, numReqTot));

    /** Custom router that ensures same network speeds as taxis in original data set. */
    controller.addOverridingModule(new AbstractModule() {
        @Override
        public void install() {
            bind(TaxiTravelTimeRouter.Factory.class);
            AmodeusUtils.bindRouterFactory(binder(), TaxiTravelTimeRouter.class.getSimpleName()).to(TaxiTravelTimeRouter.Factory.class);
        }
    });

    /** adding the dispatcher to receive and process string fleet commands */
    controller.addOverridingModule(new AbstractModule() {
        @Override
        public void install() {
            AmodeusUtils.registerDispatcherFactory(binder(), "SocketDispatcherHost", SocketDispatcherHost.Factory.class);
        }
    });

    /** adding an initial vehicle placer */
    controller.addOverridingModule(new AbstractModule() {
        @Override
        public void install() {
            AmodeusUtils.bindGeneratorFactory(binder(), RandomDensityGenerator.class.getSimpleName()).//
            to(RandomDensityGenerator.Factory.class);
        }
    });

    /** run simulation */
    controller.run();

    /** close port for visualizaiton */
    SimulationServer.INSTANCE.stopAccepting();

    /** perform analysis of simulation */
    /** output directory for saving results */
    outputDirectory = new File(config.controler().getOutputDirectory());

}
 

static public void run(Config config, Scenario scenario, boolean useAmodeus) {
    // CONFIG PART

    // Set up MATSim configuration to be compatible with DRT
    config.plans().setHandlingOfPlansWithoutRoutingMode(HandlingOfPlansWithoutRoutingMode.useMainModeIdentifier);
    config.qsim().setStartTime(0.0);
    config.qsim().setSimStarttimeInterpretation(StarttimeInterpretation.onlyUseStarttime);

    config.qsim().setNumberOfThreads(1);

    // Set up missing scoring parameters
    config.planCalcScore().getOrCreateModeParams(DRT_MODE);

    // Set up DRT mode
    DrtConfigGroup drtModeConfig = new DrtConfigGroup();
    drtModeConfig.setMode(DRT_MODE);

    drtModeConfig.setMaxTravelTimeBeta(600.0);
    drtModeConfig.setMaxTravelTimeAlpha(1.4);
    drtModeConfig.setMaxWaitTime(600.0);
    drtModeConfig.setStopDuration(60);
    drtModeConfig.setRejectRequestIfMaxWaitOrTravelTimeViolated(true);
    drtModeConfig.setOperationalScheme(OperationalScheme.door2door);

    MultiModeDrtConfigGroup drtConfig = MultiModeDrtConfigGroup.get(config);
    drtConfig.addParameterSet(drtModeConfig);
    DrtConfigs.adjustDrtConfig(drtModeConfig, config.planCalcScore(), config.plansCalcRoute());

    // Create a fleet on the fly
    String vehiclesFile = new File("test_data/drt_vehicles.xml.gz").getAbsolutePath();
    drtModeConfig.setVehiclesFile(vehiclesFile);
    createFleet(vehiclesFile, 100, scenario.getNetwork());

    // Set up DVRP
    DvrpConfigGroup dvrpConfig = DvrpConfigGroup.get(config);
    dvrpConfig.setTravelTimeEstimationAlpha(1.0);
    dvrpConfig.setTravelTimeEstimationBeta(900);

    // SCENARIO PART
    scenario.getPopulation().getFactory().getRouteFactories().setRouteFactory(DrtRoute.class, new DrtRouteFactory());

    // CONTROLLER PART
    Controler controller = new Controler(scenario);

    // Add DVRP and activate modes
    controller.addOverridingModule(new DvrpModule());
    controller.configureQSimComponents(DvrpQSimComponents.activateModes(drtModeConfig.getMode()));

    if (!useAmodeus) {
        // No Amodeus, so we use standard MultiModeDrtModule
        controller.addOverridingModule(new MultiModeDrtModule());
    } else {
        // Add DRT, but NOT with MultiModeDrtModule, but with MultiModeDrtModuleForAmodeus
        // because right now we remove DRT's analysis components as they are not compatible yet
        controller.addOverridingModule(new MultiModeDrtModuleForAmodeus());
    }

    // Here we start overriding things of DRT with Amodeus
    if (useAmodeus) {

        // This is a per-mode config, which usually is contained in a AmodeusConfigGroup,
        // here we only use it to set up a small portion of Amodeus (the dispatching part),
        // and not scoring, waiting times, etc.
        AmodeusModeConfig amodeusModeConfig = new AmodeusModeConfig(drtModeConfig.getMode());

        // We can choose the dispatcher and set additional options. Note that some dispatchers
        // rely heavily on GLPK. You need to install it and then tell JAVA where to find it
        // via -Djava.library.path=/path/to/glpk/lib/jni on the command line.
        amodeusModeConfig.getDispatcherConfig().setType("FeedforwardFluidicRebalancingPolicy");

        // Change, for instance, to "GlobalBipartiteMatchingDispatcher" if you want to
        // test without GLPK!

        // Disable Amodeus-specific output (e.g., for the viewer)
        amodeusModeConfig.getDispatcherConfig().setPublishPeriod(0);

        // Path where to generate or read a VirtualNetwork and TravelData for rebalancing.
        // Note that not all dispatchers need this.
        amodeusModeConfig.getDispatcherConfig().setVirtualNetworkPath(new File("test_data/virtualNetwork").getAbsolutePath());
        amodeusModeConfig.getDispatcherConfig().setTravelDataPath(new File("test_data/travelData").getAbsolutePath());

        // Add a subset of Amodeus modules which usually would be added automatically
        // in the upper-level AmodeusModule.
        controller.addOverridingModule(new VirtualNetworkModeModule(amodeusModeConfig));
        controller.addOverridingModule(new AmodeusModule());

        // Add overriding modules for the Drt <-> Amodeus integration, which override some
        // components of DRT. Later on, we would only override DrtOptimizer, but we are
        // not there yet, because Amodeus internally still works with AmodeusStayTask, etc.
        // and does not understand DrtStayTask, etc.
        controller.addOverridingModule(new AmodeusDrtModule(amodeusModeConfig));
        controller.addOverridingQSimModule(new AmodeusDrtQSimModule(drtModeConfig.getMode()));
    }

    controller.run();
}
 

@Test
public void testDefaultDrt() {
    Config config = ConfigUtils.createConfig(new MultiModeDrtConfigGroup(), new DvrpConfigGroup());
    Scenario scenario = TestScenarioGenerator.generateWithAVLegs(config);
    run(config, scenario, false);
}
 

@Test
public void testAVExampleWithAccessEgressAttribute() {
    AmodeusConfigGroup avConfigGroup = new AmodeusConfigGroup();

    AmodeusModeConfig operatorConfig = new AmodeusModeConfig(AmodeusModeConfig.DEFAULT_MODE);
    operatorConfig.getGeneratorConfig().setNumberOfVehicles(100);
    operatorConfig.getPricingConfig().setPricePerKm(0.48);
    operatorConfig.getPricingConfig().setSpatialBillingInterval(1000.0);
    operatorConfig.getInteractionFinderConfig().setType(LinkAttributeInteractionFinder.TYPE);
    operatorConfig.getInteractionFinderConfig().getParams().put("allowedLinkAttribute", "avflag");
    avConfigGroup.addMode(operatorConfig);

    AmodeusScoringConfig scoringParams = operatorConfig.getScoringParameters(null);
    scoringParams.setMarginalUtilityOfWaitingTime(-0.84);

    operatorConfig.setUseAccessAgress(true);

    Config config = ConfigUtils.createConfig(avConfigGroup, new DvrpConfigGroup());
    Scenario scenario = TestScenarioGenerator.generateWithAVLegs(config);

    for (Link link : scenario.getNetwork().getLinks().values()) {
        if (link.getFromNode().getCoord().getX() == 5000.0) {
            link.getAttributes().putAttribute("avflag", true);
        }
    }

    ActivityParams activityParams = new ActivityParams("amodeus interaction");
    activityParams.setTypicalDuration(1.0);
    config.planCalcScore().addActivityParams(activityParams);

    PlanCalcScoreConfigGroup.ModeParams modeParams = config.planCalcScore().getOrCreateModeParams(AmodeusModeConfig.DEFAULT_MODE); // Refactor av
    modeParams.setMonetaryDistanceRate(0.0);
    modeParams.setMarginalUtilityOfTraveling(8.86);
    modeParams.setConstant(0.0);

    config.qsim().setEndTime(40.0 * 3600.0);
    config.qsim().setSimStarttimeInterpretation(StarttimeInterpretation.onlyUseStarttime);

    Controler controler = new Controler(scenario);
    controler.addOverridingModule(new DvrpModule());
    controler.addOverridingModule(new AmodeusModule());
    controler.addOverridingQSimModule(new AmodeusQSimModule());

    controler.configureQSimComponents(AmodeusQSimModule.activateModes(avConfigGroup));

    TestScenarioAnalyzer analyzer = new TestScenarioAnalyzer();
    controler.addOverridingModule(analyzer);

    controler.run();

    Assert.assertEquals(0, analyzer.numberOfDepartures - analyzer.numberOfArrivals);
    Assert.assertEquals(163, analyzer.numberOfInteractionActivities);
}
 

@Test
public void testAVExampleWithAccessEgress() {
    AmodeusConfigGroup avConfigGroup = new AmodeusConfigGroup();

    AmodeusModeConfig operatorConfig = new AmodeusModeConfig(AmodeusModeConfig.DEFAULT_MODE);
    operatorConfig.getGeneratorConfig().setNumberOfVehicles(100);
    operatorConfig.getPricingConfig().setPricePerKm(0.48);
    operatorConfig.getPricingConfig().setSpatialBillingInterval(1000.0);
    avConfigGroup.addMode(operatorConfig);

    AmodeusScoringConfig scoringParams = operatorConfig.getScoringParameters(null);
    scoringParams.setMarginalUtilityOfWaitingTime(-0.84);

    operatorConfig.setUseAccessAgress(true);

    Config config = ConfigUtils.createConfig(avConfigGroup, new DvrpConfigGroup());
    Scenario scenario = TestScenarioGenerator.generateWithAVLegs(config);

    Iterator<? extends Person> iterator = scenario.getPopulation().getPersons().values().iterator();
    for (int i = 0; i < 3; i++) {
        Person person = iterator.next();

        for (PlanElement element : person.getSelectedPlan().getPlanElements()) {
            if (element instanceof Activity) {
                Activity activity = (Activity) element;
                activity.setCoord(CoordUtils.plus(activity.getCoord(), new Coord(5.0, 5.0)));
            }
        }
    }

    ActivityParams activityParams = new ActivityParams("amodeus interaction");
    activityParams.setTypicalDuration(1.0);
    config.planCalcScore().addActivityParams(activityParams);

    PlanCalcScoreConfigGroup.ModeParams modeParams = config.planCalcScore().getOrCreateModeParams(AmodeusModeConfig.DEFAULT_MODE); // Refactor av
    modeParams.setMonetaryDistanceRate(0.0);
    modeParams.setMarginalUtilityOfTraveling(8.86);
    modeParams.setConstant(0.0);

    Controler controler = new Controler(scenario);
    controler.addOverridingModule(new DvrpModule());
    controler.addOverridingModule(new AmodeusModule());
    controler.addOverridingQSimModule(new AmodeusQSimModule());

    controler.configureQSimComponents(AmodeusQSimModule.activateModes(avConfigGroup));

    TestScenarioAnalyzer analyzer = new TestScenarioAnalyzer();
    controler.addOverridingModule(analyzer);

    controler.run();

    Assert.assertEquals(0, analyzer.numberOfDepartures - analyzer.numberOfArrivals);
    Assert.assertEquals(6, analyzer.numberOfInteractionActivities);
}
 

@Test
public void testPreRouting() {
    AmodeusConfigGroup avConfigGroup = new AmodeusConfigGroup();

    AmodeusModeConfig operatorConfig = new AmodeusModeConfig(AmodeusModeConfig.DEFAULT_MODE);
    operatorConfig.setPredictRouteTravelTime(true);
    operatorConfig.getGeneratorConfig().setNumberOfVehicles(100);
    avConfigGroup.addMode(operatorConfig);

    AmodeusScoringConfig scoringParams = operatorConfig.getScoringParameters(null);
    scoringParams.setMarginalUtilityOfWaitingTime(-0.84);

    operatorConfig.getPricingConfig().setPricePerKm(1.0);

    Config config = ConfigUtils.createConfig(avConfigGroup, new DvrpConfigGroup());
    Scenario scenario = TestScenarioGenerator.generateWithAVLegs(config);

    config.plansCalcRoute().setRoutingRandomness(0.0);

    PlanCalcScoreConfigGroup.ModeParams modeParams = config.planCalcScore().getOrCreateModeParams(AmodeusModeConfig.DEFAULT_MODE);
    modeParams.setMonetaryDistanceRate(0.0);
    modeParams.setMarginalUtilityOfTraveling(8.86);
    modeParams.setConstant(0.0);

    StrategySettings strategySettings = new StrategySettings();
    strategySettings.setStrategyName("KeepLastSelected");
    strategySettings.setWeight(1.0);
    config.strategy().addStrategySettings(strategySettings);

    Controler controler = new Controler(scenario);
    controler.addOverridingModule(new DvrpModule());
    controler.addOverridingModule(new AmodeusModule());
    controler.addOverridingQSimModule(new AmodeusQSimModule());

    controler.configureQSimComponents(AmodeusQSimModule.activateModes(avConfigGroup));

    controler.run();

    for (Person person : scenario.getPopulation().getPersons().values()) {
        Plan plan = person.getSelectedPlan();

        for (PlanElement element : plan.getPlanElements()) {
            if (element instanceof Leg) {
                Leg leg = (Leg) element;
                AmodeusRoute route = (AmodeusRoute) leg.getRoute();

                Assert.assertTrue(route.getTravelTime().isDefined() && Double.isFinite(route.getTravelTime().seconds()));
                Assert.assertTrue(route.getExpectedDistance().isPresent());
                Assert.assertTrue(route.getWaitingTime().isDefined());
                Assert.assertTrue(route.getPrice().isPresent());
                Assert.assertTrue(route.getPrice().get() > 0.0);
            }
        }
    }
}
 

public void simulate() throws Exception {
    boolean waitForClients = scenarioOptions.getBoolean("waitForClients");
    StaticHelper.setup();

    LocationSpec locationSpec = scenarioOptions.getLocationSpec();

    ReferenceFrame referenceFrame = locationSpec.referenceFrame();

    // open server port for clients to connect to
    SimulationServer.INSTANCE.startAcceptingNonBlocking();
    SimulationServer.INSTANCE.setWaitForClients(waitForClients);

    // load MATSim configs - including av.xml where dispatcher is selected.
    System.out.println("loading config file " + configFile.getAbsoluteFile());

    GlobalAssert.that(configFile.exists()); // Test whether the config file
    // directory exists

    DvrpConfigGroup dvrpConfigGroup = new DvrpConfigGroup();
    dvrpConfigGroup.setTravelTimeEstimationAlpha(0.05);
    Config config = ConfigUtils.loadConfig(configFile.toString(), new AmodeusConfigGroup(), dvrpConfigGroup);
    config.planCalcScore().addActivityParams(new PlanCalcScoreConfigGroup.ActivityParams("activity"));

    config.qsim().setStartTime(0.0);
    config.qsim().setSimStarttimeInterpretation(StarttimeInterpretation.onlyUseStarttime);

    for (ActivityParams activityParams : config.planCalcScore().getActivityParams())
        // TODO @sebhoerl fix this to meaningful values, remove, or add comment
        // this was added because there are sometimes problems, is there a more elegant option?
        activityParams.setTypicalDuration(3600.0);

    String outputdirectory = config.controler().getOutputDirectory();
    System.out.println("outputdirectory = " + outputdirectory);

    // load scenario for simulation
    Scenario scenario = ScenarioUtils.loadScenario(config);
    Network network = scenario.getNetwork();
    Population population = scenario.getPopulation();
    GlobalAssert.that(Objects.nonNull(network) && Objects.nonNull(population));

    MatsimAmodeusDatabase db = MatsimAmodeusDatabase.initialize(network, referenceFrame);
    Controler controller = new Controler(scenario);
    AmodeusConfigurator.configureController(controller, db, scenarioOptions);

    // run simulation
    controller.run();

    // close port for visualization
    SimulationServer.INSTANCE.stopAccepting();

    Analysis analysis = Analysis.setup(scenarioOptions, new File(workingDirectory, "output/001"), network, db);
    analysis.addAnalysisExport(ate);
    analysis.addAnalysisExport(new RoboTaxiHistoriesExportFromEvents(network, config));
    analysis.addAnalysisExport(new RequestHistoriesExportFromEvents(network, config));
    analysis.run();
}
 

private static Controler prepare() throws IOException {
    File scenarioDirectory = new File(Locate.repoFolder(StandardMATSimScenarioTest.class, "amodeus"), "resources/testScenario");
    File workingDirectory = MultiFileTools.getDefaultWorkingDirectory();
    GlobalAssert.that(workingDirectory.isDirectory());
    TestFileHandling.copyScnearioToMainDirectory(scenarioDirectory.getAbsolutePath(), workingDirectory.getAbsolutePath());

    StaticHelper.setup();
    MatsimRandom.reset();

    // Set up
    Config config = ConfigUtils.createConfig(new AmodeusConfigGroup(), new DvrpConfigGroup());
    Scenario scenario = TestScenarioGenerator.generateWithAVLegs(config);

    ScenarioOptions simOptions = new ScenarioOptions(workingDirectory, ScenarioOptionsBase.getDefault());
    LocationSpec locationSpec = simOptions.getLocationSpec();
    ReferenceFrame referenceFrame = locationSpec.referenceFrame();
    MatsimAmodeusDatabase db = MatsimAmodeusDatabase.initialize(scenario.getNetwork(), referenceFrame);

    PlanCalcScoreConfigGroup.ModeParams modeParams = config.planCalcScore().getOrCreateModeParams(AmodeusModeConfig.DEFAULT_MODE);
    modeParams.setMonetaryDistanceRate(0.0);
    modeParams.setMarginalUtilityOfTraveling(8.86);
    modeParams.setConstant(0.0);

    // Config

    AmodeusConfigGroup avConfig = AmodeusConfigGroup.get(config);

    AmodeusModeConfig operatorConfig = new AmodeusModeConfig(AmodeusModeConfig.DEFAULT_MODE);
    avConfig.addMode(operatorConfig);

    GeneratorConfig generatorConfig = operatorConfig.getGeneratorConfig();
    generatorConfig.setType("VehicleToVSGenerator");
    generatorConfig.setNumberOfVehicles(100);

    // Choose a dispatcher
    DispatcherConfig dispatcherConfig = operatorConfig.getDispatcherConfig();
    dispatcherConfig.addParam("infoLinePeriod", "3600");
    dispatcherConfig.setType("FeedforwardFluidicRebalancingPolicy");

    // Make sure that we do not need the SimulationObjectCompiler
    dispatcherConfig.addParam("publishPeriod", "-1");

    // Set up stuff for TravelData (but we'll generate it on the fly)
    LPOptions lpOptions = new LPOptions(simOptions.getWorkingDirectory(), LPOptionsBase.getDefault());
    lpOptions.setProperty(LPOptionsBase.LPSOLVER, "timeInvariant");
    lpOptions.saveAndOverwriteLPOptions();

    // Set up paths
    operatorConfig.getDispatcherConfig().setVirtualNetworkPath("generatedVirtualNetwork");
    operatorConfig.getDispatcherConfig().setTravelDataPath("generatedTravelData");

    // Controller
    Controler controller = new Controler(scenario);
    AmodeusConfigurator.configureController(controller, db, simOptions);

    // Run
    return controller;
}
 

public static void main(String[] args) {
	Config config = ConfigUtils.loadConfig(args[0], new MultiModeDrtConfigGroup(), new DvrpConfigGroup(), new OTFVisConfigGroup(),
			new DrtFaresConfigGroup());

	run(config, false);
}
 

public static void run(String configFile, boolean otfvis) {
	Config config = ConfigUtils.loadConfig(configFile, new DvrpConfigGroup(), new TaxiFaresConfigGroup(),
			new OTFVisConfigGroup(), new MultiModeTaxiConfigGroup());
	createControler(config, otfvis).run();
}