ProfileRequest (OpenTripPlanner 0.19.0 API)

java.lang.Object
- org.opentripplanner.profile.ProfileRequest

All Implemented Interfaces:

Serializable, Cloneable
```
public class ProfileRequest
extends Object
implements Serializable, Cloneable
```
All the modifiable parameters for profile routing.

See Also:

Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`QualifiedModeSet`	`accessModes` The modes used to access transit
`boolean`	`analyst` If true, disable all goal direction and propagate results to the street network
`int`	`bikeSafe` The relative importance of maximizing safety when cycling
`int`	`bikeSlope` The relative importance of minimizing hills when cycling
`float`	`bikeSpeed` The speed of cycling, in meters per second
`int`	`bikeTime` The relative importance of minimizing time when cycling
`RaptorWorkerTimetable.BoardingAssumption`	`boardingAssumption` What assumption should be used when boarding frequency vehicles?
`float`	`carSpeed` The speed of driving, in meters per second
`org.joda.time.LocalDate`	`date` The date of the search
`QualifiedModeSet`	`directModes` The modes used to reach the destination without transit
`QualifiedModeSet`	`egressModes` The modes used to reach the destination after leaving transit
`double`	`fromLat` The latitude of the origin.
`double`	`fromLon` The longitude of the origin.
`int`	`fromTime` The beginning of the departure window, in seconds since midnight.
`int`	`limit` the maximum number of options presented PER ACCESS MODE
`int`	`maxBikeTime` Maximum bike time when using transit
`int`	`maxCarTime` Maximum car time before when using transit
`int`	`maxWalkTime` Maximum walk time before and after using transit, in minutes NB the time to reach the destination after leaving transit is considered separately from the time to reach transit at the start of the search; e.g.
`int`	`minBikeTime` Minimum time to ride a bike (to prevent extremely short bike legs)
`int`	`minCarTime` Minimum time to drive (to prevent extremely short driving legs)
`Option.SortOrder`	`orderBy` The order in which to return multiple options
`float`	`reachabilityThreshold` What is the minimum proportion of the time for which a destination must be accessible for it to be included in the average? This avoids issues where destinations are reachable for some very small percentage of the time, either because there is a single departure near the start of the time window, or because they take approximately 2 hours (the default maximum cutoff) to reach.
`Scenario`	`scenario` A non-destructive scenario to apply when executing this request
`int`	`streetTime` Maximum time to reach the destination without using transit
`int`	`suboptimalMinutes` This parameter compensates for the fact that GTFS does not contain information about schedule deviation (lateness).
`double`	`toLat` The latitude of the destination.
`double`	`toLon` The longitude of the destination.
`int`	`toTime` The end of the departure window, in seconds since midnight.
`TraverseModeSet`	`transitModes` The transit modes used
`float`	`walkSpeed` The speed of walking, in meters per second

Constructor Summary

Constructors
Constructor and Description

ProfileRequest()

