@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 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"));
}
@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);
}
@Test
public void testPersonAttributesIO() {
final Population population = PopulationUtils.createPopulation(ConfigUtils.createConfig());
final Person person = population.getFactory().createPerson(Id.createPersonId("Donald Trump"));
population.addPerson(person);
person.getAttributes().putAttribute("brain", false);
person.getAttributes().putAttribute("party", "republican");
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"));
Assert.assertEquals(
"Unexpected boolean attribute in " + readPerson.getAttributes(),
person.getAttributes().getAttribute("brain"),
readPerson.getAttributes().getAttribute("brain"));
Assert.assertEquals(
"Unexpected String attribute in " + readPerson.getAttributes(),
person.getAttributes().getAttribute("party"),
readPerson.getAttributes().getAttribute("party"));
}
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");
}
@Test
public void testEmptyPersonAttributesIO() {
final Population population = PopulationUtils.createPopulation(ConfigUtils.createConfig());
final Person person = population.getFactory().createPerson(Id.createPersonId("Donald Trump"));
population.addPerson(person);
final String file = utils.getOutputDirectory() + "/population.xml";
new PopulationWriter(population).writeV6(file);
// just check everything works without attributes (dtd validation etc)
final Scenario readScenario = ScenarioUtils.createScenario(ConfigUtils.createConfig());
new PopulationReader(readScenario).readFile(file);
}
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 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");
}
/**
* 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 buildPopulation() {
if (householdMap.size() == 0 || personMap.size() == 0) {
throw new RuntimeException("Either the househols or persons are of size ZERO!");
}
LOG.info("Checking that each person has an associated household in the map...");
for (Id<Person> i : personMap.keySet()) {
String s = i.toString().split("_")[0];
if (!householdMap.containsKey(Id.create(s, Household.class))) {
LOG.warn("Could not find household " + s);
}
}
LOG.info("Done checking person-household match.");
this.households = new HouseholdsImpl();
HouseholdsFactory hhf = households.getFactory();
Population population = sc.getPopulation();
PopulationFactoryImpl pf = (PopulationFactoryImpl) population.getFactory();
for (Id<Person> pid : personMap.keySet()) {
String[] sa = personMap.get(pid).split(",");
String quarterType = sa[0];
int age = Integer.parseInt(sa[1]);
String gender = sa[2].equalsIgnoreCase("Male") ? "m" : "f";
String relationship = sa[3];
String race = sa[4];
String school = sa[5];
boolean employment = sa[6].equalsIgnoreCase("Yes") ? true : false;
String mainPlaceOfWork = sa[7];
String modeToMain = sa[8];
Double income = Double.parseDouble(sa[9]);
Person person = pf.createPerson(pid);
PersonUtils.setAge(person, age);
PersonUtils.setSex(person, gender);
PersonUtils.setEmployed(person, employment);
personAttributes.putAttribute(pid.toString(), "quarterType", quarterType);
personAttributes.putAttribute(pid.toString(), "relationship", relationship);
personAttributes.putAttribute(pid.toString(), "race", race);
personAttributes.putAttribute(pid.toString(), "school", school);
personAttributes.putAttribute(pid.toString(), "mainPlaceOfWork", mainPlaceOfWork);
personAttributes.putAttribute(pid.toString(), "modeToMain", modeToMain);
personAttributes.putAttribute(pid.toString(), "income", income);
population.addPerson(person);
/* Add to household */
Id<Household> hid = Id.create(pid.toString().split("_")[0], Household.class);
if (!this.households.getHouseholds().containsKey(hid)) {
/* Household data */
String[] hsa = householdMap.get(hid).split(",");
int hhSize = Integer.parseInt(hsa[0]);
String dwellingType = hsa[1];
String hhPopulation = hsa[2];
String incomeString = hsa[3];
Income hhIncome = null;
if (!incomeString.equalsIgnoreCase("Unknown")) {
hhIncome = hhf.createIncome(Double.parseDouble(hsa[3]), IncomePeriod.year);
}
Household hh = hhf.createHousehold(hid);
hh.setIncome(hhIncome);
householdAttributes.putAttribute(hid.toString(), "dwellingType", dwellingType);
householdAttributes.putAttribute(hid.toString(), "householdSize", hhSize);
householdAttributes.putAttribute(hid.toString(), "population", hhPopulation);
/* Geography data */
String[] gsa = geographyMap.get(hid).split(",");
String municipalCode = gsa[0];
String municipalName = gsa[1];
String magisterialCode = gsa[2];
String magisterialName = gsa[3];
String districtCode = gsa[4];
String districtName = gsa[5];
String provinceCode = gsa[6];
String provinceName = gsa[7];
String eaType = gsa[8];
householdAttributes.putAttribute(hid.toString(), "municipalCode", municipalCode);
householdAttributes.putAttribute(
hid.toString(), "municipalName", correctCase(municipalName));
householdAttributes.putAttribute(hid.toString(), "magisterialCode", magisterialCode);
householdAttributes.putAttribute(
hid.toString(), "magisterialName", correctCase(magisterialName));
householdAttributes.putAttribute(hid.toString(), "districtCode", districtCode);
householdAttributes.putAttribute(hid.toString(), "districtName", correctCase(districtName));
householdAttributes.putAttribute(hid.toString(), "provinceCode", provinceCode);
householdAttributes.putAttribute(hid.toString(), "provinceName", correctCase(provinceName));
householdAttributes.putAttribute(hid.toString(), "eaType", eaType);
this.households.getHouseholds().put(hid, hh);
}
this.households.getHouseholds().get(hid).getMemberIds().add(pid);
}
/* Validate: */
LOG.info("================================================================");
LOG.info("Validating the population and households");
LOG.info("----------------------------------------------------------------");
LOG.info("Person map: " + personMap.size());
LOG.info("Household map: " + householdMap.size());
LOG.info("----------------------------------------------------------------");
LOG.info("Population size: " + sc.getPopulation().getPersons().size());
LOG.info("Number of households: " + households.getHouseholds().size());
LOG.info("================================================================");
}
@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");
}
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);
}
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());
}