Inheritance diagram for org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour:

Classes
class	Candidate

Public Member Functions
	ChooseRandomLegModeForSubtour (final MainModeIdentifier mainModeIdentifier, final PermissibleModesCalculator permissibleModesCalculator, final String[] modes, final String[] chainBasedModes, final Random rng, SubtourModeChoice.Behavior behavior, double probaForChooseRandomSingleTripMode)

	ChooseRandomLegModeForSubtour (final MainModeIdentifier mainModeIdentifier, final PermissibleModesCalculator permissibleModesCalculator, final String[] modes, final String[] chainBasedModes, final Random rng, SubtourModeChoice.Behavior behavior, double probaForChooseRandomSingleTripMode, double coordDist)

void	setSingleTripSubtourModes (final String[] singleTripSubtourModes)

List< Candidate >	determineChoiceSet (final Plan plan)

boolean	isMassConserving (final Subtour subtour)

void	run (final Plan plan)

Private Member Functions
boolean	hasSingleTripChoice (List< Trip > trips)

List< Candidate >	determineChoiceSet (final Id<? extends BasicLocation > homeLocation, final Plan plan, final List< Trip > trips, final Collection< String > permissibleModesForThisPerson)

boolean	containsUnknownMode (final Subtour subtour)

boolean	isMassConserving (final Subtour subtour, final String mode)

Id<? extends BasicLocation >	getLocationId (Activity activity)

boolean	atSameLocation (Activity firstLegUsingMode, Activity lastLegUsingMode)

Activity	findLastDestinationOfMode (final List< Trip > tripsToSearch, final String mode)

Activity	findFirstOriginOfMode (final List< Trip > tripsToSearch, final String mode)

String	getTransportMode (final Subtour subtour)

void	applyChange (final Candidate whatToDo, final Plan plan)

Private Attributes
Collection< String >	modes

final Collection< String >	chainBasedModes

final SubtourModeChoice.Behavior	behavior

Collection< String >	singleTripSubtourModes

final MainModeIdentifier	mainModeIdentifier

final Random	rng

PermissibleModesCalculator	permissibleModesCalculator

final double	probaForChangeSingleTripMode

TripsToLegsAlgorithm	tripsToLegs = null

ChooseRandomSingleLegMode	changeSingleLegMode = null

double	coordDist = 0

Static Private Attributes
static final Logger	logger = LogManager.getLogger(ChooseRandomLegModeForSubtour.class)

Detailed Description

Changes the transportation mode of one random non-empty subtour in a plan to a randomly chosen different mode given a list of possible modes, considering that the means of transport follows the law of mass conservation.

Author: michaz

See also: SubtourModeChoice

Definition at line 49 of file ChooseRandomLegModeForSubtour.java.

Constructor & Destructor Documentation

◆ ChooseRandomLegModeForSubtour() [1/2]

org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.ChooseRandomLegModeForSubtour	(	final MainModeIdentifier	mainModeIdentifier,
		final PermissibleModesCalculator	permissibleModesCalculator,
		final String []	modes,
		final String []	chainBasedModes,
		final Random	rng,
		SubtourModeChoice.Behavior	behavior,
		double	probaForChooseRandomSingleTripMode
	)

Definition at line 112 of file ChooseRandomLegModeForSubtour.java.

References org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.behavior, org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.chainBasedModes, org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.mainModeIdentifier, org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.modes, org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.permissibleModesCalculator, and org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.rng.

                                                                                                               {
         this(mainModeIdentifier, permissibleModesCalculator, modes, chainBasedModes, rng, behavior, probaForChooseRandomSingleTripMode, 0);
     }

◆ ChooseRandomLegModeForSubtour() [2/2]

org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.ChooseRandomLegModeForSubtour	(	final MainModeIdentifier	mainModeIdentifier,
		final PermissibleModesCalculator	permissibleModesCalculator,
		final String []	modes,
		final String []	chainBasedModes,
		final Random	rng,
		SubtourModeChoice.Behavior	behavior,
		double	probaForChooseRandomSingleTripMode,
		double	coordDist
	)

