PlanMutateTimeAllocation.java

Go to the documentation of this file.

/* *********************************************************************** *
 * project: org.matsim.*
 * PlanMutateTimeAllocation.java
 *                                                                         *
 * *********************************************************************** *
 *                                                                         *
 * copyright       : (C) 2007, 2008 by the members listed in the COPYING,  *
 *                   LICENSE and WARRANTY file.                            *
 * email           : info at matsim dot org                                *
 *                                                                         *
 * *********************************************************************** *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *   See also COPYING, LICENSE and WARRANTY file                           *
 *                                                                         *
 * *********************************************************************** */

package org.matsim.core.population.algorithms;

import java.util.List;
import java.util.Random;

import org.matsim.api.core.v01.population.Activity;
import org.matsim.api.core.v01.population.Leg;
import org.matsim.api.core.v01.population.Plan;
import org.matsim.api.core.v01.population.PlanElement;
import org.matsim.core.utils.misc.OptionalTime;

public final class PlanMutateTimeAllocation implements PlanAlgorithm {

    private final double mutationRange;
    private final Random random;

    public PlanMutateTimeAllocation(final double mutationRange, final Random random) {
        this.mutationRange = mutationRange;
        this.random = random;
    }

    @Override
    public void run(final Plan plan) {
        mutatePlan(plan);
    }

    private void mutatePlan(final Plan plan) {

        List<PlanElement> planElements = plan.getPlanElements();
        int max = planElements.size();

        double now = 0;

        // apply mutation to all activities except the last home activity
        for (int i = 0; i < max; i++) {

            PlanElement pe = planElements.get(i);
            
            if (pe instanceof Activity) {
                Activity act = (Activity) pe;

                // handle first activity
                if (i == 0) {
                    // set start to midnight
                    act.setStartTime(now);
                    // mutate the end time of the first activity
                    act.setEndTime(mutateTime(act.getEndTime()));
                    // calculate resulting duration
                    act.setMaximumDuration(act.getEndTime().seconds() - act.getStartTime().seconds());
                    // move now pointer
                    now += act.getEndTime().seconds();

                // handle middle activities
                } else if (i < (max - 1)) {

                    // assume that there will be no delay between arrival time and activity start time
                    act.setStartTime(now);
                    if (act.getMaximumDuration().isDefined()) {
                            // mutate the durations of all 'middle' activities
                        act.setMaximumDuration(mutateTime(act.getMaximumDuration()));
                        now += act.getMaximumDuration().seconds();
                            // set end time accordingly
                            act.setEndTime(now);
                        } else {
                            double newEndTime = mutateTime(act.getEndTime());
                            if (newEndTime < now) {
                                newEndTime = now;
                            }
                            act.setEndTime(newEndTime);
                            now = newEndTime;
                        }
                // handle last activity
                } else {

                    // assume that there will be no delay between arrival time and activity start time
                    act.setStartTime(now);
                    // invalidate duration and end time because the plan will be interpreted 24 hour wrap-around
                    act.setMaximumDurationUndefined();
                    act.setEndTimeUndefined();

                }

            } else if (pe instanceof Leg) {

                Leg leg = (Leg) pe;

                // assume that there will be no delay between end time of previous activity and departure time
                leg.setDepartureTime(now);
                // let duration untouched. if defined add it to now
                if (leg.getTravelTime().isDefined()) {
                    now += leg.getTravelTime().seconds();
                }
                final double arrTime = now;
                // set planned arrival time accordingly
                leg.setTravelTime( arrTime - leg.getDepartureTime().seconds());

            }
        }
    }

    private double mutateTime(final OptionalTime time) {
        if (time.isDefined()) {
            double t = time.seconds() + (int)((this.random.nextDouble() * 2.0 - 1.0) * this.mutationRange);
            if (t < 0) t = 0;
            if (t > 24*3600) t = 24*3600;
            return t;
        } else {
            return this.random.nextInt(24*3600);
        }
    }

}