Exemplo n.º 1
1
  @Test
  public void testLegAttributesIO() {
    final Population population = PopulationUtils.createPopulation(ConfigUtils.createConfig());

    final Person person = population.getFactory().createPerson(Id.createPersonId("Donald Trump"));
    population.addPerson(person);

    final Plan plan = population.getFactory().createPlan();
    person.addPlan(plan);
    final Leg leg = population.getFactory().createLeg("SUV");
    plan.addActivity(
        population.getFactory().createActivityFromLinkId("speech", Id.createLinkId(1)));
    plan.addLeg(leg);
    plan.addActivity(population.getFactory().createActivityFromLinkId("tweet", Id.createLinkId(2)));

    leg.getAttributes().putAttribute("mpg", 0.000001d);

    final String file = utils.getOutputDirectory() + "/population.xml";
    new PopulationWriter(population).writeV6(file);

    final Scenario readScenario = ScenarioUtils.createScenario(ConfigUtils.createConfig());
    new PopulationReader(readScenario).readFile(file);

    final Person readPerson =
        readScenario.getPopulation().getPersons().get(Id.createPersonId("Donald Trump"));
    final Leg readLeg = (Leg) readPerson.getSelectedPlan().getPlanElements().get(1);

    Assert.assertEquals(
        "Unexpected Double attribute in " + readLeg.getAttributes(),
        leg.getAttributes().getAttribute("mpg"),
        readLeg.getAttributes().getAttribute("mpg"));
  }
Exemplo n.º 2
0
  private void createOneVWTrucker(
      int i, Coord origin, Coord destination, String mode, String fromToPrefix) {
    Id<Person> personId = Id.createPersonId(fromToPrefix + i);
    Person person = scenario.getPopulation().getFactory().createPerson(personId);

    Plan plan = scenario.getPopulation().getFactory().createPlan();

    Activity source =
        scenario.getPopulation().getFactory().createActivityFromCoord("source", origin);
    double rand = random.nextDouble() * 18 * 60 * 60;
    source.setEndTime(rand);
    plan.addActivity(source);

    Leg outboundTrip = scenario.getPopulation().getFactory().createLeg(mode);
    plan.addLeg(outboundTrip);

    Activity delivery =
        scenario.getPopulation().getFactory().createActivityFromCoord("delivery", destination);
    delivery.setMaximumDuration(3600);
    plan.addActivity(delivery);

    Leg inboundTrip = scenario.getPopulation().getFactory().createLeg(mode);
    plan.addLeg(inboundTrip);
    Activity source2 =
        scenario.getPopulation().getFactory().createActivityFromCoord("source", origin);
    plan.addActivity(source2);

    person.addPlan(plan);
    scenario
        .getPopulation()
        .getPersonAttributes()
        .putAttribute(person.getId().toString(), "subpopulation", "noRep");

    scenario.getPopulation().addPerson(person);
  }
Exemplo n.º 3
0
  @Test
  public void testActivityAttributesIO() {
    final Population population = PopulationUtils.createPopulation(ConfigUtils.createConfig());

    final Person person = population.getFactory().createPerson(Id.createPersonId("Donald Trump"));
    population.addPerson(person);

    final Plan plan = population.getFactory().createPlan();
    person.addPlan(plan);
    final Activity act = population.getFactory().createActivityFromCoord("speech", new Coord(0, 0));
    plan.addActivity(act);

    act.getAttributes().putAttribute("makes sense", false);
    act.getAttributes().putAttribute("length", 1895L);

    final String file = utils.getOutputDirectory() + "/population.xml";
    new PopulationWriter(population).writeV6(file);

    final Scenario readScenario = ScenarioUtils.createScenario(ConfigUtils.createConfig());
    new PopulationReader(readScenario).readFile(file);

    final Person readPerson =
        readScenario.getPopulation().getPersons().get(Id.createPersonId("Donald Trump"));
    final Activity readAct = (Activity) readPerson.getSelectedPlan().getPlanElements().get(0);

    Assert.assertEquals(
        "Unexpected boolean attribute in " + readAct.getAttributes(),
        act.getAttributes().getAttribute("makes sense"),
        readAct.getAttributes().getAttribute("makes sense"));

    Assert.assertEquals(
        "Unexpected Long attribute in " + readAct.getAttributes(),
        act.getAttributes().getAttribute("length"),
        readAct.getAttributes().getAttribute("length"));
  }
  private void createDemand() {

    Population pop = sc.getPopulation();
    PopulationFactory fact = pop.getFactory();

    for (int i = 1; i <= 400; i++) {

      Person p = fact.createPerson(Id.createPersonId(i));
      Plan plan = fact.createPlan();
      p.addPlan(plan);
      Leg leg = fact.createLeg(TransportMode.car);
      Activity home;
      Activity work;

      if (i % 2 == 0) { // o --d1
        home = fact.createActivityFromCoord("o1", lo.getCoord());
        home.setEndTime(7 * 3600 + i);
        work = fact.createActivityFromCoord("d1", ld1.getCoord());
      } else /*if(i%2==0)*/ { // o --d2
        home = fact.createActivityFromCoord("o1", lo.getCoord());
        home.setEndTime(7 * 3600 + i);
        work = fact.createActivityFromCoord("d2", ld2.getCoord());
      }
      plan.addActivity(home);
      plan.addLeg(leg);
      plan.addActivity(work);
      pop.addPerson(p);
    }
    new PopulationWriter(pop).write(outputDir + "/input/input_plans.xml.gz");
  }
Exemplo n.º 5
0
  private void createOneTransitTrucker(
      int i, Coord origin, Coord destination, String mode, String fromToPrefix) {
    Id<Person> personId = Id.createPersonId(fromToPrefix + i);
    Person person = scenario.getPopulation().getFactory().createPerson(personId);

    Plan plan = scenario.getPopulation().getFactory().createPlan();

    Activity cargo = scenario.getPopulation().getFactory().createActivityFromCoord("cargo", origin);
    int rand = random.nextInt(18 * 60 * 60) + 1;
    cargo.setEndTime(rand);
    plan.addActivity(cargo);

    Leg outboundTrip = scenario.getPopulation().getFactory().createLeg(mode);
    plan.addLeg(outboundTrip);

    Activity cargod =
        scenario.getPopulation().getFactory().createActivityFromCoord("cargoD", destination);
    cargod.setMaximumDuration(3600);
    plan.addActivity(cargod);
    Leg inBundTrip = scenario.getPopulation().getFactory().createLeg(mode);
    plan.addLeg(inBundTrip);

    Activity cargo2 =
        scenario.getPopulation().getFactory().createActivityFromCoord("cargo", origin);
    plan.addActivity(cargo2);

    person.addPlan(plan);
    scenario
        .getPopulation()
        .getPersonAttributes()
        .putAttribute(person.getId().toString(), "subpopulation", "noRep");
    scenario.getPopulation().addPerson(person);
  }