Definition at line 121 of file ChooseRandomLegModeForSubtour.java.

References org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.behavior, org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.chainBasedModes, org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.coordDist, org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.mainModeIdentifier, org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.modes, org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.permissibleModesCalculator, and org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.rng.

                                                                                                                                 {
         this.mainModeIdentifier = mainModeIdentifier;
         this.permissibleModesCalculator = permissibleModesCalculator;
         this.modes = Arrays.asList(modes);
         this.chainBasedModes = Arrays.asList(chainBasedModes);
         this.behavior = behavior;
         this.probaForChangeSingleTripMode = probaForChooseRandomSingleTripMode;
         this.singleTripSubtourModes = this.chainBasedModes;
         this.coordDist = coordDist;
 
         this.rng = rng;
         logger.info("Chain based modes: " + this.chainBasedModes.toString());
 
         // also set up the standard change single leg mode, in order to alternatively randomize modes in
         // subtours.  kai, may'18
         if (this.probaForChangeSingleTripMode > 0.) {
             Collection<String> notChainBasedModes = new ArrayList<>(this.modes);
             notChainBasedModes.removeAll(this.chainBasedModes);
             final String[] possibleModes = notChainBasedModes.toArray(new String[]{});
             if (possibleModes.length >= 2) {
                 // nothing to choose if there is only one mode!  I also don't think that we can base this on size, since
                 // mode strings might be registered multiple times (these are not sets).  kai, may'18
 
                 this.tripsToLegs = new TripsToLegsAlgorithm(this.mainModeIdentifier);
 
                 // change single leg would not respect car availability, if car is not a chain based mode -- cr, aug'22
                 this.changeSingleLegMode = new ChooseRandomSingleLegMode(possibleModes, rng, true);
             }
         }
     }

Member Function Documentation

◆ setSingleTripSubtourModes()

void org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.setSingleTripSubtourModes ( final String [] singleTripSubtourModes )

Some subtour consist of only a single trip, e.g. if a trip starts and ends on the same link or facility. By default, for those modes, the normal chain based modes are available. But in certain cases, not all the modes should be available for such trips (e.g. car-sharing does not make much sense for such a trip), thus the list of modes available for single-trip subtours can be specified independently. As mentioned, it is initialized by the constructor to the full list of chain based modes.

Parameters

singleTripSubtourModes

Definition at line 166 of file ChooseRandomLegModeForSubtour.java.

                                                                                  {
         this.singleTripSubtourModes = Arrays.asList(singleTripSubtourModes);
     }

◆ determineChoiceSet() [1/2]

List<Candidate> org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.determineChoiceSet ( final Plan plan )

Return all possible choices for a certain plan.

Definition at line 173 of file ChooseRandomLegModeForSubtour.java.

References org.matsim.core.population.algorithms.PermissibleModesCalculator.getPermissibleModes(), org.matsim.api.core.v01.population.Plan.getPlanElements(), and org.matsim.core.router.TripStructureUtils.getTrips().

Referenced by org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.run().

                                                                {
 
         final Id<? extends BasicLocation> homeLocation = ((Activity) plan.getPlanElements().get(0)).getFacilityId() != null ?
                 ((Activity) plan.getPlanElements().get(0)).getFacilityId() :
                 ((Activity) plan.getPlanElements().get(0)).getLinkId();
         Collection<String> permissibleModesForThisPlan = permissibleModesCalculator.getPermissibleModes(plan);
 
         return determineChoiceSet(
                 homeLocation,
                 plan,
                 TripStructureUtils.getTrips(plan),
                 permissibleModesForThisPlan);
     }

Here is the call graph for this function:

◆ isMassConserving() [1/2]

boolean org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.isMassConserving ( final Subtour subtour )

Return whether a subtour is mass conserving according to configuration. Ignoring if subtours are closed.

