@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"));
}
@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);
}
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);
}
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");
}
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);
}
private static void fillPlan(
final Plan plan,
final String mode,
final Random r,
final PopulationFactory pf,
Coord homeCoord) {
Activity h1 = pf.createActivityFromCoord("h", homeCoord);
h1.setEndTime(7.0 * 3600 + r.nextDouble() * 3600.0);
plan.addActivity(h1);
Leg leg1 = pf.createLeg(mode);
plan.addLeg(leg1);
Coord workCoord;
if (r.nextDouble() < 0.5) {
workCoord =
new Coord(
(double) (int) (loc1X - 450 + 900.0 * r.nextDouble()),
(double) (int) (loc1Y - 450 + 900.0 * r.nextDouble()));
} else {
workCoord =
new Coord(
(double) (int) (loc2X - 450 + 900.0 * r.nextDouble()),
(double) (int) (loc2Y - 450 + 900.0 * r.nextDouble()));
}
Activity w = pf.createActivityFromCoord("w", workCoord);
w.setEndTime(17.0 * 3600 + r.nextDouble() * 3600.0);
plan.addActivity(w);
Leg leg2 = pf.createLeg(mode);
plan.addLeg(leg2);
if (r.nextDouble() < 0.5) {
// add shop activity
Coord shopCoord;
if (r.nextDouble() < 0.5) {
shopCoord =
new Coord(
(double) (int) (loc1X - 450 + 900.0 * r.nextDouble()),
(double) (int) (loc1Y - 450 + 900.0 * r.nextDouble()));
} else {
shopCoord =
new Coord(
(double) (int) (loc2X - 450 + 900.0 * r.nextDouble()),
(double) (int) (loc2Y - 450 + 900.0 * r.nextDouble()));
}
Activity s = pf.createActivityFromCoord("s", shopCoord);
s.setEndTime(w.getEndTime() + r.nextDouble() * 3600.0);
plan.addActivity(s);
Leg leg3 = pf.createLeg(mode);
plan.addLeg(leg3);
}
Activity h2 = pf.createActivityFromCoord("h", homeCoord);
plan.addActivity(h2);
}
@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"));
}
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"
}
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;
}
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);
}
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);
// }
}
private String enrichPlanBySingleLegAndActivity(
Coord lastActivityCoord, Plan plan, String oldmode, int maxDur, boolean canChangeMode) {
String mode = oldmode;
Coord nextDestination;
String nextActivity;
double duration;
double r = random.nextDouble();
if (r < 0.25) {
nextActivity = "private";
nextDestination = findClosestCoordFromMapRandomized(lastActivityCoord, residential, 20);
duration = 600 + random.nextInt(maxDur);
} else if (r < 0.5) {
nextActivity = "leisure";
nextDestination = findClosestCoordFromMapRandomized(lastActivityCoord, schools, 5);
duration = 600 + random.nextInt(maxDur);
} else {
nextActivity = "shopping";
nextDestination = findClosestCoordFromMapRandomized(lastActivityCoord, retail, 10);
duration = 600 + random.nextInt(maxDur);
}
Activity next =
scenario
.getPopulation()
.getFactory()
.createActivityFromCoord(nextActivity, nextDestination);
next.setMaximumDuration(duration);
double distance = CoordUtils.calcDistance(nextDestination, lastActivityCoord);
if (canChangeMode) {
if (distance < 500) {
mode = "walk";
} else if (distance < 3000) {
if (random.nextBoolean()) mode = "car";
else if (random.nextBoolean()) mode = "bike";
else mode = "pt";
} else {
if (random.nextBoolean()) mode = "car";
else mode = "pt";
}
}
plan.addLeg(scenario.getPopulation().getFactory().createLeg(mode));
plan.addActivity(next);
return mode;
}
private void enrichPlanByReturnLegAndActivity(Activity last, Plan plan, String mode, int maxDur) {
double lastEnd = 0.0;
if (last.getEndTime() != Time.UNDEFINED_TIME) {
lastEnd = last.getEndTime();
}
String newMode = enrichPlanBySingleLegAndActivity(last.getCoord(), plan, mode, maxDur, true);
Leg returnTrip = scenario.getPopulation().getFactory().createLeg(newMode);
plan.addLeg(returnTrip);
Activity home =
scenario
.getPopulation()
.getFactory()
.createActivityFromCoord(last.getType(), last.getCoord());
if (lastEnd != 0.0) {
home.setEndTime(lastEnd);
}
plan.addActivity(home);
}
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");
}
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);
}
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());
}
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);
}
/**
* 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());
}
}
/**
* 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);
}
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.");
}
private void processDiary() {
LOG.info("Processing diary...");
PopulationFactory pf = this.sc.getPopulation().getFactory();
Map<String, Integer> chainCount = new TreeMap<>();
int noTrips = 0;
int noFirstTrip = 0;
int noZoneInfo = 0;
int zoneInfo = 0;
Counter counter = new Counter(" person # ");
for (Id<Person> pId : this.tripMap.keySet()) {
List<String[]> list = tripMap.get(pId);
Map<String, String[]> map = new TreeMap<>();
for (String[] sa : list) {
String tripNumber = sa[23];
if (!tripNumber.equals("")) {
String tripId = String.format("%02d", Integer.parseInt(tripNumber));
map.put(tripId, sa);
}
}
if (map.size() == 0) {
noTrips++;
} else {
/* Try and do some magic with the diary. */
Plan plan = pf.createPlan();
/* Check the first activity. */
String chain = "";
String[] sa = map.get("01");
if (sa == null) {
/* There is no first trip numbered '01'. */
LOG.warn(pId.toString() + ": " + map.keySet().toString());
noFirstTrip++;
} else {
chain += "h";
String homeZone = sa[7];
Coord homeCoord = sampleCoord(homeZone, "h");
Activity firstHome = pf.createActivityFromCoord("h", homeCoord);
double homeEnd = 0.0;
try {
homeEnd = Time.parseTime(sa[25]);
} catch (NumberFormatException e) {
LOG.error(" TIME: ===> " + pId.toString() + ": " + sa[25]);
}
firstHome.setEndTime(homeEnd);
plan.addActivity(firstHome);
}
/* Parse the chain. */
Iterator<String> it = map.keySet().iterator();
while (it.hasNext()) {
String trip = it.next();
String[] tripSa = map.get(trip);
String tripPurpose = tripSa[33];
String matsimTrip =
DiaryEnums.TripPurpose.parseFromCode(
tripPurpose.equals("") || tripPurpose.equals(" ")
? 0
: Integer.parseInt(tripPurpose))
.getMatsimActivityCode();
chain += "-" + matsimTrip;
/* Add the trip to plan. */
String recordedMode = tripSa[34];
if (recordedMode.contains(";")) {
LOG.error("Multiple modes for " + pId.toString() + ": " + recordedMode);
throw new RuntimeException();
}
String matsimMode =
DiaryEnums.ModeOfTravel.parseFromCode(
tripSa[34].equals("") || tripSa[34].equalsIgnoreCase(" ")
? 0
: Integer.parseInt(tripSa[34]))
.getMatsimMode();
Leg leg = pf.createLeg(matsimMode);
double tripStartTime = 0.0;
double tripEndTime = 0.0;
try {
tripStartTime = Time.parseTime(tripSa[25]);
} catch (NumberFormatException e) {
LOG.error(" TIME: ===> " + pId.toString() + ": " + tripSa[25]);
}
try {
tripEndTime = Time.parseTime(tripSa[27]);
} catch (NumberFormatException e) {
LOG.error(" TIME: ===> " + pId.toString() + ": " + tripSa[27]);
}
leg.setDepartureTime(tripStartTime);
leg.setTravelTime(tripEndTime - tripStartTime);
plan.addLeg(leg);
/* Add the destination activity. */
if (tripSa[32].equals("") || tripSa[32].equals(" ")) {
if (!matsimTrip.equalsIgnoreCase("h")) {
zoneInfo++;
} else {
noZoneInfo++;
}
} else {
zoneInfo++;
}
Coord actCoord = sampleCoord(tripSa[32], matsimTrip);
Activity act = pf.createActivityFromCoord(matsimTrip, actCoord);
act.setStartTime(tripEndTime);
plan.addActivity(act);
}
/* Check and add chain. */
if (!chainCount.containsKey(chain)) {
chainCount.put(chain, 1);
} else {
int oldCount = chainCount.get(chain);
chainCount.put(chain, oldCount + 1);
}
/* Finally, associate the plan with the person. */
sc.getPopulation().getPersons().get(pId).addPlan(plan);
}
counter.incCounter();
}
counter.printCounter();
LOG.info(" Number of persons with no trips: " + noTrips);
LOG.info(" Number of persons with no first trips: " + noFirstTrip);
LOG.info(" Number of destinations without zone info: " + noZoneInfo);
LOG.info(" Number of destinations with zone info: " + zoneInfo);
/* Report the activity chain types. */
SortedSet<Entry<String, Integer>> set = entriesSortedByValues(chainCount);
Iterator<Entry<String, Integer>> iter = set.iterator();
while (iter.hasNext()) {
Entry<String, Integer> entry = iter.next();
LOG.info(" " + entry.getKey() + " (" + entry.getValue() + ")");
}
LOG.info("Done processing diary.");
}