Exemplo n.º 6
0
  @Test
  public void testCoord3dIO() {
    final Population population = PopulationUtils.createPopulation(ConfigUtils.createConfig());

    final Person person = population.getFactory().createPerson(Id.createPersonId("Donald Trump"));
    population.addPerson(person);

    final Plan plan = population.getFactory().createPlan();
    person.addPlan(plan);
    plan.addActivity(population.getFactory().createActivityFromCoord("speech", new Coord(0, 0)));
    plan.addActivity(
        population.getFactory().createActivityFromCoord("tweet", new Coord(0, 0, -100)));

    final String file = utils.getOutputDirectory() + "/population.xml";
    new PopulationWriter(population).writeV6(file);

    final Scenario readScenario = ScenarioUtils.createScenario(ConfigUtils.createConfig());
    new PopulationReader(readScenario).readFile(file);

    final Person readPerson =
        readScenario.getPopulation().getPersons().get(Id.createPersonId("Donald Trump"));
    final Activity readSpeach = (Activity) readPerson.getSelectedPlan().getPlanElements().get(0);
    final Activity readTweet = (Activity) readPerson.getSelectedPlan().getPlanElements().get(1);

    Assert.assertFalse(
        "did not expect Z value in " + readSpeach.getCoord(), readSpeach.getCoord().hasZ());

    Assert.assertTrue("did expect T value in " + readTweet.getCoord(), readTweet.getCoord().hasZ());

    Assert.assertEquals(
        "unexpected Z value in " + readTweet.getCoord(),
        -100,
        readTweet.getCoord().getZ(),
        MatsimTestUtils.EPSILON);
  }
Exemplo n.º 7
0
 /**
  * copy the person and the selected plan of the person
  *
  * @param person
  * @return
  */
 public static Person copyPerson(Person person) {
   Person newPerson = PersonImpl.createPerson(person.getId());
   PlanImpl newPlan = new PlanImpl();
   newPlan.copyFrom(person.getSelectedPlan());
   newPlan.setPerson(newPerson);
   newPerson.addPlan(newPlan);
   newPerson.setSelectedPlan(newPlan);
   PersonUtils.removeUnselectedPlans(newPerson);
   return newPerson;
 }
Exemplo n.º 8
0
  private static Person createPerson(
      final int count, final boolean joint, final Map<Id<Person>, Plan> jointPlan) {
    Id<Person> id = Id.createPersonId(count);
    Person person = PersonImpl.createPerson(id);
    PlanImpl plan = new PlanImpl(person);
    person.addPlan(plan);
    if (joint) jointPlan.put(id, plan);
    if (!plan.isSelected()) throw new RuntimeException();

    return person;
  }
Exemplo n.º 9
0
  @Override
  public void run(final Person person) {
    // if (Integer.parseInt(person.getId().toString()) < 1000000000) {
    this.person = person;
    for (Plan pl : person.getPlans()) {
      run(pl);
    }
    person.getPlans().clear();

    for (PlanImpl copyPlan : copyPlans) {
      person.addPlan(copyPlan);
    }
    copyPlans.clear();
    // }
    pw.writePerson(person);
  }
Exemplo n.º 10
0
  public void testArriveAtStop() {
    ScenarioImpl scenario = (ScenarioImpl) ScenarioUtils.createScenario(ConfigUtils.createConfig());

    NetworkImpl network = (NetworkImpl) scenario.getNetwork();
    Node node1 = network.createAndAddNode(Id.create("1", Node.class), new CoordImpl(0, 0));
    Node node2 = network.createAndAddNode(Id.create("2", Node.class), new CoordImpl(1000, 0));
    Node node3 = network.createAndAddNode(Id.create("3", Node.class), new CoordImpl(2000, 0));
    network.createAndAddLink(Id.create("1", Link.class), node1, node2, 1000.0, 10.0, 3600.0, 1);
    network.createAndAddLink(Id.create("2", Link.class), node2, node3, 1000.0, 10.0, 3600.0, 1);

    TransitScheduleFactory builder = new TransitScheduleFactoryImpl();
    PopulationFactory pb = scenario.getPopulation().getFactory();
    Person person = pb.createPerson(Id.create("1", Person.class));
    Plan plan = pb.createPlan();
    person.addPlan(plan);
    Activity homeAct = pb.createActivityFromLinkId("home", Id.create("1", Link.class));
    Leg leg = pb.createLeg(TransportMode.pt);
    TransitStopFacility stop1 =
        builder.createTransitStopFacility(
            Id.create("1", TransitStopFacility.class), scenario.createCoord(100, 100), false);
    TransitStopFacility stop2 =
        builder.createTransitStopFacility(
            Id.create("2", TransitStopFacility.class), scenario.createCoord(900, 100), false);
    TransitStopFacility stop3 =
        builder.createTransitStopFacility(
            Id.create("3", TransitStopFacility.class), scenario.createCoord(1900, 100), false);
    TransitLine line1 = builder.createTransitLine(Id.create("L1", TransitLine.class));
    leg.setRoute(new ExperimentalTransitRoute(stop1, line1, null, stop2));
    Activity workAct = pb.createActivityFromLinkId("work", Id.create("2", Link.class));
    plan.addActivity(homeAct);
    plan.addLeg(leg);
    plan.addActivity(workAct);

    QSim sim = (QSim) new QSimFactory().createMobsim(scenario, EventsUtils.createEventsManager());
    TransitAgent agent = TransitAgent.createTransitAgent(person, sim);
    sim.insertAgentIntoMobsim(agent);
    agent.endActivityAndComputeNextState(10);

    assertFalse(agent.getExitAtStop(stop1));
    assertTrue(agent.getExitAtStop(stop2));
    assertFalse(agent.getExitAtStop(stop3));
    assertTrue(agent.getExitAtStop(stop2)); // offering the same stop again should yield "true"
  }
Exemplo n.º 11
0
  private void createOneVWFlexitimeWorker(
      int i, Coord homeC, String mode, String fromToPrefix, double minHrs, double maxHrs) {
    int additionalTrips = random.nextInt(4);

    Id<Person> personId = Id.createPersonId(fromToPrefix + i + "vw");
    Person person = scenario.getPopulation().getFactory().createPerson(personId);

    Plan plan = scenario.getPopulation().getFactory().createPlan();

    Activity home = scenario.getPopulation().getFactory().createActivityFromCoord("home", homeC);

    home.setEndTime(5 * 60 * 60 + 3 * 3600 * random.nextDouble());
    plan.addActivity(home);

    Leg outboundTrip = scenario.getPopulation().getFactory().createLeg(mode);
    plan.addLeg(outboundTrip);

    Coord coord = scenario.getNetwork().getLinks().get(calcVWWorkLinkId()).getCoord();
    Activity work =
        scenario.getPopulation().getFactory().createActivityFromCoord("work_vw_flexitime", coord);
    double spread = (maxHrs - minHrs) * 3600;
    work.setMaximumDuration(minHrs * 3600 + random.nextDouble() * spread);
    plan.addActivity(work);
    if (additionalTrips == 1 || additionalTrips == 3) {
      enrichPlanBySingleLegAndActivity(coord, plan, mode, 5400, false);
    }

    Leg returnTrip = scenario.getPopulation().getFactory().createLeg(mode);
    plan.addLeg(returnTrip);

    Activity home2 = scenario.getPopulation().getFactory().createActivityFromCoord("home", homeC);
    plan.addActivity(home2);

    person.addPlan(plan);
    if (additionalTrips > 1) {
      home2.setMaximumDuration(random.nextInt(5400));

      enrichPlanByReturnLegAndActivity(home2, plan, mode, 5400);
    }
    scenario.getPopulation().addPerson(person);
  }
  private static Person createPerson(Scenario scenario, Coord home, Coord work, int i) {
    Random r = MatsimRandom.getRandom();
    PopulationFactory f = scenario.getPopulation().getFactory();
    Person p = f.createPerson(Id.createPersonId(i));
    Plan plan = f.createPlan();
    p.addPlan(plan);
    Activity h1 = f.createActivityFromCoord("home", home);
    h1.setEndTime(6 * 3600 + r.nextInt(4 * 3600));
    Leg leg = f.createLeg("taxibus");
    Activity w = f.createActivityFromCoord("work", work);
    w.setEndTime(12 * 3600 + r.nextInt(6 * 3600));
    Leg leg2 = f.createLeg("taxibus");
    Activity h2 = f.createActivityFromCoord("home", home);
    plan.addActivity(h1);
    plan.addLeg(leg);
    plan.addActivity(w);
    plan.addLeg(leg2);
    plan.addActivity(h2);

    return p;
  }