Definition at line 190 of file ChooseRandomLegModeForSubtour.java.

Referenced by org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.determineChoiceSet().

                                                            {
 
         for (String mode : chainBasedModes) {
             if (!isMassConserving(subtour, mode)) {
                 return false;
             }
         }
         return true;
     }

◆ run()

void org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.run ( final Plan plan )

Implements org.matsim.core.population.algorithms.PlanAlgorithm.

Definition at line 201 of file ChooseRandomLegModeForSubtour.java.

References org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.applyChange(), org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.determineChoiceSet(), org.matsim.core.population.algorithms.PermissibleModesCalculator.getPermissibleModes(), org.matsim.api.core.v01.population.Plan.getPlanElements(), org.matsim.core.router.TripStructureUtils.getTrips(), org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.hasSingleTripChoice(), org.matsim.core.population.algorithms.TripsToLegsAlgorithm.run(), and org.matsim.core.population.algorithms.ChooseRandomSingleLegMode.run().

                                      {
         if (plan.getPlanElements().size() <= 1) {
             return;
         }
 
         // trips are used multiple times
         List<Trip> trips = TripStructureUtils.getTrips(plan);
 
         // with certain proba, do standard single leg mode choice for not-chain-based modes:
         // if a plan consist of only chain based modes, change single trip won't be able to do anything, in this case it will be ignored
         if (this.changeSingleLegMode != null && rng.nextDouble() < this.probaForChangeSingleTripMode && hasSingleTripChoice(trips)) {
             // (the null check is for computational efficiency)
 
             this.tripsToLegs.run(plan);
             this.changeSingleLegMode.run(plan);
             return;
         }
 
         final Id<? extends BasicLocation> homeLocation = ((Activity) plan.getPlanElements().get(0)).getFacilityId() != null ?
                 ((Activity) plan.getPlanElements().get(0)).getFacilityId() :
                 ((Activity) plan.getPlanElements().get(0)).getLinkId();
 
         Collection<String> permissibleModesForThisPlan = permissibleModesCalculator.getPermissibleModes(plan);
         // (modes that agent can in principle use; e.g. cannot use car sharing if not member)
 
 
         List<Candidate> choiceSet = determineChoiceSet(homeLocation, plan, trips, permissibleModesForThisPlan);
 
         if (!choiceSet.isEmpty()) {
             Candidate whatToDo = choiceSet.get(rng.nextInt(choiceSet.size()));
             // (means that in the end we are changing modes only for one subtour)
 
             applyChange(whatToDo, plan);
         }
     }

Here is the call graph for this function:

◆ hasSingleTripChoice()

boolean org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.hasSingleTripChoice ( List< Trip > trips )

private

Checks if change single trip mode would have an option to choose from. That is the case, when not all trips are chain based.

Definition at line 240 of file ChooseRandomLegModeForSubtour.java.

References org.matsim.core.router.MainModeIdentifier.identifyMainMode().

Referenced by org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.run().

                                                           {
         return !trips.stream().map(
                 t -> mainModeIdentifier.identifyMainMode(t.getTripElements())
         ).allMatch(chainBasedModes::contains);
     }

Here is the call graph for this function:

◆ determineChoiceSet() [2/2]

List<Candidate> org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.determineChoiceSet	(	final Id<? extends BasicLocation >	homeLocation,
		final Plan	plan,
		final List< Trip >	trips,
		final Collection< String >	permissibleModesForThisPerson
	)

private

