private void setRandomTripMode(final Trip trip, final Plan plan, boolean ffcard, boolean owcard) {

    // carsharing is the new trip
    if (possibleModes.length == 2) {
      if (rng.nextBoolean()) {
        if (owcard)
          TripRouter.insertTrip(
              plan,
              trip.getOriginActivity(),
              Collections.singletonList(new LegImpl("onewaycarsharing")),
              trip.getDestinationActivity());
      } else {
        if (ffcard)
          TripRouter.insertTrip(
              plan,
              trip.getOriginActivity(),
              Collections.singletonList(new LegImpl("freefloating")),
              trip.getDestinationActivity());
      }
    } else if (possibleModes.length == 1 && possibleModes[0] != null) {
      if ((possibleModes[0].equals("freefloating") && ffcard)
          || (possibleModes[0].equals("onewaycarsharing") && owcard))
        TripRouter.insertTrip(
            plan,
            trip.getOriginActivity(),
            Collections.singletonList(new LegImpl(possibleModes[0])),
            trip.getDestinationActivity());
    } else
      TripRouter.insertTrip(
          plan, trip.getOriginActivity(), trip.getTripElements(), trip.getDestinationActivity());
  }
  @Override
  public TripRouter instantiateAndConfigureTripRouter(RoutingContext routingContext) {

    TripRouter instance = this.delegateFactory.instantiateAndConfigureTripRouter(routingContext);

    Network network = this.scenario.getNetwork();
    PopulationFactory populationFactory = this.scenario.getPopulation().getFactory();
    ModeRouteFactory modeRouteFactory =
        ((PopulationFactoryImpl) populationFactory).getModeRouteFactory();

    MultiModalConfigGroup multiModalConfigGroup =
        (MultiModalConfigGroup) scenario.getConfig().getModule(MultiModalConfigGroup.GROUP_NAME);
    Set<String> simulatedModes =
        CollectionUtils.stringToSet(multiModalConfigGroup.getSimulatedModes());
    for (String mode : simulatedModes) {

      if (instance.getRegisteredModes().contains(mode)) {
        log.warn("A routing algorithm for " + mode + " is already registered. It is replaced!");
      }

      TravelTime travelTime = this.multimodalTravelTimes.get(mode);
      if (travelTime == null) {
        throw new RuntimeException(
            "No travel time object was found for mode " + mode + "! Aborting.");
      }

      Network subNetwork = multimodalSubNetworks.get(mode);
      if (subNetwork == null) {
        subNetwork = NetworkImpl.createNetwork();
        Set<String> restrictions = new HashSet<>();
        restrictions.add(mode);
        TransportModeNetworkFilter networkFilter = new TransportModeNetworkFilter(network);
        networkFilter.filter(subNetwork, restrictions);
        this.multimodalSubNetworks.put(mode, subNetwork);
      }

      /*
       * We cannot use the travel disutility object from the routingContext since it
       * has not been created for the modes used here.
       */
      TravelDisutility travelDisutility =
          this.travelDisutilityFactory.createTravelDisutility(
              travelTime, scenario.getConfig().planCalcScore());
      LeastCostPathCalculator routeAlgo =
          this.leastCostPathCalculatorFactory.createPathCalculator(
              subNetwork, travelDisutility, travelTime);
      RoutingModule legRouterWrapper =
          DefaultRoutingModules.createNetworkRouter(mode, populationFactory, subNetwork, routeAlgo);
      instance.setRoutingModule(mode, legRouterWrapper);
    }

    return instance;
  }