Exemplo n.º 13
0
  private void createOneStudent(
      int i, Coord coord, Coord coordUniversity, String mode, String fromToPrefix) {
    int additionalTrips = random.nextInt(4);
    Id<Person> personId = Id.createPersonId(fromToPrefix + i);
    Person person = scenario.getPopulation().getFactory().createPerson(personId);

    Plan plan = scenario.getPopulation().getFactory().createPlan();

    Activity home = scenario.getPopulation().getFactory().createActivityFromCoord("home", coord);
    home.setEndTime(8 * 60 * 60 + 2 * 3600 * random.nextDouble());
    plan.addActivity(home);

    Leg outboundTrip = scenario.getPopulation().getFactory().createLeg(mode);
    plan.addLeg(outboundTrip);

    Activity university =
        scenario
            .getPopulation()
            .getFactory()
            .createActivityFromCoord("university", coordUniversity);
    university.setEndTime(16 * 60 * 60 + 2 * 3600 * random.nextDouble());
    plan.addActivity(university);

    if (additionalTrips == 1 || additionalTrips == 3) {
      enrichPlanBySingleLegAndActivity(coordUniversity, plan, mode, 5400, false);
    }

    Leg returnTrip = scenario.getPopulation().getFactory().createLeg(mode);
    plan.addLeg(returnTrip);

    Activity home2 = scenario.getPopulation().getFactory().createActivityFromCoord("home", coord);
    plan.addActivity(home2);
    if (additionalTrips > 1) {
      home2.setMaximumDuration(random.nextInt(5400));
      enrichPlanByReturnLegAndActivity(home2, plan, mode, 5400);
    }
    person.addPlan(plan);
    scenario.getPopulation().addPerson(person);
  }
Exemplo n.º 14
0
 private static void createPopulation(Scenario sc, int destination) {
   Population pop = sc.getPopulation();
   pop.getPersons().clear();
   PopulationFactory fac = pop.getFactory();
   double t = 0;
   for (int i = 0; i < NR_AGENTS / 2; i++) {
     Person pers = fac.createPerson(Id.create("b" + i, Person.class));
     Plan plan = fac.createPlan();
     pers.addPlan(plan);
     Activity act0;
     act0 = fac.createActivityFromLinkId("origin", Id.create("0", Link.class));
     act0.setEndTime(t);
     plan.addActivity(act0);
     Leg leg = fac.createLeg("walkct");
     plan.addLeg(leg);
     Activity act1 =
         fac.createActivityFromLinkId("destination", Id.create(destination, Link.class));
     plan.addActivity(act1);
     pop.addPerson(pers);
   }
   //		for (int i = NR_AGENTS / 2; i < NR_AGENTS; i++) {
   //			Person pers = fac.createPerson(Id.create("b" + i, Person.class));
   //			Plan plan = fac.createPlan();
   //			pers.addPlan(plan);
   //			Activity act0;
   //			act0 = fac.createActivityFromLinkId("origin",
   //					Id.create(destination + 1, Link.class));
   //			act0.setEndTime(t);
   //			plan.addActivity(act0);
   //			Leg leg = fac.createLeg("walkct");
   //			plan.addLeg(leg);
   //			Activity act1 = fac.createActivityFromLinkId("destination",
   //					Id.create(1, Link.class));
   //			plan.addActivity(act1);
   //			pop.addPerson(pers);
   //		}
 }
  public void testTransitRouteCopy() {
    Config config = super.loadConfig(null);
    config.scenario().setUseTransit(true);
    config.scenario().setUseVehicles(true);
    ScenarioImpl scenario = (ScenarioImpl) ScenarioUtils.createScenario(config);

    Id<Node> nodeId1 = Id.create("1", Node.class);
    Id<Node> nodeId2 = Id.create("2", Node.class);
    Id<Node> nodeId3 = Id.create("3", Node.class);
    Id<Link> linkId1 = Id.create("1", Link.class);
    Id<Link> linkId2 = Id.create("2", Link.class);

    // build network
    Network network = scenario.getNetwork();
    NetworkFactory nBuilder = network.getFactory();
    Node node1 = nBuilder.createNode(nodeId1, scenario.createCoord(0, 0));
    Node node2 = nBuilder.createNode(nodeId2, scenario.createCoord(1000, 0));
    Node node3 = nBuilder.createNode(nodeId3, scenario.createCoord(2000, 0));
    network.addNode(node1);
    network.addNode(node2);
    network.addNode(node3);
    Link link1 = nBuilder.createLink(linkId1, node1, node2);
    Link link2 = nBuilder.createLink(linkId2, node2, node3);
    network.addLink(link1);
    network.addLink(link2);

    // build schedule
    TransitSchedule schedule = scenario.getTransitSchedule();
    TransitScheduleFactory sBuilder = schedule.getFactory();

    TransitStopFacility stopF1 =
        sBuilder.createTransitStopFacility(
            Id.create("1", TransitStopFacility.class), scenario.createCoord(1000.0, 0), false);
    TransitStopFacility stopF2 =
        sBuilder.createTransitStopFacility(
            Id.create("2", TransitStopFacility.class), scenario.createCoord(2000.0, 0), false);
    stopF1.setLinkId(link1.getId());
    stopF2.setLinkId(link2.getId());
    schedule.addStopFacility(stopF1);
    schedule.addStopFacility(stopF2);

    TransitLine tLine1 = sBuilder.createTransitLine(Id.create("1", TransitLine.class));

    TransitRouteStop stop1 = sBuilder.createTransitRouteStop(stopF1, 0, 0);
    TransitRouteStop stop2 = sBuilder.createTransitRouteStop(stopF2, 100, 100);
    ArrayList<TransitRouteStop> stops = new ArrayList<TransitRouteStop>();
    stops.add(stop1);
    stops.add(stop2);

    NetworkRoute netRoute = new LinkNetworkRouteImpl(link1.getId(), link2.getId());
    netRoute.setLinkIds(link1.getId(), Collections.<Id<Link>>emptyList(), link2.getId());
    TransitRoute tRoute1 =
        sBuilder.createTransitRoute(Id.create("1", TransitRoute.class), netRoute, stops, "bus");

    tRoute1.addDeparture(sBuilder.createDeparture(Id.create("1", Departure.class), 7.0 * 3600));
    tLine1.addRoute(tRoute1);
    schedule.addTransitLine(tLine1);

    // build vehicles
    new CreateVehiclesForSchedule(schedule, scenario.getVehicles()).run();

    // build population
    Population population = scenario.getPopulation();
    PopulationFactory pBuilder = population.getFactory();
    Person person1 = pBuilder.createPerson(Id.create("1", Person.class));
    Plan plan = pBuilder.createPlan();
    Activity homeAct = pBuilder.createActivityFromLinkId("h", linkId1);
    homeAct.setEndTime(7.0 * 3600);
    plan.addActivity(homeAct);
    Leg leg = pBuilder.createLeg(TransportMode.pt);
    ExperimentalTransitRoute tRoute = new ExperimentalTransitRoute(stopF1, tLine1, tRoute1, stopF2);
    leg.setRoute(tRoute);
    plan.addLeg(leg);
    plan.addActivity(pBuilder.createActivityFromLinkId("w", linkId2));
    person1.addPlan(plan);
    population.addPerson(person1);

    // prepare config
    config.controler().setFirstIteration(0);
    config.controler().setLastIteration(1);

    ActivityParams params = new ActivityParams("h");
    params.setTypicalDuration(16.0 * 3600);
    config.planCalcScore().addActivityParams(params);
    params = new ActivityParams("w");
    params.setTypicalDuration(8.0 * 3600);
    config.planCalcScore().addActivityParams(params);

    StrategySettings tam = new StrategySettings(Id.create(1, StrategySettings.class));
    tam.setStrategyName("TimeAllocationMutator");
    tam.setWeight(1.0);
    config.strategy().addStrategySettings(tam);

    // run
    Controler controler = new Controler(scenario);
    controler.getConfig().controler().setWriteEventsInterval(0);
    controler.setCreateGraphs(false);
    controler.run();

    // checks
    assertEquals(1, population.getPersons().size());
    assertEquals(2, person1.getPlans().size());
    assertEquals(
        ExperimentalTransitRoute.class,
        ((Leg) person1.getPlans().get(0).getPlanElements().get(1)).getRoute().getClass());
    assertEquals(
        ExperimentalTransitRoute.class,
        ((Leg) person1.getPlans().get(1).getPlanElements().get(1)).getRoute().getClass());
  }
