org.matsim.vehicles.Vehicle Java Examples

/**
 * Removes vehicles that are not used in the schedule
 */
public static void cleanVehicles(TransitSchedule schedule, Vehicles vehicles) {
	log.info("Removing not used vehicles...");
	int removed = 0;
	final Set<Id<Vehicle>> usedVehicles = new HashSet<>();
	for(TransitLine transitLine : schedule.getTransitLines().values()) {
		for(TransitRoute transitRoute : transitLine.getRoutes().values()) {
			for(Departure departure : transitRoute.getDepartures().values()) {
				usedVehicles.add(departure.getVehicleId());
			}
		}
	}
	for(Id<Vehicle> vehicleId : new HashSet<>(vehicles.getVehicles().keySet())) {
		if(!usedVehicles.contains(vehicleId)) {
			vehicles.removeVehicle(vehicleId);
			removed++;
		}
	}
	log.info(removed + " vehicles removed");
}
 

/**
	 * @return A list of all departures of this route.
	 * If firstDepartureTime or usedVehicle are not set before this is called, null is returned.
	 * If vehicleType is not set, the vehicle is not in the list and entry will not be created.
	 */
	public List<Departure> getDepartures() {
		if(firstDepartureTime < 0 || getVehicleId() == null) {
			log.error("getDepartures before first departureTime and usedVehicleId set.");
			return null;
		}
		if(vehicleTypeId == null) {
			//log.warn("VehicleType not defined in vehicles list.");
			return null;
		}

		List<Departure> departures = new ArrayList<>();
		for(int i = 0; i < numberOfDepartures; i++) {
			// Departure ID
//			Id<Departure> departureId = Id.create(routeDescription + "_" + String.format("%04d", i + 1), Departure.class);
			Id<Departure> departureId = Id.create(String.format("%05d", depId++), Departure.class);
			// Departure time
			double departureTime = firstDepartureTime + (i * cycleTime) - initialDelay;
			// Departure vehicle
//			Id<Vehicle> vehicleId = Id.create(getVehicleId() + "_" + String.format("%04d", i + 1), Vehicle.class);
			Id<Vehicle> vehicleId = Id.create(getVehicleId() + "_" + departureId, Vehicle.class);
			// create and add departure
			departures.add(createDeparture(departureId, departureTime, vehicleId));
		}
		return departures;
	}
 

@Override
public void handleEvent(ActivityEndEvent event) {
    if (AmodeusIdentifiers.isValid(event.getPersonId())) {
        String mode = AmodeusIdentifiers.getMode(event.getPersonId());
        Id<Vehicle> vehicleId = Id.createVehicleId(event.getPersonId());

        VehicleActivityItem activity = currentActivities.remove(vehicleId);
        boolean isStarted = activity != null;

        if (!isStarted) {
            activity = new VehicleActivityItem();
            activities.add(activity);
        }

        activity.mode = mode;
        activity.vehicleId = vehicleId;

        activity.link = linkFinder.getLink(event.getLinkId());
        activity.type = event.getActType();

        activity.endTime = event.getTime();
    }
}
 

@Override
public void handleEvent(PersonDepartureEvent event) {
    if (AmodeusIdentifiers.isValid(event.getPersonId())) {
        String mode = AmodeusIdentifiers.getMode(event.getPersonId());
        Id<Vehicle> vehicleId = Id.createVehicleId(event.getPersonId());

        VehicleMovementItem movement = new VehicleMovementItem();
        movements.add(movement);

        movement.mode = mode;
        movement.vehicleId = vehicleId;

        movement.originLink = linkFinder.getLink(event.getLinkId());
        movement.departureTime = event.getTime();

        currentMovements.put(vehicleId, movement);
    }
}
 

@Override
public void handleEvent(PersonArrivalEvent event) {
    if (AmodeusIdentifiers.isValid(event.getPersonId())) {
        Id<Vehicle> vehicleId = Id.createVehicleId(event.getPersonId());

        VehicleMovementItem movement = currentMovements.remove(vehicleId);

        if (movement == null) {
            throw new IllegalStateException("Found arrival without departure");
        }

        movement.destinationLink = linkFinder.getLink(event.getLinkId());
        movement.arrivalTime = event.getTime();

        movement.numberOfPassengers = passengers.getNumberOfPassengers(vehicleId);
    }
}
 

@Override
public void handleEvent(ActivityStartEvent event) {
    if (AmodeusIdentifiers.isValid(event.getPersonId())) {
        String mode = AmodeusIdentifiers.getMode(event.getPersonId());
        Id<Vehicle> vehicleId = Id.createVehicleId(event.getPersonId());

        VehicleActivityItem activity = new VehicleActivityItem();
        activities.add(activity);

        activity.mode = mode;
        activity.vehicleId = vehicleId;

        activity.link = linkFinder.getLink(event.getLinkId());
        activity.type = event.getActType();

        activity.startTime = event.getTime();

        currentActivities.put(vehicleId, activity);
    }
}
 

