public void testScenarioRun() {

    // load config and use ParallelQSim with 2 Threads
    Config config = loadConfig("test/scenarios/equil/config.xml");
    QSimConfigGroup qSimConfig = config.qsim();
    qSimConfig.setNumberOfThreads(2);
    config.controler().setMobsim("qsim");
    config.controler().setLastIteration(0);
    config.qsim().setStartTime(0.0);
    config
        .qsim()
        .setSimStarttimeInterpretation(QSimConfigGroup.StarttimeInterpretation.onlyUseStarttime);

    Controler controler = new Controler(config);
    controler.addOverridingModule(new WithinDayModule());
    controler.addOverridingModule(
        new AbstractModule() {
          @Override
          public void install() {
            addMobsimListenerBinding().to(MobsimListenerForTests.class);
          }
        });
    controler.getConfig().controler().setCreateGraphs(false);
    controler.getConfig().controler().setDumpDataAtEnd(false);
    controler.getConfig().controler().setWriteEventsInterval(0);
    controler.getConfig().controler().setWritePlansInterval(0);
    controler.run();
  }
  public KMZPtCountSimComparisonWriter(final Controler controler) {
    this.controler = controler;

    // load data
    net = controler.getScenario().getNetwork();
    MatsimCountsReader reader = new MatsimCountsReader(occupCounts);
    reader.readFile(controler.getConfig().ptCounts().getOccupancyCountsFileName());
    scalefactor = controler.getConfig().ptCounts().getCountsScaleFactor();

    reader = null; // M
  }
  protected void write(
      final OccupancyAnalyzer ocupAnalizer, final int itNum, final boolean stopZoneConversion) {

    PtCountComparisonAlgorithm4confTimeBinSize ccaOccupancy =
        new PtCountComparisonAlgorithm4confTimeBinSize(ocupAnalizer, occupCounts, net, scalefactor);
    ccaOccupancy.calculateComparison();

    // set and use kml writter
    Config config = controler.getConfig();
    PtCountSimComparisonKMLWriter kmlWriter =
        new PtCountSimComparisonKMLWriter(
            ccaOccupancy.getComparison(),
            ccaOccupancy.getComparison(),
            ccaOccupancy.getComparison(),
            TransformationFactory.getCoordinateTransformation(
                config.global().getCoordinateSystem(), TransformationFactory.WGS84),
            occupCounts,
            occupCounts,
            occupCounts);
    kmlWriter.setIterationNumber(itNum);

    // write counts comparison
    String kmlFile;
    String ocuppCompTxtFile;
    String outDir;
    if (controler.getControlerIO() != null) {
      kmlFile = controler.getControlerIO().getIterationFilename(itNum, kmzFile);
      ocuppCompTxtFile = controler.getControlerIO().getIterationFilename(itNum, txtCompFile);
      outDir = controler.getControlerIO().getIterationPath(itNum) + S;
    } else { // <-it happens when this method is invoked outside a simulation run
      outDir =
          controler.getConfig().controler().getOutputDirectory() + ITERS + itNum + SL + itNum + PNT;
      kmlFile = outDir + kmzFile;
      ocuppCompTxtFile = outDir + txtCompFile;
    }
    kmlWriter.writeFile(kmlFile);
    ccaOccupancy.write(ocuppCompTxtFile);

    //// extract the specific plot in the iteration folder
    String plotName = (stopZoneConversion) ? STR_HOUROCCUPPLOT : STR_ERRPLOT;
    KMZ_Extractor extractor = new KMZ_Extractor(kmlFile, outDir);
    extractor.extractFile(plotName);
    log.info(kmlFile + strDONE);

    plotName = null;
    extractor = null;
    outDir = null;
    kmlFile = null;
    ccaOccupancy = null;
    kmlWriter = null;
  }
示例#4
0
  /** @param args */
  public static void main(String[] args) {
    log.info("Running SylviaMain...");
    String[] args2 = null;
    if (args == null || args.length == 0) {
      throw new RuntimeException("No arguments given, expecting path to config!");
    } else {
      args2 = args;
    }

    //		DgCottbusSylviaAnalysisControlerListener analysis = new
    // DgCottbusSylviaAnalysisControlerListener();

    Controler controler = new Controler(args2);
    DgSylviaConfig sylviaConfig = new DgSylviaConfig();
    // FIXME: Take care that the normal SignalsControllerListener is NOT added.
    controler.addControlerListener(
        new DgSylviaControlerListenerFactory(sylviaConfig).createSignalsControllerListener());
    //		controler.addControlerListener(analysis);
    controler
        .getConfig()
        .controler()
        .setOverwriteFileSetting(
            OutputDirectoryHierarchy.OverwriteFileSetting.overwriteExistingFiles);
    controler.run();
  }
  public static void main(String[] args) {

    Controler controler = null;
    if (args.length == 0) {
      controler = new Controler(initSampleScenario());
    } else controler = new Controler(args);

    /*
     * Scoring also has to take the social costs into account.
     * This cannot be moved to the initializer since the scoring functions
     * are created even before the startup event is created.
     */
    // controler.setScoringFunctionFactory(new TimeAndMoneyDependentScoringFunctionFactory());

    InitializerV2 initializer = new InitializerV2(0.1);
    controler.addControlerListener(initializer);
    controler
        .getConfig()
        .controler()
        .setOverwriteFileSetting(
            true
                ? OutputDirectoryHierarchy.OverwriteFileSetting.overwriteExistingFiles
                : OutputDirectoryHierarchy.OverwriteFileSetting.failIfDirectoryExists);
    controler.run();
  }
示例#6
0
  public static void main(String[] args) throws IOException {

    Config c = ConfigUtils.createConfig();
    ConfigUtils.loadConfig(c, RAW_INPUT + "output_config.xml.gz");

    Scenario sc = ScenarioUtils.createScenario(c);
    //		Network net = sc.getNetwork();
    new MatsimNetworkReader(sc.getNetwork()).readFile(RAW_INPUT + "/output_network.xml.gz");
    new PopulationReader(sc).readFile(RAW_INPUT + "output_plans.xml.gz");
    //		dropDepTimes(sc.getPopulation());

    c.controler().setOutputDirectory(NEW_DIR + "output/");
    c.network().setInputFile(NEW_DIR + "input/network.xml.gz");
    c.plans().setInputFile(NEW_DIR + "input/population.xml.gz");

    new NetworkWriter(sc.getNetwork()).write(c.network().getInputFile());
    new PopulationWriter(sc.getPopulation(), sc.getNetwork()).write(c.plans().getInputFile());
    new ConfigWriter(c).write(NEW_DIR + "input/config.xml");

    c.controler().setLastIteration(0);

    Controler cntr = new Controler(sc);
    cntr.getConfig()
        .controler()
        .setOverwriteFileSetting(
            OutputDirectoryHierarchy.OverwriteFileSetting.overwriteExistingFiles);
    cntr.run();

    Analyzer.main(
        new String[] {
          NEW_DIR + "/output/ITERS/it.0/0.events.xml.gz",
          "/Users/laemmel/arbeit/papers/2015/TRBwFZJ/hybridsim_trb2016/analysis/runagain-vehicles_plot_data"
        });
  }
示例#7
0
  private double walkingDistanceFor3CarScenarioWithVariableParkingCapacity(int parkingCapacity) {
    ParkingChoiceLib.isTestCaseRun = true;
    Config config = super.loadConfig("test/input/playground/wrashid/parkingChoice/chessConfig.xml");
    Controler controler = new Controler(config);

    // setup parking infrastructure
    LinkedList<PParking> parkingCollection = new LinkedList<PParking>();

    for (int i = 0; i < 10; i++) {
      for (int j = 0; j < 10; j++) {
        ParkingImpl parking =
            new ParkingImpl(new Coord((double) (i * 1000 + 500), (double) (j * 1000 + 500)));
        parking.setMaxCapacity(parkingCapacity);
        parkingCollection.add(parking);
      }
    }

    ParkingModule parkingModule = new ParkingModule(controler, parkingCollection);

    controler
        .getConfig()
        .controler()
        .setOverwriteFileSetting(
            true
                ? OutputDirectoryHierarchy.OverwriteFileSetting.overwriteExistingFiles
                : OutputDirectoryHierarchy.OverwriteFileSetting.failIfDirectoryExists);

    controler.run();

    return parkingModule.getAverageWalkingDistance();
  }
示例#8
0
  public static void main(final String[] args) {

    String configFile = args[0];
    Config config;

    // reading the config file:
    config = ConfigUtils.loadConfig(configFile);

    // manipulate config
    // add "pt interaction" cause controler.init() is called too late and in a protected way
    ActivityParams transitActivityParams = new ActivityParams(PtConstants.TRANSIT_ACTIVITY_TYPE);
    transitActivityParams.setTypicalDuration(120.0);
    config.planCalcScore().addActivityParams(transitActivityParams);

    // reading the scenario (based on the config):
    MutableScenario sc = (MutableScenario) ScenarioUtils.loadScenario(config);

    Controler tc = new Controler(sc);
    tc.setScoringFunctionFactory(
        new BvgScoringFunctionFactory(sc, new BvgScoringFunctionConfigGroup(config)));

    // Not needed to use own scoring function

    //		if(args.length > 1 && args[1].equalsIgnoreCase("true")){
    //			tc.setUseOTFVis(true);
    //		}
    tc.getConfig()
        .controler()
        .setOverwriteFileSetting(
            true
                ? OutputDirectoryHierarchy.OverwriteFileSetting.overwriteExistingFiles
                : OutputDirectoryHierarchy.OverwriteFileSetting.failIfDirectoryExists);
    //			tc.setCreateGraphs(false);
    tc.run();
  }
示例#9
0
  /**
   * Tests the setup with a traffic light that shows all the time green in the 0th iteration. After
   * the mobsim is run the signal settings are changed thus in the 1st iteration the signal should
   * be red in sec [0,99] and green in [100,2000]
   */
  @Test
  public void testModifySignalControlDataOnsetOffset() {
    // configure and load standard scenario
    Fixture fixture = new Fixture();
    Scenario scenario = fixture.createAndLoadTestScenario(false);
    scenario.getConfig().controler().setFirstIteration(0);
    scenario.getConfig().controler().setLastIteration(1);
    scenario.getConfig().controler().setOutputDirectory(testUtils.getOutputDirectory());

    Controler controler = new Controler(scenario);
    controler.getConfig().controler().setCreateGraphs(false);
    controler.addControlerListener(
        new AfterMobsimListener() {

          @Override
          public void notifyAfterMobsim(AfterMobsimEvent event) {
            Scenario scenario = event.getServices().getScenario();
            int dropping = 0;
            int onset = 100;
            for (SignalSystemControllerData intersectionSignal :
                ((SignalsData) scenario.getScenarioElement(SignalsData.ELEMENT_NAME))
                    .getSignalControlData()
                    .getSignalSystemControllerDataBySystemId()
                    .values()) {

              for (SignalPlanData plan : intersectionSignal.getSignalPlanData().values()) {
                plan.setCycleTime(2000);
                for (SignalGroupSettingsData data :
                    plan.getSignalGroupSettingsDataByGroupId().values()) {
                  data.setDropping(dropping);
                  data.setOnset(onset);
                }
              }
            }
          }
        });

    controler.addControlerListener(
        new IterationStartsListener() {

          @Override
          public void notifyIterationStarts(IterationStartsEvent event) {
            event.getServices().getEvents().addHandler(new EventsLogger());

            TestLink2EnterEventHandler enterHandler = new TestLink2EnterEventHandler();
            if (0 == event.getIteration()) {
              enterHandler.link2EnterTime = 38.0;
            }

            if (1 == event.getIteration()) {
              enterHandler.link2EnterTime = 100.0;
              SignalGroupStateChangedEventHandler signalsHandler0 =
                  new TestSignalGroupStateChangedHandler();
              event.getServices().getEvents().addHandler(signalsHandler0);
            }
          }
        });

    controler.run();
  }
