@Override protected void relaxNode(final Node outNode, final Node toNode, final RouterPriorityQueue<Node> pendingNodes) { this.controlCounter++; if (this.controlCounter == controlInterval) { int newLandmarkIndex = checkToAddLandmark(outNode, toNode); if (newLandmarkIndex > 0) { updatePendingNodes(newLandmarkIndex, toNode, pendingNodes); } this.controlCounter = 0; } this.fastRouter.relaxNode(outNode, toNode, pendingNodes); }
@Override /*package*/ void initFromNode(final Node fromNode, final Node toNode, final double startTime, final RouterPriorityQueue<Node> pendingNodes) { // If it is an imaginary node, we relax it. if (fromNode instanceof ImaginaryNode) { relaxImaginaryNode((ImaginaryNode) fromNode, pendingNodes, startTime); } // ... otherwise: default behaviour. else super.initFromNode(fromNode, toNode, startTime, pendingNodes); }
@Override public Path calcLeastCostPath(final Node fromNode, final Node toNode, final double startTime, final Person person, final Vehicle vehicle) { this.controlCounter = 0; // reset counter for each calculated path! if (this.landmarks.length >= 2) { initializeActiveLandmarks(fromNode, toNode, 2); } else { initializeActiveLandmarks(fromNode, toNode, this.landmarks.length); } return super.calcLeastCostPath(fromNode, toNode, startTime, person, vehicle); }
private boolean containsMode( final Subtour s ) { for ( Trip t : s.getTrips() ) { if ( tripRouter.getMainModeIdentifier().identifyMainMode( t.getTripElements() ).equals( mode ) ) { return true; } } return false; } }
private boolean containsUnknownMode(final Subtour subtour) { for (Trip trip : subtour.getTrips()) { if (!modes.contains( mainModeIdentifier.identifyMainMode( trip.getTripElements() ))) { return true; } } return false; }
private String identifyMainMode(final Trip t) { return tripRouter.getMainModeIdentifier().identifyMainMode( t.getTripElements() ); }
@Override public PlanAlgorithm createPlanRoutingAlgorithm( final TripRouter tripRouter) { return new PlanRouter(tripRouter); } });
private MultiNodeDijkstra makeMultiNodeDikstra(Network network, TravelDisutility travelDisutility, TravelTime travelTime, boolean fastRouter) { if (fastRouter) { return (MultiNodeDijkstra) new FastMultiNodeDijkstraFactory().createPathCalculator(network, travelDisutility, travelTime); } else return (MultiNodeDijkstra) new MultiNodeDijkstraFactory().createPathCalculator(network, travelDisutility, travelTime); }
public Trip findTripAfterActivity( Plan plan, Activity activity ) { return TripStructureUtils.findTripStartingAtActivity( activity, plan, tripRouter.getStageActivityTypes() ) ; }
public static Provider<TripRouter> createTripRouterProvider( final Scenario scenario, final LeastCostPathCalculatorFactory leastCostAlgoFactory, final Provider<TransitRouter> transitRouterFactory) { TripRouterFactoryBuilderWithDefaults builder = new TripRouterFactoryBuilderWithDefaults(); builder.setLeastCostPathCalculatorFactory(leastCostAlgoFactory); builder.setTransitRouterFactory(transitRouterFactory); return builder.build(scenario); }
private void calculatePaths(Node fromNode, Map<Id<Node>, ToNode> toNodes, double startTime) { RoutingNetworkImaginaryNode imaginaryNode = new RoutingNetworkImaginaryNode(toNodes.values()); multiNodeDijkstra.setSearchAllEndNodes(true); multiNodeDijkstra.calcLeastCostPath(fromNode, imaginaryNode, startTime, null, null); // get path for each ToNode // XXX in most cases we need costs/times, while paths could be constructed lazily only when needed // TODO add getCost/Time() to MultiNodeDijkstra for (ToNode toNode : toNodes.values()) { toNode.path = multiNodeDijkstra.constructPath(fromNode, toNode.node, startTime); } }
@Override protected void relaxNode(final Node outNode, final Node toNode, final RouterPriorityQueue<Node> pendingNodes) { this.controlCounter++; if (this.controlCounter == controlInterval) { int newLandmarkIndex = checkToAddLandmark(outNode, toNode); if (newLandmarkIndex > 0) { updatePendingNodes(newLandmarkIndex, toNode, pendingNodes); } this.controlCounter = 0; } super.relaxNode(outNode, toNode, pendingNodes); }
public DynRoutingModule(String mode) { this.mode = mode; this.stageActivityType = mode + " interaction"; this.stageActivityTypes = new StageActivityTypesImpl(stageActivityType); }
protected void relaxImaginaryNode(final ImaginaryNode outNode, final RouterPriorityQueue<Node> pendingNodes, final double currTime) { double currCost = 0.0; // should be 0 for (InitialNode initialNode : outNode.initialNodes) { double travelTime = initialNode.initialTime; double travelCost = initialNode.initialCost; DijkstraNodeData data = getData(initialNode.node); Link l = null; // fromLink - use a dummy link here?? visitNode(initialNode.node, data, pendingNodes, currTime + travelTime, currCost + travelCost, l); } }
/** * Creates an instance filled with the components passed as parameter */ public CompositeStageActivityTypes( final StageActivityTypes... components) { for ( StageActivityTypes c : components ) { addActivityTypes( c ); } }
@Override public LeastCostPathCalculatorFactory getFactory(final Network network, final TravelDisutility costCalc, final TravelTime timeCalc) { return new FastDijkstraFactory(); } });
@Override public boolean equals( Object obj ) { if ( !(obj instanceof AccessEgressStageActivityTypes) ) { return false ; } AccessEgressStageActivityTypes other = (AccessEgressStageActivityTypes) obj ; return other.isStageActivity(NetworkRoutingInclAccessEgressModule.this.stageActivityType) ; } @Override public int hashCode() {
/** * Returns the data for the given Node. Creates a new AStarNodeData if none exists yet. * * @param n The node for which to return the data for.. * @return The data to the given Node */ @Override protected AStarNodeData getData(final Node n) { return (AStarNodeData) super.getData(n); }
@Override public LeastCostPathCalculatorFactory getFactory(final Network network, final TravelDisutility costCalc, final TravelTime timeCalc) { return new FastAStarEuclideanFactory(); } });
@Override public String identifyMode(final Subtour subtour) { return modeIdentifier.identifyMainMode( subtour.getTrips().get( 0 ).getTripElements() ); } }