@Override
public double getLinkTravelTime(Link link, double time, Person person, Vehicle vehicle) {
    double speed = link.getFreespeed();
    LinkSpeedTimeSeries timeSeries = lsData.get(link);
    if (Objects.nonNull(timeSeries))
        speed = timeSeries.getSpeedsFloor((int) time);
    return link.getLength() / speed;
}
 

public void removePassenger(Id<Vehicle> vehicleId, Id<Person> passengerId) {
    ensurePassengers(vehicleId);

    if (!passengers.get(vehicleId).remove(passengerId)) {
        throw new IllegalStateException(String.format("Passenger '%s' is not in vehicle '%s'", passengerId, vehicleId));
    }
}
 

public void addPassenger(Id<Vehicle> vehicleId, Id<Person> passengerId) {
    ensurePassengers(vehicleId);

    if (!passengers.get(vehicleId).add(passengerId)) {
        throw new IllegalStateException(String.format("Passenger '%s' is already in vehicle '%s'", passengerId, vehicleId));
    }
}
 

@Override
public Future<Path> calcLeastCostPath(Node fromNode, Node toNode, double starttime, Person person, Vehicle vehicle) {
    Future<Path> future = executor.submit(() -> {
        LeastCostPathCalculator calculator = calculators.take();
        Path path = calculator.calcLeastCostPath(fromNode, toNode, starttime, person, vehicle);
        calculators.put(calculator);
        return path;
    });

    // futures.add(future);
    return future;
}
 

@Override
public Id<Vehicle> getVehicleId() {
	return null;
}
 

@Override
public Future<Path> calcLeastCostPath(Node fromNode, Node toNode, double starttime, //
        Person person, Vehicle vehicle) {
    return delegate.calcLeastCostPath(fromNode, toNode, starttime, person, vehicle);
}
 

private Departure createDeparture(Id<Departure> departureId, double departureTime, Id<Vehicle> vehicleId) {
	Departure departure = scheduleFactory.createDeparture(departureId, departureTime);
	departure.setVehicleId(vehicleId);
	return departure;
}
 

@Override
public Future<Path> calcLeastCostPath(Node fromNode, Node toNode, double starttime, Person person, Vehicle vehicle) {
    return delegate.calcLeastCostPath(fromNode, toNode, starttime, person, vehicle);
}
 

@Override
public double getLinkTravelTime(Link link, double time, Person person, Vehicle vehicle) {
    return link.getLength() / link.getFreespeed();
}
 

@Override
public double getLinkTravelDisutility(Link link, double time, Person person, Vehicle vehicle) {
    return calcLinkTravelCost(link);
}
 

@Override
public double getLinkTravelTime(Link link, double time, Person person, Vehicle vehicle) {
	return link.getLength() / link.getFreespeed();
}
 

@Override
public double getLinkTravelDisutility(Link link, double time, Person person, Vehicle vehicle) {
	return this.getLinkMinimumTravelDisutility(link);
}
 

@Override
public double getLinkTravelTime(Link link, double time, Person person, Vehicle vehicle) {
	return link.getLength() / link.getFreespeed();
}
 

@Override
public double getLinkTravelDisutility(Link link, double time, Person person, Vehicle vehicle) {
	return this.calcLinkTravelCost(link);
}
 

@Override
public Future<Path> calcLeastCostPath(Node fromNode, Node toNode, double starttime, Person person, Vehicle vehicle) {
    /** here a path neets to be computed and returned accordign to your custom logic */
    throw new RuntimeException("This CustomRouter is not functional.");
}
 

@Override
public Future<Path> calcLeastCostPath(Node fromNode, Node toNode, double starttime, Person person, Vehicle vehicle) {
    return delegate.calcLeastCostPath(fromNode, toNode, starttime, person, vehicle);
}
 

public Collection<Id<Person>> getPassengerIds(Id<Vehicle> vehicleId) {
    ensurePassengers(vehicleId);
    return passengers.get(vehicleId);
}
 

public int getNumberOfPassengers(Id<Vehicle> vehicleId) {
    ensurePassengers(vehicleId);
    return passengers.get(vehicleId).size();
}
 

@Override
public Future<Path> calcLeastCostPath(Node fromNode, Node toNode, double starttime, Person person, Vehicle vehicle) {
    return ConcurrentUtils.constantFuture(delegate.calcLeastCostPath(fromNode, toNode, starttime, person, vehicle));
}
 

public boolean hasPassenger(Id<Vehicle> vehicleId, Id<Person> passengerId) {
    ensurePassengers(vehicleId);
    return passengers.get(vehicleId).contains(passengerId);
}
 

private void ensurePassengers(Id<Vehicle> vehicleId) {
    if (!passengers.containsKey(vehicleId)) {
        passengers.put(vehicleId, new HashSet<>());
    }
}
 

@Override
public void setVehicleId(Id<Vehicle> id) {

}
 

Future<LeastCostPathCalculator.Path> calcLeastCostPath(Node fromNode, Node toNode, double starttime, final Person person, final Vehicle vehicle);