/**
   * 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()));
 }
Пример #3
0
  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);
  }
Пример #4
0
  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.");
   }
 }
Пример #7
0
  public static void main(String[] args) {

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

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

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

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

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

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

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

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

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

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

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

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

    /*
     * Write the population (of 1 Person) to a file.
     */
    MatsimWriter popWriter =
        new org.matsim.api.core.v01.population.PopulationWriter(population, network);
    popWriter.write("H:\\Mike Work\\input\\population.xml");
  }
Пример #8
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.");
  }
Пример #9
0
  /**
   * @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");

  }