示例#10
0
  public static void main(String[] args) {
    Config config = ConfigUtils.createConfig();
    ConfigUtils.loadConfig(config, args[0]);
    final Controler controler = new Controler(ScenarioUtils.loadScenario(config));
    final WaitTimeStuckCalculator waitTimeCalculator =
        new WaitTimeStuckCalculator(
            controler.getScenario().getPopulation(),
            controler.getScenario().getTransitSchedule(),
            controler.getConfig().travelTimeCalculator().getTraveltimeBinSize(),
            (int)
                (controler.getConfig().qsim().getEndTime()
                    - controler.getConfig().qsim().getStartTime()));
    controler.getEvents().addHandler(waitTimeCalculator);
    final StopStopTimeCalculator stopStopTimeCalculator =
        new StopStopTimeCalculator(
            controler.getScenario().getTransitSchedule(),
            controler.getConfig().travelTimeCalculator().getTraveltimeBinSize(),
            (int)
                (controler.getConfig().qsim().getEndTime()
                    - controler.getConfig().qsim().getStartTime()));
    controler.getEvents().addHandler(stopStopTimeCalculator);
    final VehicleOccupancyCalculator vehicleOccupancyCalculator =
        new VehicleOccupancyCalculator(
            controler.getScenario().getTransitSchedule(),
            ((ScenarioImpl) controler.getScenario()).getTransitVehicles(),
            controler.getConfig().travelTimeCalculator().getTraveltimeBinSize(),
            (int)
                (controler.getConfig().qsim().getEndTime()
                    - controler.getConfig().qsim().getStartTime()));
    controler.getEvents().addHandler(vehicleOccupancyCalculator);
    controler.addOverridingModule(
        new AbstractModule() {
          @Override
          public void install() {
            bind(TransitRouter.class)
                .toProvider(
                    new TransitRouterEventsWSVFactory(
                        controler.getScenario(),
                        waitTimeCalculator.getWaitTimes(),
                        stopStopTimeCalculator.getStopStopTimes(),
                        vehicleOccupancyCalculator.getVehicleOccupancy()));
          }
        });

    // yyyyyy note that in the above script only the router is modified, but not the scoring.  With
    // standard matsim, a slower bu
    // less crowded pt route will only be accepted by the agent when the faster but more crowded
    // option was never presented
    // to the agent.  kai, jul'15

    controler.run();
  }
  private static void connectFacilitiesWithNetwork(Controler controler) {
    ActivityFacilities facilities = controler.getScenario().getActivityFacilities();
    // log.warn("number of facilities: " +facilities.getFacilities().size());
    NetworkImpl network = (NetworkImpl) controler.getScenario().getNetwork();
    // log.warn("number of links: " +network.getLinks().size());

    WorldConnectLocations wcl = new WorldConnectLocations(controler.getConfig());
    wcl.connectFacilitiesWithLinks(facilities, network);
  }
示例#12
0
  public static void main(final String[] args) {
    final String configFile = args[0];

    // This allows to get a log file containing the log messages happening
    // before controler init.
    OutputDirectoryLogging.catchLogEntries();

    // This is the location choice MultiNodeDijkstra.
    // Suppress all log messages of level below error --- to avoid spaming the config
    // file with zillions of "not route found" messages.
    Logger.getLogger(org.matsim.core.router.MultiNodeDijkstra.class)
        .setLevel(Level.ERROR); // this is location choice
    Logger.getLogger(org.matsim.pt.router.MultiNodeDijkstra.class).setLevel(Level.ERROR);

    final Config config =
        ConfigUtils.loadConfig(
            configFile,
            // this adds a new config group, used by the specific scoring function
            // we use
            new KtiLikeScoringConfigGroup(),
            new DestinationChoiceConfigGroup());

    // This is currently needed for location choice: initializing
    // the location choice writes K-values files to the output directory, which:
    // - fails if the directory does not exist
    // - makes the controler crash latter if the unsafe setOverwriteFiles( true )
    // is not called.
    // This ensures that we get safety with location choice working as expected,
    // before we sort this out and definitely kick out setOverwriteFiles.
    createEmptyDirectoryOrFailIfExists(config.controler().getOutputDirectory());
    final Scenario scenario = ScenarioUtils.loadScenario(config);

    final Controler controler = new Controler(scenario);
    controler
        .getConfig()
        .controler()
        .setOverwriteFileSetting(
            true
                ? OutputDirectoryHierarchy.OverwriteFileSetting.overwriteExistingFiles
                : OutputDirectoryHierarchy.OverwriteFileSetting.failIfDirectoryExists);

    connectFacilitiesWithNetwork(controler);

    initializeLocationChoice(controler);

    // We use a specific scoring function, that uses individual preferences
    // for activity durations.
    controler.setScoringFunctionFactory(
        new MATSim2010ScoringFunctionFactory(
            controler.getScenario(),
            new StageActivityTypesImpl(PtConstants.TRANSIT_ACTIVITY_TYPE)));

    controler.run();
  }
  @Test
  public void test_RunTutorial() {
    Config config = this.utils.loadConfig("test/scenarios/pt-tutorial/config.xml");
    config.planCalcScore().setWriteExperiencedPlans(true);
    config.controler().setLastIteration(0);
    config.plans().setInputFile("test/scenarios/pt-tutorial/population2.xml");
    Controler controler = new Controler(config);
    controler
        .getConfig()
        .controler()
        .setOverwriteFileSetting(
            OutputDirectoryHierarchy.OverwriteFileSetting.overwriteExistingFiles);
    controler.getConfig().controler().setCreateGraphs(false);
    controler.run();

    MutableScenario s = (MutableScenario) controler.getScenario();
    Assert.assertNotNull(s.getTransitSchedule());
    Assert.assertEquals(4, s.getTransitSchedule().getFacilities().size());
    Assert.assertEquals(1, s.getTransitSchedule().getTransitLines().size());
  }
