public void writeData() { for (List<Tuple<Id, Double>> list : this.positions.values()) { for (Tuple<Id, Double> info : list) { System.out.println(info.getFirst().toString() + "\t" + info.getSecond().toString()); } System.out.println(); } }
private DataContainer getLinkToLinkTravelTimeData(Tuple<Id<Link>, Id<Link>> fromLinkToLink, final boolean createIfMissing) { DataContainer data = this.linkToLinkData.get(fromLinkToLink); if ((null == data) && createIfMissing) { data = new DataContainer(this.ttDataFactory.createTravelTimeData(fromLinkToLink.getFirst())); this.linkToLinkData.put(fromLinkToLink, data); } return data; }
@Deprecated //not tested private int getNumberOfCarsAtDistancePerSecond(Id<Link> linkId, Double distanceMeter, double timeSeconds){ Tuple<Double, Double> tuple = this.linkFirstSecondDistanceMeterMap.get(linkId); int numberOfCarsFirstDetector = this.getNumberOfCarsInDistance(linkId, tuple.getFirst(), timeSeconds); int numberOfCarsSecondDetector = this.getNumberOfCarsInDistance(linkId, tuple.getSecond(), timeSeconds); log.error("Link " + linkId + " first pos: " + tuple.getFirst() + " second pos: " + tuple.getSecond()); log.error("NumberOfCars SecondDetector: " + numberOfCarsSecondDetector + " first detector: " + numberOfCarsFirstDetector); return numberOfCarsFirstDetector - numberOfCarsSecondDetector ; }
/** * Initialize the quadtrees of all available activity types */ private void initTrees(ActivityFacilities facilities, DestinationChoiceConfigGroup config) { log.info("Doing location choice for activities: " + this.flexibleTypes.toString()); for (String flexibleType : this.flexibleTypes) { Tuple<QuadTree<ActivityFacilityWithIndex>, ActivityFacilityImpl[]> tuple = this.lcContext.getQuadTreeAndFacilities(flexibleType); this.quadTreesOfType.put(flexibleType, tuple.getFirst()); this.facilitiesOfType.put(flexibleType, tuple.getSecond()); } }
/** * Scales a vector given by start and end point by a factor. Changes only the start coordinate of the vector. * @param scaleFactor a scale factor in [0..1] * @return a tuple with the scaled start point as first and the old end point as * second entry * @deprecated not used yet */ @Deprecated public static Tuple<Point2D.Double, Point2D.Double> scaleVectorStart(final Point2D.Double start, final Point2D.Double end, double scaleFactor) { Tuple<Point2D.Double, Point2D.Double> scaledVector = calculateScaledVector(start, end, scaleFactor); return new Tuple<Point2D.Double, Point2D.Double>(scaledVector.getFirst(), end); }
public Tuple<QuadTree<ActivityFacilityWithIndex>, ActivityFacilityImpl[]> getQuadTreeAndFacilities(String activityType) { if (this.cacheQuadTrees) { QuadTree<ActivityFacilityWithIndex> quadTree = this.quadTreesOfType.get(activityType); ActivityFacilityImpl[] facilities = this.facilitiesOfType.get(activityType); if (quadTree == null || facilities == null) { Tuple<QuadTree<ActivityFacilityWithIndex>, ActivityFacilityImpl[]> tuple = getTuple(activityType); this.quadTreesOfType.put(activityType, tuple.getFirst()); this.facilitiesOfType.put(activityType, tuple.getSecond()); return tuple; } else return new Tuple<QuadTree<ActivityFacilityWithIndex>, ActivityFacilityImpl[]>(quadTree, facilities); } else return getTuple(activityType); }
@Override public int compare(final Tuple<Double, MobsimAgent> o1, final Tuple<Double, MobsimAgent> o2) { int ret = o1.getFirst().compareTo(o2.getFirst()); // first compare time information if (ret == 0) { ret = o2.getSecond().getId().compareTo(o1.getSecond().getId()); // if they're equal, compare the Ids: the one with the larger Id should be first } return ret; } }
@Override public int compare(Tuple<Double, MobsimAgent> o1, Tuple<Double, MobsimAgent> o2) { int ret = o1.getFirst().compareTo(o2.getFirst()); // first compare time information if (ret == 0) { ret = o2.getSecond().getId().compareTo(o1.getSecond().getId()); // if they're equal, compare the Ids: the one with the larger Id should be first } return ret; } });
public MeasurementCadytsContext(Config config, Tuple<Counts<Measurement>, Measurements> tuple) { CadytsConfigGroup cadytsConfig = ConfigUtils.addOrGetModule(config, CadytsConfigGroup.GROUP_NAME, CadytsConfigGroup.class ) ; cadytsConfig.setWriteAnalysisFile(true); this.counts = tuple.getFirst() ; this.measurements = tuple.getSecond() ; Set<String> measurementsSet = new TreeSet<>(); for (Id<Measurement> id : this.counts.getCounts().keySet()) { measurementsSet.add(id.toString()); } cadytsConfig.setCalibratedItems(measurementsSet); this.writeAnalysisFile = cadytsConfig.isWriteAnalysisFile(); }
@Override public void handleEvent(VehicleArrivesAtFacilityEvent event) { if(!useVehicleIds || vehicleIds.contains(event.getVehicleId().toString())) { Tuple<String, Double> route = inTransitVehicles.remove(event.getVehicleId().toString()); if(route!=null) try { stopStopTimes.get(route.getFirst()).get(event.getFacilityId().toString()).addStopStopTime((int) (route.getSecond()/timeSlot), event.getTime()-route.getSecond()); } catch(Exception e) { //System.out.println("No: "+route.getFirst()+"-->"+event.getFacilityId()); } inTransitVehicles.put(event.getVehicleId().toString(), new Tuple<String, Double>(event.getFacilityId().toString(), event.getTime())); } } @Override
@Override public void handleEvent(VehicleArrivesAtFacilityEvent event) { if(!useVehicleIds || vehicleIds.contains(event.getVehicleId())) { Tuple<Id<TransitStopFacility>, Double> route = inTransitVehicles.remove(event.getVehicleId()); if(route!=null) stopStopTimes.get(route.getFirst()).get(event.getFacilityId()).addStopStopTime((int) (route.getSecond()/timeSlot), event.getTime()-route.getSecond()); inTransitVehicles.put(event.getVehicleId(), new Tuple<Id<TransitStopFacility>, Double>(event.getFacilityId(), event.getTime())); } } @Override
@Deprecated //not tested private void registerCarsAtDistancePerSecondMonitoring(Id<Link> linkId, Double distanceMeter){ double firstDistanceMeter = distanceMeter; Link link = this.network.getLinks().get(linkId); double secondDistanceMeter = distanceMeter - 2 * link.getFreespeed(); //TODO could also exceed link length if (secondDistanceMeter < 0.0){ firstDistanceMeter = 2* link.getFreespeed(); secondDistanceMeter = 0.0; } Tuple<Double, Double> tuple = new Tuple<Double, Double>(firstDistanceMeter, secondDistanceMeter); log.error("Link " + linkId + " first pos: " + tuple.getFirst() + " second pos: " + tuple.getSecond() + " length " + link.getLength()); this.linkFirstSecondDistanceMeterMap.put(link.getId(), tuple); this.registerNumberOfCarsInDistanceMonitoring(linkId, firstDistanceMeter); this.registerNumberOfCarsInDistanceMonitoring(linkId, secondDistanceMeter); }
@Override public void handleEvent(VehicleArrivesAtFacilityEvent event) { if(vehicleIds.contains(event.getVehicleId())) { Tuple<Id<TransitStopFacility>, Double> route = inTransitVehicles.remove(event.getVehicleId()); if(route!=null) stopStopTimes.get(new Tuple<Id<TransitStopFacility>, Id<TransitStopFacility>>(route.getFirst(), event.getFacilityId())).addStopStopTime((int) (route.getSecond()/timeSlot), event.getTime()-route.getSecond()); inTransitVehicles.put(event.getVehicleId(), new Tuple<Id<TransitStopFacility>, Double>(event.getFacilityId(), event.getTime())); } } @Override
private XMLIntergreenTimes convertDataToXml() { ObjectFactory fac = new ObjectFactory(); XMLIntergreenTimes xmlContainer = fac.createXMLIntergreenTimes(); for (IntergreensForSignalSystemData intergreens : this.intergreensData.getIntergreensForSignalSystemDataMap().values()) { XMLSignalSystem xmlss = fac.createXMLIntergreenTimesXMLSignalSystem(); xmlss.setRefId(intergreens.getSignalSystemId().toString()); xmlContainer.getSignalSystem().add(xmlss); for (Tuple<Id<SignalGroup>, Id<SignalGroup>> endingBeginningSgIds : intergreens.getEndingBeginningSignalGroupKeys()){ XMLEndingSignalGroupType xmlEnding = this.getXmlEnding(xmlss.getEndingSignalGroup(), endingBeginningSgIds.getFirst()); if (xmlEnding == null){ xmlEnding = fac.createXMLEndingSignalGroupType(); xmlEnding.setRefId(endingBeginningSgIds.getFirst().toString()); xmlss.getEndingSignalGroup().add(xmlEnding); } XMLBeginningSignalGroup xmlBeginn = fac.createXMLEndingSignalGroupTypeXMLBeginningSignalGroup(); xmlBeginn.setRefId(endingBeginningSgIds.getSecond().toString()); xmlBeginn.setTimeSeconds(BigInteger.valueOf(intergreens.getIntergreenTime(endingBeginningSgIds.getFirst(), endingBeginningSgIds.getSecond()))); xmlEnding.getBeginningSignalGroup().add(xmlBeginn); } } return xmlContainer; }
private void setMaxExtensionTimeInSylviaPlan(Tuple<SignalPlan, SylviaSignalPlan> plans) { int ext = plans.getFirst().getCycleTime() - plans.getSecond().getCycleTime(); plans.getSecond().setMaxExtensionTime(ext); }
private void handleTeleportationArrivals() { double now = internalInterface.getMobsim().getSimTimer().getTimeOfDay(); while (teleportationList.peek() != null) { Tuple<Double, MobsimAgent> entry = teleportationList.peek(); if (entry.getFirst() <= now) { teleportationList.poll(); MobsimAgent personAgent = entry.getSecond(); personAgent.notifyArrivalOnLinkByNonNetworkMode(personAgent .getDestinationLinkId()); double distance = personAgent.getExpectedTravelDistance(); this.eventsManager.processEvent(new TeleportationArrivalEvent(this.internalInterface.getMobsim().getSimTimer().getTimeOfDay(), personAgent.getId(), distance)); personAgent.endLegAndComputeNextState(now); this.teleportationData.remove(personAgent.getId()); internalInterface.arrangeNextAgentState(personAgent); } else { break; } } }
@Override public Trip findTrip(Leg prevLeg, double earliestDepartureTime_s) { ExperimentalTransitRoute route = (ExperimentalTransitRoute) prevLeg.getRoute(); Id accessStopId = route.getAccessStopId(); Id egressStopId = route.getEgressStopId(); Tuple<Double, Double> routeTravelTime = transitPerformance.getRouteTravelTime(route.getLineId(), route.getRouteId(), accessStopId, egressStopId, earliestDepartureTime_s); final double accessTime_s = earliestDepartureTime_s + routeTravelTime.getFirst(); final double egressTime_s = accessTime_s + routeTravelTime.getSecond(); return new Trip(null, accessTime_s, egressTime_s); } }
public void run(){ EventsManager events = EventsUtils.createEventsManager(); CarTripsExtractor carTripsExtractor = new CarTripsExtractor(populationIds, network); events.addHandler(carTripsExtractor); new MatsimEventsReader(events).readFile(eventsFile); List<CarTrip> carTrips = carTripsExtractor.getTrips(); Collections.shuffle(carTrips, MatsimRandom.getRandom()); int i = 0; for (CarTrip trip : carTrips){ Tuple<Double,Double> timeDistance = travelTimeValidator.getTravelTime(trip); double validatedTravelTime = timeDistance.getFirst(); trip.setValidatedTravelTime(validatedTravelTime); trip.setValidatedTravelDistance(timeDistance.getSecond()); i++; if (i>=numberOfTripsToValidate){ break; } } writeTravelTimeValidation(outputfolder, carTrips); } private void writeTravelTimeValidation(String folder, List<CarTrip> trips){
/** * @param coord * @return */ private Tuple<Integer, Integer>[] getZoneTuplesForLinks(Coord coord) { Tuple<Integer, Integer> zoneTuple = getZoneTupleForLinks(coord); int x = zoneTuple.getFirst(); int y = zoneTuple.getSecond(); return new Tuple[] { zoneTuple, new Tuple<Integer, Integer>(x-1, y-1), new Tuple<Integer, Integer>(x, y-1), new Tuple<Integer, Integer>(x+1, y-1), new Tuple<Integer, Integer>(x-1, y), new Tuple<Integer, Integer>(x+1, y), new Tuple<Integer, Integer>(x-1, y+1), new Tuple<Integer, Integer>(x, y+1), new Tuple<Integer, Integer>(x+1, y+1) }; }