Definition at line 246 of file ChooseRandomLegModeForSubtour.java.

                                                                     {
 
         final List<Subtour> subtours = new ArrayList<>(TripStructureUtils.getSubtours(plan, coordDist));
         final ArrayList<Candidate> choiceSet = new ArrayList<>();
 
         // there is no subtour containing all trips, so it will be added
         if (behavior == SubtourModeChoice.Behavior.betweenAllAndFewerConstraints && trips.size() > 0 && subtours.stream().noneMatch(s -> s.getTrips().equals(trips))) {
             subtours.add(0, TripStructureUtils.getUnclosedRootSubtour(plan));
         }
 
         for (Subtour subtour : subtours) {
 
             // If subtour is not closed, it will still be considered if constrains are disabled
             if (!subtour.isClosed() && behavior != SubtourModeChoice.Behavior.betweenAllAndFewerConstraints) {
                 continue;
             }
 
             if (containsUnknownMode(subtour)) {
                 continue;
             }
 
             final Id<? extends BasicLocation> subtourStartLocation =
 //                  anchorAtFacilities ?
                     subtour.getTrips().get(0).getOriginActivity().getFacilityId() != null ?
                             subtour.getTrips().get(0).getOriginActivity().getFacilityId() :
                             subtour.getTrips().get(0).getOriginActivity().getLinkId();
 
             final Collection<String> testingModes =
                     subtour.getTrips().size() == 1 ?
                             singleTripSubtourModes :
                             chainBasedModes;
             // I am not sure what the singleTripSubtourModes thing means.  But apart from that ...
 
             // ... test whether a vehicle was brought to the subtourStartLocation:
             final Set<String> usableChainBasedModes = new LinkedHashSet<>();
             for (String mode : testingModes) {
                 Id<? extends BasicLocation> vehicleLocation = homeLocation;
                 Activity lastDestination =
                         findLastDestinationOfMode(
                                 trips.subList(
                                         0,
                                         trips.indexOf(subtour.getTrips().get(0))),
                                 mode);
                 if (lastDestination != null) {
                     vehicleLocation = getLocationId(lastDestination);
                 }
                 if (vehicleLocation.equals(subtourStartLocation)) {
                     usableChainBasedModes.add(mode);
                     // can have more than one mode here when subtour starts at home.
                 }
             }
 
             // yy My intuition is that with the above condition, a switch of an all-car plan with at least
             // one explicit sub-tour could switch to an all-bicycle plan only via first changing the
             // explicit sub-tour first to a non-chain-based mode.  kai, jul'18
 
             // The top-level subtour may use all chain-based modes freely for the whole plan
 
             Set<String> usableModes = new LinkedHashSet<>();
             if (isMassConserving(subtour) || (behavior == SubtourModeChoice.Behavior.betweenAllAndFewerConstraints && subtour.getParent() == null)) { // We can only replace a subtour if it doesn't itself move a vehicle from one place to another
                 for (String candidate : permissibleModesForThisPerson) {
                     if (chainBasedModes.contains(candidate)) {
                         // for chain-based modes, only add if vehicle is available:
                         if (usableChainBasedModes.contains(candidate)) {
                             usableModes.add(candidate);
                         }
                     } else {
                         // for non-chain-based modes, always add:
                         usableModes.add(candidate);
                     }
                 }
             }
 
             if (behavior == SubtourModeChoice.Behavior.betweenAllAndFewerConstraints) {
 
                 // only remove candidates if the whole trip uses the same mode
                 usableModes.removeIf(mode -> subtour.getTrips().stream().allMatch(
                         trip-> mode.equals(mainModeIdentifier.identifyMainMode(trip.getTripElements()))
                 ));
 
             } else {
                 // The old behaviour removes candidates that could change trips to a different mode
                 usableModes.remove(getTransportMode(subtour));
             }
 
 
             // (remove current mode so we don't get it again; note that the parent plan is kept anyways)
             for (String transportMode : usableModes) {
                 choiceSet.add(
                         new Candidate(trips,
                                 subtour,
                                 transportMode));
             }
         }
         return choiceSet;
     }

Here is the call graph for this function:

◆ containsUnknownMode()

boolean org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.containsUnknownMode ( final Subtour subtour )

private

Definition at line 347 of file ChooseRandomLegModeForSubtour.java.