Exemplo n.º 16
0
  /**
   * Tests that plans with missing act locations are completed (=xy2links and routed) before the
   * mobsim starts.
   *
   * @author mrieser
   */
  @Test
  public void testCalcMissingActLinks() {
    Config config = this.utils.loadConfig(null);
    Fixture f = new Fixture(config);

    /* Create a person with two plans, driving from link 1 to link 3, starting at 7am.  */
    Population population = f.scenario.getPopulation();
    PopulationFactory factory = population.getFactory();
    Person person1 = null;
    Activity act1a = null;
    Activity act1b = null;
    Activity act2a = null;
    Activity act2b = null;
    Leg leg1 = null;
    Leg leg2 = null;

    person1 = PersonImpl.createPerson(Id.create(1, Person.class));
    // --- plan 1 ---
    Plan plan1 = factory.createPlan();
    person1.addPlan(plan1);
    double x1 = -50.0;
    act1a = factory.createActivityFromCoord("h", new Coord(x1, 10.0));
    act1a.setEndTime(7.0 * 3600);
    plan1.addActivity(act1a);
    leg1 = factory.createLeg(TransportMode.car);
    plan1.addLeg(leg1);
    // DO NOT CREATE A ROUTE FOR THE LEG!!!
    double y1 = -10.0;
    act1b = factory.createActivityFromCoord("h", new Coord(1075.0, y1));
    plan1.addActivity(act1b);
    // --- plan 2 ---
    Plan plan2 = factory.createPlan();
    person1.addPlan(plan2);
    double x = -50.0;
    double y = -10.0;
    act2a = factory.createActivityFromCoord("h", new Coord(x, y));
    act2a.setEndTime(7.9 * 3600);
    plan2.addActivity(act2a);
    leg2 = factory.createLeg(TransportMode.car);
    plan2.addLeg(leg2);
    // DO NOT CREATE A ROUTE FOR THE LEG!!!
    act2b = factory.createActivityFromCoord("h", new Coord(1111.1, 10.0));
    plan2.addActivity(act2b);
    population.addPerson(person1);

    // Complete the configuration for our test case
    // - set scoring parameters
    ActivityParams actParams = new ActivityParams("h");
    actParams.setTypicalDuration(8 * 3600);
    actParams.setPriority(1.0);
    config.planCalcScore().addActivityParams(actParams);
    // - define iterations
    config.controler().setLastIteration(0);
    // - make sure we don't use threads, as they are not deterministic
    config.global().setNumberOfThreads(1);

    // Now run the simulation
    Controler controler = new Controler(f.scenario);
    controler.getConfig().controler().setCreateGraphs(false);
    controler.getConfig().controler().setWriteEventsInterval(0);
    controler.addOverridingModule(
        new AbstractModule() {
          @Override
          public void install() {
            bindMobsim()
                .toProvider(
                    new Provider<Mobsim>() {
                      @Override
                      public Mobsim get() {
                        return new FakeMobsim();
                      }
                    });
          }
        });
    controler.setDumpDataAtEnd(false);
    controler.run();
    /* if something goes wrong, there will be an exception we don't catch and the test fails,
     * otherwise, everything is fine. */

    // check that BOTH plans have their act-locations calculated
    assertEquals(f.link1.getId(), act1a.getLinkId());
    assertEquals(f.link3.getId(), act1b.getLinkId());
    assertEquals(f.link1.getId(), act2a.getLinkId());
    assertEquals(f.link3.getId(), act2b.getLinkId());

    // check that BOTH plans have a route set, even when we only run 1 iteration where only one of
    // them is used.
    // assertNotNull(leg1.getRoute());
    // assertNotNull(leg2.getRoute());
    // but do not assume that the leg will be the same instance...
    for (Plan plan : new Plan[] {plan1, plan2}) {
      assertEquals(
          "unexpected plan length in " + plan.getPlanElements(), 3, plan.getPlanElements().size());
      assertNotNull(
          "null route in plan " + plan.getPlanElements(),
          ((Leg) plan.getPlanElements().get(1)).getRoute());
    }
  }
Exemplo n.º 17
0
  /**
   * Tests that the travel times are correctly calculated during the simulation.
   *
   * @author mrieser
   */
  @Test
  public void testTravelTimeCalculation() {
    Config config = this.utils.loadConfig(null);
    Fixture f = new Fixture(config);

    /* Create 2 persons driving from link 1 to link 3, both starting at the
     * same time at 7am.  */
    Population population = f.scenario.getPopulation();
    PopulationFactory factory = population.getFactory();
    Person person1 = null;

    person1 = factory.createPerson(Id.create("1", Person.class));
    Plan plan1 = factory.createPlan();
    person1.addPlan(plan1);
    Activity a1 = factory.createActivityFromLinkId("h", f.link1.getId());
    a1.setEndTime(7.0 * 3600);
    plan1.addActivity(a1);
    Leg leg1 = factory.createLeg(TransportMode.car);
    plan1.addLeg(leg1);
    NetworkRoute route1 =
        ((PopulationFactoryImpl) f.scenario.getPopulation().getFactory())
            .createRoute(NetworkRoute.class, f.link1.getId(), f.link3.getId());
    leg1.setRoute(route1);
    ArrayList<Id<Link>> linkIds = new ArrayList<Id<Link>>();
    linkIds.add(f.link2.getId());
    route1.setLinkIds(f.link1.getId(), linkIds, f.link3.getId());
    plan1.addActivity(factory.createActivityFromLinkId("h", f.link3.getId()));
    population.addPerson(person1);

    Person person2 = factory.createPerson(Id.create("2", Person.class));
    Plan plan2 = factory.createPlan();
    person2.addPlan(plan2);
    Activity a2 = factory.createActivityFromLinkId("h", f.link1.getId());
    a2.setEndTime(7.0 * 3600);
    plan2.addActivity(a2);
    Leg leg2 = factory.createLeg(TransportMode.car);
    plan2.addLeg(leg2);
    NetworkRoute route2 =
        ((PopulationFactoryImpl) f.scenario.getPopulation().getFactory())
            .createRoute(NetworkRoute.class, f.link1.getId(), f.link3.getId());
    leg2.setRoute(route2);
    route2.setLinkIds(f.link1.getId(), linkIds, f.link3.getId());
    plan2.addActivity(factory.createActivityFromLinkId("h", f.link3.getId()));
    population.addPerson(person2);

    // Complete the configuration for our test case
    // - set scoring parameters
    ActivityParams actParams = new ActivityParams("h");
    actParams.setTypicalDuration(8 * 3600);
    actParams.setPriority(1.0);
    config.planCalcScore().addActivityParams(actParams);
    // - define iterations
    config.controler().setLastIteration(0);
    // - make sure we don't use threads, as they are not deterministic
    config.global().setNumberOfThreads(0);

    // Now run the simulation
    Controler controler = new Controler(f.scenario);
    controler.getConfig().controler().setCreateGraphs(false);
    controler.getConfig().controler().setWriteEventsInterval(0);
    controler.setDumpDataAtEnd(false);
    controler.run();

    // test if we got the right result
    // the actual result is 151sec, not 150, as each vehicle "loses" 1sec in the buffer
    assertEquals(
        "TravelTimeCalculator has wrong result",
        151.0,
        controler.getLinkTravelTimes().getLinkTravelTime(f.link2, 7 * 3600, null, null),
        0.0);

    // now test that the ReRoute-Strategy also knows about these travel times...
    config.controler().setLastIteration(1);
    ConfigGroup strategyParams = config.getModule("strategy");
    strategyParams.addParam("maxAgentPlanMemorySize", "4");
    strategyParams.addParam("ModuleProbability_1", "1.0");
    strategyParams.addParam("Module_1", "ReRoute");
    // Run the simulation again
    controler = new Controler(f.scenario);
    controler.getConfig().controler().setCreateGraphs(false);
    controler
        .getConfig()
        .controler()
        .setOverwriteFileSetting(
            OutputDirectoryHierarchy.OverwriteFileSetting.overwriteExistingFiles);
    controler.getConfig().controler().setWriteEventsInterval(0);
    controler.run();

    // test that the plans have the correct times
    assertEquals(
        "ReRoute seems to have wrong travel times.",
        151.0,
        ((Leg) (person1.getPlans().get(1).getPlanElements().get(1))).getTravelTime(),
        0.0);
  }