示例#14
0
  /*
   * Just starts a randomized router.
   *
   */
  @Ignore
  @Test
  public final void test2() {

    String configFile1 = testUtils.getPackageInputDirectory() + "CNTest/config1.xml";
    Controler controler = new Controler(configFile1);
    TollHandler tollHandler = new TollHandler(controler.getScenario());

    final CongestionTollTimeDistanceTravelDisutilityFactory factory =
        new CongestionTollTimeDistanceTravelDisutilityFactory(
            new RandomizingTimeDistanceTravelDisutilityFactory(
                TransportMode.car, controler.getConfig().planCalcScore()),
            tollHandler,
            controler.getConfig().planCalcScore());
    factory.setSigma(3.);

    controler.addOverridingModule(
        new AbstractModule() {
          @Override
          public void install() {
            this.bindCarTravelDisutilityFactory().toInstance(factory);
          }
        });

    controler.addControlerListener(
        new MarginalCongestionPricingContolerListener(
            controler.getScenario(),
            tollHandler,
            new CongestionHandlerImplV3(controler.getEvents(), controler.getScenario())));
    controler.addOverridingModule(new OTFVisFileWriterModule());
    controler
        .getConfig()
        .controler()
        .setOverwriteFileSetting(
            OutputDirectoryHierarchy.OverwriteFileSetting.deleteDirectoryIfExists);
    controler.run();
  }
  // test if a delayed arrival at the last activity results in the right monetary amount
  @Test
  public final void test2() {

    String configFile =
        testUtils.getPackageInputDirectory() + "AdvancedMarginalCongestionPricingTest/config2.xml";

    Config config = ConfigUtils.loadConfig(configFile);
    config.plansCalcRoute().setInsertingAccessEgressWalk(false);

    final Scenario scenario = ScenarioUtils.loadScenario(config);
    Controler controler = new Controler(scenario);

    EventsManager events = controler.getEvents();

    final List<CongestionEvent> congestionEvents = new ArrayList<CongestionEvent>();
    final List<PersonMoneyEvent> moneyEvents = new ArrayList<PersonMoneyEvent>();

    events.addHandler(
        new CongestionEventHandler() {

          @Override
          public void reset(int iteration) {}

          @Override
          public void handleEvent(CongestionEvent event) {
            congestionEvents.add(event);
          }
        });

    events.addHandler(
        new PersonMoneyEventHandler() {

          @Override
          public void reset(int iteration) {}

          @Override
          public void handleEvent(PersonMoneyEvent event) {
            moneyEvents.add(event);
          }
        });

    final TollHandler tollHandler = new TollHandler(controler.getScenario());
    final TollDisutilityCalculatorFactory tollDisutilityCalculatorFactory =
        new TollDisutilityCalculatorFactory(tollHandler, controler.getConfig().planCalcScore());
    controler.addOverridingModule(
        new AbstractModule() {
          @Override
          public void install() {
            addControlerListenerBinding()
                .toProvider(
                    new Provider<ControlerListener>() {
                      @Inject Scenario scenario;
                      @Inject EventsManager eventsManager;

                      @Override
                      public ControlerListener get() {
                        return new AdvancedMarginalCongestionPricingContolerListener(
                            scenario,
                            tollHandler,
                            new CongestionHandlerImplV3(eventsManager, (MutableScenario) scenario));
                      }
                    });
            bindCarTravelDisutilityFactory().toInstance(tollDisutilityCalculatorFactory);
          }
        });
    controler.addOverridingModule(new OTFVisFileWriterModule());
    controler
        .getConfig()
        .controler()
        .setOverwriteFileSetting(
            OutputDirectoryHierarchy.OverwriteFileSetting.overwriteExistingFiles);
    controler.run();

    // test if there is only one congestion event and only one money event
    Assert.assertEquals("Wrong number of congestion events.", 1, congestionEvents.size());
    Assert.assertEquals("Wrong number of money events.", 1, moneyEvents.size());

    // test if the delay is 2 seconds
    double delay = congestionEvents.get(0).getDelay();
    Assert.assertEquals("Wrong delay.", 2.0, delay, MatsimTestUtils.EPSILON);

    double amountFromEvent = moneyEvents.get(0).getAmount();
    double tripDelayDisutility =
        delay
            / 3600.
            * controler
                .getConfig()
                .planCalcScore()
                .getModes()
                .get(TransportMode.car)
                .getMarginalUtilityOfTraveling()
            * (-1);

    // home duration morning: 28800.
    // home duration evening with delay: (24 * 3600.) - 57705.
    // home duration evening without delay: (24 * 3600.) - 57703.

    // with delay --> 80.581739442040600
    // without delay --> 80.584243964094500

    double activityDelayDisutility = 80.584243964094500 - 80.581739442040600;
    double amount =
        (-1)
            * (activityDelayDisutility + tripDelayDisutility)
            / controler.getConfig().planCalcScore().getMarginalUtilityOfMoney();
    Assert.assertEquals("Wrong amount.", amount, amountFromEvent, MatsimTestUtils.EPSILON);
  }
  @Override
  public void notifyStartup(StartupEvent event) {
    Controler controler = event.getControler();

    // compute or read maxDCScore but do not add it to the context:
    // context can then be given to scoring classes both during regular scoring and in
    // pre-processing
    ReadOrComputeMaxDCScore computer = new ReadOrComputeMaxDCScore(dcContext);
    computer.readOrCreateMaxDCScore(controler, dcContext.kValsAreRead());
    this.personsMaxDCScoreUnscaled = computer.getPersonsMaxEpsUnscaled();

    for (String actType : this.dcContext.getFlexibleTypes()) {
      controler.addControlerListener(
          new DistanceStats(
              controler.getConfig(), "best", actType, dcContext.getConverter(), TransportMode.car));
      controler.addControlerListener(
          new DistanceStats(
              controler.getConfig(), "best", actType, dcContext.getConverter(), TransportMode.pt));
      controler.addControlerListener(
          new DistanceStats(
              controler.getConfig(),
              "best",
              actType,
              dcContext.getConverter(),
              TransportMode.bike));
      controler.addControlerListener(
          new DistanceStats(
              controler.getConfig(),
              "best",
              actType,
              dcContext.getConverter(),
              TransportMode.walk));
      controler.addControlerListener(
          new DistanceStats(
              controler.getConfig(),
              "best",
              actType,
              dcContext.getConverter(),
              TransportMode.other));
      controler.addControlerListener(
          new DistanceStats(
              controler.getConfig(),
              "best",
              actType,
              dcContext.getConverter(),
              TransportMode.ride));
      controler.addControlerListener(
          new DistanceStats(
              controler.getConfig(),
              "best",
              actType,
              dcContext.getConverter(),
              TransportMode.transit_walk));
    }
    MaxDCScoreWrapper dcScore = new MaxDCScoreWrapper();
    dcScore.setPersonsMaxDCScoreUnscaled(personsMaxDCScoreUnscaled);
    controler
        .getScenario()
        .addScenarioElement(DestinationChoiceBestResponseContext.ELEMENT_NAME, dcContext);
    controler.getScenario().addScenarioElement(MaxDCScoreWrapper.ELEMENT_NAME, dcScore);

    log.info("dc initialized");
  }
  public static void main(final String[] args) {
    final String configFile = args[0];

    // This allows to get a log file containing the log messages happening
    // before controler init.
    OutputDirectoryLogging.catchLogEntries();

    // This is the location choice MultiNodeDijkstra.
    // Suppress all log messages of level below error --- to avoid spaming the config
    // file with zillions of "not route found" messages.
    Logger.getLogger(org.matsim.core.router.MultiNodeDijkstra.class)
        .setLevel(Level.ERROR); // this is location choice
    Logger.getLogger(org.matsim.pt.router.MultiNodeDijkstra.class).setLevel(Level.ERROR);

    final Config config =
        ConfigUtils.loadConfig(
            configFile,
            // this adds a new config group, used by the specific scoring function
            // we use

            new KtiLikeScoringConfigGroup());

    // This is currently needed for location choice: initializing
    // the location choice writes K-values files to the output directory, which:
    // - fails if the directory does not exist
    // - makes the controler crash latter if the unsafe setOverwriteFiles( true )
    // is not called.
    // This ensures that we get safety with location choice working as expected,
    // before we sort this out and definitely kick out setOverwriteFiles.
    createEmptyDirectoryOrFailIfExists(config.controler().getOutputDirectory());

    OneWayCarsharingRDConfigGroup configGroup = new OneWayCarsharingRDConfigGroup();
    config.addModule(configGroup);

    FreeFloatingConfigGroup configGroupff = new FreeFloatingConfigGroup();
    config.addModule(configGroupff);

    TwoWayCSConfigGroup configGrouptw = new TwoWayCSConfigGroup();
    config.addModule(configGrouptw);

    AllCSModesConfigGroup configGroupAll = new AllCSModesConfigGroup();
    config.addModule(configGroupAll);

    final Scenario scenario = ScenarioUtils.loadScenario(config);

    final Controler controler = new Controler(scenario);
    controler
        .getConfig()
        .controler()
        .setOverwriteFileSetting(
            true
                ? OutputDirectoryHierarchy.OverwriteFileSetting.overwriteExistingFiles
                : OutputDirectoryHierarchy.OverwriteFileSetting.failIfDirectoryExists);

    Set<String> modes = new TreeSet<String>();
    modes.add("freefloating");
    modes.add("twowaycarsharing");
    modes.add("onewaycarsharing");
    modes.add("car");
    modes.add("walk");
    modes.add("pt");
    modes.add("bike");
    TripsAnalyzer tripsAnalyzer =
        new TripsAnalyzer(
            controler.getConfig().getParam("controler", "outputDirectory") + "/tripsFile",
            controler.getConfig().getParam("controler", "outputDirectory") + "/durationsFile",
            controler.getConfig().getParam("controler", "outputDirectory") + "/distancesFile",
            modes,
            true,
            controler.getScenario().getNetwork());

    controler.addControlerListener(tripsAnalyzer);

    controler.addControlerListener(
        new AllCSModesTestListener(
            controler,
            Integer.parseInt(
                controler.getConfig().getModule("AllCSModes").getValue("statsWriterFrequency"))));

    controler.addOverridingModule(
        new AbstractModule() {
          @Override
          public void install() {
            bindMobsim().toProvider(AllCSModesQsimFactory.class);
          }
        });

    controler.addOverridingModule(
        new AbstractModule() {

          @Override
          public void install() {

            addRoutingModuleBinding("twowaycarsharing").toInstance(new TwoWayCSRoutingModule());
            addRoutingModuleBinding("freefloating").toInstance(new FreeFloatingRoutingModule());
            addRoutingModuleBinding("onewaycarsharing")
                .toInstance(new OneWayCarsharingRDRoutingModule());

            bind(MainModeIdentifier.class)
                .toInstance(
                    new MainModeIdentifier() {

                      final MainModeIdentifier defaultModeIdentifier = new MainModeIdentifierImpl();

                      @Override
                      public String identifyMainMode(List<? extends PlanElement> tripElements) {

                        for (PlanElement pe : tripElements) {
                          if (pe instanceof Leg
                              && ((Leg) pe).getMode().equals("twowaycarsharing")) {
                            return "twowaycarsharing";
                          } else if (pe instanceof Leg
                              && ((Leg) pe).getMode().equals("onewaycarsharing")) {
                            return "onewaycarsharing";
                          } else if (pe instanceof Leg
                              && ((Leg) pe).getMode().equals("freefloating")) {
                            return "freefloating";
                          }
                        }
                        // if the trip doesn't contain a carsharing leg,
                        // fall back to the default identification method.
                        return defaultModeIdentifier.identifyMainMode(tripElements);
                      }
                    });
          }
        });

    connectFacilitiesWithNetwork(controler);

    initializeLocationChoice(controler);

    // We use a specific scoring function, that uses individual preferences
    // for activity durations.
    controler.setScoringFunctionFactory(
        new CarsharingMATSimLectureScoringFunctionFactory(
            controler.getScenario(),
            new StageActivityTypesImpl(PtConstants.TRANSIT_ACTIVITY_TYPE)));

    controler.run();
  }
示例#18
0
  /*
   * Tests if different travel disutility factories result in the same outcome.
   *
   */
  @Ignore
  @Test
  public final void test3() {

    String configFile1 = testUtils.getPackageInputDirectory() + "CNTest/config1.xml";

    // 1:

    Config config1 = ConfigUtils.loadConfig(configFile1);
    String outputDirectory1 = testUtils.getOutputDirectory() + "a";
    config1.controler().setOutputDirectory(outputDirectory1);

    Scenario scenario1 = ScenarioUtils.loadScenario(config1);
    Controler controler1 = new Controler(scenario1);

    TollHandler tollHandler1 = new TollHandler(scenario1);

    final CongestionTollTimeDistanceTravelDisutilityFactory factory1 =
        new CongestionTollTimeDistanceTravelDisutilityFactory(
            new RandomizingTimeDistanceTravelDisutilityFactory(
                TransportMode.car, config1.planCalcScore()),
            tollHandler1,
            config1.planCalcScore());
    factory1.setSigma(0.);
    factory1.setBlendFactor(0.1);

    controler1.addOverridingModule(
        new AbstractModule() {
          @Override
          public void install() {
            this.bindCarTravelDisutilityFactory().toInstance(factory1);
          }
        });

    controler1.addControlerListener(
        new MarginalCongestionPricingContolerListener(
            controler1.getScenario(),
            tollHandler1,
            new CongestionHandlerImplV3(controler1.getEvents(), controler1.getScenario())));
    controler1.addOverridingModule(new OTFVisFileWriterModule());
    controler1
        .getConfig()
        .controler()
        .setOverwriteFileSetting(
            OutputDirectoryHierarchy.OverwriteFileSetting.deleteDirectoryIfExists);
    controler1.run();

    // 2: "deprecated way"

    Config config2 = ConfigUtils.loadConfig(configFile1);
    String outputDirectory2 = testUtils.getOutputDirectory() + "b";
    config2.controler().setOutputDirectory(outputDirectory2);

    Scenario scenario2 = ScenarioUtils.loadScenario(config2);
    Controler controler2 = new Controler(scenario2);

    TollHandler tollHandler2 = new TollHandler(scenario2);

    final TollDisutilityCalculatorFactory factory2 =
        new TollDisutilityCalculatorFactory(tollHandler2, config2.planCalcScore());
    controler2.addOverridingModule(
        new AbstractModule() {
          @Override
          public void install() {
            bindCarTravelDisutilityFactory().toInstance(factory2);
          }
        });

    controler2.addControlerListener(
        new MarginalCongestionPricingContolerListener(
            controler2.getScenario(),
            tollHandler2,
            new CongestionHandlerImplV3(controler2.getEvents(), controler2.getScenario())));
    controler2.addOverridingModule(new OTFVisFileWriterModule());
    controler2
        .getConfig()
        .controler()
        .setOverwriteFileSetting(
            OutputDirectoryHierarchy.OverwriteFileSetting.deleteDirectoryIfExists);
    controler2.run();

    // compare

    LinkDemandEventHandler handler1 = analyzeEvents(outputDirectory1, configFile1); // a
    System.out.println("Bottleneck demand - (a): " + getBottleneckDemand(handler1)); // a

    LinkDemandEventHandler handler2 = analyzeEvents(outputDirectory2, configFile1); // b
    System.out.println("Bottleneck demand - (b): " + getBottleneckDemand(handler2)); // b

    Assert.assertEquals(
        "run a and b should result in the exact same outcome (without accounting for randomness!)",
        true,
        getBottleneckDemand(handler1) == getBottleneckDemand(handler2));
  }