References org.matsim.core.router.TripStructureUtils.Subtour.getTrips(), and org.matsim.core.router.MainModeIdentifier.identifyMainMode().

Referenced by org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.determineChoiceSet().

                                                                {
         for (Trip trip : subtour.getTrips()) {
             if (!modes.contains(mainModeIdentifier.identifyMainMode(trip.getTripElements()))) {
                 return true;
             }
         }
         return false;
     }

Here is the call graph for this function:

◆ isMassConserving() [2/2]

boolean org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.isMassConserving	(	final Subtour	subtour,
		final String	mode
	)

private

Definition at line 356 of file ChooseRandomLegModeForSubtour.java.

References org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.atSameLocation(), org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.findFirstOriginOfMode(), org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.findLastDestinationOfMode(), and org.matsim.core.router.TripStructureUtils.Subtour.getTrips().

                                {
         final Activity firstOrigin =
                 findFirstOriginOfMode(
                         subtour.getTrips(),
                         mode);
 
         if (firstOrigin == null) {
             return true;
         }
 
         final Activity lastDestination =
                 findLastDestinationOfMode(
                         subtour.getTrips(),
                         mode);
 
         return atSameLocation(firstOrigin, lastDestination);
     }

Here is the call graph for this function:

◆ getLocationId()

Id<? extends BasicLocation> org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.getLocationId ( Activity activity )

private

Definition at line 376 of file ChooseRandomLegModeForSubtour.java.

References org.matsim.api.core.v01.population.Activity.getFacilityId(), and org.matsim.api.core.v01.population.Activity.getLinkId().

Referenced by org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.determineChoiceSet().

                                                                          {
         return activity.getFacilityId() != null ?
                 activity.getFacilityId() :
                 activity.getLinkId();
     }

Here is the call graph for this function:

◆ atSameLocation()

boolean org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.atSameLocation	(	Activity	firstLegUsingMode,
		Activity	lastLegUsingMode
	)

private

Definition at line 382 of file ChooseRandomLegModeForSubtour.java.

References org.matsim.core.utils.geometry.CoordUtils.calcEuclideanDistance(), org.matsim.api.core.v01.population.Activity.getCoord(), org.matsim.api.core.v01.population.Activity.getFacilityId(), and org.matsim.api.core.v01.population.Activity.getLinkId().

Referenced by org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.isMassConserving().

                                                               {
         if (firstLegUsingMode.getFacilityId() != null)
             return firstLegUsingMode.getFacilityId().equals(lastLegUsingMode.getFacilityId());
         else if ( coordDist > 0 && firstLegUsingMode.getCoord() != null && lastLegUsingMode.getCoord() != null)
             return CoordUtils.calcEuclideanDistance(firstLegUsingMode.getCoord(), lastLegUsingMode.getCoord()) <= coordDist;
         else
             return firstLegUsingMode.getLinkId().equals(lastLegUsingMode.getLinkId());
     }

Here is the call graph for this function:

◆ findLastDestinationOfMode()

Activity org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.findLastDestinationOfMode	(	final List< Trip >	tripsToSearch,
		final String	mode
	)

private

Definition at line 392 of file ChooseRandomLegModeForSubtour.java.

References org.matsim.core.router.MainModeIdentifier.identifyMainMode().

Referenced by org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.determineChoiceSet(), and org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.isMassConserving().

                                {
         final List<Trip> reversed = new ArrayList<>(tripsToSearch);
         Collections.reverse(reversed);
         for (Trip trip : reversed) {
             if (mode.equals(mainModeIdentifier.identifyMainMode(trip.getTripElements()))) {
                 return trip.getDestinationActivity();
             }
         }
         return null;
     }

Here is the call graph for this function:

◆ findFirstOriginOfMode()

Activity org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.findFirstOriginOfMode	(	final List< Trip >	tripsToSearch,
		final String	mode
	)

private

Definition at line 405 of file ChooseRandomLegModeForSubtour.java.

References org.matsim.core.router.MainModeIdentifier.identifyMainMode().