Exemplo n.º 18
0
  public void cleanUpScenario(Scenario sc) {
    LOG.info("Cleaning up scenario...");
    /* TODO Still need to figure out what cleaning up must happen. */

    /* Search for location-less activities, and sample its locations from
     * the kernel density estimates. */
    LOG.info("Sampling locations for those without known zones...");
    int locationsFixed = 0;
    int knownLocations = 0;
    for (Person person : sc.getPopulation().getPersons().values()) {
      Plan plan = person.getSelectedPlan();
      if (plan != null) {
        for (PlanElement pe : plan.getPlanElements()) {
          if (pe instanceof Activity) {
            Activity act = (Activity) pe;
            Coord coord = act.getCoord();
            if (coord.getX() == 0.0 || coord.getY() == 0.0) {
              ((ActivityImpl) act).setCoord(sampleActivityLocation(act.getType()));
              locationsFixed++;
            } else {
              knownLocations++;
            }
          }
        }
      }
    }
    LOG.info("Number of known locations: " + knownLocations);
    LOG.info("Number of locations fixed: " + locationsFixed);
    LOG.info("Done sampling locations.");

    /* Ensure each activity, except the last, has both a start and end time. */
    LOG.info("Ensure each activity has an end time...");
    for (Person person : sc.getPopulation().getPersons().values()) {
      Plan plan = person.getSelectedPlan();
      if (plan != null) {
        List<PlanElement> list = plan.getPlanElements();
        for (int i = 0; i < list.size() - 2; i += 2) {
          PlanElement pe = list.get(i);
          if (pe instanceof Activity) {
            Activity act = (Activity) pe;
            double endTime = act.getEndTime();
            if (endTime < 0.0) {
              double legStart = ((Leg) list.get(i + 1)).getDepartureTime();
              act.setEndTime(legStart);
            }
          } else {
            LOG.warn("Every second PlanElement should be of type 'Activity'.");
          }
        }
      }
    }
    LOG.info("Done fixing activity end times.");

    /* Ensure that the home location/coordinate for all members in the
     * household are the same for all their "h" activities. */
    LOG.info("Fix home locations for each household member. ");
    int homeLocationsFixed = 0;
    int nonTravellers = 0;
    for (Household hh : sc.getHouseholds().getHouseholds().values()) {
      Object o =
          sc.getHouseholds()
              .getHouseholdAttributes()
              .getAttribute(hh.getId().toString(), "transportZone");
      if (o instanceof String) {
        String zoneId = (String) o;
        Coord homeCoord = null;
        if (zoneId != null && !zoneId.equalsIgnoreCase("")) {
          /* There is known home zone. */
          Point p = this.zoneMap.get(zoneId).sampleRandomInteriorPoint();
          homeCoord = CoordUtils.createCoord(p.getX(), p.getY());
        } else {
          /* There is no transport zone. */
          homeCoord = sampleActivityLocation("h");
        }

        /* Now assign the home coordinate to ALL home activities for
         * all members of the household. */
        for (Id<Person> id : hh.getMemberIds()) {
          Person person = sc.getPopulation().getPersons().get(id);
          Plan plan = person.getSelectedPlan();
          if (plan != null) {
            for (PlanElement pe : person.getSelectedPlan().getPlanElements()) {
              if (pe instanceof ActivityImpl) {
                ActivityImpl act = (ActivityImpl) pe;
                if (act.getType().equalsIgnoreCase("h")) {
                  act.setCoord(homeCoord);
                  homeLocationsFixed++;
                }
              }
            }
          } else {
            /* The member does not have ANY plan. We 'fix' this by
             * adding aPlan with a single home-based activity for
             * which not times are specified. */
            Plan stayHomePlan = sc.getPopulation().getFactory().createPlan();
            Activity act = sc.getPopulation().getFactory().createActivityFromCoord("h", homeCoord);
            stayHomePlan.addActivity(act);
            person.addPlan(stayHomePlan);
            nonTravellers++;
          }
        }
      }
    }
    LOG.info("Total number of home locations fixed: " + homeLocationsFixed);
    LOG.info("      Total number of non-travellers: " + nonTravellers);
    LOG.info("Done fixing home locations.");

    /* TODO Check what to do with those household members that are not
     * travelling. Are they just given a single 'h' activities, and
     * left at that? */

    /* Look for erroneous activity times that can/should be fixed in
     * the raw travel diary input data. This will typically include very
     * long activity times or leg durations. */
    LOG.info("Checking leg durations:");
    int remainingLegOddities = 0;
    double legDurationThreshold = Time.parseTime("03:00:00");
    for (Person p : sc.getPopulation().getPersons().values()) {
      Plan plan = p.getSelectedPlan();
      if (plan != null) {
        for (PlanElement pe : plan.getPlanElements()) {
          if (pe instanceof Leg) {
            double duration = ((Leg) pe).getTravelTime();
            if (duration < 0 || duration > legDurationThreshold) {
              LOG.warn(
                  " -> Odd leg duration: "
                      + p.getId().toString()
                      + " ("
                      + Time.writeTime(duration)
                      + ")");
              remainingLegOddities++;
            }
          }
        }
      }
    }
    LOG.info("Done checking leg durations. (" + remainingLegOddities + " remain)");

    /* Parse the activity duration times in an effort to pick up
     * erroneous travel time data that results in negative activity
     * durations. Then fix in input data. */
    LOG.info("Checking activity durations (from leg times):");
    int remainingActivityOddities = 0;
    double activityDurationThreshold = Time.parseTime("16:00:00");
    for (Person p : sc.getPopulation().getPersons().values()) {
      Plan plan = p.getSelectedPlan();
      if (plan != null) {
        for (int i = 1; i < plan.getPlanElements().size() - 2; i += 2) {
          PlanElement pe1 = plan.getPlanElements().get(i);
          PlanElement pe2 = plan.getPlanElements().get(i + 2);
          if (pe1 instanceof Leg && pe2 instanceof Leg) {
            Leg l1 = (Leg) pe1;
            Leg l2 = (Leg) pe2;
            double act = l2.getDepartureTime() - (l1.getDepartureTime() + l1.getTravelTime());
            if (act < 0 || act > activityDurationThreshold) {
              LOG.warn(
                  " -> Odd activity duration: "
                      + p.getId().toString()
                      + " ("
                      + Time.writeTime(act)
                      + ")");
              remainingActivityOddities++;
            }
          } else {
            LOG.error("PlanElements not of type Leg!!");
            LOG.error("   pe1: " + pe1.getClass().toString());
            LOG.error("   pe2: " + pe2.getClass().toString());
          }
        }
      }
    }
    LOG.info("Done checking activity durations. (" + remainingActivityOddities + " remain)");

    /* TODO Fix plans for night workers. They typically start with 'h',
     * but should actually start with 'w'. */

    /* TODO Consider what to do with repeating activities, especially
     * consecutive home activities. */

    /* Convert all activity locations to a projected coordinate system. */
    LOG.info("Converting all activity locations to EPSG:3857...");
    CoordinateTransformation ct =
        TransformationFactory.getCoordinateTransformation("WGS84", "EPSG:3857");
    for (Person person : sc.getPopulation().getPersons().values()) {
      Plan plan = person.getSelectedPlan();
      if (plan != null) {
        for (PlanElement pe : plan.getPlanElements()) {
          if (pe instanceof Activity) {
            Activity act = (Activity) pe;
            ((ActivityImpl) act).setCoord(ct.transform(act.getCoord()));
          }
        }
      }
    }
    LOG.info("Done converting activity locations.");

    LOG.info("Done cleaning up scenario.");
  }
  @Test
  public void testPruneSmallestJointPlan() {
    final JointPlans jointPlans = new JointPlans();
    final Map<Id<Person>, Plan> smallJp = new HashMap<>();
    final Map<Id<Person>, Plan> bigJp = new HashMap<>();

    final ReplanningGroup group = new ReplanningGroup();

    Id<Person> id = Id.createPersonId(1);
    {
      final Person person = PopulationUtils.createPerson(id);
      group.addPerson(person);
      {
        final Plan plan = jointPlans.getFactory().createIndividualPlan(person);
        plan.setScore(1d);
        person.addPlan(plan);
        bigJp.put(id, plan);
      }
      {
        final Plan plan = jointPlans.getFactory().createIndividualPlan(person);
        plan.setScore(0d);
        person.addPlan(plan);
        smallJp.put(id, plan);
      }
    }

    id = Id.createPersonId(2);
    {
      final Person person = PopulationUtils.createPerson(id);
      group.addPerson(person);
      {
        final Plan plan = jointPlans.getFactory().createIndividualPlan(person);
        plan.setScore(0d);
        person.addPlan(plan);
        bigJp.put(id, plan);
      }
      {
        final Plan plan = jointPlans.getFactory().createIndividualPlan(person);
        plan.setScore(1d);
        person.addPlan(plan);
        smallJp.put(id, plan);
      }
    }

    id = Id.createPersonId(3);
    {
      final Person person = PopulationUtils.createPerson(id);
      group.addPerson(person);
      {
        final Plan plan = jointPlans.getFactory().createIndividualPlan(person);
        plan.setScore(1d);
        person.addPlan(plan);
        bigJp.put(id, plan);
      }
      {
        final Plan plan = jointPlans.getFactory().createIndividualPlan(person);
        plan.setScore(0d);
        person.addPlan(plan);
      }
    }

    jointPlans.addJointPlan(jointPlans.getFactory().createJointPlan(bigJp));
    jointPlans.addJointPlan(jointPlans.getFactory().createJointPlan(smallJp));

    test(new ConflictSolverTestsFixture(jointPlans, group, smallJp.values()));
  }
  @Override
  public void notifyShutdown(ShutdownEvent event) {
    Scenario newScenario = ScenarioUtils.createScenario(ConfigUtils.createConfig());
    Population newPopulation = newScenario.getPopulation();
    MoneyEventHandler moneyHandler = choiceGenerationControler.getMoneyEventHandler();
    CrowdingPsimHandler crowdingPsimHandler = choiceGenerationControler.getCrowdingPsimHandler();

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

      Id<Person> orgPersonId = Id.create(personId.toString().split("_")[0], Person.class);

      Double monetaryPayments = moneyHandler.getPersonId2amount().get(personId);
      if (monetaryPayments == null) {
        monetaryPayments = 0.0;
      }

      Plan planToAdd = null;
      if (personId.toString().contains("_")) {
        planToAdd = population.getPersons().get(personId).getSelectedPlan();
        planToAdd.getCustomAttributes().put("toll", monetaryPayments.toString());
        if (crowdingPsimHandler.getPerson2crowdingDisutility().containsKey(personId)) {
          planToAdd.setScore(
              planToAdd.getScore()
                  + crowdingPsimHandler.getPerson2crowdingDisutility().get(personId));
        }
      } else {
        planToAdd = initialPlans.get(personId);
        // planToAdd.getCustomAttributes().put("toll", monetaryPayments.toString());
      }

      if (newPopulation.getPersons().containsKey(orgPersonId)) {
        newPopulation.getPersons().get(orgPersonId).addPlan(planToAdd);
      } else {
        Person newPerson = newPopulation.getFactory().createPerson(orgPersonId);
        newPerson.addPlan(planToAdd);
        newPopulation.addPerson(newPerson);
      }
    }

    /*Write score table to SQL*/
    Integer relativeOutputDirectory =
        event.getServices().getConfig().controler().getOutputDirectory().split("/").length;

    String tableName = schema + ".scores_";
    String tableSuffix =
        event
            .getServices()
            .getConfig()
            .controler()
            .getOutputDirectory()
            .split("/")[relativeOutputDirectory - 1];
    tableSuffix = tableSuffix.replaceAll("\\.0x", "x");
    tableSuffix = tableSuffix.replaceAll("-", "_");
    tableSuffix = tableSuffix.replaceAll("\\.5", "5");
    tableSuffix = tableSuffix.replaceAll("\\.1", "1");
    tableSuffix = tableSuffix.replaceAll("\\.0", "0");
    tableName = tableName + tableSuffix;

    IndividualScoreFromPopulationSQLWriter sqlWriter =
        new IndividualScoreFromPopulationSQLWriter(event.getServices().getConfig(), newPopulation);
    sqlWriter.writeToDatabase(connectionPropertiesPath, schema, tableName);

    new PopulationWriter(newScenario.getPopulation())
        .write(
            choiceGenerationControler.getControler().getConfig().controler().getOutputDirectory()
                + "/output_plansJoin.xml");
  }
  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");

  }
