/**
* Contains rules about when to leave an Activity, considering the current time and the properties
* of the Activity. Specifically, determines how maximum duration and specific end time are played
* against each other.
*
* @param act The Activity
* @param now The current simulation time
* @param activityDurationInterpretation The name of one of several rules of how to interpret
* Activity fields.
* @return The departure time
*/
static double calculateDepartureTime(
Activity act,
double now,
PlansConfigGroup.ActivityDurationInterpretation activityDurationInterpretation) {
if (act.getMaximumDuration() == Time.UNDEFINED_TIME
&& (act.getEndTime() == Time.UNDEFINED_TIME)) {
// yyyy does this make sense? below there is at least one execution path where this should
// lead to an exception. kai, oct'10
return Double.POSITIVE_INFINITY;
} else {
double departure = 0;
if (activityDurationInterpretation.equals(
PlansConfigGroup.ActivityDurationInterpretation.minOfDurationAndEndTime)) {
// person stays at the activity either until its duration is over or until its end time,
// whatever comes first
if (act.getMaximumDuration() == Time.UNDEFINED_TIME) {
departure = act.getEndTime();
} else if (act.getEndTime() == Time.UNDEFINED_TIME) {
departure = now + act.getMaximumDuration();
} else {
departure = Math.min(act.getEndTime(), now + act.getMaximumDuration());
}
} else if (activityDurationInterpretation.equals(
PlansConfigGroup.ActivityDurationInterpretation.endTimeOnly)) {
if (act.getEndTime() != Time.UNDEFINED_TIME) {
departure = act.getEndTime();
} else {
throw new IllegalStateException(
"activity end time not set and using something else not allowed.");
}
} else if (activityDurationInterpretation.equals(
PlansConfigGroup.ActivityDurationInterpretation.tryEndTimeThenDuration)) {
// In fact, as of now I think that _this_ should be the default behavior. kai, aug'10
if (act.getEndTime() != Time.UNDEFINED_TIME) {
departure = act.getEndTime();
} else if (act.getMaximumDuration() != Time.UNDEFINED_TIME) {
departure = now + act.getMaximumDuration();
} else {
throw new IllegalStateException(
"neither activity end time nor activity duration defined; don't know what to do.");
}
} else {
throw new IllegalStateException("should not happen");
}
if (departure < now) {
// we cannot depart before we arrived, thus change the time so the time stamp in events will
// be right
// [[how can events not use the simulation time? kai, aug'10]]
departure = now;
// actually, we will depart in (now+1) because we already missed the departing in this time
// step
}
return departure;
}
}
private void handleFirstActivity(EventsToScore eventsToScore, Fixture f, Activity activity) {
eventsToScore.handleEvent(
new ActivityEndEvent(
activity.getEndTime(),
f.person.getId(),
activity.getLinkId(),
activity.getFacilityId(),
activity.getType()));
}
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);
}
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);
}
private void writeAct(final Activity act, final BufferedWriter out) throws IOException {
out.write("\t\t\t<act type=\"");
out.write(act.getType());
out.write("\"");
if (act.getLinkId() != null) {
out.write(" link=\"");
out.write(act.getLinkId().toString());
out.write("\"");
}
if (act.getFacilityId() != null) {
out.write(" facility=\"");
out.write(act.getFacilityId().toString());
out.write("\"");
}
if (act.getCoord() != null) {
final Coord coord = coordinateTransformation.transform(act.getCoord());
out.write(" x=\"");
out.write(Double.toString(coord.getX()));
out.write("\" y=\"");
out.write(Double.toString(coord.getY()));
out.write("\"");
}
if (act.getStartTime() != Time.UNDEFINED_TIME) {
out.write(" start_time=\"");
out.write(Time.writeTime(act.getStartTime()));
out.write("\"");
}
if (act != null) {
Activity a = act;
if (a.getMaximumDuration() != Time.UNDEFINED_TIME) {
out.write(" max_dur=\"");
out.write(Time.writeTime(a.getMaximumDuration()));
out.write("\"");
}
}
if (act.getEndTime() != Time.UNDEFINED_TIME) {
out.write(" end_time=\"");
out.write(Time.writeTime(act.getEndTime()));
out.write("\"");
}
out.write(" />\n");
}
@Override
public final void handleActivity(Activity activity) {
double startTime = activity.getStartTime();
double endTime = activity.getEndTime();
if (startTime == Time.UNDEFINED_TIME && endTime != Time.UNDEFINED_TIME) {
for (ActivityScoring activityScoringFunction : activityScoringFunctions) {
activityScoringFunction.handleFirstActivity(activity);
}
} else if (startTime != Time.UNDEFINED_TIME && endTime != Time.UNDEFINED_TIME) {
for (ActivityScoring activityScoringFunction : activityScoringFunctions) {
activityScoringFunction.handleActivity(activity);
}
} else if (startTime != Time.UNDEFINED_TIME && endTime == Time.UNDEFINED_TIME) {
for (ActivityScoring activityScoringFunction : activityScoringFunctions) {
activityScoringFunction.handleLastActivity(activity);
}
} else {
throw new RuntimeException(
"Trying to score an activity without start or end time. Should not happen.");
}
}
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");
}
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.");
}
/**
* @param args
* @throws FactoryException
*/
public static void main(String[] args) throws FactoryException {
String popFile = args[0];
String facFile = args[1];
String netFile = args[2];
int n = Integer.parseInt(args[3]);
String outDir = args[4];
Logger logger = Logger.getLogger(DemoScenario.class);
MathTransform transform = CRS.findMathTransform(CRSUtils.getCRS(31467), CRSUtils.getCRS(3857));
Config config = ConfigUtils.createConfig();
Scenario scenario = ScenarioUtils.createScenario(config);
/*
* remove foreign persons and extract subsample
*/
logger.info("Loading persons...");
MatsimPopulationReader pReader = new MatsimPopulationReader(scenario);
pReader.readFile(popFile);
logger.info("Done.");
logger.info("Removing foreign persons...");
Set<Id<Person>> remove = new HashSet<>();
for (Id<Person> id : scenario.getPopulation().getPersons().keySet()) {
if (id.toString().startsWith("foreign")) {
remove.add(id);
}
}
int cnt = 0;
for (Id<Person> id : remove) {
if (scenario.getPopulation().getPersons().remove(id) != null) {
cnt++;
}
}
logger.info(String.format("Done. Removed %s foreign persons.", cnt));
logger.info("Drawing population subsample...");
List<Person> persons = new ArrayList<>(scenario.getPopulation().getPersons().values());
Collections.shuffle(persons);
Population population = PopulationUtils.createPopulation(config);
cnt = 0;
for (int i = 0; i < n; i++) {
population.addPerson(persons.get(i));
}
logger.info("Done.");
logger.info("Bluring activity end times...");
Random random = new XORShiftRandom();
for (Person person : population.getPersons().values()) {
for (Plan plan : person.getPlans()) {
for (int i = 0; i < plan.getPlanElements().size(); i += 2) {
Activity act = (Activity) plan.getPlanElements().get(i);
double endTim = act.getEndTime() - 15 * 60 + (random.nextDouble() * 30 * 60);
act.setEndTime(endTim);
double startTim = act.getStartTime() - 15 * 60 + (random.nextDouble() * 30 * 60);
act.setStartTime(startTim);
}
}
}
logger.info("Done.");
logger.info("Writing population...");
PopulationWriter pWriter = new PopulationWriter(population);
pWriter.write(String.format("%s/plans.xml.gz", outDir));
logger.info("Done.");
/*
* filter only used facilities
*/
logger.info("Loading facilities...");
MatsimFacilitiesReader fReader = new MatsimFacilitiesReader(scenario);
fReader.readFile(facFile);
logger.info("Done.");
logger.info("Removing unsused facilities...");
Set<Id<ActivityFacility>> unused =
new HashSet<>(scenario.getActivityFacilities().getFacilities().keySet());
for (Person person : population.getPersons().values()) {
for (Plan plan : person.getPlans()) {
for (int i = 0; i < plan.getPlanElements().size(); i += 2) {
Activity act = (Activity) plan.getPlanElements().get(i);
unused.remove(act.getFacilityId());
}
}
}
logger.info("Done.");
logger.info("Transforming facility coordinates...");
for (ActivityFacility fac : scenario.getActivityFacilities().getFacilities().values()) {
double[] points = new double[] {fac.getCoord().getX(), fac.getCoord().getY()};
try {
transform.transform(points, 0, points, 0, 1);
} catch (TransformException e) {
e.printStackTrace();
}
((ActivityFacilityImpl) fac).setCoord(new Coord(points[0], points[1]));
}
logger.info("Done.");
logger.info("Writing facilities...");
FacilitiesWriter fWrtier = new FacilitiesWriter(scenario.getActivityFacilities());
fWrtier.write(String.format("%s/facilities.xml.gz", outDir));
logger.info("Done.");
/*
* clean network from foreign links
*/
logger.info("Loading network...");
MatsimNetworkReader nReader = new MatsimNetworkReader(scenario);
nReader.readFile(netFile);
logger.info("Done.");
logger.info("Removing foreign links...");
Set<Id<Link>> linksRemove = new HashSet<>();
for (Id<Link> id : scenario.getNetwork().getLinks().keySet()) {
if (id.toString().contains(".l")) {
linksRemove.add(id);
}
}
for (Id<Link> id : linksRemove) {
scenario.getNetwork().removeLink(id);
}
logger.info("Done.");
logger.info("Removing foreign nodes...");
Set<Id<Node>> nodesRemove = new HashSet<>();
for (Id<Node> id : scenario.getNetwork().getNodes().keySet()) {
if (id.toString().contains(".n")) {
nodesRemove.add(id);
}
}
for (Id<Node> id : nodesRemove) {
scenario.getNetwork().removeNode(id);
}
logger.info("Done.");
logger.info("Transforming node coordinates...");
for (Node node : scenario.getNetwork().getNodes().values()) {
double[] points = new double[] {node.getCoord().getX(), node.getCoord().getY()};
try {
transform.transform(points, 0, points, 0, 1);
} catch (TransformException e) {
e.printStackTrace();
}
((NodeImpl) node).setCoord(new Coord(points[0], points[1]));
}
logger.info("Done.");
logger.info("Writing network...");
NetworkWriter nWriter = new NetworkWriter(scenario.getNetwork());
nWriter.write(String.format("%s/network.xml.gz", outDir));
logger.info("Done.");
}
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");
}