示例#19
0
  public static void main(String[] args) {

    //		SubpopulationConfig subPopConfig = new SubpopulationConfig();
    //		subPopConfig.run();
    //		Config config = subPopConfig.getPatnaConfig();
    Config config = ConfigUtils.loadConfig(args[0]);
    Scenario sc = ScenarioUtils.loadScenario(config);

    sc.getConfig().qsim().setUseDefaultVehicles(false);
    ((ScenarioImpl) sc).createVehicleContainer();

    Map<String, VehicleType> modesType = new HashMap<String, VehicleType>();
    VehicleType slum_car =
        VehicleUtils.getFactory().createVehicleType(Id.create("slum_car", VehicleType.class));
    slum_car.setMaximumVelocity(60.0 / 3.6);
    slum_car.setPcuEquivalents(1.0);
    modesType.put("slum_car", slum_car);
    sc.getVehicles().addVehicleType(slum_car);

    VehicleType nonSlum_car =
        VehicleUtils.getFactory().createVehicleType(Id.create("nonSlum_car", VehicleType.class));
    nonSlum_car.setMaximumVelocity(60.0 / 3.6);
    nonSlum_car.setPcuEquivalents(1.0);
    modesType.put("nonSlum_car", nonSlum_car);
    sc.getVehicles().addVehicleType(nonSlum_car);

    VehicleType slum_motorbike =
        VehicleUtils.getFactory().createVehicleType(Id.create("slum_motorbike", VehicleType.class));
    slum_motorbike.setMaximumVelocity(60.0 / 3.6);
    slum_motorbike.setPcuEquivalents(0.25);
    modesType.put("slum_motorbike", slum_motorbike);
    sc.getVehicles().addVehicleType(slum_motorbike);

    VehicleType nonSlum_motorbike =
        VehicleUtils.getFactory()
            .createVehicleType(Id.create("nonSlum_motorbike", VehicleType.class));
    nonSlum_motorbike.setMaximumVelocity(60.0 / 3.6);
    nonSlum_motorbike.setPcuEquivalents(0.25);
    modesType.put("nonSlum_motorbike", nonSlum_motorbike);
    sc.getVehicles().addVehicleType(nonSlum_motorbike);

    VehicleType slum_bike =
        VehicleUtils.getFactory().createVehicleType(Id.create("slum_bike", VehicleType.class));
    slum_bike.setMaximumVelocity(15.0 / 3.6);
    slum_bike.setPcuEquivalents(0.25);
    modesType.put("slum_bike", slum_bike);
    sc.getVehicles().addVehicleType(slum_bike);

    VehicleType nonSlum_bike =
        VehicleUtils.getFactory().createVehicleType(Id.create("nonSlum_bike", VehicleType.class));
    nonSlum_bike.setMaximumVelocity(15.0 / 3.6);
    nonSlum_bike.setPcuEquivalents(0.25);
    modesType.put("nonSlum_bike", nonSlum_bike);
    sc.getVehicles().addVehicleType(nonSlum_bike);

    VehicleType slum_walk =
        VehicleUtils.getFactory().createVehicleType(Id.create("slum_walk", VehicleType.class));
    slum_walk.setMaximumVelocity(1.5);
    //		walk.setPcuEquivalents(0.10);
    modesType.put("slum_walk", slum_walk);
    sc.getVehicles().addVehicleType(slum_walk);

    VehicleType nonSlum_walk =
        VehicleUtils.getFactory().createVehicleType(Id.create("nonSlum_walk", VehicleType.class));
    nonSlum_walk.setMaximumVelocity(1.5);
    //		walk.setPcuEquivalents(0.10);
    modesType.put("nonSlum_walk", nonSlum_walk);
    sc.getVehicles().addVehicleType(nonSlum_walk);

    VehicleType slum_pt =
        VehicleUtils.getFactory().createVehicleType(Id.create("slum_pt", VehicleType.class));
    slum_pt.setMaximumVelocity(40 / 3.6);
    //		pt.setPcuEquivalents(5);
    modesType.put("slum_pt", slum_pt);
    sc.getVehicles().addVehicleType(slum_pt);

    VehicleType nonSlum_pt =
        VehicleUtils.getFactory().createVehicleType(Id.create("nonSlum_pt", VehicleType.class));
    nonSlum_pt.setMaximumVelocity(40 / 3.6);
    //		pt.setPcuEquivalents(5);
    modesType.put("nonSlum_pt", nonSlum_pt);
    sc.getVehicles().addVehicleType(nonSlum_pt);

    for (Person p : sc.getPopulation().getPersons().values()) {
      Id<Vehicle> vehicleId = Id.create(p.getId(), Vehicle.class);
      String travelMode = null;
      for (PlanElement pe : p.getSelectedPlan().getPlanElements()) {
        if (pe instanceof Leg) {
          travelMode = ((Leg) pe).getMode();
          break;
        }
      }
      Vehicle vehicle =
          VehicleUtils.getFactory().createVehicle(vehicleId, modesType.get(travelMode));
      sc.getVehicles().addVehicle(vehicle);
    }

    final Controler controler = new Controler(sc);

    //		IOUtils.deleteDirectory(new File(controler.getConfig().controler().getOutputDirectory()));
    controler
        .getConfig()
        .controler()
        .setOverwriteFileSetting(
            true
                ? OutputDirectoryHierarchy.OverwriteFileSetting.overwriteExistingFiles
                : OutputDirectoryHierarchy.OverwriteFileSetting.failIfDirectoryExists);
    controler.setDumpDataAtEnd(true);
    controler.getConfig().controler().setCreateGraphs(true);

    controler.addOverridingModule(
        new AbstractModule() {
          @Override
          public void install() {
            addPlanStrategyBinding("ChangeLegMode_slum")
                .toProvider(
                    new javax.inject.Provider<PlanStrategy>() {
                      String[] availableModes_slum = {
                        "slum_bike", "slum_motorbike", "slum_pt", "slum_walk"
                      };

                      @Override
                      public PlanStrategy get() {
                        final Builder builder = new Builder(new RandomPlanSelector<Plan, Person>());
                        builder.addStrategyModule(
                            new ChangeLegMode(
                                controler.getConfig().global().getNumberOfThreads(),
                                availableModes_slum,
                                true));
                        builder.addStrategyModule(new ReRoute(controler.getScenario()));
                        return builder.build();
                      }
                    });
          }
        });

    controler.addOverridingModule(
        new AbstractModule() {
          @Override
          public void install() {
            addPlanStrategyBinding("ChangeLegMode_nonSlum")
                .toProvider(
                    new javax.inject.Provider<PlanStrategy>() {
                      String[] availableModes_nonSlum = {
                        "nonSlum_car",
                        "nonSlum_bike",
                        "nonSlum_motorbike",
                        "nonSlum_pt",
                        "nonSlum_walk"
                      };

                      @Override
                      public PlanStrategy get() {
                        final Builder builder = new Builder(new RandomPlanSelector<Plan, Person>());
                        builder.addStrategyModule(
                            new ChangeLegMode(
                                controler.getConfig().global().getNumberOfThreads(),
                                availableModes_nonSlum,
                                true));
                        builder.addStrategyModule(new ReRoute(controler.getScenario()));
                        return builder.build();
                      }
                    });
          }
        });

    //		controler.setScoringFunctionFactory(new
    // SubPopulationScoringFactory(controler.getScenario()));
    controler.run();
  }
 public ParkAndRideInvalidateStartTimes(final Controler controler) {
   super(controler.getConfig().global());
 }
  // test if the right number of money events are thrown
  @Test
  public final void test4() {

    String configFile =
        testUtils.getPackageInputDirectory() + "AdvancedMarginalCongestionPricingTest/config4.xml";

    Config config = ConfigUtils.loadConfig(configFile);
    config.plansCalcRoute().setInsertingAccessEgressWalk(false);

    final Scenario scenario = ScenarioUtils.loadScenario(config);
    Controler controler = new Controler(scenario);

    EventsManager events = controler.getEvents();

    final List<CongestionEvent> congestionEvents = new ArrayList<CongestionEvent>();
    final List<PersonMoneyEvent> moneyEvents = new ArrayList<PersonMoneyEvent>();

    events.addHandler(
        new CongestionEventHandler() {

          @Override
          public void reset(int iteration) {}

          @Override
          public void handleEvent(CongestionEvent event) {
            congestionEvents.add(event);
          }
        });

    events.addHandler(
        new PersonMoneyEventHandler() {

          @Override
          public void reset(int iteration) {}

          @Override
          public void handleEvent(PersonMoneyEvent event) {
            moneyEvents.add(event);
          }
        });

    final TollHandler tollHandler = new TollHandler(controler.getScenario());
    final TollDisutilityCalculatorFactory tollDisutilityCalculatorFactory =
        new TollDisutilityCalculatorFactory(tollHandler, controler.getConfig().planCalcScore());
    controler.addOverridingModule(
        new AbstractModule() {
          @Override
          public void install() {
            addControlerListenerBinding()
                .toProvider(
                    new Provider<ControlerListener>() {
                      @Inject Scenario scenario;
                      @Inject EventsManager eventsManager;

                      @Override
                      public ControlerListener get() {
                        return new AdvancedMarginalCongestionPricingContolerListener(
                            scenario,
                            tollHandler,
                            new CongestionHandlerImplV3(eventsManager, (MutableScenario) scenario));
                      }
                    });
            bindCarTravelDisutilityFactory().toInstance(tollDisutilityCalculatorFactory);
          }
        });
    controler.addOverridingModule(new OTFVisFileWriterModule());
    controler
        .getConfig()
        .controler()
        .setOverwriteFileSetting(
            OutputDirectoryHierarchy.OverwriteFileSetting.overwriteExistingFiles);
    controler.run();

    // test if there are three congestion events and three money events
    Assert.assertEquals("Wrong number of congestion events.", 3, congestionEvents.size());
    Assert.assertEquals("Wrong number of money events.", 3, moneyEvents.size());
  }
  public static void main(String[] args) {
    Config config = ConfigUtils.createConfig();
    config.controler().setLastIteration(0);
    config.controler().setOutputDirectory("./freespeed-output");
    config.controler().setMobsim(MobsimType.JDEQSim.toString());
    // config.controler().setMobsim("DoNothing");
    config.global().setCoordinateSystem("EPSG:3395");
    config.global().setNumberOfThreads(8);
    config.controler().setWriteSnapshotsInterval(5);
    //		config.getQSimConfigGroup().setStorageCapFactor(100);
    //		config.getQSimConfigGroup().setFlowCapFactor(100);
    //		config.getQSimConfigGroup().setSnapshotStyle(QSimConfigGroup.SNAPSHOT_AS_QUEUE);
    //		config.getQSimConfigGroup().setRemoveStuckVehicles(false);
    //		config.getQSimConfigGroup().setNumberOfThreads(8);
    //		config.getQSimConfigGroup().setEndTime(27*60*60);
    config.plansCalcRoute().setTeleportedModeSpeed("other", 5.0 / 3.6); // 5 km/h beeline
    config.plansCalcRoute().setBeelineDistanceFactor(1.0);
    config.plansCalcRoute().setNetworkModes(Arrays.asList("car"));
    config.controler().setWriteEventsInterval(10);
    ActivityParams sighting = new ActivityParams("sighting");
    // sighting.setOpeningTime(0.0);
    // sighting.setClosingTime(0.0);
    sighting.setTypicalDuration(30.0 * 60);
    config.planCalcScore().addActivityParams(sighting);
    config
        .planCalcScore()
        .getModes()
        .get(TransportMode.car)
        .setMarginalUtilityOfTraveling((double) 0);
    config.planCalcScore().getModes().get(TransportMode.car).setConstant((double) 0);
    config.planCalcScore().getModes().get(TransportMode.car).setMonetaryDistanceRate((double) 0);
    // config.planCalcScore().setWriteExperiencedPlans(true);
    config.setParam("JDEQSim", "flowCapacityFactor", "100");
    config.setParam("JDEQSim", "storageCapacityFactor", "100");
    double endTime = 60 * 60 * 32;
    config.setParam("JDEQSim", "endTime", Double.toString(endTime));

    Scenario scenario = ScenarioUtils.createScenario(config);
    new MatsimNetworkReader(scenario).readFile("/Users/zilske/d4d/output/network.xml");
    AltPopulationReaderMatsimV5 altPopulationReaderMatsimV5 =
        new AltPopulationReaderMatsimV5(scenario);
    //	altPopulationReaderMatsimV5.readFile("/Users/zilske/d4d/output/population.xml");
    altPopulationReaderMatsimV5.readFile("/Users/zilske/d4d/output/population-capital-only.xml");
    ParallelPersonAlgorithmRunner.run(
        scenario.getPopulation(),
        8,
        new PersonAlgorithm() {

          @Override
          public void run(Person person) {
            PlanUtils.insertLinkIdsIntoGenericRoutes(person.getSelectedPlan());
          }
        });

    //		ParallelPersonAlgorithmRunner.run(scenario.getPopulation(), 8, new PersonAlgorithm() {
    //
    //			@Override
    //			public void run(Person person) {
    //				Plan plan = person.getSelectedPlan();
    //				for (int i = 0; i < plan.getPlanElements().size()-2; i++) {
    //					PlanElement pe = plan.getPlanElements().get(i);
    //					if (pe instanceof Activity) {
    //						Activity activity = (Activity) pe;
    //						Leg leg = (Leg) plan.getPlanElements().get(i+1);
    //						Activity nextActivity = (Activity) plan.getPlanElements().get(i+2);
    //						double earliest = activity.getEndTime();
    //						double latest = nextActivity.getEndTime() - leg.getTravelTime();
    //						activity.setEndTime(earliest + MatsimRandom.getRandom().nextDouble() * (latest -
    // earliest));
    //					}
    //				}
    //			}
    //
    //		});

    Controler controler = new Controler(scenario);
    controler
        .getConfig()
        .controler()
        .setOverwriteFileSetting(
            true
                ? OutputDirectoryHierarchy.OverwriteFileSetting.overwriteExistingFiles
                : OutputDirectoryHierarchy.OverwriteFileSetting.failIfDirectoryExists);
    controler.run();
  }
  public void CreateChoiceSets() {

    PopulationFactory populationFactory = population.getFactory();
    ArrayList<Person> newPersons = new ArrayList<>();

    /*Clean routes*/
    PlanRouteStripper planRouteStripper = new PlanRouteStripper();
    planRouteStripper.run(population);

    for (Id<Person> personId : population.getPersons().keySet()) {

      Plan plan = population.getPersons().get(personId).getSelectedPlan();
      plan.getCustomAttributes()
          .put(
              "toll",
              population
                  .getPersonAttributes()
                  .getAttribute(personId.toString(), "selectedPlanToll"));
      initialPlans.put(personId, plan);

      population.getPersons().get(personId).createCopyOfSelectedPlanAndMakeSelected();

      Plan planTmp = population.getPersons().get(personId).getSelectedPlan();
      population.getPersons().get(personId).getPlans().clear();
      population.getPersons().get(personId).addPlan(planTmp);
    }

    /*Create optimal walk plan and substitute it in the planMap*/
    OptimalWalkPlanFinder optimalWalkPlanFinder = new OptimalWalkPlanFinder(controler.getConfig());

    for (Id<Person> personId : population.getPersons().keySet()) {

      /* Plan cloning for each mode*/
      HashMap<String, Plan> planMap = new HashMap<>();

      Leg firstLeg =
          (Leg) population.getPersons().get(personId).getSelectedPlan().getPlanElements().get(1);
      String initialMode = firstLeg.getMode();

      // If "No PT"
      if (initialMode == "pt" && simType.equals("noPT")) initialMode = "walk";

      planMap.put(initialMode, population.getPersons().get(personId).getSelectedPlan());

      // String[] modes =
      // controler.getScenario().getConfig().getModule("subtourModeChoice").getValue("modes").split(",");
      // String[] modes = {"car","walk"};

      ArrayList<String> relevantModes = new ArrayList<String>();
      relevantModes.add("car");
      if (!simType.equals("carOnly") && !simType.equals("noPT")) relevantModes.add("pt");

      for (String mode : relevantModes) {
        if (!initialMode.equals(mode) && !mode.equals("walk")) {
          population.getPersons().get(personId).createCopyOfSelectedPlanAndMakeSelected();
          Plan planForModeChange = population.getPersons().get(personId).getSelectedPlan();

          for (int j = 1; j < planForModeChange.getPlanElements().size(); j += 2) {
            Leg leg = (Leg) planForModeChange.getPlanElements().get(j);
            leg.setMode(mode);
          }

          planMap.put(mode, planForModeChange);
        }
      }

      /*Check if walk is a viable alternative and if so, add it to the choice set*/
      if (!initialMode.equals("walk")
          && optimalWalkPlanFinder.getWalkTravelTime(planMap.get(initialMode)) <= 3600.0
          && !simType.equals("carOnly")) {
        population.getPersons().get(personId).createCopyOfSelectedPlanAndMakeSelected();
        Plan planForModeChange = population.getPersons().get(personId).getSelectedPlan();
        planForModeChange = optimalWalkPlanFinder.findOptimalWalkPlan(planForModeChange);
        for (int j = 1; j < planForModeChange.getPlanElements().size(); j += 2) {
          Leg leg = (Leg) planForModeChange.getPlanElements().get(j);
          leg.setMode("walk");
        }

        planMap.put("walk", planForModeChange);
      }
      ;

      // String[] relevantModes = {"car","pt"};

      /* Departure time modification for each mode*/
      for (String mode : relevantModes) {
        Plan basePlan = planMap.get(mode);
        population.getPersons().get(personId).setSelectedPlan(basePlan);

        for (int i = 0; i < 6; i++) {
          population.getPersons().get(personId).createCopyOfSelectedPlanAndMakeSelected();
        }

        population.getPersons().get(personId).setSelectedPlan(basePlan);

        int planModCounter = 0;
        /* Departure time modification */
        for (Plan planToModify : population.getPersons().get(personId).getPlans()) {

          if (((Leg) planToModify.getPlanElements().get(1)).getMode().equals(mode)
              && !PersonUtils.isSelected(planToModify)) {

            // Home departure time + 1h
            if (planModCounter == 0) {
              Activity act = (Activity) planToModify.getPlanElements().get(0);
              act.setEndTime(act.getEndTime() + 3600.0);
            }

            // Home departure time - 1h
            if (planModCounter == 1) {
              Activity act = (Activity) planToModify.getPlanElements().get(0);
              act.setEndTime(act.getEndTime() - 3600.0);
            }

            // Work departure time + 1h
            if (planModCounter == 2) {
              Activity act = (Activity) planToModify.getPlanElements().get(2);
              act.setEndTime(act.getEndTime() + 3600.0);
            }

            // Work departure time - 1h
            if (planModCounter == 3) {
              Activity act = (Activity) planToModify.getPlanElements().get(2);
              act.setEndTime(act.getEndTime() - 3600.0);
            }

            // Home departure time + 1h, Work departure time +1h
            if (planModCounter == 4) {
              Activity act = (Activity) planToModify.getPlanElements().get(0);
              act.setEndTime(act.getEndTime() + 3600.0);

              Activity act2 = (Activity) planToModify.getPlanElements().get(2);
              act2.setEndTime(act2.getEndTime() + 3600.0);
            }

            // Home departure time - 1h, Work departure time -1h
            if (planModCounter == 5) {
              Activity act = (Activity) planToModify.getPlanElements().get(0);
              act.setEndTime(act.getEndTime() - 3600.0);

              Activity act2 = (Activity) planToModify.getPlanElements().get(2);
              act2.setEndTime(act2.getEndTime() - 3600.0);
            }

            //                      NOT REALISTIC
            //						//Home departure time +1h, Work departure time -1h
            //						if (planModCounter == 6) {
            //							Activity act = (Activity) planToModify.getPlanElements().get(0);
            //							act.setEndTime(act.getEndTime() + 3600.0);
            //
            //							Activity act2 = (Activity) planToModify.getPlanElements().get(2);
            //							act2.setEndTime(act2.getEndTime() - 3600.0);
            //						}
            //
            //						//Home departure time - 1h, Work departure time +1h
            //						if (planModCounter == 7) {
            //							Activity act = (Activity) planToModify.getPlanElements().get(0);
            //							act.setEndTime(act.getEndTime() - 3600.0);
            //
            //							Activity act2 = (Activity) planToModify.getPlanElements().get(2);
            //							act2.setEndTime(act2.getEndTime() + 3600.0);
            //						}

            planModCounter++;
          }
        }
      }

      /*Plan split to different persons*/
      int count = 0;
      population.getPersons().get(personId).setSelectedPlan(planMap.get(initialMode));
      for (Plan newPlan : population.getPersons().get(personId).getPlans()) {
        if (personId.toString().equals("1000")) System.out.println();
        if (!PersonUtils.isSelected(newPlan)) {
          count++;
          Person newPerson =
              populationFactory.createPerson(Id.createPersonId(personId.toString() + "_" + count));
          newPerson.addPlan(newPlan);
          newPerson.setSelectedPlan(newPlan);
          newPersons.add(newPerson);
          population
              .getPersonAttributes()
              .putAttribute(
                  newPerson.getId().toString(),
                  "income",
                  population.getPersonAttributes().getAttribute(personId.toString(), "income"));
          population
              .getPersonAttributes()
              .putAttribute(
                  newPerson.getId().toString(),
                  "betaFactor",
                  population.getPersonAttributes().getAttribute(personId.toString(), "betaFactor"));
        }
      }

      /*Clear all plans from initial person*/
      //			population.getPersons().get(personId).getPlans().clear();
      //			population.getPersons().get(personId).addPlan(initialPlans.get(personId));
      //			population.getPersons().get(personId).setSelectedPlan(initialPlans.get(personId));

      /*Clear all plans from initial person*/
      population.getPersons().get(personId).getPlans().clear();

      Person tempPerson = population.getFactory().createPerson(Id.create(20000, Person.class));
      tempPerson.addPlan(initialPlans.get(personId));
      tempPerson.setSelectedPlan(initialPlans.get(personId));
      tempPerson.createCopyOfSelectedPlanAndMakeSelected();
      Plan tempPlan = tempPerson.getSelectedPlan();
      population.getPersons().get(personId).addPlan(tempPlan);
      population.getPersons().get(personId).setSelectedPlan(tempPlan);
    }

    /*Add new agents to the simulation*/
    for (Person newPerson : newPersons) {
      population.addPerson(newPerson);
    }

    /*Write out new population file*/
    //		System.out.println("New number of persons: " + population.getPersons().size());
    //		new org.matsim.core.population.PopulationWriter(population,
    // controler.getScenario().getNetwork()).write("/Volumes/DATA 1 (WD 2
    // TB)/output_SelectExp1_5p_"+simType+"_1000it_Dwell/popText.xml");

  }