Exemplo n.º 22
0
  private void createOnePerson(
      int i,
      Coord coord,
      Coord coordWork,
      String mode,
      String toFromPrefix,
      double personalRandom) {
    Id<Person> personId = Id.createPersonId(toFromPrefix + i);
    Person person = scenario.getPopulation().getFactory().createPerson(personId);

    Plan plan = scenario.getPopulation().getFactory().createPlan();

    // Planerzeugung inkl. Zufallslogik für Start- bzw. Endezeiten
    // 60% Plan: home-work-home

    // CARSHARING MODE
    if (personalRandom < 0.6) {
      double csRandom = rnd.nextDouble();
      if (csRandom > 0.33 && csRandom < 0.67) mode = "freefloating";
      if (csRandom >= 0.67) mode = "twowaycarsharing";
    }

    Activity home = scenario.getPopulation().getFactory().createActivityFromCoord("home", coord);
    double startTime =
        7.5 * 60 * 60 + (2 * 60 * 60 * rnd.nextDouble()); // ZufallsStartZeit 7.30-9.30Uhr
    home.setEndTime(startTime);
    plan.addActivity(home);

    Leg hinweg1 = scenario.getPopulation().getFactory().createLeg(mode);
    plan.addLeg(hinweg1);

    // 10% Plan: home-KINDERGARTEN1-work-KINDERGARTEN2-home
    // kindergarten AM
    if ((personalRandom > 0.6) && (personalRandom <= 0.7)) {

      Activity kindergarten1 =
          scenario
              .getPopulation()
              .getFactory()
              .createActivityFromCoord(
                  "kindergarten1", this.findClosestCoordFromMap(coord, kindergartens));
      kindergarten1.setEndTime(
          startTime + (0.4 * 60 * 60) + (0.1 * 60 * 60 * rnd.nextDouble())); // DropOff-Zeit 5-10min
      plan.addActivity(kindergarten1);

      Leg hinweg2 = scenario.getPopulation().getFactory().createLeg(mode);
      plan.addLeg(hinweg2);
    }

    Activity work =
        scenario.getPopulation().getFactory().createActivityFromCoord("work", coordWork);
    double workEndTime =
        startTime
            + (7.5 * 60 * 60)
            + (1 * 60 * 60 * rnd.nextDouble()); // Arbeitszeit 7,5-8,5 Stunden
    work.setEndTime(workEndTime);
    plan.addActivity(work);

    Leg rueckweg1 = scenario.getPopulation().getFactory().createLeg(mode);
    plan.addLeg(rueckweg1);

    // kindergarten PM
    if ((personalRandom > 0.6) && (personalRandom <= 0.7)) {

      Activity kindergarten2 =
          scenario
              .getPopulation()
              .getFactory()
              .createActivityFromCoord(
                  "kindergarten2", this.findClosestCoordFromMap(coord, kindergartens));
      kindergarten2.setEndTime(
          workEndTime
              + (0.4 * 60 * 60)
              + (0.1 * 60 * 60 * rnd.nextDouble())); // PickUp-Zeit 5-10min
      plan.addActivity(kindergarten2);

      Leg rückweg2 = scenario.getPopulation().getFactory().createLeg(mode);
      plan.addLeg(rückweg2);
    }

    // 30% Plan: home-work-home-SHOPPEN-home
    if (personalRandom > 0.7) {

      Activity home2 = scenario.getPopulation().getFactory().createActivityFromCoord("home", coord);
      double startShoppingTime = workEndTime + (1 * 60 * 60) + (0.5 * 60 * 60 * rnd.nextDouble());
      home2.setEndTime(startShoppingTime);
      plan.addActivity(home2);

      Leg zumShoppen = scenario.getPopulation().getFactory().createLeg(mode);
      plan.addLeg(zumShoppen);

      Activity shopping =
          scenario
              .getPopulation()
              .getFactory()
              .createActivityFromCoord("shopping", this.findClosestCoordFromMap(coord, shops));
      shopping.setEndTime(
          startShoppingTime
              + (1 * 60 * 60)
              + (1 * 60 * 60 * rnd.nextDouble())); // Shoppen 1-2 Stunden
      plan.addActivity(shopping);

      Leg vomShoppen = scenario.getPopulation().getFactory().createLeg(mode);
      plan.addLeg(vomShoppen);
    }

    Activity home3 = scenario.getPopulation().getFactory().createActivityFromCoord("home", coord);
    plan.addActivity(home3);

    person.addPlan(plan);
    scenario.getPopulation().addPerson(person);
  }