Referenced by org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.isMassConserving().

                                {
         for (Trip trip : tripsToSearch) {
             if (mode.equals(mainModeIdentifier.identifyMainMode(trip.getTripElements()))) {
                 return trip.getOriginActivity();
             }
         }
         return null;
     }

Here is the call graph for this function:

◆ getTransportMode()

String org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.getTransportMode ( final Subtour subtour )

private

Definition at line 416 of file ChooseRandomLegModeForSubtour.java.

References org.matsim.core.router.TripStructureUtils.Subtour.getTrips(), and org.matsim.core.router.MainModeIdentifier.identifyMainMode().

Referenced by org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.determineChoiceSet().

                                                            {
         return mainModeIdentifier.identifyMainMode(
                 subtour.getTrips().get(0).getTripElements());
     }

Here is the call graph for this function:

◆ applyChange()

void org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.applyChange	(	final Candidate	whatToDo,
		final Plan	plan
	)

private

Definition at line 421 of file ChooseRandomLegModeForSubtour.java.

References org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.behavior, org.matsim.core.replanning.modules.SubtourModeChoice.Behavior.betweenAllAndFewerConstraints, org.matsim.core.population.PopulationUtils.createLeg(), org.matsim.core.replanning.modules.SubtourModeChoice.Behavior.fromSpecifiedModesToSpecifiedModes, org.matsim.api.core.v01.population.Plan.getPerson(), org.matsim.core.router.TripStructureUtils.getTrips(), org.matsim.core.router.TripStructureUtils.Subtour.getTrips(), org.matsim.core.router.TripStructureUtils.Subtour.getTripsWithoutSubSubtours(), org.matsim.core.router.MainModeIdentifier.identifyMainMode(), org.matsim.core.router.TripRouter.insertTrip(), org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.Candidate.newTransportMode, and org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.Candidate.subtour.

Referenced by org.matsim.core.population.algorithms.ChooseRandomLegModeForSubtour.run().

                              {
 
         boolean containsChainBasedMode = false;
         Set<String> originalModes = new HashSet<>();
 
         // Trips that are not part of any child subtour
         Set<Trip> childTrips = new HashSet<>(whatToDo.subtour.getTripsWithoutSubSubtours());
 
         for (Trip trip : whatToDo.subtour.getTrips()) {
 
             String mainMode = mainModeIdentifier.identifyMainMode(trip.getTripElements());
 
             if (childTrips.contains(trip) && chainBasedModes.contains(mainMode))
                 containsChainBasedMode = true;
 
             if (childTrips.contains(trip))
                 originalModes.add(mainMode);
 
             if (behavior == SubtourModeChoice.Behavior.fromSpecifiedModesToSpecifiedModes) {
                 if (!modes.contains(mainMode)) {
                     // (ignore trips with modes that are not in "modes".   MATSIM-809)
                     continue;
                 }
             }
 
             TripRouter.insertTrip(
                     plan,
                     trip.getOriginActivity(),
                     Collections.singletonList(PopulationUtils.createLeg(whatToDo.newTransportMode)),
                     trip.getDestinationActivity());
         }
 
 
         // If this is a subtour covering all trips, this constraint will be ignored
         // this is because the whole plan is always added as a whole even if not a subtour
         if (behavior == SubtourModeChoice.Behavior.betweenAllAndFewerConstraints
                 && containsChainBasedMode && originalModes.size() > 1
                 && TripStructureUtils.getTrips(plan).size() != whatToDo.subtour.getTrips().size()
         ) {
             logger.error("Subtour of person {} contains a mix of chain- and non-chainbased modes: {}. " +
                     "Subtour mode-choice won't be able to go back to this state. You need to adjust the input beforehand or disable 'betweenAllAndFewerConstraints'.", plan.getPerson().getId(), originalModes);
             throw new IllegalStateException("Subtour contains a mix of chain- and non-chainbased modes.");
         }
 
     }