示例#24
0
  public void run(ParkControl parkControl) {
    Controler controler = parkControl.controller;
    if (!parkControl.evUsage) {
      System.out.println("Iteration end stats does not work without EV usage");
      return;
    }

    LinkedList<Id> totEVDriving = new LinkedList<Id>();
    LinkedList<Id> totNEVDriving = new LinkedList<Id>();
    LinkedList<Id> totEVNotDriving = new LinkedList<Id>();
    LinkedList<Id> totNEVNotDriving = new LinkedList<Id>();
    LinkedList<Id> secEVDriving = new LinkedList<Id>();
    LinkedList<Id> secNEVDriving = new LinkedList<Id>();
    LinkedList<Id> secEVNotDriving = new LinkedList<Id>();
    LinkedList<Id> secNEVNotDriving = new LinkedList<Id>();
    LinkedList<Id> workEVDriving = new LinkedList<Id>();
    LinkedList<Id> workNEVDriving = new LinkedList<Id>();
    LinkedList<Id> workEVNotDriving = new LinkedList<Id>();
    LinkedList<Id> workNEVNotDriving = new LinkedList<Id>();
    LinkedList<Id> totCharged = new LinkedList<Id>();
    LinkedList<Id> workCharged = new LinkedList<Id>();
    LinkedList<Id> secCharged = new LinkedList<Id>();
    LinkedList<Id> totHadToCharge = new LinkedList<Id>();
    LinkedList<Id> workHadToCharge = new LinkedList<Id>();
    LinkedList<Id> secHadToCharge = new LinkedList<Id>();
    LinkedList<Id> totOutOfBattery = new LinkedList<Id>();
    LinkedList<Id> workOutOfBattery = new LinkedList<Id>();
    LinkedList<Id> secOutOfBattery = new LinkedList<Id>();
    LinkedList<Id> totEvNotParked = new LinkedList<Id>();
    LinkedList<Id> workEvNotParked = new LinkedList<Id>();
    LinkedList<Id> secEvNotParked = new LinkedList<Id>();
    LinkedList<Id> totNEvNotParked = new LinkedList<Id>();
    LinkedList<Id> workNEvNotParked = new LinkedList<Id>();
    LinkedList<Id> secNEvNotParked = new LinkedList<Id>();
    LinkedList<Id> totBrookingsEVsDriving = new LinkedList<Id>();
    LinkedList<Id> totBrookingsEVsNotDriving = new LinkedList<Id>();
    LinkedList<Id> workBrookingsEVsDriving = new LinkedList<Id>();
    LinkedList<Id> workBrookingsEVsNotDriving = new LinkedList<Id>();
    LinkedList<Id> secBrookingsEVsDriving = new LinkedList<Id>();
    LinkedList<Id> secBrookingsEVsNotDriving = new LinkedList<Id>();
    LinkedList<Id> totEVParkedAtHome = new LinkedList<Id>();
    LinkedList<Id> totNEVParkedAtHome = new LinkedList<Id>();
    LinkedList<Id> workEVParkedAtHome = new LinkedList<Id>();
    LinkedList<Id> workNEVParkedAtHome = new LinkedList<Id>();
    LinkedList<Id> secEVParkedAtHome = new LinkedList<Id>();
    LinkedList<Id> secNEVParkedAtHome = new LinkedList<Id>();

    VMCharts chart = new VMCharts();
    chart.addChart("Util vs Traveldistance");
    chart.setAx("Util vs Traveldistance", false);
    chart.setBox("Util vs Traveldistance", true);
    chart.setInterval("Util vs Traveldistance", 10000);
    chart.addSeries("Util vs Traveldistance", "NEV");
    chart.addSeries("Util vs Traveldistance", "EV");

    chart.addChart("Util vs Traveldistance EV");
    chart.setAx("Util vs Traveldistance EV", false);
    chart.setBox("Util vs Traveldistance EV", true);
    chart.setInterval("Util vs Traveldistance EV", 10000);
    chart.addSeries("Util vs Traveldistance EV", "EV");

    EVControl evControl = parkControl.evControl;

    for (Person person : controler.getScenario().getPopulation().getPersons().values()) {
      PersonImpl personImpl = (PersonImpl) person;
      double soc;
      boolean notParked = false;
      boolean parkedAtHome = false;
      PlanImpl planImpl = (PlanImpl) personImpl.getSelectedPlan();
      LegImpl legImpl = (LegImpl) planImpl.getNextLeg(planImpl.getFirstActivity());
      Id id = person.getId();
      LinkedList<ParkingSpot> selectedParkings = parkings.get(id);
      Activity firstAct = planImpl.getFirstActivity();
      String actType = planImpl.getNextActivity(legImpl).getType();
      ParkingSpot firstSelectedSpot;
      ParkingSpot homeSpot;
      String facId = firstAct.getFacilityId().toString();
      if (parkings.containsKey(id)) {
        firstSelectedSpot = selectedParkings.getFirst();
        homeSpot = selectedParkings.getLast();
      } else {
        firstSelectedSpot = new ParkingSpot();
        homeSpot = new ParkingSpot();
        notParked = true;
      }
      if (homeSpot != null
          && homeSpot.parking != null
          && homeSpot.parking.facilityActType != null) {
        if (homeSpot.parking.facilityActType.equals("home")) {
          parkedAtHome = true;
        }
      }

      if (evControl.hasEV(person.getId()) && firstSelectedSpot != null) {
        soc = evControl.stateOfChargePercentage(person.getId());
      } else soc = -150;

      double score = personImpl.getSelectedPlan().getScore();
      double distance = getPlanDistance(planImpl);
      if (score < 0) {
        score = -1;
      }
      if (evControl.hasEV(person.getId())) {
        VMCharts.addValues("Util vs Traveldistance", "EV", distance, score);
        VMCharts.addValues("Util vs Traveldistance EV", "EV", distance, score);
      } else {
        VMCharts.addValues("Util vs Traveldistance", "NEV", distance, score);
      }

      if (evControl.hasEV(person.getId())) {
        if (legImpl.getMode().equals("car")) {
          totEVDriving.add(id);
          if (facId.contains("B")) {
            totBrookingsEVsDriving.add(id);
          }
          if (firstSelectedSpot.charge) {
            totCharged.add(id);
          }
          if (soc < 50) {
            totHadToCharge.add(id);
          }
          if (soc < 0) {
            totOutOfBattery.add(id);
          }
          if (notParked) {
            totEvNotParked.add(id);
          }
          if (parkedAtHome) {
            totEVParkedAtHome.add(id);
          }
          if (actType.equals("work")) {
            workEVDriving.add(id);
            if (facId.contains("B")) {
              workBrookingsEVsDriving.add(id);
            }
            if (firstSelectedSpot.charge) {
              workCharged.add(id);
            }
            if (soc < 50) {
              workHadToCharge.add(id);
            }
            if (soc < 0) {
              workOutOfBattery.add(id);
            }
            if (notParked) {
              workEvNotParked.add(id);
            }
            if (parkedAtHome) {
              workEVParkedAtHome.add(id);
            }
          } else if (actType.equals("secondary")) {
            secEVDriving.add(id);
            if (facId.contains("B")) {
              secBrookingsEVsDriving.add(id);
            }
            if (firstSelectedSpot.charge) {
              secCharged.add(id);
            }
            if (soc < 50) {
              secHadToCharge.add(id);
            }
            if (soc < 0) {
              secOutOfBattery.add(id);
            }
            if (notParked) {
              secEvNotParked.add(id);
            }
            if (parkedAtHome) {
              secEVParkedAtHome.add(id);
            }
          }
        } else {
          totEVNotDriving.add(id);
          if (facId.contains("B")) {
            totBrookingsEVsNotDriving.add(id);
          }
          if (actType.equals("work")) {
            workEVNotDriving.add(id);
            if (facId.contains("B")) {
              workBrookingsEVsNotDriving.add(id);
            }
          } else if (actType.equals("secondary")) {
            secEVNotDriving.add(id);
            if (facId.contains("B")) {
              secBrookingsEVsNotDriving.add(id);
            }
          }
        }
      } else {
        if (legImpl.getMode().equals("car")) {
          totNEVDriving.add(id);
          if (notParked) {
            totNEvNotParked.add(id);
          }
          if (parkedAtHome) {
            totNEVParkedAtHome.add(id);
          }
          if (actType.equals("work")) {
            workNEVDriving.add(id);
            if (notParked) {
              workNEvNotParked.add(id);
            }
            if (parkedAtHome) {
              workNEVParkedAtHome.add(id);
            }
          } else if (actType.equals("secondary")) {
            secNEVDriving.add(id);
            if (notParked) {
              secNEvNotParked.add(id);
            }
            if (parkedAtHome) {
              secNEVParkedAtHome.add(id);
            }
          }
        } else {
          totNEVNotDriving.add(id);
          if (actType.equals("work")) {
            workNEVNotDriving.add(id);
          } else if (actType.equals("secondary")) {
            secNEVNotDriving.add(id);
          }
        }
      }
    }

    chart.addChart("Parkinglot occupancy");
    chart.setAx("Parkinglot occupancy", false);
    chart.setAxis("Parkinglot occupancy", "time", "occupancy [0..1]");
    chart.setLine("Parkinglot occupancy", true);
    for (Parking parking : parkControl.parkingMap.getParkings()) {
      if (parking.ocupancyStats == true) {
        chart.addSeries("Parkinglot occupancy", Integer.toString(parking.id) + "EV");
        chart.addSeries("Parkinglot occupancy", Integer.toString(parking.id) + "NEV");
        for (Double[] values : parking.occupancyList) {
          VMCharts.addValues(
              "Parkinglot occupancy", Integer.toString(parking.id) + "EV", values[0], values[1]);
          VMCharts.addValues(
              "Parkinglot occupancy", Integer.toString(parking.id) + "NEV", values[0], values[2]);
        }
      }
    }

    CSVWriter writer =
        new CSVWriter(
            controler.getConfig().getModule("controler").getValue("outputDirectory")
                + "/parkhistory/parkstats_"
                + controler.getIterationNumber());
    writer.writeLine("Total: ");
    writer.writeLine(
        "EVs in use: "
            + totEVDriving.size()
            + " ("
            + totBrookingsEVsDriving.size()
            + " Brookings)");
    writer.writeLine(
        "EVs not in use: "
            + totEVNotDriving.size()
            + " ("
            + totBrookingsEVsNotDriving.size()
            + " Brookings)");
    writer.writeLine("EVs not parked: " + totEvNotParked.size());
    writer.writeLine("EVs parked at home: " + totEVParkedAtHome.size());
    writer.writeLine("charged: " + totCharged.size());
    writer.writeLine("had to charge: " + totHadToCharge.size());
    writer.writeLine("out of battery: " + totOutOfBattery.size());
    writer.writeLine("NEVs in use: " + totNEVDriving.size());
    writer.writeLine("NEVs not in use: " + totNEVNotDriving.size());
    writer.writeLine("NEVs not parked: " + totNEvNotParked.size());
    writer.writeLine("NEVs parked at home: " + totNEVParkedAtHome.size());
    writer.writeLine("");
    writer.writeLine("Work: ");
    writer.writeLine(
        "EVs in use: "
            + workEVDriving.size()
            + " ("
            + workBrookingsEVsDriving.size()
            + " Brookings)");
    writer.writeLine(
        "EVs not in use: "
            + workEVNotDriving.size()
            + " ("
            + workBrookingsEVsNotDriving.size()
            + " Brookings)");
    writer.writeLine("EVs not parked: " + workEvNotParked.size());
    writer.writeLine("EVs parked at home: " + workEVParkedAtHome.size());
    writer.writeLine("charged: " + workCharged.size());
    writer.writeLine("had to charge: " + workHadToCharge.size());
    writer.writeLine("out of battery: " + workOutOfBattery.size());
    writer.writeLine("NEVs in use: " + workNEVDriving.size());
    writer.writeLine("NEVs not in use: " + workNEVNotDriving.size());
    writer.writeLine("NEVs not parked: " + workNEvNotParked.size());
    writer.writeLine("NEVs parked at home: " + workNEVParkedAtHome.size());
    writer.writeLine("");
    writer.writeLine("Secondary: ");
    writer.writeLine(
        "EVs in use: "
            + secEVDriving.size()
            + " ("
            + secBrookingsEVsDriving.size()
            + " Brookings)");
    writer.writeLine(
        "EVs not in use: "
            + secEVNotDriving.size()
            + " ("
            + secBrookingsEVsNotDriving.size()
            + " Brookings)");
    writer.writeLine("EVs not parked: " + secEvNotParked.size());
    writer.writeLine("EVs parked at home: " + secEVParkedAtHome.size());
    writer.writeLine("charged: " + secCharged.size());
    writer.writeLine("had to charge: " + secHadToCharge.size());
    writer.writeLine("out of battery: " + secOutOfBattery.size());
    writer.writeLine("NEVs in use: " + secNEVDriving.size());
    writer.writeLine("NEVs not in use: " + secNEVNotDriving.size());
    writer.writeLine("NEVs not parked: " + secNEvNotParked.size());
    writer.writeLine("NEVs parked at home: " + secNEVParkedAtHome.size());
    writer.writeLine("");

    writer.close();
  }