Exemplo n.º 23
0
 @Override
 public boolean addPlan(Plan p) {
   return delegate.addPlan(p);
 }
Exemplo n.º 24
0
  private void createOneVWShiftWorker(int i, Coord homeC, String mode, String fromToPrefix) {
    int additionalTrips = random.nextInt(4);

    Id<Person> personId = Id.createPersonId(fromToPrefix + i + "vw");
    Person person = scenario.getPopulation().getFactory().createPerson(personId);

    Plan plan = scenario.getPopulation().getFactory().createPlan();

    int rand = random.nextInt(3) + 1;
    switch (rand) {
      case 1:
        Activity home =
            scenario.getPopulation().getFactory().createActivityFromCoord("home", homeC);
        home.setEndTime(5 * 60 * 60);
        plan.addActivity(home);

        Leg outboundTrip = scenario.getPopulation().getFactory().createLeg(mode);
        plan.addLeg(outboundTrip);

        Coord coord3 = scenario.getNetwork().getLinks().get(calcVWWorkLinkId()).getCoord();
        Activity shift1 =
            scenario.getPopulation().getFactory().createActivityFromCoord("work_vw_shift1", coord3);
        shift1.setEndTime(13 * 60 * 60 + 40 * 60);
        plan.addActivity(shift1);
        if (additionalTrips == 1 || additionalTrips == 3) {
          enrichPlanBySingleLegAndActivity(coord3, plan, mode, 5400, false);
        }

        Leg returnTrip = scenario.getPopulation().getFactory().createLeg(mode);
        plan.addLeg(returnTrip);

        Activity home2 =
            scenario.getPopulation().getFactory().createActivityFromCoord("home", homeC);
        plan.addActivity(home2);
        if (additionalTrips > 1) {
          home2.setMaximumDuration(random.nextInt(5400));

          enrichPlanByReturnLegAndActivity(home2, plan, mode, 5400);
        }
        break;
      case 2:
        home = scenario.getPopulation().getFactory().createActivityFromCoord("home", homeC);
        home.setEndTime(13 * 60 * 60);

        plan.addActivity(home);

        if (additionalTrips > 1) {

          enrichPlanByReturnLegAndActivity(home, plan, mode, 5400);
          home.setEndTime(8 * 3600 + random.nextInt(7200));
          ;
        }

        if (additionalTrips == 1 || additionalTrips == 3) {
          enrichPlanBySingleLegAndActivity(homeC, plan, mode, 5400, false);
        }
        outboundTrip = scenario.getPopulation().getFactory().createLeg(mode);
        plan.addLeg(outboundTrip);

        Coord coord = scenario.getNetwork().getLinks().get(calcVWWorkLinkId()).getCoord();
        Activity shift2 =
            scenario.getPopulation().getFactory().createActivityFromCoord("work_vw_shift2", coord);
        shift2.setEndTime(21 * 60 * 60 + 40 * 60);
        plan.addActivity(shift2);

        returnTrip = scenario.getPopulation().getFactory().createLeg(mode);
        plan.addLeg(returnTrip);

        home2 = scenario.getPopulation().getFactory().createActivityFromCoord("home", homeC);
        plan.addActivity(home2);

        break;
      case 3:
        Id<Link> workLink = calcVWWorkLinkId();
        Coord coord2 = scenario.getNetwork().getLinks().get(workLink).getCoord();
        Activity shift3 =
            scenario.getPopulation().getFactory().createActivityFromCoord("work_vw_shift3", coord2);
        shift3.setEndTime(5 * 60 * 60 + 40 * 60);
        plan.addActivity(shift3);

        if (additionalTrips == 1 || additionalTrips == 3) {
          enrichPlanBySingleLegAndActivity(coord2, plan, mode, 5400, false);
        }
        outboundTrip = scenario.getPopulation().getFactory().createLeg(mode);
        plan.addLeg(outboundTrip);

        home = scenario.getPopulation().getFactory().createActivityFromCoord("homeD", homeC);
        home.setEndTime(21 * 60 * 60);
        plan.addActivity(home);

        if (additionalTrips > 1) {

          enrichPlanByReturnLegAndActivity(home, plan, mode, 5400);
          home.setEndTime(8 * 3600 + random.nextInt(7200));
          ;
        }

        outboundTrip = scenario.getPopulation().getFactory().createLeg(mode);
        plan.addLeg(outboundTrip);

        Activity shift32 =
            scenario
                .getPopulation()
                .getFactory()
                .createActivityFromCoord(
                    "work_vw_shift3", scenario.getNetwork().getLinks().get(workLink).getCoord());

        plan.addActivity(shift32);
        break;
    }

    person.addPlan(plan);
    scenario.getPopulation().addPerson(person);
  }