예제 #3
0
  @Override
  public PlanAlgorithm getPlanAlgoInstance() {
    final TripRouter tripRouter = tripRouterProvider.get();
    ChooseActivityToInsert algo =
        new ChooseActivityToInsert(
            MatsimRandom.getLocalInstance(),
            tripRouter.getStageActivityTypes(),
            this.scenario,
            shopFacilityQuadTree,
            leisureFacilityQuadTree);

    return algo;
  }
  @Override
  public TripRouter instantiateAndConfigureTripRouter(RoutingContext routingContext) {
    // TODO Auto-generated method stub

    final TripRouter router = delegate.instantiateAndConfigureTripRouter(routingContext);

    // add our module to the instance
    router.setRoutingModule("movingpathways", new AAMRoutingModule(this.scenario));

    /*
    router.setRoutingModule(TransportMode.pt,
    		new TransitMultiModalAccessRoutingModule(
    				scenario,
    				new InitialNodeRouter(
    					router.getRoutingModule( "movingpathways" ),
    					scenario.getConfig().transitRouter().getSearchRadius(),
    					1,
    					scoringParams )

    				) );

    */
    final MainModeIdentifier defaultModeIdentifier = router.getMainModeIdentifier();
    router.setMainModeIdentifier(
        new MainModeIdentifier() {
          @Override
          public String identifyMainMode(final List<? extends PlanElement> tripElements) {
            boolean hadMovingPathway = false;
            for (PlanElement pe : tripElements) {
              if (pe instanceof Leg) {
                final Leg l = (Leg) pe;
                if (l.getMode().equals("movingpathways")) {
                  hadMovingPathway = true;
                }
                if (l.getMode().equals(TransportMode.transit_walk)) {
                  return TransportMode.pt;
                }
              }
            }

            if (hadMovingPathway) {
              // there were bike sharing legs but no transit walk
              return "movingpathways";
            }

            return defaultModeIdentifier.identifyMainMode(tripElements);
          }
        });

    return router;
  }
  // package protected for tests
  final void removePassengerTrip(final JointTrip toRemove, final JointPlan jointPlan) {
    final Plan passengerPlan = jointPlan.getIndividualPlan(toRemove.getPassengerId());

    final Trip tripWithLeg =
        getTripWithLeg(passengerPlan, toRemove.getPassengerLeg(), stagesWithJointTypes);

    TripRouter.insertTrip(
        passengerPlan,
        tripWithLeg.getOriginActivity(),
        Collections.singletonList(PopulationUtils.createLeg(TransportMode.pt)),
        tripWithLeg.getDestinationActivity());
  }
  private Alternative<ModeNests> calcAlternative(
      final int i,
      final String mode,
      final ActivityFacility origin,
      final ActivityFacility destination,
      final Person person) {
    final Trip trip =
        new Trip(
            origin, router.calcRoute(mode, origin, destination, 12 * 3600, person), destination);

    return new Alternative<>(
        ModeNests.valueOf(mode), Id.create(i + "_" + mode, Alternative.class), trip);
  }
  @Override
  public TripRouter get() {
    final TripRouter tripRouter = defaultFactory.get();

    final TransitRouterWrapper routingModule =
        new TransitRouterWrapper(
            transitRouterFactory.get(),
            scenario.getTransitSchedule(),
            scenario.getNetwork(), // use a walk router in case no PT path is found
            DefaultRoutingModules.createTeleportationRouter(
                TransportMode.transit_walk,
                scenario.getPopulation().getFactory(),
                scenario
                    .getConfig()
                    .plansCalcRoute()
                    .getModeRoutingParams()
                    .get(TransportMode.walk)));

    tripRouter.setRoutingModule(TransportMode.pt, routingModule);

    return tripRouter;
  }
  private void repareDriverTrips(final JointTrip toRemove, final JointPlan plan) {
    final List<TripStructureUtils.Trip> subtrips =
        getDriverTrip(toRemove, plan.getIndividualPlan(toRemove.getDriverId()));
    final List<PlanElement> newTrip = new ArrayList<PlanElement>();
    newTrip.add(PopulationUtils.createLeg(TransportMode.car));

    // "state" variables, changed in the loop:
    // - keeps track of the passengers currently in the vehicle.
    //   Pick-up or drop-offs are created at each change
    Set<Id> currentPassengers = Collections.<Id>emptySet();
    for (TripStructureUtils.Trip subtrip : subtrips) {
      final Leg leg = getDriverLegIfItIs(subtrip);
      final Route route = leg == null ? null : leg.getRoute();

      final Set<Id> newPassengers =
          route != null
              ? new HashSet<Id>(((DriverRoute) route).getPassengersIds())
              : Collections.<Id>emptySet();
      // note that no check of the mode is done...
      if (!newPassengers.equals(currentPassengers)) {
        newTrip.add(
            PopulationUtils.createActivityFromLinkId(
                JointActingTypes.INTERACTION,
                route != null ? route.getStartLinkId() : subtrip.getOriginActivity().getLinkId()));

        // as the spatial structure of the trip is modified, it is possible
        // that some pre-existing subtours are removed. Thus, a driver that may
        // have walked to a pick up (because at the same location as its departure)
        // may then have to drive to pick up the second passenger directly if
        // the first passenger was removed. Setting all non-driver legs
        // to car ensures to have a consistent mode chain.
        // XXX It could be done in a smarter way, so that if no subtour is removed, no modification
        // is done
        // For instance, when removing an "intern" trip, first PU and last DO are
        // left untouched, and thus access and egress leg need not be touched.
        newTrip.add(leg != null ? leg : PopulationUtils.createLeg(TransportMode.car));
        currentPassengers = newPassengers;
      }
    }

    TripRouter.insertTrip(
        plan.getIndividualPlan(toRemove.getDriverId()),
        subtrips.get(0).getOriginActivity(),
        newTrip,
        subtrips.get(subtrips.size() - 1).getDestinationActivity());
  }
  private boolean microRouteCurrentLegRoute(
      Leg leg,
      Person person,
      int currentLinkIndex,
      double time,
      Network network,
      TripRouter tripRouter,
      Random random,
      Plan plan) {

    Route route = leg.getRoute();

    // if the route type is not supported (e.g., because it is a walking agent)
    if (!(route instanceof NetworkRoute)) return false;

    if (random.nextFloat() > 0.3) return false; // only 30% replanners

    PersonImpl p = (PersonImpl) person;
    int legnr = plan.getPlanElements().indexOf(leg);

    //	logger.warn(legnr);

    if (p.getAge() == legnr) {
      //		logger.error("agent already replanned");
      //		return false; // agent has been replanned already
    } else {
      //		p.setAge(legnr);
    }

    NetworkRoute oldRoute = (NetworkRoute) route;

    /*
     *  Get the Id of the current Link.
     *  Create a List that contains all links of a route, including the Start- and EndLinks.
     */
    List<Id<Link>> allLinkIds = getRouteLinkIds(oldRoute); //

    int links2go = allLinkIds.size() - (currentLinkIndex + 1); //

    if (links2go >= 3) {
      Id<Link> startLink = allLinkIds.get(0);
      Id<Link> endLink = allLinkIds.get(allLinkIds.size() - 1);

      // The linkIds of the new Route ---------------------------
      List<Id<Link>> linkIds = new ArrayList<Id<Link>>();
      // start of the old route
      linkIds.addAll(allLinkIds.subList(1, currentLinkIndex)); // currentLinkIndex exclusive

      // micro-reroute part of route ---------------------------
      Id<Link> currentLinkId = allLinkIds.get(currentLinkIndex); // link 1, currentLinkIndex = 1
      Link fromLink = network.getLinks().get(currentLinkId);

      int jump = random.nextInt(links2go - 2) + 2; // start with 2
      int toLinkIndex = (currentLinkIndex + jump); // jump over one link //
      Id<Link> toLinkId = allLinkIds.get(toLinkIndex); //
      Link toLink = network.getLinks().get(toLinkId); //

      Facility<ActivityFacility> fromFacility = new LinkWrapperFacility(fromLink);
      Facility<ActivityFacility> toFacility = new LinkWrapperFacility(toLink);

      List<? extends PlanElement> planElements =
          tripRouter.calcRoute(leg.getMode(), fromFacility, toFacility, time, person); //

      if (planElements.size() != 1) {
        throw new RuntimeException(
            "Expected a list of PlanElements containing exactly one element, "
                + "but the returned list contained "
                + planElements.size()
                + " elements.");
      }
      Leg newLeg = (Leg) planElements.get(0);
      Route newRoute = newLeg.getRoute();
      linkIds.addAll(getRouteLinkIds(newRoute)); // currentLinkIndex => startLink

      // remainder of the old route ---------------------------
      if (toLinkIndex + 1 < allLinkIds.size() - 1) { // if route is not yet finished:
        linkIds.addAll(allLinkIds.subList(toLinkIndex + 1, allLinkIds.size() - 1));
      }

      // Overwrite old Route
      if (linkIds.size() > 2 && toLinkId.compareTo(fromLink.getId()) != 0) {
        List<Id<Link>> middleLinks = linkIds.subList(0, linkIds.size()); // to is exclusive

        //				String str = oldRoute.toString();
        //				int lo = oldRoute.getLinkIds().size();

        oldRoute.setLinkIds(startLink, middleLinks, endLink);

        //				if (oldRoute.getLinkIds().size() != lo) {
        //					logger.info(person.getId() + " :" + str + "\n" +
        //							oldRoute.toString());
        //				}
      } // else do not replace route
    }
    return true;
  }
  private void initializeFreeFLoatingParkingCarLeg(double now) {
    this.state = MobsimAgent.State.LEG;

    PlanElement pe = this.getCurrentPlanElement();

    Leg leg = (Leg) pe;
    Route route = leg.getRoute();

    // create route for the car part of the freefloating trip
    parkingSpot =
        parkingModule.parkFreeFloatingVehicle(
            Id.create(vehID, Vehicle.class),
            this.scenario.getNetwork().getLinks().get(route.getEndLinkId()).getCoord(),
            this.person.getId(),
            now);

    double travelTime = 0.0;
    List<Id<Link>> ids = new ArrayList<Id<Link>>();

    Provider<TripRouter> tripRouterFactory = controler.getTripRouterProvider();

    TripRouter tripRouter = tripRouterFactory.get();

    Coord coordStart =
        new Coord(
            scenario.getNetwork().getLinks().get(route.getEndLinkId()).getCoord().getX(),
            scenario.getNetwork().getLinks().get(route.getEndLinkId()).getCoord().getY());

    TwoWayCSFacility startFacility =
        new TwoWayCSFacilityImpl(
            Id.create("1000000000", TwoWayCSFacility.class), coordStart, route.getEndLinkId());

    Coord coordEnd =
        new Coord(
            scenario.getNetwork().getLinks().get(parkingSpot.getLinkId()).getCoord().getX(),
            scenario.getNetwork().getLinks().get(parkingSpot.getLinkId()).getCoord().getY());
    TwoWayCSFacility endFacility =
        new TwoWayCSFacilityImpl(
            Id.create("1000000001", TwoWayCSFacility.class), coordEnd, parkingSpot.getLinkId());

    for (PlanElement pe1 : tripRouter.calcRoute("car", startFacility, endFacility, now, person)) {

      if (pe1 instanceof Leg) {
        ids = ((NetworkRoute) ((Leg) pe1).getRoute()).getLinkIds();
        travelTime += ((Leg) pe1).getTravelTime();
      }
    }

    LegImpl carLeg = new LegImpl("freefloatingparking");

    carLeg.setTravelTime(travelTime);
    NetworkRoute route1 =
        ((PopulationFactoryImpl) scenario.getPopulation().getFactory())
            .getModeRouteFactory()
            .createRoute(NetworkRoute.class, route.getEndLinkId(), parkingSpot.getLinkId());
    route1.setLinkIds(route.getEndLinkId(), ids, parkingSpot.getLinkId());
    route1.setTravelTime(travelTime);
    // route1.setVehicleId(new IdImpl("FF_" + (vehID)));
    carLeg.setRoute(route1);
    this.cachedDestinationLinkId = parkingSpot.getLinkId();

    // set the route according to the next leg
    this.currentLeg = carLeg;
    this.cachedRouteLinkIds = null;
    this.currentLinkIdIndex = 0;
    this.cachedNextLinkId = null;

    return;
  }