How to use

TripStructureUtils$Subtour

in

org.matsim.core.router

private void applyChange(
    final Candidate whatToDo,
    final Plan plan)
{
  for (Trip trip : whatToDo.subtour.getTrips()) {
    if ( behavior== SubtourModeChoice.Behavior.fromSpecifiedModesToSpecifiedModes ) {
      if (!modes.contains(mainModeIdentifier.identifyMainMode(trip.getTripElements()))) {
        // (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());
    }
}

          new Subtour(
              subtourStartIndex,
              subtourEndIndex,
new Subtour(
    0,
    trips.size(),

private List<Subtour> getRootSubtoursWithMode(final Plan plan) {
  final Collection<Subtour> allSubtours = TripStructureUtils.getSubtours( plan , tripRouter.getStageActivityTypes() );
  final List<Subtour> roots = new ArrayList<Subtour>();
  for ( Subtour s : allSubtours ) {
    if ( s.getParent() != null ) continue;
    if ( !containsMode( s ) ) continue;
    roots.add( s );
  }
  return roots;
}

@Override
public boolean equals(final Object other) {
  if (other == null) return false;
  if ( !other.getClass().equals( getClass() ) ) return false;
  final Subtour s = (Subtour) other;
  return s.trips.equals( trips ) &&
      areChildrenCompatible( children , s.children ) &&
      (s.parent == null ? parent == null : s.parent.equals( parent )) &&
      (s.isClosed == isClosed);
}

@Test
public void testGetTripsWithoutSubSubtours() throws Exception {
  for (Fixture f : allFixtures( useFacilitiesAsAnchorPoint )) {
    final int nTrips = TripStructureUtils.getTrips( f.plan , CHECKER ).size();
    final Collection<Subtour> subtours =
      TripStructureUtils.getSubtours(
          f.plan,
          CHECKER
      );
    int countTrips = 0;
    for (Subtour s : subtours) {
      countTrips += s.getTripsWithoutSubSubtours().size();
    }
    assertEquals(
        "[anchorAtFacilities="+f.useFacilitiesAsAnchorPoint+"] "+
        "unexpected total number of trips in subtours without subsubtours",
        countTrips,
        nTrips);
  }
}

@Test
public void testFatherhood() throws Exception {
  for (Fixture f : allFixtures( useFacilitiesAsAnchorPoint )) {
    final Collection<Subtour> subtours = TripStructureUtils.getSubtours( f.plan , CHECKER);
    for (Subtour s : subtours) {
      for ( Subtour child : s.getChildren() ) {
        assertEquals(
            "[anchorAtFacilities="+f.useFacilitiesAsAnchorPoint+"] "+
            "wrong father!",
            child.getParent(),
            s);
      }
      if ( s.getParent() != null ) {
        assertTrue(
            "[anchorAtFacilities="+f.useFacilitiesAsAnchorPoint+"] "+
            "father does not have subtour has a child",
            s.getParent().getChildren().contains( s ));
      }
    }
  }
}

/*for tests*/ double calcOverlap(final GroupPlans gps) {
  final List<SubtourRecord> tours = getVehicularToursSortedByStartTime( gps );
  double overlap = 0;
  for ( final SubtourRecord tour : tours ) {
    Id veh = null;
    for ( final Trip t : tour.subtour.getTrips() ) {
      veh = getVehicle( t );
      if ( veh != null ) break;
    }
    
    for ( final VehicleRecord vr : tour.possibleVehicles ) {
      if ( vr.id.equals( veh ) ) {
        overlap += Math.max( 0 , vr.availableFrom - tour.startTime );
        if ( vr.availableFrom < tour.endTime ) {
          vr.availableFrom = tour.endTime;
        }
        break;
      }
    }
  }
  return overlap;
}

private void processAllocation(final List<SubtourRecord> vehicularTours) {
  for ( final SubtourRecord r : vehicularTours ) {
    for ( final Trip t : r.subtour.getTrips() ) {
      for ( final Leg leg : t.getLegsOnly() ) {
        if ( !vehicularModes.contains( leg.getMode() ) ) continue;
        if ( allowNullRoutes && leg.getRoute() == null ) {
          // this is not so nice...
          leg.setRoute( new VehicleOnlyNetworkRoute() );
        }
        if ( !( leg.getRoute() instanceof NetworkRoute ) ) {
          throw new RuntimeException( "route for mode "+leg.getMode()+" has non-network route "+leg.getRoute() );
        }
        ((NetworkRoute) leg.getRoute()).setVehicleId( r.allocatedVehicle );
      }
    }
  }
}

plan.addActivity(somewhereElse);
Subtour subtour1 = new Subtour(
    Arrays.asList(
      new Trip(home1, Collections.<PlanElement>singletonList(leg2), work),
      new Trip(home2, Collections.<PlanElement>singletonList(leg1), somewhereElse)),
    false);
Subtour subtour2 = new Subtour(Arrays.asList(
    new Trip(home1, Collections.<PlanElement>singletonList(leg2), work),
    new Trip(work, Collections.<PlanElement>singletonList(leg3), home2)), true);

Activity home2 = createActivityFromLocationId(anchorAtFacilities, fact, "home", createId(2,anchorAtFacilities));
plan.addActivity(home2);
Subtour subtour1 = new Subtour(
    Arrays.asList(
      new Trip(somewhereElse, Collections.<PlanElement>singletonList(leg1), home1),
      new Trip(work, Collections.<PlanElement>singletonList(leg3), home2)),
    false);
Subtour subtour2 = new Subtour(Arrays.asList(
    new Trip(home1, Collections.<PlanElement>singletonList(leg2), work),
    new Trip(work, Collections.<PlanElement>singletonList(leg3), home2)), true);

boolean atLeastOneSubtourWithDifferentChainBasedModes = false;
if (subtour.getChildren().isEmpty()) {
  String modePreviousTripSameSubtour = null;
  for (Trip trip: subtour.getTrips()) {

plan,
Arrays.asList(
  new Subtour(
    Arrays.asList(
      new Trip( act1 , trip1 , act2 ),

  new Subtour(
        Arrays.asList(
          new Trip( act1 , trip1 , act2 ),
        false);
final Subtour childSubtour =
  new Subtour(
        Arrays.asList(
          new Trip( act2 , trip2 , act3 ) ),

@Override
public void run(final Plan plan) {
  for ( Subtour subtour : TripStructureUtils.getSubtours( plan , stages ) ) {
    // not clear what we should do with open tours
    if ( !subtour.isClosed() ) continue;
    // only consider "root" tours: tours without (closed) parent
    if ( subtour.getParent() != null && subtour.getParent().isClosed() ) continue;
    final String mode = modeIdentifier.identifyMode( subtour );
    for ( Trip trip : subtour.getTrips() ) {
      TripRouter.insertTrip(
          plan,
          trip.getOriginActivity(),
          Collections.singletonList( PopulationUtils.createLeg(mode) ),
          trip.getDestinationActivity() );
    }
  }
}

  new Subtour(
        Arrays.asList(
          new Trip( act1 , trip1 , act2 ),
        true);
final Subtour childSubtour =
  new Subtour(
        Arrays.asList(
          new Trip( act2 , trip2 , act3 ) ),

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

boolean containsMutatedMode = false;
for (Trip trip : mutated.getTripsWithoutSubSubtours()) {
  if ( expectedMode.equals( trip.getLegsOnly().get( 0 ).getMode() ) ) {
    assertTrue(
if ( !mutateds.contains( s.getParent() ) ) {
  nMutatedWithoutMutatedFather++;

public List<Trip> getTripsWithoutSubSubtours() {
  final List<Trip> list = new ArrayList<>();
  for (Trip t : trips) {
    boolean isInChildSt = false;
    for (Subtour child : children) {
      if ( child.contains( t ) ) {
        isInChildSt = true;
        break;
      }
    }
    if ( !isInChildSt ) {
      list.add( t );
    }
  }
  return list;
}

  new Subtour(
        Arrays.asList(
          new Trip( act1 , trip1 , act2 ),
        true);
final Subtour secondSubtour =
  new Subtour(
        Arrays.asList(
          new Trip( act3 , trip3 , act4 ),

private String getTransportMode(final Subtour subtour) {
  return mainModeIdentifier.identifyMainMode(
      subtour.getTrips().get( 0 ).getTripElements() );
}