示例#25
0
 public static void main(String[] args) throws IOException, ClassNotFoundException {
   Config config = ConfigUtils.createConfig();
   ConfigUtils.loadConfig(config, args[0]);
   final Controler controler = new Controler(ScenarioUtils.loadScenario(config));
   if (args.length > 3) {
     final StopStopTimeCalculator stopStopTimeCalculatorEvents =
         new StopStopTimeCalculator(
             controler.getScenario().getTransitSchedule(),
             controler.getConfig().travelTimeCalculator().getTraveltimeBinSize(),
             (int)
                 (controler.getConfig().qsim().getEndTime()
                     - controler.getConfig().qsim().getStartTime()));
     stopStopTimeCalculatorEvents.setUseVehicleIds(false);
     EventsManager eventsManager = EventsUtils.createEventsManager(controler.getConfig());
     eventsManager.addHandler(stopStopTimeCalculatorEvents);
     (new MatsimEventsReader(eventsManager)).readFile(args[3]);
     controler.addOverridingModule(
         new AbstractModule() {
           @Override
           public void install() {
             bindMobsim()
                 .toProvider(
                     new Provider<Mobsim>() {
                       @Override
                       public Mobsim get() {
                         return new PTQSimFactory(stopStopTimeCalculatorEvents.getStopStopTimes())
                             .createMobsim(controler.getScenario(), controler.getEvents());
                       }
                     });
           }
         });
   } else
     controler.addOverridingModule(
         new AbstractModule() {
           @Override
           public void install() {
             bindMobsim()
                 .toProvider(
                     new Provider<Mobsim>() {
                       @Override
                       public Mobsim get() {
                         return new PTQSimFactory()
                             .createMobsim(controler.getScenario(), controler.getEvents());
                       }
                     });
           }
         });
   controler
       .getConfig()
       .controler()
       .setOverwriteFileSetting(
           true
               ? OutputDirectoryHierarchy.OverwriteFileSetting.overwriteExistingFiles
               : OutputDirectoryHierarchy.OverwriteFileSetting.failIfDirectoryExists);
   controler.addControlerListener(
       new CalibrationStatsListener(
           controler.getEvents(),
           new String[] {args[1], args[2]},
           1,
           "Travel Survey (Benchmark)",
           "Red_Scheme",
           new HashSet<Id<Person>>()));
   WaitTimeStuckCalculator waitTimeCalculator =
       new WaitTimeStuckCalculator(
           controler.getScenario().getPopulation(),
           controler.getScenario().getTransitSchedule(),
           controler.getConfig().travelTimeCalculator().getTraveltimeBinSize(),
           (int)
               (controler.getConfig().qsim().getEndTime()
                   - controler.getConfig().qsim().getStartTime()));
   controler.getEvents().addHandler(waitTimeCalculator);
   StopStopTimeCalculator stopStopTimeCalculator =
       new StopStopTimeCalculator(
           controler.getScenario().getTransitSchedule(),
           controler.getConfig().travelTimeCalculator().getTraveltimeBinSize(),
           (int)
               (controler.getConfig().qsim().getEndTime()
                   - controler.getConfig().qsim().getStartTime()));
   controler.getEvents().addHandler(stopStopTimeCalculator);
   final TransitRouterEventsWSFactory factory =
       new TransitRouterEventsWSFactory(
           controler.getScenario(),
           waitTimeCalculator.getWaitTimes(),
           stopStopTimeCalculator.getStopStopTimes());
   controler.addOverridingModule(
       new AbstractModule() {
         @Override
         public void install() {
           bind(TransitRouter.class).toProvider(factory);
         }
       });
   controler.run();
 }
