@Override
public double getLinkMinimumTravelDisutility(Link link) {
if (this.marginalUtlOfDistance == 0.0) {
return (link.getLength() / link.getFreespeed()) * this.travelCostFactor;
}
return (link.getLength() / link.getFreespeed()) * this.travelCostFactor
- this.marginalUtlOfDistance * link.getLength();
}
@Override
public double getLinkTravelDisutility(
final Link link, final double time, final Person person, final Vehicle vehicle) {
if (this.marginalUtlOfDistance == 0.0) {
return (link.getLength() / link.getFreespeed(time)) * this.travelCostFactor;
}
return (link.getLength() / link.getFreespeed(time)) * this.travelCostFactor
- this.marginalUtlOfDistance * link.getLength();
}
private static double calculateFreespeedTravelTimeToNode(Network network, Path path, Node node) {
double travelTime = 0.0;
for (Link l : path.links) {
travelTime += l.getLength() / l.getFreespeed();
}
return travelTime;
}
private void computeDelays(AfterMobsimEvent event) {
TravelTime travelTime = event.getServices().getLinkTravelTimes();
int timeBinSize =
this.congestionInfo.getScenario().getConfig().travelTimeCalculator().getTraveltimeBinSize();
for (Link link : this.congestionInfo.getScenario().getNetwork().getLinks().values()) {
Map<Integer, Double> time2avgDelay = new HashMap<>();
double freespeedTravelTime = link.getLength() / link.getFreespeed();
int timeBinCounter = 0;
for (int endTime = timeBinSize;
endTime
<= this.congestionInfo.getScenario().getConfig().travelTimeCalculator().getMaxTime();
endTime = endTime + timeBinSize) {
double avgDelay =
travelTime.getLinkTravelTime(link, (endTime - timeBinSize / 2.), null, null)
- freespeedTravelTime;
time2avgDelay.put(timeBinCounter, avgDelay);
timeBinCounter++;
}
if (this.congestionInfo.getlinkInfos().containsKey(link.getId())) {
this.congestionInfo.getlinkInfos().get(link.getId()).setTime2avgDelay(time2avgDelay);
} else {
LinkInfo linkInfo = new LinkInfo(link.getId());
linkInfo.setTime2avgDelay(time2avgDelay);
this.congestionInfo.getlinkInfos().put(link.getId(), linkInfo);
}
}
}
private Path convertNodeListtoPath(List<Node> nodelist, List<Link> linklist) {
double traveltime = 0;
for (Link l : linklist) {
traveltime += l.getLength() / l.getFreespeed();
}
return new Path(nodelist, linklist, traveltime, 0);
}
private SimpleFeature createFeature(
Link link,
GeometryFactory geofac,
PolygonFeatureFactory factory,
List<CountSimComparison> countSimLinkLeaveComparisonList,
Double linkDelay1,
Double linkDelay2) {
Coordinate[] coords = PolygonFeatureGenerator.createPolygonCoordsForLink(link, 20.0);
Object[] attribs = new Object[10 + 5 * (numberOfHours + 1) + 1];
attribs[0] = link.getId().toString();
attribs[1] = link.getFromNode().getId().toString();
attribs[2] = link.getToNode().getId().toString();
attribs[3] = link.getLength();
attribs[4] = link.getFreespeed();
attribs[5] = link.getCapacity();
attribs[6] = link.getNumberOfLanes();
attribs[7] = link.getNumberOfLanes();
attribs[8] = ((LinkImpl) link).getType();
// total delay caused by the link
attribs[9] = linkDelay1;
attribs[10] = linkDelay2;
int i = 11;
double sumAbsLinkLeaveDif = 0.0;
double absLinkLeaveDif = 0.0;
double sumAbsLinkLeaveRun1 = 0.0;
double sumAbsLinkLeaveRun2 = 0.0;
for (CountSimComparison csc : countSimLinkLeaveComparisonList) {
// analyze only the selected time period
if (csc.getHour() > firstHour && csc.getHour() <= lastHour) {
// csc contains the number of link leave events in the time period between csc.getHour()-1
// and csc.getHour()
absLinkLeaveDif = csc.getSimulationValue() - csc.getCountValue();
attribs[i] = csc.getCountValue();
attribs[i + numberOfHours + 1] = csc.getSimulationValue();
attribs[i + 2 * (numberOfHours + 1)] = absLinkLeaveDif;
attribs[i + 3 * (numberOfHours + 1)] =
(absLinkLeaveDif / link.getCapacity()) * 100; // in percent
attribs[i + 4 * (numberOfHours + 1)] = absLinkLeaveDif * link.getLength();
sumAbsLinkLeaveDif += absLinkLeaveDif;
sumAbsLinkLeaveRun1 += csc.getCountValue();
sumAbsLinkLeaveRun2 += csc.getSimulationValue();
i++;
}
}
attribs[10 + numberOfHours + 1] = sumAbsLinkLeaveRun1;
attribs[10 + 2 * (numberOfHours + 1)] = sumAbsLinkLeaveRun2;
attribs[10 + 3 * (numberOfHours + 1)] =
sumAbsLinkLeaveDif; // C: meanAbsLinkLeaveDif = sumAbsLinkLeaveDif/5
// mean (error/capacity) in percent per hour, i.e flow difference of the morning peak divided by
// the maximal link capacity in this time period
attribs[10 + 4 * (numberOfHours + 1)] = (sumAbsLinkLeaveDif / (link.getCapacity() * 5)) * 100;
attribs[10 + 5 * (numberOfHours + 1)] =
sumAbsLinkLeaveDif * link.getLength(); // alternative: meanAbsLinkLeaveDif*link.getLength();
return factory.createPolygon(coords, attribs, link.getId().toString());
}
private int addStopOnLink(Link link) {
if (link == null) {
return 0;
}
if (linkToNodeNotInServiceArea(link)) {
return 0;
}
if (linkHasAlreadyAFormalPTStopFromTheGivenSchedule(link)) {
return 0;
}
if (link.getFreespeed() >= this.pConfigGroup.getSpeedLimitForStops()) {
return 0;
}
if (this.linkId2StopFacilityMap.get(link.getId()) != null) {
log.warn("Link " + link.getId() + " has already a stop. This should not happen. Check code.");
return 0;
}
Id<TransitStopFacility> stopId =
Id.create(this.pConfigGroup.getPIdentifier() + link.getId(), TransitStopFacility.class);
TransitStopFacility stop =
this.transitSchedule
.getFactory()
.createTransitStopFacility(stopId, link.getToNode().getCoord(), false);
stop.setLinkId(link.getId());
this.transitSchedule.addStopFacility(stop);
return 1;
}
public static void main(String[] args) {
String path2MATSimNetwork = args[0];
MutableScenario scenario =
(MutableScenario) ScenarioUtils.createScenario(ConfigUtils.createConfig());
MatsimNetworkReader networkReader = new MatsimNetworkReader(scenario.getNetwork());
networkReader.readFile(path2MATSimNetwork);
Network network = scenario.getNetwork();
String speedFactor = args[1];
String capacityFactor = args[2];
radius = Integer.parseInt(args[3]);
final BufferedWriter out = IOUtils.getBufferedWriter(args[4]);
try {
// Header
out.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
out.newLine();
out.write(
"<networkChangeEvents xmlns=\"http://www.matsim.org/files/dtd\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:schemaLocation=\"http://www.matsim.org/files/dtd http://www.matsim.org/files/dtd/networkChangeEvents.xsd\">");
out.newLine();
// reduce capacity and speed:
out.write(" <networkChangeEvent startTime=\"07:00:00\">");
out.newLine();
for (Link link : network.getLinks().values()) {
if (isLinkAffected(link)) {
out.write(" <link refId=\"" + link.getId().toString() + "\"/>");
out.newLine();
}
}
out.write(" <flowCapacity type=\"scaleFactor\" value=\"" + capacityFactor + "\"/>");
out.newLine();
out.write(" <freespeed type=\"scaleFactor\" value=\"" + speedFactor + "\"/>");
out.newLine();
out.write(" </networkChangeEvent>");
out.newLine();
// reset capacity and speed:
for (Link link : network.getLinks().values()) {
if (isLinkAffected(link)) {
out.write(" <networkChangeEvent startTime=\"09:00:00\">");
out.newLine();
out.write(" <link refId=\"" + link.getId().toString() + "\"/>");
out.newLine();
out.write(
" <flowCapacity type=\"absolute\" value=\"" + link.getCapacity() + "\"/>");
out.newLine();
out.write(" <freespeed type=\"absolute\" value=\"" + link.getFreespeed() + "\"/>");
out.newLine();
out.write(" </networkChangeEvent>");
out.newLine();
}
}
// Footer:
out.write("</networkChangeEvents>");
out.newLine();
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
MutableScenario scenario =
(MutableScenario) ScenarioUtils.createScenario(ConfigUtils.createConfig());
MatsimNetworkReader networkReader = new MatsimNetworkReader(scenario.getNetwork());
networkReader.readFile(args[0]);
int numberOfLinks = 0;
double length = 0.0;
double length1 = 0.0;
double length2 = 0.0;
double length3 = 0.0;
Node previousNode1 = null;
Node previousNode2 = null;
for (Link l : scenario.getNetwork().getLinks().values()) {
if (previousNode1 != null) {
if (l.getFromNode().getId() != previousNode2.getId()
&& l.getToNode().getId() != previousNode1.getId()) {
numberOfLinks++;
length += l.getLength();
if (l.getFreespeed() > 24.99) {
length1 += l.getLength();
} else if (l.getFreespeed() < 13.88) {
length3 += l.getLength();
} else length2 += l.getLength();
}
} else {
numberOfLinks++;
length += l.getLength();
if (l.getFreespeed() > 24.99) {
length1 += l.getLength();
} else if (l.getFreespeed() < 13.88) {
length3 += l.getLength();
} else length2 += l.getLength();
}
previousNode1 = l.getFromNode();
previousNode2 = l.getToNode();
}
System.out.println(numberOfLinks);
System.out.println(length / 1000);
System.out.println(length1 / 1000);
System.out.println(length2 / 1000);
System.out.println(length3 / 1000);
}
public void add() {
List<Link> links = ((BusLaneAdderPanel) layersPanels.get(PanelIds.ONE)).getLinks();
Node prevNode = links.get(0).getFromNode();
for (Link link : links)
if (!link.getAllowedModes().contains("bus")) {
exitSave();
JOptionPane.showMessageDialog(this, "Wrong path, network saved");
}
for (int i = 0; i < links.size(); i++) {
Link link = links.get(i);
Node node = null;
if (link.getNumberOfLanes() == 1) {
Set<String> modes = new HashSet<String>();
modes.add("bus");
link.setAllowedModes(modes);
node = link.getToNode();
} else {
Node oldNode = link.getToNode();
if (i == links.size() - 1 || oldNode.getInLinks().size() + oldNode.getOutLinks().size() > 2)
node = oldNode;
else {
node =
network
.getFactory()
.createNode(
Id.createNodeId("fl" + oldNode.getId().toString()), oldNode.getCoord());
network.addNode(node);
}
LinkImpl newLink =
(LinkImpl)
network
.getFactory()
.createLink(Id.createLinkId("fl" + link.getId().toString()), prevNode, node);
Set<String> modes = new HashSet<String>();
modes.add("car");
newLink.setAllowedModes(modes);
newLink.setCapacity(link.getCapacity());
newLink.setFreespeed(link.getFreespeed());
newLink.setLength(link.getLength());
newLink.setNumberOfLanes(link.getNumberOfLanes() - 1);
newLink.setOrigId(((LinkImpl) link).getOrigId());
newLink.setType(((LinkImpl) link).getType());
network.addLink(newLink);
Set<String> modes2 = new HashSet<String>();
modes2.add("bus");
link.setAllowedModes(modes2);
link.setCapacity(900);
link.setNumberOfLanes(1);
}
prevNode = node;
}
((BusLaneAdderPanel) layersPanels.get(PanelIds.ONE)).clearSelection();
}
private TransitRoute createRoute(
Id<TransitRoute> routeID, TransitStopFacility startStop, TransitStopFacility endStop) {
FreespeedTravelTimeAndDisutility tC = new FreespeedTravelTimeAndDisutility(-6.0, 0.0, 0.0);
LeastCostPathCalculator routingAlgo = new Dijkstra(this.net, tC, tC);
Node startNode = this.net.getLinks().get(startStop.getLinkId()).getToNode();
Node endNode = this.net.getLinks().get(endStop.getLinkId()).getFromNode();
int startTime = 0 * 3600;
// get Route
Path path = routingAlgo.calcLeastCostPath(startNode, endNode, startTime, null, null);
NetworkRoute route = new LinkNetworkRouteImpl(startStop.getLinkId(), endStop.getLinkId());
route.setLinkIds(
startStop.getLinkId(), NetworkUtils.getLinkIds(path.links), endStop.getLinkId());
// get stops at Route
List<TransitRouteStop> stops = new LinkedList<TransitRouteStop>();
// first stop
TransitRouteStop routeStop =
this.tS.getFactory().createTransitRouteStop(startStop, startTime, startTime);
stops.add(routeStop);
// additional stops
for (Link link : path.links) {
startTime += link.getLength() / link.getFreespeed();
if (this.tS.getFacilities().get(link.getId()) == null) {
continue;
}
routeStop =
this.tS
.getFactory()
.createTransitRouteStop(
this.tS.getFacilities().get(link.getId()), startTime, startTime);
stops.add(routeStop);
}
// last stop
startTime +=
this.net.getLinks().get(endStop.getLinkId()).getLength()
/ this.net.getLinks().get(endStop.getLinkId()).getFreespeed();
routeStop = this.tS.getFactory().createTransitRouteStop(endStop, startTime, startTime);
stops.add(routeStop);
// register departure
TransitRoute transitRoute =
this.tS.getFactory().createTransitRoute(routeID, route, stops, "pt");
return transitRoute;
}
public static void main(String[] args) {
Scenario scenario = ScenarioUtils.createScenario(ConfigUtils.createConfig());
String basedir = "C:/Users/Joschka/Documents/shared-svn/projects/vw_rufbus/scenario/input/";
new MatsimNetworkReader(scenario.getNetwork()).readFile(basedir + "network.xml");
for (Link link : scenario.getNetwork().getLinks().values()) {
double speed = link.getFreespeed();
if (speed < 10) link.setFreespeed(0.75 * speed);
else if (speed < 20) link.setFreespeed(0.7 * speed);
else if (speed < 30) {
if (link.getNumberOfLanes() < 2) link.setFreespeed(0.7 * speed);
else link.setFreespeed(0.75 * speed);
} else link.setFreespeed(0.7 * speed);
}
new NetworkWriter(scenario.getNetwork()).write(basedir + "networks.xml");
}
public double getEnergyConsumptionForLinkInJoule(
Vehicle vehicle, double timeSpentOnLink, Link link) {
double speedOfVehicleOnLinkInKmPerHour =
Vehicle.getAverageSpeedOfVehicleOnLinkInMetersPerSecond(timeSpentOnLink, link)
/ 1000
* 3600;
if (speedOfVehicleOnLinkInKmPerHour > maxAllowedSpeedInNetworkInKmPerHour) {
return 0;
}
return energyConsumptionTable.getEnergyConsumptionInJoule(
vehicle.getVehicleClassId(),
speedOfVehicleOnLinkInKmPerHour,
link.getFreespeed(),
link.getLength());
}
private void assignProps(Collection<Link> links, Link link) {
double capacity = 0;
double freespeed = 0;
double lanes = 0;
for (Link origLink : links) {
capacity += origLink.getCapacity();
freespeed = Math.max(freespeed, origLink.getFreespeed());
lanes += origLink.getNumberOfLanes();
}
link.setCapacity(capacity);
link.setFreespeed(freespeed);
link.setNumberOfLanes(lanes);
link.setLength(
NetworkUtils.getEuclideanDistance(
link.getFromNode().getCoord(), link.getToNode().getCoord()));
}
@Override
public double getLinkMinimumTravelDisutility(Link link) {
double constantPerforming = -6.0 / 3600.0; // this is a hack! TODO: take from config
double marginalUtilityOfTime_util_s =
params.getScoringParameters(null).modeParams.get(this.mode).marginalUtilityOfTraveling_s
+ constantPerforming;
double marginalUtilityOfDistance_util_m =
params.getScoringParameters(null).modeParams.get(this.mode).marginalUtilityOfDistance_m;
double monetaryDistanceRate =
params.getScoringParameters(null).modeParams.get(this.mode).monetaryDistanceCostRate;
double marginalUtilityOfMoney = params.getScoringParameters(null).marginalUtilityOfMoney;
final double marginalUtilityOfDistanceFromMoney_util_m =
monetaryDistanceRate * marginalUtilityOfMoney; // [money/m]*[util/money]
// Needs to be positive:
return -1.0
* (marginalUtilityOfTime_util_s * (link.getLength() / link.getFreespeed())
+ (marginalUtilityOfDistance_util_m + marginalUtilityOfDistanceFromMoney_util_m)
* link.getLength());
}
public void convertNet2Shape(Network net, String crs, String outputFile) {
SimpleFeatureTypeBuilder typeBuilder = new SimpleFeatureTypeBuilder();
typeBuilder.setCRS(MGC.getCRS(crs));
typeBuilder.setName("link feature");
typeBuilder.add("Line String", LineString.class);
typeBuilder.add("id", String.class);
typeBuilder.add("length", Double.class);
typeBuilder.add("freespeed", Double.class);
typeBuilder.add("capacity", Double.class);
SimpleFeatureBuilder builder = new SimpleFeatureBuilder(typeBuilder.buildFeatureType());
List<SimpleFeature> features = new ArrayList<SimpleFeature>();
for (Link link : net.getLinks().values()) {
Coord from = link.getFromNode().getCoord();
Coord to = link.getToNode().getCoord();
SimpleFeature feature =
builder.buildFeature(
link.getId().toString(),
new Object[] {
new GeometryFactory()
.createLineString(
new Coordinate[] {MGC.coord2Coordinate(from), MGC.coord2Coordinate(to)}),
link.getId().toString(),
link.getLength(),
link.getFreespeed(),
link.getCapacity()
});
features.add(feature);
}
ShapeFileWriter.writeGeometries(features, outputFile);
}
public static void main(String[] args) {
// Input file
String networkFile = "D:/Workspace/container/demand/input/iv_counts/network.xml";
// Get network, which is needed to calculate distances
Config config = ConfigUtils.createConfig();
Scenario scenario = ScenarioUtils.createScenario(config);
MatsimNetworkReader networkReader = new MatsimNetworkReader(scenario);
networkReader.readFile(networkFile);
Network network = scenario.getNetwork();
// Create needed objects
int numberOfNodes = 0;
int numberOfLinks = 0;
Map<Double, Integer> capacityMap = new HashMap<Double, Integer>();
int capacity0To1000 = 0;
int capacity1000To2000 = 0;
int capacity2000To3000 = 0;
int capacity3000To4000 = 0;
int capacity4000To5000 = 0;
int capacity5000ToInf = 0;
Map<Double, Integer> freeSpeedMap = new HashMap<Double, Integer>();
Map<Double, Integer> numberOfLanesMap = new HashMap<Double, Integer>();
int linksWithMoreThanOneMode = 0;
double maxLength = Integer.MIN_VALUE;
double minLength = Integer.MAX_VALUE;
// Do calculations
for (Node node : network.getNodes().values()) {
numberOfNodes++;
}
for (Link link : network.getLinks().values()) {
numberOfLinks++;
double capacity = link.getCapacity();
if (!capacityMap.containsKey(capacity)) {
capacityMap.put(capacity, 1);
} else {
int quantityCapacity = capacityMap.get(capacity);
capacityMap.put(capacity, quantityCapacity + 1);
}
if (capacity < 1000) {
capacity0To1000++;
} else if (capacity >= 1000 && capacity < 2000) {
capacity1000To2000++;
} else if (capacity >= 2000 && capacity < 3000) {
capacity2000To3000++;
} else if (capacity >= 3000 && capacity < 4000) {
capacity3000To4000++;
} else if (capacity >= 4000 && capacity < 5000) {
capacity4000To5000++;
} else if (capacity >= 5000) {
capacity5000ToInf++;
} else {
System.err.println("Error!");
}
double freeSpeed = link.getFreespeed();
if (!freeSpeedMap.containsKey(freeSpeed)) {
freeSpeedMap.put(freeSpeed, 1);
} else {
int quantityFreeSpeed = freeSpeedMap.get(freeSpeed);
freeSpeedMap.put(freeSpeed, quantityFreeSpeed + 1);
}
double numberOfLanes = link.getNumberOfLanes();
if (!numberOfLanesMap.containsKey(numberOfLanes)) {
numberOfLanesMap.put(numberOfLanes, 1);
} else {
int quantityNumberOfLanes = numberOfLanesMap.get(numberOfLanes);
numberOfLanesMap.put(numberOfLanes, quantityNumberOfLanes + 1);
}
if (link.getAllowedModes().size() > 1) {
linksWithMoreThanOneMode++;
}
double length = link.getLength();
if (length > maxLength) {
maxLength = length;
}
if (length < minLength) {
minLength = length;
}
}
// Write information to console
System.out.println("Number of Nodes: " + numberOfNodes);
System.out.println("Number of Links: " + numberOfLinks);
for (Double capacity : capacityMap.keySet()) {
System.out.println(capacityMap.get(capacity) + " links have a capacity of " + capacity + ".");
}
System.out.println(capacity0To1000 + " links have a capacity of less than 1000.");
System.out.println(
capacity1000To2000 + " links have a capacity of at least 1000 and less than 2000.");
System.out.println(
capacity2000To3000 + " links have a capacity of at least 2000 and less than 3000.");
System.out.println(
capacity3000To4000 + " links have a capacity of at least 3000 and less than 4000.");
System.out.println(
capacity4000To5000 + " links have a capacity of at least 4000 and less than 5000.");
System.out.println(capacity5000ToInf + " links have a capacity of at least 5000.");
for (Double freeSpeed : freeSpeedMap.keySet()) {
System.out.println(
freeSpeedMap.get(freeSpeed)
+ " links have a free speed of "
+ freeSpeed
+ " / "
+ freeSpeed * 3.6
+ ".");
}
for (Double numberOfLanes : numberOfLanesMap.keySet()) {
System.out.println(
numberOfLanesMap.get(numberOfLanes) + " links have " + numberOfLanes + " lanes.");
}
System.out.println(linksWithMoreThanOneMode + " links allow more than one mode.");
System.out.println("Maximum link length is: " + maxLength);
System.out.println("Minimum link length is: " + minLength);
}
public QSimDensityDrawer(Scenario sc) {
for (Link l : sc.getNetwork().getLinks().values()) {
if (l.getId().toString().contains("jps")
|| l.getId().toString().contains("el")
|| l.getAllowedModes().contains("walk2d")
|| l.getCapacity() >= 100000
|| l.getFreespeed() > 100
|| l.getId().toString().contains("el")) {
continue;
}
float width = (float) (l.getCapacity() / sc.getNetwork().getCapacityPeriod() / 1.3);
boolean isCar = false;
if (l.getFreespeed() > 1.35) {
width = (float) (l.getNumberOfLanes() * 3.5);
isCar = true;
} else {
width = (float) (width);
}
double dx = l.getToNode().getCoord().getX() - l.getFromNode().getCoord().getX();
double dy = l.getToNode().getCoord().getY() - l.getFromNode().getCoord().getY();
double length = Math.sqrt(dx * dx + dy * dy);
dx /= length;
dy /= length;
LinkInfo info = new LinkInfo();
info.id = l.getId();
info.cap =
(l.getLength() / ((NetworkImpl) sc.getNetwork()).getEffectiveCellSize())
* l.getNumberOfLanes();
double x0 = l.getFromNode().getCoord().getX();
double y0 = l.getFromNode().getCoord().getY();
double x1 = l.getToNode().getCoord().getX();
double y1 = l.getToNode().getCoord().getY();
x0 += dy * width / 2;
x1 += dy * width / 2;
y0 -= dx * width / 2;
y1 -= dx * width / 2;
info.width = width;
info.x0 = x0;
info.x1 = x1;
info.y0 = y0;
info.y1 = y1;
double tan = dx / dy;
double atan = Math.atan(tan);
if (atan > 0) {
atan -= Math.PI / 2;
} else {
atan += Math.PI / 2;
}
double offsetX = dy * .075;
double offsetY = -dx * .075;
if (dx > 0) {
offsetX *= -1;
offsetY *= -1;
}
info.tx = (x0 + x1) / 2 + offsetX;
info.ty = (y0 + y1) / 2 + offsetY;
info.text = "0";
info.atan = atan;
info.isCar = isCar;
if (isCar) {
info.cap = l.getLength() / 7.5 * l.getNumberOfLanes();
}
this.links.add(info);
this.map.put(l.getId(), info);
}
}
private static boolean isLinkOfType(
Link link, double freeSpeed, double capacity, double numLanes) {
return Math.abs(link.getFreespeed() - freeSpeed) < 0.01
&& Math.abs(link.getCapacity() - capacity) < 0.01
&& link.getNumberOfLanes() == numLanes;
}
public TransitRouteData(Network network, TransitRoute transitRoute) {
this.transportMode = transitRoute.getTransportMode();
this.firstDeparture = Double.MAX_VALUE;
this.lastDeparture = -Double.MAX_VALUE;
this.vehIds = new TreeSet<String>();
this.numberOfDepartures = 0;
for (Departure departure : transitRoute.getDepartures().values()) {
this.firstDeparture = Math.min(this.firstDeparture, departure.getDepartureTime());
this.lastDeparture = Math.max(this.lastDeparture, departure.getDepartureTime());
this.vehIds.add(departure.getVehicleId().toString());
this.numberOfDepartures++;
}
this.firstStop = transitRoute.getStops().get(0).getStopFacility();
this.lastStop =
transitRoute.getStops().get(transitRoute.getStops().size() - 1).getStopFacility();
if (this.firstStop == this.lastStop) {
// get the stop location of stop with the largest distance between first and last stop
TransitStopFacility currentViaStop = null;
double currentViaDistance = Double.NEGATIVE_INFINITY;
for (TransitRouteStop stop : transitRoute.getStops()) {
double distanceFirstPotentialVia =
CoordUtils.calcDistance(this.firstStop.getCoord(), stop.getStopFacility().getCoord());
double distanceLastProtenialVia =
CoordUtils.calcDistance(this.lastStop.getCoord(), stop.getStopFacility().getCoord());
double newDistance =
Math.sqrt(
Math.pow(distanceFirstPotentialVia, 2) + Math.pow(distanceLastProtenialVia, 2));
if (newDistance > currentViaDistance) {
// this one is farther away - keep it
currentViaStop = stop.getStopFacility();
currentViaDistance = newDistance;
}
}
this.viaStop = currentViaStop;
} else {
// get the stop in the middle of the line
this.viaStop =
transitRoute.getStops().get((int) (transitRoute.getStops().size() / 2)).getStopFacility();
}
// calculate the length of the route
double distance = 0.0;
double freeSpeedTravelTime = 0.0;
for (Id<Link> linkId : transitRoute.getRoute().getLinkIds()) {
Link link = network.getLinks().get(linkId);
distance += link.getLength();
freeSpeedTravelTime += link.getLength() / link.getFreespeed();
}
// add last link but not the first link
Link link = network.getLinks().get(transitRoute.getRoute().getEndLinkId());
distance += link.getLength();
freeSpeedTravelTime += link.getLength() / link.getFreespeed();
this.distance = distance;
this.freeSpeedTravelTime = freeSpeedTravelTime;
this.travelTime =
transitRoute.getStops().get(transitRoute.getStops().size() - 1).getArrivalOffset();
this.avgSpeed = this.distance / this.travelTime;
}
@Override
public void notifyAfterMobsim(AfterMobsimEvent event) {
Network network = event.getServices().getScenario().getNetwork();
DescriptiveStatistics error = new DescriptiveStatistics();
DescriptiveStatistics errorAbs = new DescriptiveStatistics();
DescriptivePiStatistics errorWeighted = new WSMStatsFactory().newInstance();
TDoubleArrayList errorVals = new TDoubleArrayList();
TDoubleArrayList caps = new TDoubleArrayList();
TDoubleArrayList speeds = new TDoubleArrayList();
for (Count count : counts.getCounts().values()) {
if (!count.getId().toString().startsWith(ODCalibrator.VIRTUAL_ID_PREFIX)) {
double obsVal = 0;
for (int i = 1; i < 25; i++) {
obsVal += count.getVolume(i).getValue();
}
if (obsVal > 0) {
double simVal = calculator.getOccupancy(count.getId());
simVal *= factor;
double err = (simVal - obsVal) / obsVal;
error.addValue(err);
errorAbs.addValue(Math.abs(err));
errorWeighted.addValue(Math.abs(err), 1 / obsVal);
Link link = network.getLinks().get(count.getId());
errorVals.add(Math.abs(err));
caps.add(link.getCapacity());
speeds.add(link.getFreespeed());
}
}
}
logger.info(
String.format(
"Relative counts error: mean = %s, var = %s, stderr = %s, min = %s, max = %s",
error.getMean(),
error.getVariance(),
error.getStandardDeviation(),
error.getMin(),
error.getMax()));
logger.info(
String.format(
"Absolute relative counts error: mean = %s, var = %s, stderr = %s, min = %s, max = %s",
errorAbs.getMean(),
errorAbs.getVariance(),
errorAbs.getStandardDeviation(),
errorAbs.getMin(),
errorAbs.getMax()));
logger.info(
String.format(
"Absolute weigthed relative counts error: mean = %s, var = %s, stderr = %s, min = %s, max = %s",
errorWeighted.getMean(),
errorWeighted.getVariance(),
errorWeighted.getStandardDeviation(),
errorWeighted.getMin(),
errorWeighted.getMax()));
String outdir = event.getServices().getControlerIO().getIterationPath(event.getIteration());
try {
TDoubleDoubleHashMap map = Correlations.mean(caps.toArray(), errorVals.toArray());
StatsWriter.writeHistogram(
map, "capacity", "counts", String.format("%s/countsError.capacity.txt", outdir));
map = Correlations.mean(speeds.toArray(), errorVals.toArray());
StatsWriter.writeHistogram(
map, "speed", "counts", String.format("%s/countsError.speed.txt", outdir));
StatsWriter.writeHistogram(
Histogram.createHistogram(error, new LinearDiscretizer(0.1), false),
"Error",
"Frequency",
String.format("%s/countsError.hist.txt", outdir));
StatsWriter.writeHistogram(
Histogram.createHistogram(errorAbs, new LinearDiscretizer(0.1), false),
"Error (absolute)",
"Frequency",
String.format("%s/countsErrorAbs.hist.txt", outdir));
StatsWriter.writeHistogram(
Histogram.createHistogram(errorWeighted, new LinearDiscretizer(0.1), true),
"Error (weighted)",
"Frequency",
String.format("%s/countsErrorWeighted.hist.txt", outdir));
CountsCompare2GeoJSON.write(calculator, counts, factor, network, outdir);
NetworkLoad2GeoJSON.write(
event.getServices().getScenario().getNetwork(),
calculator,
factor,
outdir + "/network.json");
} catch (Exception e) {
e.printStackTrace();
}
String rootOutDir = event.getServices().getControlerIO().getOutputPath();
boolean append = false;
if (event.getIteration() > 0) {
append = true;
}
writeErrorFile(error, String.format("%s/countsError.txt", rootOutDir), append);
writeErrorFile(errorAbs, String.format("%s/countsAbsError.txt", rootOutDir), append);
}
@Override
public double getLinkTravelTime(Link link, double time, Person person, Vehicle vehicle) {
return link.getLength() / link.getFreespeed(time);
}