Exemplo n.º 25
0
  public static void main(String[] args) {

    /*
     * We enter coordinates in the WGS84 reference system, but we want them to appear in the population file
     * projected to UTM33N, because we also generated the network in UTM33N.
     */
    CoordinateTransformation ct =
        TransformationFactory.getCoordinateTransformation(
            TransformationFactory.WGS84, TransformationFactory.WGS84_UTM33N);

    /*
     * First, create a new Config and a new Scenario.
     */
    Config config = ConfigUtils.createConfig();
    Scenario sc = ScenarioUtils.createScenario(config);

    /*
     * Pick the Network and the Population out of the Scenario for convenience.
     */
    Network network = sc.getNetwork();
    Population population = sc.getPopulation();

    /*
     * Pick the PopulationFactory out of the Population for convenience.
     * It contains methods to create new Population items.
     */
    PopulationFactory populationFactory = population.getFactory();

    /*
     * Create a Person designated "1" and add it to the Population.
     */

    long key = 1;
    for (long i = 1; i <= 5000; i++) {
      key = i;
      Person person = populationFactory.createPerson(Id.createPersonId(key));
      population.addPerson(person);

      /*
       * Create a Plan for the Person
       */
      Plan plan = populationFactory.createPlan();

      /*
       * Create a "home" Activity for the Person. In order to have the Person end its day at the same location,
       * we keep the home coordinates for later use (see below).
       * Note that we use the CoordinateTransformation created above.
       */
      Coord homeCoordinates = new Coord(686661.13571, 4827510.51845);
      Activity activity1 = populationFactory.createActivityFromCoord("home", homeCoordinates);
      activity1.setEndTime(
          21600
              + i * 0.72); // leave at 6 o'clock, one vehicle entering after other in a short while
      // so that there is no peak at one second
      // activity1.setEndTime(21600);
      plan.addActivity(activity1); // add the Activity to the Plan

      /*
       * Create a Leg. A Leg initially hasn't got many attributes. It just says that a car will be used.
       */
      plan.addLeg(populationFactory.createLeg("car"));

      /*
       * Create a "work" Activity, at a different location.
       */
      Activity activity2 =
          populationFactory.createActivityFromCoord("work", new Coord(689426.65361, 4826700.65288));
      activity2.setEndTime(57600); // leave at 4 p.m.
      plan.addActivity(activity2);
      System.out.println("Last Departure Time: " + claculateTime(activity1.getEndTime()));

      /*
       * Create another car Leg.
       */
      person.addPlan(plan);
    }

    for (long i = 1; i <= 5000; i++) {
      key = i + 5000;
      Person person = populationFactory.createPerson(Id.createPersonId(key));
      population.addPerson(person);
      Plan plan = populationFactory.createPlan();
      Coord homeCoordinates = new Coord(686661.13571, 4826063.88649);
      Activity activity1 = populationFactory.createActivityFromCoord("home", homeCoordinates);
      activity1.setEndTime(21600 + i * 1); // leave at 6 o'clock
      // activity1.setEndTime(21600);
      plan.addActivity(activity1); // add the Activity to the Plan
      plan.addLeg(populationFactory.createLeg("car"));
      Activity activity2 =
          populationFactory.createActivityFromCoord("work", new Coord(689426.65361, 4826700.65288));
      activity2.setEndTime(57600); // leave at 4 p.m.
      plan.addActivity(activity2);
      System.out.println("Last Departure Time: " + claculateTime(activity1.getEndTime()));
      person.addPlan(plan);
    }

    /*
     * Write the population (of 1 Person) to a file.
     */
    MatsimWriter popWriter =
        new org.matsim.api.core.v01.population.PopulationWriter(population, network);
    popWriter.write("H:\\Mike Work\\input\\population.xml");
  }
Exemplo n.º 26
0
  private static void makePopulation(
      final int nOfPersonFromEachHome, final String networkFilename, final String filename) {
    Scenario sc = ScenarioUtils.createScenario(ConfigUtils.createConfig());
    Population pop = sc.getPopulation();
    PopulationFactory pf = pop.getFactory();

    Random r = new Random(4711);
    int pId = 0;

    double baseX = 1000;
    double baseY = 1000;
    for (int i = 0; i < nOfPersonFromEachHome; i++) {
      pId++;
      String mode = (r.nextDouble() < 0.50 ? TransportMode.car : TransportMode.pt);

      Person person = pf.createPerson(Id.create(pId, Person.class));
      Plan plan = pf.createPlan();
      Coord homeCoord =
          new Coord(
              (double) (int) (baseX - 450 + 900 * r.nextDouble()),
              (double) (int) (baseY - 450 + 900 * r.nextDouble()));
      fillPlan(plan, mode, r, pf, homeCoord);
      person.addPlan(plan);
      pop.addPerson(person);
    }

    baseX = 1000;
    baseY = 4000;
    for (int i = 0; i < nOfPersonFromEachHome; i++) {
      pId++;
      String mode = (r.nextDouble() < 0.50 ? TransportMode.car : TransportMode.pt);

      Person person = pf.createPerson(Id.create(pId, Person.class));
      Plan plan = pf.createPlan();
      Coord homeCoord =
          new Coord(
              (double) (int) (baseX - 450 + 900 * r.nextDouble()),
              (double) (int) (baseY - 450 + 900 * r.nextDouble()));
      fillPlan(plan, mode, r, pf, homeCoord);
      person.addPlan(plan);
      pop.addPerson(person);
    }

    baseX = 4000;
    baseY = 4000;
    for (int i = 0; i < nOfPersonFromEachHome; i++) {
      pId++;
      String mode = (r.nextDouble() < 0.50 ? TransportMode.car : TransportMode.pt);

      Person person = pf.createPerson(Id.create(pId, Person.class));
      Plan plan = pf.createPlan();
      Coord homeCoord =
          new Coord(
              (double) (int) (baseX - 450 + 900.0 * r.nextDouble()),
              (double) (int) (baseY - 450 + 900.0 * r.nextDouble()));
      fillPlan(plan, mode, r, pf, homeCoord);
      person.addPlan(plan);
      pop.addPerson(person);
    }

    new MatsimNetworkReader(sc.getNetwork()).readFile(networkFilename);
    NetworkImpl carNetwork = NetworkImpl.createNetwork();
    new TransportModeNetworkFilter(sc.getNetwork())
        .filter(carNetwork, CollectionUtils.stringToSet(TransportMode.car));
    new XY2Links(carNetwork, null).run(pop);

    new PopulationWriter(pop, null).write(filename);
  }