示例#26
0
  public static void main(String[] args) {
    Config config = ConfigUtils.createConfig();
    config.removeModule(StrategyConfigGroup.GROUP_NAME);
    config.addModule(new StrategyPopsConfigGroup());
    ConfigUtils.loadConfig(config, args[0]);
    controler = new Controler(ScenarioUtils.loadScenario(config));
    controler
        .getConfig()
        .controler()
        .setOverwriteFileSetting(
            true
                ? OutputDirectoryHierarchy.OverwriteFileSetting.overwriteExistingFiles
                : OutputDirectoryHierarchy.OverwriteFileSetting.failIfDirectoryExists);
    controler.addControlerListener(
        new LegHistogramListener(
            controler.getEvents(), true, controler.getScenario().getPopulation()));
    controler.addControlerListener(
        new ScoreStats(
            controler.getScenario().getPopulation(),
            ScoreStatsControlerListener.FILENAME_SCORESTATS,
            true));
    // services.addControlerListener(new CalibrationStatsListener(services.getEvents(), new
    // String[]{args[1], args[2]}, 1, "Travel Survey (Benchmark)", "Red_Scheme", new
    // HashSet<Id<Person>>()));
    final WaitTimeStuckCalculator waitTimeCalculator =
        new WaitTimeStuckCalculator(
            controler.getScenario().getPopulation(),
            controler.getScenario().getTransitSchedule(),
            controler.getConfig().travelTimeCalculator().getTraveltimeBinSize(),
            (int)
                (controler.getConfig().qsim().getEndTime()
                    - controler.getConfig().qsim().getStartTime()));
    controler.getEvents().addHandler(waitTimeCalculator);
    final StopStopTimeCalculator stopStopTimeCalculator =
        new StopStopTimeCalculator(
            controler.getScenario().getTransitSchedule(),
            controler.getConfig().travelTimeCalculator().getTraveltimeBinSize(),
            (int)
                (controler.getConfig().qsim().getEndTime()
                    - controler.getConfig().qsim().getStartTime()));
    controler.getEvents().addHandler(stopStopTimeCalculator);
    controler.addOverridingModule(
        new AbstractModule() {
          @Override
          public void install() {
            bind(TransitRouter.class)
                .toProvider(
                    new TransitRouterWSImplFactory(
                        controler.getScenario(),
                        waitTimeCalculator.getWaitTimes(),
                        stopStopTimeCalculator.getStopStopTimes()));
          }
        });
    controler.setScoringFunctionFactory(
        new CharyparNagelOpenTimesScoringFunctionFactory(
            controler.getConfig().planCalcScore(), controler.getScenario()));
    AbstractModule myStrategyManagerModule =
        new AbstractModule() {

          @Override
          public void install() {
            bind(StrategyManager.class).toInstance(myLoadStrategyManager());
          }
        };
    controler.addOverridingModule(myStrategyManagerModule);
    controler.run();
  }