Constructors
Constructor and Description
`ProfileRequest()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type Method and Description

ProfileRequest clone()
- Methods inherited from class java.lang.Object
  equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`ProfileRequest`	`clone()`

- Field Detail
  - fromLat
```
public double fromLat
```
    The latitude of the origin.
  - fromLon
```
public double fromLon
```
    The longitude of the origin.
  - toLat
```
public double toLat
```
    The latitude of the destination. Must be set even in Analyst mode.
  - toLon
```
public double toLon
```
    The longitude of the destination. Must be set even in Analyst mode.
  - fromTime
```
public int fromTime
```
    The beginning of the departure window, in seconds since midnight.
  - toTime
```
public int toTime
```
    The end of the departure window, in seconds since midnight.
  - walkSpeed
```
public float walkSpeed
```
    The speed of walking, in meters per second
  - bikeSpeed
```
public float bikeSpeed
```
    The speed of cycling, in meters per second
  - carSpeed
```
public float carSpeed
```
    The speed of driving, in meters per second
  - streetTime
```
public int streetTime
```
    Maximum time to reach the destination without using transit
  - maxWalkTime
```
public int maxWalkTime
```
    Maximum walk time before and after using transit, in minutes NB the time to reach the destination after leaving transit is considered separately from the time to reach transit at the start of the search; e.g. if you set maxWalkTime to 600 (ten minutes), you could potentially walk up to ten minutes to reach transit, and up to _another_ ten minutes to reach the destination after leaving transit. This is required because hard resource limiting on non-objective variables is algorithmically invalid. Consider a case where there is a destination 10 minutes from transit and an origin 5 minutes walk from a feeder bus and 15 minutes walk from a fast train, and the walk budget is 20 minutes. If an intermediate point in the search (for example, a transfer station) is reached by the fast train before it is reached by the bus, the route using the bus will be dominated. When we leave transit, though, we have already used up 15 minutes of our walk budget and don't have enough remaining to reach the destination. This is solved by using separate walk budgets at the origin and destination. It could also be solved (although this would slow the algorithm down) by retaining all Pareto-optimal combinations of (travel time, walk distance).
  - maxBikeTime
```
public int maxBikeTime
```
    Maximum bike time when using transit
  - maxCarTime
```
public int maxCarTime
```
    Maximum car time before when using transit
  - minBikeTime
```
public int minBikeTime
```
    Minimum time to ride a bike (to prevent extremely short bike legs)
  - minCarTime
```
public int minCarTime
```
    Minimum time to drive (to prevent extremely short driving legs)
  - date
```
public org.joda.time.LocalDate date
```
    The date of the search
  - orderBy
```
public Option.SortOrder orderBy
```
    The order in which to return multiple options
  - limit
```
public int limit
```
    the maximum number of options presented PER ACCESS MODE
  - accessModes
```
public QualifiedModeSet accessModes
```
    The modes used to access transit
  - egressModes
```
public QualifiedModeSet egressModes
```
    The modes used to reach the destination after leaving transit
  - directModes
```
public QualifiedModeSet directModes
```
    The modes used to reach the destination without transit
  - transitModes
```
public TraverseModeSet transitModes
```
    The transit modes used
  - analyst
```
public boolean analyst
```
    If true, disable all goal direction and propagate results to the street network
  - reachabilityThreshold
```
public float reachabilityThreshold
```
    What is the minimum proportion of the time for which a destination must be accessible for it to be included in the average? This avoids issues where destinations are reachable for some very small percentage of the time, either because there is a single departure near the start of the time window, or because they take approximately 2 hours (the default maximum cutoff) to reach. Consider a search run with time window 7AM to 9AM, and an origin and destination connected by an express bus that runs once at 7:05. For the first five minutes of the time window, accessibility is very good. For the rest, there is no accessibility; if we didn't have this rule in place, the average would be the average of the time the destination is reachable, and the time it is unreachable would be excluded from the calculation (see issue 2148) There is another issue that this rule does not completely address. Consider a trip that takes 1:45 exclusive of wait time and runs every half-hour. Half the time it takes less than two hours and is considered and half the time it takes more than two hours and is excluded, so the average is biased low on very long trips. This rule catches the most egregious cases (say where we average only the best four minutes out of a two-hour span) but does not completely address the issue. However if you're looking at a time cutoff significantly less than two hours, it's not a big problem. Significantly less is half the headway of your least-frequent service, because if there is a trip on your least-frequent service that takes on average the time cutoff plus one minute it will be unbiased and considered unreachable iff the longest trip is less than two hours, which it has to be if the time cutoff plus half the headway is less than two hours, assuming a symmetric travel time The default is 0.5.
  - boardingAssumption
```
public RaptorWorkerTimetable.BoardingAssumption boardingAssumption
```
    What assumption should be used when boarding frequency vehicles?
  - bikeSafe
```
public int bikeSafe
```
    The relative importance of maximizing safety when cycling
  - bikeSlope
```
public int bikeSlope
```
    The relative importance of minimizing hills when cycling
  - bikeTime
```
public int bikeTime
```
    The relative importance of minimizing time when cycling
  - suboptimalMinutes
```
public int suboptimalMinutes
```
    This parameter compensates for the fact that GTFS does not contain information about schedule deviation (lateness). The min-max travel time range for some trains is zero, since the trips are reported to always have the same timings in the schedule. Such an option does not overlap (temporally) its alternatives, and is too easily eliminated by an alternative that is only marginally better. We want to effectively push the max travel time of alternatives out a bit to account for the fact that they don't always run on schedule.
  - scenario
```
public Scenario scenario
```
    A non-destructive scenario to apply when executing this request
- Constructor Detail
  - ProfileRequest
```
public ProfileRequest()
```
- Method Detail
  - clone
```
public ProfileRequest clone()
                     throws CloneNotSupportedException
```
    Overrides:
    
    clone in class Object
    
    Throws:
    
    CloneNotSupportedException

Class ProfileRequest

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

fromLat

fromLon

toLat

toLon

fromTime

toTime

walkSpeed

bikeSpeed

carSpeed

streetTime

maxWalkTime

maxBikeTime

maxCarTime

minBikeTime

minCarTime

date

orderBy

limit

accessModes

egressModes

directModes

transitModes

analyst

reachabilityThreshold

boardingAssumption

bikeSafe

bikeSlope

bikeTime

suboptimalMinutes

scenario

Constructor Detail

ProfileRequest

Method Detail

clone