示例#27
0
  public void run() {

    new MatsimNetworkReader(scenario).readFile(scenario.getConfig().network().getInputFile());
    new TransitScheduleReaderV1(scenario)
        .readFile(this.scenario.getConfig().transit().getTransitScheduleFile());
    Logger.getLogger(this.getClass())
        .fatal(
            "cannot say if the following should be vehicles or transit vehicles; aborting ... .  kai, feb'15");
    System.exit(-1);
    new VehicleReaderV1((scenario).getTransitVehicles())
        .readFile(this.scenario.getConfig().transit().getVehiclesFile());

    Controler controler = new Controler(this.scenario);
    controler
        .getConfig()
        .controler()
        .setOverwriteFileSetting(
            OutputDirectoryHierarchy.OverwriteFileSetting.overwriteExistingFiles);
    controler.addOverridingModule(new OTFVisFileWriterModule());
    controler.addControlerListener(
        new OptControlerListener(
            this.fare,
            this.scenario,
            this.calculate_inVehicleTimeDelayEffects,
            this.calculate_waitingTimeDelayEffects,
            this.calculate_capacityDelayEffects,
            this.marginalCostPricingPt,
            this.calculate_carCongestionEffects,
            this.marginalCostPricingCar));

    ControlerConfigGroup controlerConfGroup = controler.getConfig().controler();
    if (controlerConfGroup.getLastIteration() == 0) {
      controlerConfGroup.setWriteEventsInterval(1);
      controlerConfGroup.setWritePlansInterval(1);
    } else {
      controlerConfGroup.setWriteEventsInterval(controlerConfGroup.getLastIteration());
      controlerConfGroup.setWritePlansInterval(controlerConfGroup.getLastIteration());
    }

    PlanCalcScoreConfigGroup planCalcScoreConfigGroup = controler.getConfig().planCalcScore();
    planCalcScoreConfigGroup.setMarginalUtilityOfMoney(MARGINAL_UTILITY_OF_MONEY);
    planCalcScoreConfigGroup.setPerforming_utils_hr(PERFORMING);

    planCalcScoreConfigGroup.getModes().get(TransportMode.car).setConstant(CONSTANT_CAR);
    planCalcScoreConfigGroup
        .getModes()
        .get(TransportMode.car)
        .setMarginalUtilityOfTraveling(TRAVEL_CAR);
    planCalcScoreConfigGroup
        .getModes()
        .get(TransportMode.car)
        .setMonetaryDistanceRate(MONETARY_DISTANCE_COST_RATE_CAR);

    planCalcScoreConfigGroup.getModes().get(TransportMode.walk).setConstant(CONSTANT_WALK);
    planCalcScoreConfigGroup
        .getModes()
        .get(TransportMode.walk)
        .setMarginalUtilityOfTraveling(TRAVEL_WALK);
    planCalcScoreConfigGroup
        .getModes()
        .get(TransportMode.pt)
        .setMonetaryDistanceRate(MONETARY_DISTANCE_COST_RATE_PT);

    planCalcScoreConfigGroup.getModes().get(TransportMode.pt).setConstant(CONSTANT_PT);
    planCalcScoreConfigGroup
        .getModes()
        .get(TransportMode.pt)
        .setMarginalUtilityOfTraveling(TRAVEL_PT_IN_VEHICLE);
    planCalcScoreConfigGroup.setMarginalUtlOfWaitingPt_utils_hr(TRAVEL_PT_WAITING);
    planCalcScoreConfigGroup.setUtilityOfLineSwitch(LINE_SWITCH);

    planCalcScoreConfigGroup.setLateArrival_utils_hr(LATE_ARRIVAL);
    planCalcScoreConfigGroup.setEarlyDeparture_utils_hr(EARLY_DEPARTURE);
    planCalcScoreConfigGroup.setMarginalUtlOfWaiting_utils_hr(WAITING);

    OptimizationScoringFunctionFactory scoringfactory =
        new OptimizationScoringFunctionFactory(scenario, STUCK_SCORE);

    controler.setScoringFunctionFactory(scoringfactory);

    controler.getConfig().controler().setCreateGraphs(false);
    controler.run();
  }
示例#28
0
  public static void main(String[] args) {
    Config config = new Config();
    config.addCoreModules();
    Controler controler = new Controler(config);

    // controler settings
    controler
        .getConfig()
        .controler()
        .setOverwriteFileSetting(
            true
                ? OutputDirectoryHierarchy.OverwriteFileSetting.overwriteExistingFiles
                : OutputDirectoryHierarchy.OverwriteFileSetting.failIfDirectoryExists);
    controler.getConfig().controler().setCreateGraphs(false);

    // controlerConfigGroup
    ControlerConfigGroup ccg = controler.getConfig().controler();
    ccg.setOutputDirectory(outputPath);
    ccg.setFirstIteration(0);
    ccg.setLastIteration(0);
    ccg.setMobsim("qsim");
    Set set = new HashSet();
    set.add(EventsFileFormat.xml);
    ccg.setEventsFileFormats(set);
    //		ccg.setRunId("321");

    // qsimConfigGroup
    QSimConfigGroup qcg = controler.getConfig().qsim();
    qcg.setStartTime(0 * 3600.);
    qcg.setEndTime(30 * 3600.);
    qcg.setFlowCapFactor(0.1);
    qcg.setStorageCapFactor(0.3);
    //		qcg.setFlowCapFactor(0.01);
    //		qcg.setStorageCapFactor(0.03);
    qcg.setNumberOfThreads(1);
    qcg.setRemoveStuckVehicles(false);
    qcg.setStuckTime(10.0);

    // planCalcScoreConfigGroup
    PlanCalcScoreConfigGroup pcs = controler.getConfig().planCalcScore();
    Set<String> activities = new HashSet<String>();
    activities.add("unknown");
    activities.add("work");
    activities.add("pickup");
    activities.add("with adult");
    activities.add("other");
    activities.add("pvWork");
    activities.add("pvHome");
    activities.add("gvHome");
    activities.add("education");
    activities.add("business");
    activities.add("shopping");
    activities.add("private");
    activities.add("leisure");
    activities.add("sports");
    activities.add("home");
    activities.add("friends");

    for (String activity : activities) {
      ActivityParams params = new ActivityParams(activity);
      params.setTypicalDuration(30 * 3600);
      pcs.addActivityParams(params);
    }

    // strategy
    StrategyConfigGroup scg = controler.getConfig().strategy();
    StrategySettings strategySettings =
        new StrategySettings(Id.create("1", StrategySettings.class));
    strategySettings.setStrategyName("ChangeExpBeta");
    strategySettings.setWeight(1.0);
    scg.addStrategySettings(strategySettings);

    // network
    NetworkConfigGroup ncg = controler.getConfig().network();
    ncg.setInputFile(networkFile);

    // plans
    PlansConfigGroup pcg = controler.getConfig().plans();
    pcg.setInputFile(plansFile);

    // define emission tool input files

    EmissionsConfigGroup ecg = new EmissionsConfigGroup();
    controler.getConfig().addModule(ecg);
    ecg.setEmissionRoadTypeMappingFile(roadTypeMappingFile);
    ecg.setEmissionVehicleFile(emissionVehicleFile);

    ecg.setAverageWarmEmissionFactorsFile(averageFleetWarmEmissionFactorsFile);
    ecg.setAverageColdEmissionFactorsFile(averageFleetColdEmissionFactorsFile);

    ecg.setUsingDetailedEmissionCalculation(isUsingDetailedEmissionCalculation);
    ecg.setDetailedWarmEmissionFactorsFile(detailedWarmEmissionFactorsFile);
    ecg.setDetailedColdEmissionFactorsFile(detailedColdEmissionFactorsFile);

    // TODO: the following does not work yet. Need to force controler to always write events in the
    // last iteration.
    VspExperimentalConfigGroup vcg = controler.getConfig().vspExperimental();
    vcg.setWritingOutputEvents(false);

    controler.addControlerListener(new EmissionControlerListener());
    controler.run();
  }
示例#29
0
  public static void main(final String[] args) {
    log.info(
        "Starting the matsim run from the urbansim interface.  This looks a little rough initially since 'normal' matsim");
    log.info("is not entered until later (after 'DONE with demand generation from urbansim').");

    int year = 0;
    double samplingRate = 0.01;
    for (int ii = 1; ii < args.length; ii++) { // args[0] is the config file
      log.info(" ii: " + ii + " args[ii]: " + args[ii]);
      String[] parts = args[ii].split("=");
      if (parts[0].equals("--year")) {
        year = Integer.parseInt(parts[1]);
      } else if (parts[0].equals("--samplingRate")) {
        samplingRate = Double.parseDouble(parts[1]);
      }
    }
    log.info("year: " + year + " samplingRate: " + samplingRate);
    for (int ii = args.length - 1; ii >= 1; ii--) {
      args[ii] = "";
    }

    // parse the config arguments so we have a config.  generate scenario data from this

    Config config = ConfigUtils.loadConfig(args[0]);
    MatsimRandom.reset(config.global().getRandomSeed());
    Scenario scenario = ScenarioUtils.createScenario(config);
    ScenarioUtils.loadScenario(scenario);

    // get the network.  Always cleaning it seems a good idea since someone may have modified the
    // input files manually in
    // order to implement policy measures.  Get network early so readXXX can check if links still
    // exist.
    Network network = scenario.getNetwork();

    log.info("");
    log.info("cleaning network ...");
    NetworkCleaner nwCleaner = new NetworkCleaner();
    nwCleaner.run(network);
    log.info("... finished cleaning network.");
    log.info("");

    ReadFromUrbansimParcelModel readFromUrbansim = new ReadFromUrbansimParcelModel(year);

    // read urbansim facilities (these are simply those entities that have the coordinates!)
    ActivityFacilitiesImpl facilities =
        new ActivityFacilitiesImpl("urbansim locations (gridcells _or_ parcels _or_ ...)");
    ActivityFacilitiesImpl zones = new ActivityFacilitiesImpl("urbansim zones");
    readFromUrbansim.readFacilities(facilities, zones);

    new FacilitiesWriter(facilities).write(PATH_TO_OPUS_MATSIM + "tmp/locations.xml.gz");

    Population oldPop;
    if (config.plans().getInputFile() != null) {
      log.info(
          "Population specified in matsim config file; assuming WARM start with pre-existing pop file.");
      log.info(
          "Persons not found in pre-existing pop file are added; persons no longer in urbansim persons file are removed.");
      oldPop = scenario.getPopulation();
      log.info(
          "Note that the `continuation of iterations' will only work if you set this up via different config files for");
      log.info(" every year and know what you are doing.");
    } else {
      log.warn("No population specified in matsim config file; assuming COLD start.");
      log.info("(I.e. generate new pop from urbansim files.)");
      oldPop = null;
    }

    Population newPop =
        ((MutableScenario) ScenarioUtils.createScenario(ConfigUtils.createConfig()))
            .getPopulation();
    // read urbansim persons.  Generates hwh acts as side effect
    readFromUrbansim.readPersons(oldPop, newPop, facilities, network, samplingRate);
    oldPop = null;
    System.gc();

    new PopulationWriter(newPop, network).write(PATH_TO_OPUS_MATSIM + "tmp/pop.xml.gz");

    log.info("### DONE with demand generation from urbansim ###");

    ((MutableScenario) scenario).setPopulation(newPop);
    Controler controler = new Controler(scenario);
    controler
        .getConfig()
        .controler()
        .setOverwriteFileSetting(
            true
                ? OutputDirectoryHierarchy.OverwriteFileSetting.overwriteExistingFiles
                : OutputDirectoryHierarchy.OverwriteFileSetting.failIfDirectoryExists);

    // The following lines register what should be done _after_ the iterations were run:
    MyControlerListener myControlerListener = new MyControlerListener(zones);
    controler.addControlerListener(myControlerListener);

    // run the iterations, including the post-processing:
    controler.run();
  }