All Classes Interface Summary Class Summary Enum Summary Exception Summary
| Class |
Description |
| AbstractPhysicalCost |
Class for dynamic cost functions, which calculate link segment costs for each iteration
|
| AbstractVirtualCost |
Object to handle the travel time cost of a virtual link
|
| AccessGroupProperties |
Contains the properties of a mode specific to a link segment type
|
| AccessGroupPropertiesFactory |
Create Mode specific access properties to be used on macroscopic link segment types
|
| AccessGroupPropertiesImpl |
Group of modes with specific properties for the macroscopic perspective on the supply side, i.e.
|
| AcyclicMinMaxShortestPathAlgorithm |
Build a min/max shortest path tree for a given origin vertex.
|
| ACyclicSubGraph |
An acyclic sub graph contains a subset of the full graph without cycles.
|
| ACyclicSubGraphImpl |
An acyclic sub graph contains a subset of the full graph without cycles.
|
| AlgorithmB |
Algorithm B implementation based on the work of Dial (2006).
|
| AlgorithmBEquilibration |
All the functionality to equilibrate algorithm B
|
| AlgorithmBSimulationData |
Simulation data which are specific to Traditional Static Assignment
|
| ApplicationProperties |
Class supporting easy access to application.properties file
|
| ApplyToNodeModelResult |
Apply this to the result of a Tampere node model execution for a particular node, it is invoked with the node the model was invoked on, the resulting flow acceptance factors and
the sending flow turn flows (rows are entry link segments, columns outgoing link segments).
|
| ArgumentParser |
This class parses program arguments and returns them as a map of file types
and file locations.
|
| ArgumentStyle |
Supported styles for argument parsing
|
| ArrayUtils |
General methods for arrays
|
| AStarShortestPathAlgorithm |
A* shortest path algorithm
A* shortest path is a one-to-one implementation of the shortest path algorithm based on the generalized costs on each link segment (edge).
|
| BaseOutputFormatter |
Base class for all formatters of output data, i.e.
|
| BaseReaderImpl<T> |
Abstract base class implementation for converter readers which has a mechanism to (optionally) keep track of entities by their source id as PLANit only indexes by internal id
|
| BaseWriterImpl<T> |
abstract base class implementation to write a PLANit network to disk with id mapping sorted for convenience
|
| BicycleMode |
the predefined bicycle mode
name: bicycle
maxspeed (km/h): 15
pcu: 0.2
vehicular type: VEHICULAR
motorisation: NON_MOTORISED
track: ROAD
use: PRIVATE
|
| BoxUtils |
Utility class assisting in more complex (auto-)boxing of types in for example container classes
|
| BPRConfigurator |
Configurator for BPRLinkTravelTimeCost implementation
|
| BPRLinkTravelTimeCost |
Well known BPR link performance function to compute travel time cost on link segment based on flow and configuration parameters.
|
| BreakEdgeEvent |
Wrapper around break edge event
|
| BreakEdgeSegmentEvent |
Wrapper around break edge segment event
|
| Builder<T> |
Builder class to build something of type T
|
| Bush |
A bush is an acyclic directed graph comprising of all implicit paths used by an origin to reach all its destinations.
|
| BushFlowUpdateConsumer<T extends NetworkFlowUpdateData> |
Base Consumer to apply during bush based network flow update for each origin bush
|
| BushTurnData |
Track the turn based data of a bush.
|
| BushTurnFlowUpdateConsumer |
Consumer to apply during bush based turn flow update for each non-zero demand bush
|
| BusMode |
the predefined bus mode
name: bus
maxspeed (km/h): 100
pcu: 2
vehicular type: VEHICULAR
motorisation: MOTORISED
track: ROAD
use: PUBLIC
|
| CalculatedSpeedOutputProperty |
Calculate speed output property class
|
| CapacityPeriod |
|
| CapacityPerLaneOutputProperty |
Capacity per lane in pcu/h
|
| CarHighOccupancyMode |
the predefined car hov mode
name: car_hov
maxspeed (km/h): 130
pcu: 1
vehicular type: VEHICULAR
motorisation: MOTORISED
track: ROAD
use: HIGH_OCCUPANCY
|
| CarMode |
the predefined car mode
name: car
maxspeed (km/h): 130
pcu: 1
vehicular type: VEHICULAR
motorisation: MOTORISED
track: ROAD
use: PRIVATE
|
| CarShareMode |
the predefined car share mode
name: car
maxspeed (km/h): 130
pcu: 1
vehicular type: VEHICULAR
motorisation: MOTORISED
track: ROAD
use: RIDE_SHARE
|
| Centroid |
A centroid is a special type of vertex representing the location of departure/arrival of traffic
in
a zone
|
| CentroidFactory |
Factory interface for centroids
|
| CentroidFactoryImpl |
Factory for creating centroids
|
| CentroidImpl |
Centroid implementation
|
| CharacterUtils |
character utility class
|
| CloneUtils |
Some utility methods to use serialization to allow for deep copy cloning without knowing anything about the objects type
|
| Configurator<T> |
This is the base class for all configuration oriented proxy classes.
|
| Connectoid |
the connecting component between zone(s) and the network.
|
| ConnectoidEdge |
the connecting component between centroid and a first physical node in the network.
|
| ConnectoidEdgeFactory |
Factory interface for connectoid edges
|
| ConnectoidEdgeFactoryImpl |
Factory for creating connectoid edges on connectoid edge container
|
| ConnectoidEdgeImpl |
Edge implementation that represent edges that exist between centroids and connectoids (their node reference), so not physical entities but rather virtual links
|
| ConnectoidEdges |
Container to register and manager connectoid edges.
|
| ConnectoidEdgesImpl |
Connectoid edge container implementation
|
| ConnectoidHelper |
Class to provide functionality for parsing PLANit connectoids from OSM entities
|
| ConnectoidImpl |
connectoid connecting one or more (transfer/OD) zone(s) to the physical road network, the type of connectoid depends on the implementing class
|
| Connectoids<T extends Connectoid> |
Container to register and manager connectoids that define the points of access for
zones regarding infrastructure network (layer)
|
| ConnectoidSegment |
Connectoid segment represents a directional virtual segment connecting a centroid and a physical
node.
|
| ConnectoidSegmentFactory |
Factory interface for connectoid segments
|
| ConnectoidSegmentFactoryImpl |
Factory for creating connectoid segments on connectoid segments container
|
| ConnectoidSegmentImpl |
The link segment that connects a zone to the physical network is not a physical link segment.
|
| ConnectoidSegments |
Container to register and manager connectoids that define the points of access for
zones regarding infrastructure network (layer)
|
| ConnectoidSegmentsImpl |
Connectoid segments container implementation
|
| ConnectoidsImpl<T extends Connectoid> |
Base implementation of Connectoids container and factory class
|
| ConnectoidType |
Types of connectoids to more easily identify their purpose
|
| ContainerisedDirectedPathFactory |
Factory interface for directed paths
|
| ContainerisedDirectedPathFactoryImpl |
Factory for creating directed paths on container
|
| Converter<T> |
Convert PLANit entities parsed by a reader from one format and persisted with a writer to another
|
| ConverterBase |
Base converter for PLANit entities
|
| ConverterEntity |
Base interface for classes able to read/write something
|
| ConverterReader<T> |
Interface for classes able to convert entities of some type which are then returned
|
| ConverterReaderSettings |
Settings to be derived from this dummy interface for all readers compatible with the converter setup.
|
| ConverterWriter<T> |
Interface for classes able to write a PLANit entities of given type to disk
|
| ConverterWriterSettings |
Settings to be derived from this dummy interface for all writers compatible with the converter setup.
|
| Cost<T extends EdgeSegment> |
Cost of an EdgeSegment
|
| CostTimesFlowOutputProperty |
Cost times flow output property class
|
| CountryNames |
Country names that can be converted into ISO2 codes (work in progress, currently only left hand drive countries present)
|
| CountrySpecificDefaultUtils |
Class with some common functionality for defaults that are country specific and stored in CSV files
|
| CsvFileOutputFormatter |
Class containing common methods required by classes which write results to CSV output files
|
| CSVOutputFormatter |
Output formatter for CSV output, i.e.
|
| CsvTextFileOutputFormatter |
This interfaces defines behaviours which output formatters which generate a CSV output file must
have.
|
| CumulativeEvent |
A cumulative event represents a cumulative pcu point in space-time with (potential) additional information.
|
| CumulativePoint |
Represents a cumulative point in time
|
| CumulativePointImpl |
Represents a cumulative point in time
|
| CustomPlanItProject |
The top-level class which hosts a single project.
|
| DataType |
Enumeration of possible output data types
|
| Demands |
Container class for all demands registered on the project.
|
| DemandsReader |
Interface to read a PLANit demands
|
| DemandsWriter |
Interface to write a PLANit demands to disk
|
| DensityOutputProperty |
Density output property in pcu/km
|
| DestinationZoneExternalIdOutputProperty |
|
| DestinationZoneIdOutputProperty |
|
| DestinationZoneXmlIdOutputProperty |
|
| DijkstraShortestPathAlgorithm |
Dijkstra's shortest path algorithm
Dijkstra's shortest path is a one-to-all implementation of the shortest path algorithm based on the generalized costs on each link segment (edge).
|
| DirectedConnectoid |
A directed connectoid is referring to an edge segment in a network (layer) which is directed for access
hence, the connectoid also being directed
TODO: we can potentially get rid of UndirectedConnectoid and let DirectedConnectoid extend from base since they
now both rely on accessNodes
|
| DirectedConnectoidFactory |
Factory interface for directed connectoids
|
| DirectedConnectoidFactoryImpl |
Factory for creating directed connectoids (on container)
|
| DirectedConnectoidImpl |
Undirected connectoid connecting one or more (transfer/OD) zone(s) to the physical road network, each connection will yield a connectoid edge and two connectoid segments when
constructing the transport network internally based on the referenced node
|
| DirectedConnectoids |
container and factory class for directed connectoids
|
| DirectedConnectoidsImpl |
Implementation of directed connectoids class
|
| DirectedEdge |
Directed Edge interface connecting two vertices in a directional fashion.
|
| DirectedEdgeFactory |
Factory interface for creating directed edges.
|
| DirectedEdgeFactoryImpl |
Factory for creating directed edges on directed edges container
|
| DirectedEdgeImpl |
Edge class connecting two vertices via some geometry.
|
| DirectedEdges |
Container and managing class for directed edges in a graph.
|
| DirectedEdgesImpl |
Implementation of DirectedEdges interface
|
| DirectedGraph<V extends DirectedVertex,E extends DirectedEdge,ES extends EdgeSegment> |
Interface for a directed graph with explicit container types rather than the base containers.
|
| DirectedGraphImpl<V extends DirectedVertex,E extends DirectedEdge,ES extends EdgeSegment> |
A directed graph implementation consisting of directed vertices, directed edges and edge segments
|
| DirectedGraphModificationEvent |
Interface for the group of events that are used around directed graph modification
|
| DirectedGraphModifier |
Modify directed graph elements .
|
| DirectedGraphModifierEventProducer |
Interface dedicated to the DirectedGraphModifier event related exposed methods.
|
| DirectedGraphModifierEventType |
Directed graph modifier event type class.
|
| DirectedGraphModifierImpl |
Implementation of a directed graph modifier that supports making changes to any untyped directed graph.
|
| DirectedGraphModifierListener |
To serve as base listener class for all directed graph modification events, where its onX method provides any
graph modification event as parameter
|
| DirectedPath |
Path interface representing a path through the network on edge segment level
|
| DirectedPathFactory |
Factory interface for directed paths
|
| DirectedPathFactoryImpl |
Factory for creating directed paths on container
|
| DirectedPathImpl |
This object represents a path based on a number of consecutive LinkSegments
The path creation makes use of the fact that the origin pair will have a null EdgeSegment, so there is no need to specify the origin.
|
| DirectedPaths |
Support directed paths as container and factory class
|
| DirectedPathsImpl |
Implementation of DirectedPaths interface
|
| DirectedSubGraph |
A directed subgraph interface for a given parent graph by registering edge segments on it (and therefore vertices and edges)
|
| DirectedVertex |
Directed vertex representation connected to one or more edge segments that have direction.
|
| DirectedVertexFactory |
Factory interface for creating vertex instances
|
| DirectedVertexFactoryImpl |
Factory for creating vertices on vertices container
|
| DirectedVertexImpl |
vertex representation connected to one or more entry and exit edges
|
| DirectedVertices |
Container class for directed vertices and creating instances within this container via factory.
|
| DirectedVerticesImpl |
DirectedVertices implementation container and factory access
|
| DistanceUnit |
Unit class for all distance related units
|
| DownstreamNodeExternalIdOutputProperty |
|
| DownstreamNodeIdOutputProperty |
|
| DownstreamNodeLocationOutputProperty |
|
| DownstreamNodeXmlIdOutputProperty |
|
| DrivingDirectionDefaultByCountry |
convenience class that provides the driving direction per country (left hand drive or not)
based on https://en.wikipedia.org/wiki/Left-_and_right-hand_traffic
|
| Edge |
Edge interface connecting two vertices in a non-directional fashion.
|
| EdgeFactory |
Factory interface for creating edge instances
|
| EdgeFactoryImpl |
Factory for creating edges on edges container
|
| EdgeImpl |
Edge class connecting two vertices via some geometry.
|
| Edges |
Container and factory class for edges in a graph, also to be used to create and register edges of any
(derived) type
|
| EdgeSegment |
EdgeSegment represents an edge in a particular (single) direction.
|
| EdgeSegmentFactory |
Factory interface for creating edge segment instances
|
| EdgeSegmentFactoryImpl |
Factory for creating edge segments on edge segments container
|
| EdgeSegmentImpl |
EdgeSegment represents an edge in a particular (single) direction.
|
| EdgeSegments |
Container and factory class for edge segments in a graph, also to be used to create and register edge segments of any
(derived) type
|
| EdgeSegmentsImpl |
Implementation of EdgeSegments interface.
|
| EdgesImpl |
Implementation of Edges interface
|
| EnumConversionUtil |
Some methods to convert the XML schema enums to PLANit memory model enums
|
| EnumConverter |
Utility methods to convert enumerations from the PLANit org.planit.output.enums package into enumerations generated from the output XSD file
|
| EpsgCodesByCountry |
convenience method that provides a mapping from country name to a possible EPSG coordinate
reference system code, e.g., "EPSG:1234".
|
| Event |
The Event interface defines a typed event (using the EventType).
|
| EventBasedLtm |
Event based Link Transmission Model implementation (eLTM) for network loading using a capacity constrained (Deterministic) assignment
|
| EventBasedLtmConfigurator |
Configurator for eLTM
Fundamental diagram: NEWELL
Node Model: TAMPERE
|
| EventBasedLtmTrafficAssignmentBuilder |
The eLTM traffic assignment builder.
|
| EventImpl |
The Base implementation for LocalEvent interface.
|
| EventListener |
Base interface for event listeners.
|
| EventListenerPriority |
Priority that a listener can claim upon registration for events.
|
| EventProducer |
Interface to signify event producers.
|
| EventProducerImpl |
The EventProducer is the base class able to produce events.
|
| EventType |
Event type wraps a String representing the unique name identifier for an event.
|
| ExternalIdAble |
A class implementing this interface signals that it is external id-able.
|
| ExternalIdAbleImpl |
Implementation of ExternalIdable interface including hash and equals based on id
|
| FileOutputFormatter |
Common methods used by output formatters which write data to physical files
|
| FileUtils |
Lightweight File utilities
|
| FixedConnectoidTravelTimeCost |
Class holding fixed connectoid costs for each connectoid segment
|
| FixedVirtualCostConfigurator |
Configurator for FixedConnectoidTravelTimeCost implementation
|
| FlowOutputProperty |
Property to provide the Flow rate in PCU/hour.
|
| FormatUtils |
Utility methods for formatting doubles
|
| FreeFlowLinkTravelTimeConfigurator |
Configurator for FreeFlowLinkTravelTimeCost implementation
|
| FreeFlowLinkTravelTimeCost |
Simplest possible travel time cost, namely fixed to free flow travel time regardless of the flows measured.
|
| FundamentalDiagram |
The base interface for the Fundamental Diagram component type.
|
| FundamentalDiagramBranch |
A fundamental diagram has two branches each one can have a particular shape.
|
| FundamentalDiagramComponent |
Fundamental diagram traffic component.
|
| FundamentalDiagramConfigurator<T extends FundamentalDiagramComponent> |
Base class for all fundamental diagram configurator implementations
|
| FundamentalDiagramConfiguratorFactory |
factory for the fundamental diagram types supported directory by PLANit
|
| FundamentalDiagramImpl |
Base class for fundamental diagram instances
|
| GapFunction |
Abstract base class for gap functions
|
| GapFunctionConfigurator<T extends GapFunction> |
Base class for all vgap function configurator implementations
|
| GapFunctionConfiguratorFactory |
factory for the gap function types supported directory by PLANit
|
| GoodsMode |
the predefined goods vehicle mode, i.e., truck below 3.5 tonnes
name: gv
maxspeed (km/h): 100
pcu: 1.8
vehicular type: VEHICULAR
motorisation: MOTORISED
track: ROAD
use: GOODS
|
| Graph<V extends Vertex,E extends Edge> |
Interface for a graph with explicit container types rather than the base containers.
|
| GraphEntities<E extends GraphEntity> |
Container class for any graph entities and a factory to create them
|
| GraphEntitiesImpl<E extends GraphEntity> |
Base class for containers of entities on graph
|
| GraphEntity |
Placeholder interface for all graph entities.
|
| GraphEntityFactory<E extends GraphEntity> |
A base abstract class for factories that create graph entities on an underlying container
No specification of the container here because it is used as a placeholder to be able to let
derived classes implement this interface with as much freedom as possible.
|
| GraphEntityFactoryImpl<E extends GraphEntity> |
Base implementation for creating and registering graph entities on underlying container and conducting changes to ids based on the factory settings for egenrating ids.
|
| GraphEntityImpl |
Base implementation for graph entity (edge, vertex, etc.)
|
| GraphImpl<V extends Vertex,E extends Edge> |
A graph implementation consisting of vertices and edges
|
| GraphModificationEvent |
Interface for the group of events that are used around graph modification
|
| GraphModifier<V extends Vertex,E extends Edge> |
Modify graph elements
|
| GraphModifierEventProducer |
Interface dedicated to the GraphModifier event related exposed methods. |
| GraphModifierEventType |
graph modifier event type class.
|
| GraphModifierImpl |
Apply modifications to the graph in an integrated fashion.
|
| GraphModifierListener |
To serve as base listener class for all graph modification events, where its onX method provides any
graph modification event as parameter
|
| GroupUnit |
A combined unit consisting of multiple simple (single) units
|
| GtfsAgenciesScheme |
The scheme used for GTFS agencies, namely an agency.txt file and a GtfsAgency in memory object to go with each entry
|
| GtfsAgency |
In memory representation of a GTFS entry in agency.txt
|
| GtfsAttribution |
In memory representation of a GTFS entry in attributions.txt
|
| GtfsAttributionsScheme |
The scheme used for GTFS attributions, namely an attributions.txt file and a GtfsAttribution in memory object to go with each entry
|
| GtfsCalendar |
In memory representation of a GTFS entry in calendar.txt
|
| GtfsCalendarDate |
In memory representation of a GTFS entry in calendar_dates.txt
|
| GtfsCalendarDatesScheme |
The scheme used for GTFS calendar dates, namely a calendar_dates.txt file and a GtfsCalendarDate in memory object to go with each entry
|
| GtfsCalendarsScheme |
The scheme used for GTFS calendars, namely a calendar.txt file and a GtfsCalendar in memory object to go with each entry
|
| GtfsFareAttribute |
In memory representation of a GTFS entry in fare_attributes.txt
|
| GtfsFareAttributesScheme |
The scheme used for GTFS fare attributes, namely a fare_attributes.txt file and a GtfsFareAttribute in memory object to go with each entry
|
| GtfsFareRule |
In memory representation of a GTFS entry in fare_rules.txt
|
| GtfsFareRulesScheme |
The scheme used for GTFS fare rules, namely a fare_rules.txt file and a GtfsFareRule in memory object to go with each entry
|
| GtfsFeedInfo |
In memory representation of a GTFS entry in feed_info.txt
|
| GtfsFeedInfoScheme |
The scheme used for GTFS fare rules, namely a fare_rules.txt file and a GtfsFareRule in memory object to go with each entry
|
| GtfsFileConditions |
Class indicating conditions regarding the presence of the GTFS file type
|
| GtfsFileHandler<T extends GtfsObject> |
A file handler base class to handle callbacks for a particular GTFS file type
|
| GtfsFileHandlerAgency |
Base handler for handling agencies
|
| GtfsFileHandlerAttributions |
Base handler for handling attributions
|
| GtfsFileHandlerCalendarDates |
Base handler for handling calendar dates
|
| GtfsFileHandlerCalendars |
Base handler for handling (service) calendars
|
| GtfsFileHandlerFareAttributes |
Base handler for handling fare attributes
|
| GtfsFileHandlerFareRules |
Base handler for handling fare attributes
|
| GtfsFileHandlerFeedInfo |
Base handler for handling feed information
|
| GtfsFileHandlerFrequencies |
Base handler for handling frequencies
|
| GtfsFileHandlerLevels |
Base handler for handling levels
|
| GtfsFileHandlerPathways |
Base handler for handling pathways
|
| GtfsFileHandlerRoutes |
Base handler for handling routes
|
| GtfsFileHandlerShapes |
Base handler for handling shape attributes
|
| GtfsFileHandlerStops |
Base handler for handling stops
|
| GtfsFileHandlerStopTimes |
Base handler for handling stop times
|
| GtfsFileHandlerTransfers |
Base handler for handling transfers
|
| GtfsFileHandlerTranslations |
Base handler for handling translations
|
| GtfsFileHandlerTrips |
Base handler for handling trips
|
| GtfsFileReaderAgencies |
A GTFS file reader for parsing GTFS agencies
|
| GtfsFileReaderAttributions |
A GTFS file reader for parsing GTFS attributions entries
|
| GtfsFileReaderBase |
A GTFS file reader containing generic code for any GTFS file
|
| GtfsFileReaderCalendarDates |
A GTFS file reader for parsing GTFS calendar date entries
|
| GtfsFileReaderCalendars |
A GTFS file reader for parsing GTFS calendar entries
|
| GtfsFileReaderFareAttributes |
A GTFS file reader for parsing GTFS fare attributes entries
|
| GtfsFileReaderFareRules |
A GTFS file reader for parsing GTFS fare rule entries
|
| GtfsFileReaderFeedInfo |
A GTFS file reader for parsing GTFS feed info entries
|
| GtfsFileReaderFrequencies |
A GTFS file reader for parsing GTFS frequencies
|
| GtfsFileReaderLevels |
A GTFS file reader for parsing GTFS levels
|
| GtfsFileReaderPathways |
A GTFS file reader for parsing GTFS pathways
|
| GtfsFileReaderRoutes |
A GTFS file reader for parsing GTFS routes
|
| GtfsFileReaderSettings |
General settings applicable to all GTFS file readers
|
| GtfsFileReaderShapes |
A GTFS file reader for parsing GTFS shapes entries
|
| GtfsFileReaderStops |
A GTFS file reader for parsing GTFS stops
|
| GtfsFileReaderStopTimes |
A GTFS file reader for parsing GTFS stop times
|
| GtfsFileReaderTransfers |
A GTFS file reader for parsing GTFS transfers entries
|
| GtfsFileReaderTranslations |
A GTFS file reader for parsing GTFS translation entries
|
| GtfsFileReaderTrips |
A GTFS file reader for parsing GTFS trips
|
| GtfsFileScheme |
Each GTFS file scheme represents on particular GTFS file and its mapping to an in memory GTFS object
|
| GtfsFileSchemeFactory |
Factory class to create most common GTFS file schemes
|
| GtfsFileType |
Supported GTFS file types and their corresponding (default) file name in which entries are expected to be found
|
| GtfsFileTypePresence |
Options regarding the presence of a GTFS file type
|
| GtfsFrequenciesScheme |
The scheme used for GTFS frequencies, namely a frequencies.txt file and a GtfsFrequency in memory object to go with each entry
|
| GtfsFrequency |
In memory representation of a GTFS entry in frequencies.txt
|
| GtfsKeyType |
List of all available GTFS keys used in GTFS files
|
| GtfsLevel |
In memory representation of a GTFS entry in levels.txt
|
| GtfsLevelsScheme |
The scheme used for GTFS levels, namely a levels.txt file and a GtfsLevel in memory object to go with each entry
|
| GtfsObject |
Base class for any GTFS memory model object with key value pairs for the data
|
| GtfsObjectFactory |
|
| GtfsObjectType |
The available supported object types and their corresponding class.
|
| GtfsPathway |
In memory representation of a GTFS entry in pathways.txt
|
| GtfsPathwaysScheme |
The scheme used for GTFS pathways, namely a pathways.txt file and a GtfsPathway in memory object to go with each entry
|
| GtfsReader |
Top level GTFS reader for one or more GTFS files.
|
| GtfsReaderFactory |
top level class to get things started.
|
| GtfsRoute |
In memory representation of a GTFS entry in routes.txt
|
| GtfsRoutesScheme |
The scheme used for GTFS routes, namely a routes.txt file and a GtfsAgency in memory object to go with each entry
|
| GtfsShape |
In memory representation of a GTFS entry in shapes.txt
|
| GtfsShapesScheme |
The scheme used for GTFS fare rules, namely a fare_rules.txt file and a GtfsFareRule in memory object to go with each entry
|
| GtfsStop |
In memory representation of a GTFS entry in stops.txt
|
| GtfsStopsScheme |
The scheme used for GTFS stops, namely an stops.txt file and a GtfsStop in memory object to go with each entry
|
| GtfsStopTime |
In memory representation of a GTFS entry in stop_times.txt
|
| GtfsStopTimesScheme |
The scheme used for GTFS stop times, namely a stop_times.txt file and a GtfsStopTime in memory object to go with each entry
|
| GtfsTransfer |
In memory representation of a GTFS entry in transfers.txt
|
| GtfsTransfersScheme |
The scheme used for GTFS transfers, namely a transfers.txt file and a GtfsTransfer in memory object to go with each entry
|
| GtfsTranslation |
In memory representation of a GTFS entry in translations.txt
|
| GtfsTranslationsScheme |
The scheme used for GTFS translations, namely a translations.txt file and a GtfsTranslation in memory object to go with each entry
|
| GtfsTrip |
In memory representation of a GTFS entry in trips.txt
|
| GtfsTripsScheme |
The scheme used for GTFS trips, namely a trips.txt file and a GtfsTrip in memory object to go with each entry
|
| GtfsUtils |
general utilities specific to this GTFS API
|
| HashUtils |
Common location to provide some utilities for common hashing tasks
|
| HeavyGoodsMode |
the predefined heavy goods vehicle mode, i.e., truck over 3.5 tonnes
name: hgv
maxspeed (km/h): 90
pcu: 2.5
vehicular type: VEHICULAR
motorisation: MOTORISED
track: ROAD
use: GOODS
|
| IdAble |
A class implementing this interface signals that it is id-able
|
| IdAbleImpl |
Implementation of Idable interface including hash and equals based on id
|
| IdGenerator |
Convenience class to track unique ids across different classes that decide to
use a generator for their id members.
|
| IdGroupingToken |
Class used as token to group ids, i.e., ids for a class generated with this token will be unique within this group.
|
| IdMapperFunctionFactory |
Factory that creates functions for id mapping from PLANit ids to ids to be used for persistence.
|
| IdMapperType |
Indicates which PLANit id to use for extracting ids on the output format.
|
| InflowOutflowData |
During sLTM loading we use temporary inflow and outflow rates resulting from node model updates.
|
| InflowOutputProperty |
Property to provide the Inflow rate in PCU/hour.
|
| InitialiseBushEdgeSegmentDemandConsumer |
Initialise the bush for a given origin/destination with the shortest path being offered from the destination to the origin via the provided edge segments in the callback.
|
| InitialLinkSegmentCost |
Initial Link Segment Costs stored by mode
|
| InitialModesLinkSegmentCost |
Wrapper around all initial costs per link segment per mode.
|
| InitialPhysicalCost |
The initial physical costs for the network
|
| InputBuilderListener |
Base input builder class that gets notified whenever traffic assignment components are to be populated or configured.
|
| InteractorAccessee |
Interactor accessee.
|
| InteractorAccessor<T extends InteractorAccessee> |
Interactor accessor.
|
| IntermodalConverter |
A converter that supports intermodal networks, i.e., a combination of both a network and a zoning with transfer zones
|
| IntermodalConverterFactory |
Factory class for creating intermodal network converters for specific reader/writer combinations
|
| IntermodalReader |
Abstract base class implementation to parser an intermodal PLANit network
|
| IntermodalWriter |
abstract base class implementation to write an intermodal PLANit network to disk
|
| IterationIndexOutputProperty |
|
| JAXBUtils |
Utility methods for parsing XML data
|
| LargeHeavyGoodsMode |
the predefined large heavy goods vehicle mode, i.e., large articulated truck, larger than heavy goods
name: lhgv
maxspeed (km/h): 90
pcu: 3
vehicular type: VEHICULAR
motorisation: MOTORISED
track: ROAD
use: GOODS
|
| LengthOutputProperty |
|
| LengthUnits |
|
| LightRailMode |
the predefined lightrail mode
name: lightrail
maxspeed (km/h): 70
pcu: 6
vehicular type: VEHICULAR
motorisation: MOTORISED
track: RAIL
use: PUBLIC
|
| LinearFundamentalDiagramBranch |
A linear fundamental diagram branch implementation
|
| Link |
Link interface which extends the Edge interface with a unique id (not all edges are links) as
well as an external id
|
| LinkBasedRelativeDualityGapFunction |
Gap function based on the work of Bovy and Jansen (1983) who take the different between the current system travel time and the system travel time if all flow were to be assigned
to the shortest paths, divided by the system travel time
|
| LinkBasedRelativeGapConfigurator |
Link based relative duality gap function configurator
|
| LinkFactory |
Factory interface for creating links.
|
| LinkFactoryImpl |
Factory for creating links on links container
|
| LinkImpl |
Link class connecting two nodes via some geometry.
|
| LinkInflowOutflowAccessee |
Link inflow/outflow accessee.
|
| LinkInflowOutflowAccessor |
Link Volume Accessor interface
|
| LinkOutputTypeConfiguration |
The configuration for the link output type.
|
| Links |
rimary managed container class for links with access to factory capable of creating new links and registering them on the container
directly
|
| LinkSegment |
Interface for link segments (directional) part of link (non-directional).
|
| LinkSegmentBoundary |
LinkSegment boundary of a link segment.
|
| LinkSegmentBoundary.Location |
Location types for a link segment boundary
|
| LinkSegmentCostOutputProperty |
Link segment cost property.
|
| LinkSegmentData |
POJO to store Link segment based variables by the link segment internal id for sLTM link segment based data.
|
| LinkSegmentExpectedResultsDto |
DTO object containing extra fields specific to BPR function
The first
|
| LinkSegmentExternalIdOutputProperty |
|
| LinkSegmentFactory |
Factory to create link segments and register them on its container
|
| LinkSegmentFactoryImpl |
Factory for creating link segments on link segments container
|
| LinkSegmentIdOutputProperty |
|
| LinkSegmentImpl |
Link segment object representing physical links in the network and storing their properties
|
| LinkSegments |
Primary managed container for linkSegments explicitly and create them on the container via
its dedicated factory class
|
| LinkSegmentsImpl |
Link segments primary managed container implementation
|
| LinkSegmentTypeIdOutputProperty |
|
| LinkSegmentTypeNameOutputProperty |
|
| LinkSegmentTypeXmlIdOutputProperty |
|
| LinkSegmentXmlIdOutputProperty |
Property reflecting the input xml id used when parsing the link segment in native PLANit format.
|
| LinksImpl |
Links primary managed container implementation
|
| LinkVolumeAccessee |
Link Volume accessee object.
|
| LinkVolumeAccessor |
Link Volume Accessor interface
|
| LocaleUtils |
Utilities for locale
|
| Logging |
Utility class to close the current logger
|
| LoggingUtils |
some utilities for consistent logging message creation in PLANit
|
| LogitChoiceModel |
The logit choice model base class.
|
| LogitChoiceModelConfigurator<T extends LogitChoiceModel> |
Base class for all logit choice model configurator implementations
|
| LogitChoiceModelConfiguratorFactory |
factory for the logit choice model types supported directory by PLANit
|
| LongMapWrapper<V> |
Version of MApWrapper when we use Long as key
|
| LongMapWrapperImpl<V> |
Wrapper class for a map instance with Long keys
|
| LtmAssignment |
Link Transmission Model implementation base implementation for network loading based on LTM network loading paradigm.
|
| LtmConfigurator<T extends LtmAssignment> |
Configurator for sLTM.
|
| LtmTrafficAssignmentBuilder<T extends LtmAssignment> |
An LTM traffic assignment builder is assumed to only support Link Transmission Model (LTM) traffic assignment instances.
|
| MacroscopicConstants |
|
| MacroscopicLinkOutputTypeAdapter |
Interface defining the methods required for a macroscopic link (segment) output adapter
|
| MacroscopicLinkOutputTypeAdapterImpl |
Top-level abstract class which defines the common methods required by macroscopic link output type adapters.
|
| MacroscopicLinkSegment |
Macroscopic traffic modeling oriented link segment.
|
| MacroscopicLinkSegmentFactory |
Factory to create link segments and register them on its container
|
| MacroscopicLinkSegmentFactoryImpl |
Factory for creating link segments on link segments container
|
| MacroscopicLinkSegmentImpl |
Link segment for macroscopic transport networks.
|
| MacroscopicLinkSegments |
Primary managed container for MacroscopicLinkSegments explicitly and create them on the container via
its dedicated factory class
|
| MacroscopicLinkSegmentsImpl |
Link segments container implementation
|
| MacroscopicLinkSegmentType |
The macroscopic link segment type characteristics are contained in this class
|
| MacroscopicLinkSegmentTypeFactory |
Factory to create link segments and register them on its container
|
| MacroscopicLinkSegmentTypeFactoryImpl |
Factory for creating macroscopic link segment types on link segment types container
|
| MacroscopicLinkSegmentTypeImpl |
Each macroscopic link segment is of a particular type reflecting segment specific properties.
|
| MacroscopicLinkSegmentTypes |
A container interface for macroscopic link segment types
|
| MacroscopicLinkSegmentTypesImpl |
Implementation of the container interface
|
| MacroscopicNetwork |
Macroscopic Network which stores one or more macroscopic network infrastructure layers that together form the complete (intermodal) network.
|
| MacroscopicNetworkLayer |
Macroscopic physical network layer consisting of nodes, links and macroscopic link segments
|
| MacroscopicNetworkLayerConfigurator |
Configurator class that allows one to create and modify a setup for the mapping of modes and macroscopic network layers without actually creating them yet.
|
| MacroscopicNetworkLayerFactory |
Factory interface for creating macroscopic network layers
|
| MacroscopicNetworkLayerFactoryImpl |
Factory for creating macroscopic network layer instances
|
| MacroscopicNetworkLayerImpl |
Macroscopic physical Network (layer) that supports one or more modes and link segment types, where the modes are registered on the network (Infrastructure network) level
|
| MacroscopicNetworkLayers |
interface to manage macroscopic physical network layers, i.e., layers that contain a topologically meaningful representation in the form of nodes and links
|
| MacroscopicNetworkLayersImpl |
Implementation of container and factory to manager layers.
|
| ManagedGraphEntities<E extends GraphEntity> |
Container class for any graph entities and a factory to create them
|
| ManagedId |
Interface supporting methods that aid in classes that implement IdAble where this id is based
on a generated id via the IdGenerator using class signatures and grouping tokens to manage the id generation
for the instances
|
| ManagedIdEntities<E extends ManagedId> |
Container class for any managed id derived entities and a factory to create them
|
| ManagedIdEntitiesImpl<E extends ManagedId> |
Base class for containers of managed id entities
|
| ManagedIdEntityFactory<E extends ManagedId> |
A base abstract class for factories that create entities with a managed internal id.
|
| ManagedIdEntityFactoryImpl<E extends ManagedId> |
Base implementation for creating and registering managed id entities and conducting changes to ids based on the factory settings for generating ids.
|
| ManualInitialLinkSegmentCost |
Initial Link Segment Cost for which all the link segments have the same cost value for a specified mode
|
| MapWrapper<K,V> |
Wrap a map as a named class
|
| MapWrapperImpl<K,V> |
Abstract Wrapper class implemented for a map instance
|
| MatsimIntermodalWriter |
A class that takes a PLANit intermodal network and writes it as a MATSim intermodal network.
|
| MatsimIntermodalWriterFactory |
Factory for creating PLANitMatsimIntermodalWriters
|
| MatsimIntermodalWriterSettings |
Settings specific to writing the intermodal related outputs in Matsim format (network and pt)
|
| MatsimNetworkWriter |
A class that takes a PLANit network and writes it as a MATSIM network.
|
| MatsimNetworkWriterFactory |
Factory for creating PLANitMatsimWriters
|
| MatsimNetworkWriterSettings |
Settings for the MATSIM writer
By default the MATSIM writer will activate all available predefined PLANit modes for writing.
|
| MatsimNetworkXmlAttributes |
MATSIM network XML attributes used
|
| MatsimNetworkXmlElements |
MATSIM network XML elements used
|
| MatsimTransitXmlAttributes |
MATSIM transit XML attributes used
|
| MatsimTransitXmlElements |
MATSIM transit XML elements used
|
| MatsimWriter<T> |
Base class from which all matsim writers derive
|
| MatsimZoningWriter |
A class that takes a PLANit zoning and extracts and writes the MATSIM public transport information to disk.
|
| MatsimZoningWriterFactory |
Factory for creating PLANitMatsim zoning writers.
|
| MatsimZoningWriterSettings |
Settings specific to writing the zoning related output in Matsim format (pt)
|
| MaximumDensityOutputProperty |
Maximum density in pcu/km
|
| MaximumSpeedOutputProperty |
|
| MemoryOutputFormatter |
OutputFormatter which stores data in memory, using specified keys and output properties.
|
| MemoryOutputIterator |
Iterator which loops through the keys and values stored in the MemoryOutputFormatter
This class is a wrapper for MultiKeyPlanItDataIterator.
|
| MinMaxPathResult |
Track results of a min-max path tree path execution allowing one to extract both minimum and maximum cost paths along the tree.
|
| MinMaxPathResultImpl |
Implementation of the MinMaxPathResult interface
|
| Mode |
Interface to represent a mode
|
| ModeData |
Object to store the flows for each mode during the assignment iterations
|
| ModeExternalIdOutputProperty |
|
| ModeFactory |
Factory interface for creating mode instances
|
| ModeFactoryImpl |
Factory for creating modes on modes container
|
| ModeFeaturesFactory |
Factory class to create physical and usability features for custom modes
|
| ModeIdOutputProperty |
|
| ModeImpl |
A Mode is a user class feature representing a single form of transport (car, truck etc.).
|
| Modes |
container class and factory methods for modes with some
|
| ModesImpl |
Implementation of the Modes interface to create and register modes
|
| ModeXmlIdOutputProperty |
|
| ModifiedLinkSegmentTypes |
Helper class that tracks all modified, i.e., custom link segment types, that differ from the default link segment types
created for open street map road and rail way types.
|
| ModifiedZoneIdsEvent |
Wrapper for all events fired with zoning as a source
|
| MotorBikeMode |
the predefined motor bike mode
name: bicycle
maxspeed (km/h): 130
pcu: 0.5
vehicular type: VEHICULAR
motorisation: NON_MOTORISED
track: ROAD
use: PRIVATE
|
| MotorisationModeType |
A (vehicular) mode is either motorised or not; part of physical features
|
| MSASmoothing |
MSA smoothing object
|
| MSASmoothingConfigurator |
configurator for MSA smoothing implementation
|
| MultiConverter<T,U> |
Convert multiple PLANit entities parsed by a reader from one format and persisted with a writer to another
|
| MultiConverterReader<T,U> |
Interface for classes able to convert entities of multiple types which are then returned
|
| MultiConverterWriter<T,U> |
Interface for classes able to write a PLANit entities of given type to disk
|
| MultiKeyPlanItData |
Class which holds arrays of output property values, identified by arrays of output keys
This class is a wrapper for the MultiKeyMap object which is a Map with multiple keys.
|
| MultiKeyPlanItDataIterator |
Iterator which returns the keys and values for each row in a MultiKeyPlanItData object.
|
| MultiKeyPlanItDataIteratorImpl |
Implementation of the MultiKeyPlanItDataIterator interface
|
| MultinomialLogit |
MNL choice model implementation
|
| MultinomialLogitConfigurator |
MNL configurator implementations
|
| Network |
Base class for any network.
|
| NetworkConverter |
Network converter class able to convert a network from one type to another
|
| NetworkConverterFactory |
Factory class for creating network converters
|
| NetworkFileColumnType |
Enumeration giving roles of columns in TNTP network input file
|
| NetworkFlowUpdateData |
Base class to aid updating of the network link flows during loading.
|
| NetworkLoading |
Network loading traffic component
|
| NetworkLoadingFactorData |
Track the sLTM variables representing the various factors used:
flow acceptance factors (alphas)
flow capacity factors (betas)
storage capacity factors (gammas)
|
| NetworkReader |
Interface to read a PLANit network
|
| NetworkReaderImpl |
A network reader implementation with built-in convenience containers that maps ids used by the external data source to relate entities to each other to the created PLANit
entries.
|
| NetworkTurnFlowUpdateData |
Base class to aid updating of the network turn flows during loading.
|
| NetworkWriter |
Interface to write a PLANit network to disk
|
| NewellFundamentalDiagram |
Implementation of a Newell (triangular) fundamental diagram for a road section (link segment)
|
| NewellFundamentalDiagramComponent |
Newell fundamental diagram traffic component
|
| NewellFundamentalDiagramConfigurator |
Configurator for Newell Fundamental diagram implementation.
|
| Node |
Node is a vertex but not all vertices are nodes.
|
| NodeFactory |
Factory interface for creating node instances
|
| NodeFactoryImpl |
Factory for creating nodes on nodes container
|
| NodeImpl |
Node representation connected to one or more entry and exit links
|
| NodeModel |
Node model algorithm base interface
|
| NodeModelComponent |
Node model traffic component
|
| NodeModelConfigurator<T extends NodeModelComponent> |
Base class for all node model configurator implementations
|
| NodeModelConfiguratorFactory |
factory for the node model types supported directory by PLANit
|
| Nodes |
Container class for primary managed nodes container and access to factory to create and register them on this instance
|
| NodesImpl |
Nodes primary managed container implementation
|
| NoneUnit |
Simple unit that comprises a single unit
|
| NormBasedGapConfigurator |
Norm based gap function configurator
|
| NormBasedGapFunction |
Gap function based on the norm, e.g.
|
| NotNull |
NotNull predicate
|
| NullaryDoubleSupplier |
Lightweight Nullaryfunction implementation to supply doubles in the form of a NullaryFunction<Double> compatible with
OjAlgo
|
| NumberOfLanesOutputProperty |
|
| OdCostOutputProperty |
|
| OdData<T> |
Interface defining methods for objects which store data related to origin and destination
|
| OdDataImpl<T> |
Base class containing common methods required by all classes which implement ODData
|
| OdDataIterator<T> |
Defines methods for an iterator which moves through a matrix of origin-destination cells
|
| OdDemandMatrix |
This class handles the OD demand matrix.
|
| OdDemands |
OdData representing Origin-Destination demands without a specific container reference so a general typed definition of OdDemands can be used for access
|
| OdHashed<T> |
This interface represents a hashed based implementation for handling origin-demand matrices of a certain type where the data is modelled by a single hash key generated from the
OD zone information
|
| OdHashedImpl<T> |
This class stores paths by their origin and destination by creating a unique hash for the combined ids of the od zones.
|
| OdHashedIterator<T> |
Base Hash key oriented Iterator which runs through available ods that have non-zero values
|
| OdMatrix<T,U> |
This class contains common methods for handling origin-demand matrices of a certain type where the entire matrix is modelled even if some combinations of ODs do not contain any
data.
|
| OdMatrixImpl<T,U> |
This class contains common methods for handling origin-demand matrices.
|
| OdMatrixIterator<T,U> |
BAse matrix oriented Iterator which runs through rows and columns of some matrix type of container, making the value, row and column of each cell available
|
| OdNonPrimitiveMatrix<T> |
This class contains common methods for handling origin-demand matrices where values are non primitive types, i.e.
|
| OdNonPrimitiveMatrixIterator<T> |
Iterator of OdMatrix with objects stored as raw two dimensional array
|
| OdOutputTypeAdapter |
Interface defining the methods required for an Origin-Destination output adapter
|
| OdOutputTypeAdapterImpl |
Top-level abstract class which defines the common methods required by OD output type adapters
|
| OdOutputTypeConfiguration |
The configuration for the origin-destination output type.
|
| OdPathIterator |
Iterator for directed paths tracked by od
|
| OdPathMatrix |
This class stores the path objects from each origin to each destination in a full matrix form
|
| OdPaths |
A container class for Origin-Destination paths.
|
| OdPathSets |
Contains one or more origin-destination based path sets that can be used in assignment.
|
| OdPathsHashed |
This class stores paths by their origin and destination by creating a unique hash for the combined ids of the od zones.
|
| OdPrimitiveMatrix<T extends Number> |
This class contains common methods for handling origin-demand matrices.
|
| OdPrimitiveMatrixIterator<T extends Number> |
Iterator of OdMatrix with primitives stored as Array2D
|
| OdSkimMatrix |
This class stores an OD Skim matrix.
|
| OdSkimSubOutputType |
Enumeration of possible values of OD Skim Output Type
|
| OdZone |
an OdZone is a zone where trips terminate and or commence
|
| OdZoneFactory |
Factory interface for directed connectoids
|
| OdZoneFactoryImpl |
Factory for creating od zones (on container)
|
| OdZoneImpl |
An Od zone
|
| OdZones |
Container class for OdZones
|
| OdZonesImpl |
implementation of the Zones <T> interface for Od zones
|
| OneToAllShortestPathAlgorithm |
An algorithm which calculates the shortest (a.k.a.
|
| OneToOneShortestPathAlgorithm |
An algorithm which calculates the shortest (a.k.a.
|
| OriginZoneExternalIdOutputProperty |
|
| OriginZoneIdOutputProperty |
|
| OriginZoneXmlIdOutputProperty |
|
| Osm4JUtils |
Utiilities regarding the use of the OSM4J reader that provides us with raw stream of OSM entities to parse
|
| OsmAccessTags |
Access tags as described on https://wiki.openstreetmap.org/wiki/Key:access.
|
| OsmBicycleTags |
Commonly used tags in relation to bicycles or bicycle ways.
|
| OsmBoundingAreaUtils |
Utilities regarding the use of a bounding box when parsing OSM data
|
| OsmBusWayTags |
Commonly used tags in relation to busways
Note that buses and/or public service vehicles have three different possible tagging schemes that are supported by open street maps, namely:
busway scheme
lanes:mode scheme
mode:lanes scheme
The tags and method in this class are focussed on the busways only
|
| OsmConstants |
Some constants used by PLANit OSM
|
| OsmDirectionTags |
Tags related to directions, e.g.
|
| OsmHighwaySettings |
All highway specific settings
|
| OsmHighwayTags |
OSM "highway" values, e.g.
|
| OsmHighwayTypeConfiguration |
Configuration options regarding the activation/deactivation of specific OSM highway types in the parser
|
| OsmInfrastructureConfiguration |
Base class with common functionality for configuration OSM ways (highway/rail)
|
| OsmIntermodalReader |
Parse OSM input in either *.osm or *.osm.pbf format and return PLANit intermodal network which includes the transfer zones
of a zoning instance.
|
| OsmIntermodalReaderFactory |
Factory for creating PLANitOsmIntermodalReaders
|
| OsmIntermodalReaderSettings |
Capture all the user configurable settings regarding the OSM intermodal reader, which in turn has a network
and zoning reader.
|
| OsmJunctionTags |
Tags related to junction values, e.g.
|
| OsmLaneDefaults |
configure and retrieve the default configuration for the number of lanes for various osm way types (these are the total lanes on a link covering both directions.
|
| OsmLanesModeTaggingSchemeHelper |
The lanesMode tagging scheme is one of a number of tagging schemes used by OSM to identify dedicated lanes for specific modes.
|
| OsmLaneTaggingSchemeHelper |
The tagging scheme helper is the base class for different lane based tagging schemes.
|
| OsmLaneTags |
tags related to lanes and some basic convenience methods to check for lane related OSM tags
|
| OsmModeAccessDefaults |
Class representing the default mode access restrictions/allowance for modes for a given
highway type.
|
| OsmModeAccessDefaultsByCountry |
The defaults for the mode access in case no specific restrictions are indicated on the highway=type way.
|
| OsmModeAccessDefaultsCategory |
Class representing the default mode access restrictions/allowance for modes for a given
category of OSM ways, e.g.
|
| OsmModeHelper |
Class to support parsing and other functionality that depends on the configuration of the readers regarding OSM modes and their mappng to PLANit modes
|
| OsmModeLanesTaggingSchemeHelper |
The modeLanes tagging scheme is one of a number of tagging schemes used by OSM to identify dedicated lanes for specific modes.
|
| OsmModeUtils |
Utilities in relation to parsing OSM modes when constructing a PLANit model from it.
|
| OsmMultiPolygonTags |
tags used by Osm Multiplogyon relation
|
| OsmNetworkHandler |
Handler that handles, i.e., converts, nodes, ways, and relations.
|
| OsmNetworkHandlerHelper |
Helper class for the OSM network handlers, providing static helper methods that reflect common code across various
handlers that are not considered general enough to be part of a utility class.
|
| OsmNetworkHandlerProfiler |
Track statistics on OSM network handler
|
| OsmNetworkLayerModeParser |
Class to support parsing of OSM modes on OSM ways given the configuration provided for each PLANit network layer
|
| OsmNetworkLayerParser |
Takes care of populating a PLANit layer based on the OSM way information that has been identified
as relevant to this layer by the OsmNetworkHandler |
| OsmNetworkPreProcessingHandler |
Preprocessing Handler that identifies which nodes of osm ways - that are marked for inclusion even if they fall (partially) outside the bounding polygon -
are to be kept.
|
| OsmNetworkReader |
Parse OSM input in either *.osm or *.osm.pbf format and return PLANit network instance
|
| OsmNetworkReaderData |
Data specifically required in the network reader while parsing OSM data
|
| OsmNetworkReaderFactory |
Factory for creating PLANitOSMReaders
|
| OsmNetworkReaderLayerData |
Class containing data that maps Osm entities to PLANit entities required during parsing for a specific network layer
|
| OsmNetworkReaderSettings |
All general settings (and sub-settings classes) for the OSM reader pertaining to parsing network infrastructure.
|
| OsmNetworkToZoningReaderData |
Class that hosts all the data gathered (e.g., references, mappings, etc.) during the parsing of the OSM network
that is also of use to the OSM zoning reader.
|
| OsmNodeUtils |
Utilities in relation to parsing OSM nodes while constructing a PLANit model from it
|
| OsmOneWayTags |
common OSM one way tags and some helper methods
|
| OsmPedestrianTags |
pedestrian related tags which are not really grouped in a logical way in OSM, hence we provide all of them here as well as some convenience methods
to quickly collect some of the most relevant ones.
|
| OsmPtv1Tags |
Tags related specifically to public transport infrastructure and services for the OSM PTv1 tagging scheme.
|
| OsmPtv2Tags |
Tags related specifically to public transport infrastructure and services for the OSM PTv2 tagging scheme.
|
| OsmPtVersionScheme |
Enum highlighting the different (supported) public transport tagging schemes
|
| OsmPtVersionSchemeUtils |
Utilities regarding the tagging of OSM entities and the various PT version schemes that exist
|
| OsmPublicTransportModeHelper |
class that provides functionality to parse/filter public transport modes from OSM entities based
on the user defined settings
|
| OsmPublicTransportReaderSettings |
Capture all the user configurable settings regarding how to
parse (if at all) (public transport) transfer infrastructure such as stations, poles, platforms, and other
stop and tranfer related infrastructure
|
| OsmRailFeatureTags |
OSM rail feature tags that could be of value for a network.
|
| OsmRailModeTags |
Most OSM rail based mode tags.
|
| OsmRailwaySettings |
Settings specific to railways when parsing OSM files and converting them to a PLANit memory model
|
| OsmRailwayTags |
Most OSM rail way tags that could be of value for a network.
|
| OsmRailwayTypeConfiguration |
|
| OsmReaderSettings |
Settings relevant for a Planit Xml reader
|
| OsmRelationTypeTags |
Relation types that exist
|
| OsmRelationUtils |
Utilities in relation to parsing OSM relations while constructing a PLANit model from it
|
| OsmRoadModeCategoryTags |
|
| OsmRoadModeTags |
Most OSM road based mode tags.
|
| OsmSpeedLimitDefaults |
A class containing instances for each of the OSM speed limit default categories: urban/non-urban highways and railways
|
| OsmSpeedLimitDefaultsByCountry |
Convenience class for quickly collecting the speed limits for various countries, where possible
based on https://wiki.openstreetmap.org/wiki/OSM_tags_for_routing/Maxspeed (highway types)
|
| OsmSpeedLimitDefaultsCategory |
Container class for storing speed limits for different waytypes for OSM.
|
| OsmSpeedTags |
common speed limit information tags
|
| OsmTags |
common OSM tags that we might need to refer to
|
| OsmTagUtils |
Class with some general convenience methods for dealing with OSM tags
|
| OsmWaterModeTags |
Most OSM water based mode tags.
|
| OsmWaySettings |
Base class with shared settings across different types of Osm ways (highway, railway)
|
| OsmWayUtils |
Utilities in relation to parsing osm ways and constructing a PLANit model from it
|
| OsmZoningHandlerBase |
Base Handler for all zoning handlers.
|
| OsmZoningHandlerProfiler |
Track statistics on Osm zoning handler
|
| OsmZoningPostProcessingHandler |
Handler that conducts final parsing round where all stop_positions in relations are mapped to the now parsed transfer zones.
|
| OsmZoningPreProcessingHandler |
Handler that is applied before we conduct the actual handling of the zones by exploring the OSM relations
in the file and highlighting a subset of ways that we are supposed to retain even though they are not tagged
by themselves in a way that warrants keeping them.
|
| OsmZoningProcessingHandler |
Handler that handles, i.e., converts, nodes, ways, and relations to the relevant transfer zones.
|
| OsmZoningReader |
Parse OSM input in either *.osm or *.osm.pbf format and return PLANit zoning instance comprising of the identified transfer zones.
|
| OsmZoningReaderData |
Data specifically required in the zoning reader while parsing OSM data
|
| OsmZoningReaderFactory |
Factory for creating PLANitOSM zoning Readers.
|
| OsmZoningReaderOsmData |
Data specifically required in the zoning reader while parsing OSM data
|
| OsmZoningReaderPlanitData |
Data specifically required in the zoning reader while parsing OSM data
|
| OutflowOutputProperty |
Property to provide the Outflow rate in PCU/hour.
|
| OutputAdapter |
Output Adapter which stores output type adapters for each Output Manager and defines top-level method which apply to all output types
|
| OutputConfiguration |
Class containing the general output configuration and the type specific configurations for some traffic assignment
|
| OutputFormatter |
Interface for persisting output data in a particular format
|
| OutputFormatterFactory |
Factory to create output writers of any compatible type
|
| OutputManager |
Base class for output writers containing basic functionality regarding all things output
|
| OutputProperty |
Template for output property classes which can be included in the output files.
|
| OutputPropertyPriority |
Enumeration giving the priority of output properties.
|
| OutputPropertyType |
Enumeration of possible output properties
|
| OutputType |
Different configurations exist for different types of output which we
identify via this enum
GENERAL:
LINK: link based output
SIMULATION: simulation based output such as profile information, objects created etc.
|
| OutputTypeAdapter |
Top-level interface for all output type adapters
|
| OutputTypeAdapterImpl |
Top-level abstract class which defines the common methods required by all output type adapters
|
| OutputTypeConfiguration |
Configuration for a specific output type including the adapter allowing access to the underlying raw data
|
| OutputTypeEnum |
Marker interface to allow us to store outputType and suboutputTypeEnums in the same collection
without issue while still being able to distinguish between the two
|
| OutputUtils |
Utility Functions used during output
|
| Pair<A,B> |
Custom pair class similar to C++.
|
| Pas |
Paired Alternative Segment (PAS) implementation comprising two subpaths (segments), one of a higher cost than the other.
|
| PasManager |
Container class for tracking all unique PASs indexed by their last (merge) vertex
|
| PathChoice |
The path choice traffic assignment component responsible for the configuration of the path choice methodology and the path associated with this procedure.
|
| PathChoiceBuilder<T extends PathChoice> |
All path choice instances are built using this or a derived version of this builder
|
| PathChoiceBuilderFactory |
Path choice builder factory for the path choice types supported directory by PLANit
|
| PathChoiceConfigurator<T extends PathChoice> |
Base class for all path choice configurator implementations
|
| PathChoiceConfiguratorFactory |
factory for the path choice types supported directory by PLANit
|
| PathFlowUpdateConsumer<T extends NetworkFlowUpdateData> |
Base Consumer to apply during path based flow update for each combination of origin, destination, and demand
|
| PathIdOutputProperty |
|
| PathLinkSendingFlowUpdateConsumer |
Consumer to apply during path based loading to update the inflows on the provided raw array by their link segment ids for each combination of origin, destination, and demand
|
| PathOutputIdentificationType |
Enumeration of possible Id types used to identify a Path
|
| PathOutputStringProperty |
|
| PathOutputTypeAdapter |
Output type adapter interface for paths
|
| PathOutputTypeAdapterImpl |
Top-level abstract class which defines the common methods required by Path output type adapters
|
| PathOutputTypeConfiguration |
The configuration for the OD path output type.
|
| PathTurnFlowUpdateConsumer |
Consumer to apply during path based turn flow update for each combination of origin, destination, and demand
|
| PathUtils |
Path utilities
|
| PcuCapacitated |
Interface that signifies implementing classes adopt some form of capacitated restriction based on PCUs (passenger car units), these can be
links, link segments, or other entities that are otherwise not necessarily related in terms of their class hierarchy, but do support this
capacitated feature.
|
| PedestrianMode |
the predefined pedestrian mode
name: pedestrian
maxspeed (km/h): 5
pcu: 0.1
vehicular type: NO_VEHICLE
motorisation: NON_MOTORISED
track: ROAD
use: PRIVATE
|
| PhysicalCost |
Interface to classify costs of physical links
Physical links can be either InitialPhysicalCosts (which are read in at the start and are constant) or PhysicalCosts (which are derived from other inputs and are recalculated
after each iteration).
|
| PhysicalCostConfigurator<T extends AbstractPhysicalCost> |
Base class for all physical cost configurator implementations
|
| PhysicalCostConfiguratorFactory |
Traffic assignment builder factory for the physical cost types supported directory by PLANit
|
| PhysicalLayer |
Physical topological Network consisting of nodes, links and link segments
|
| PhysicalLinkOutputTypeAdapterImpl |
Abstract class which defines the common methods required by Link output type adapters that specifically pertain to networks that have adopted physical layers for their network
representation
|
| PhysicalModeFeatures |
the physical features of a mode are listed by this class.
|
| PhysicalModeFeaturesImpl |
the physical features of a mode are listed by this class.
|
| PiecewiseLinearCumulativeCurve |
Represents a piecewise linear cumulative curve
|
| PlanitComponent<T extends PlanitComponent<T> & Serializable> |
PLANit components are the main building blocks to create PLANit applications with.
|
| PlanitComponentBuilder<T> |
Builder class to build something of type T which is a PLANit component.
|
| PlanitComponentEvent |
Interface for the group of events that are used around PLANit component (creation)
|
| PlanitComponentEventType |
PLANit component event type class.
|
| PlanitComponentFactory<T extends PlanitComponent<?>> |
Generic factory class for registered subclasses of predefined PLANit components, so it does not create instances of T but of subclasses of T.
|
| PlanitComponentListener |
To serve as base listener class for all PLANit component related events, where its onX method provides any graph modification event as parameter
|
| PlanitCrsUtils |
Utilities for coordinate Reference systems
|
| PlanitDemandsReader |
Reader to parse PLANit demands from native XML format
|
| PlanitDemandsReaderSettings |
Settings for the PLANit zoning reader
|
| PlanItException |
General exception for PlanIt which wraps exceptions thrown during execution
|
| PlanitExceptionConsumer<T> |
Allows for a consumer interface that throws PlanitExceptions
|
| PlanitExceptionFunction<T,R> |
Allows for a functional interface that throws PlanitExceptions
|
| PlanitGmlUtils |
Utilities specific to GML
|
| PlanitGraphGeoUtils |
A class with utility methods that levarage the geospatial information of planit enities pertaining to graphs.
|
| PlanItInputBuilder |
Class which reads inputs from XML input files
|
| PlanitIntermodalReader |
Planit intermodal reader in native format.
|
| PlanitIntermodalReaderFactory |
Factory class for creating zoning reader in the native PLANit format
|
| PlanitIntermodalReaderSettings |
Settings of PLANit intermodal reader
|
| PlanitIntermodalWriter |
Planit intermodal writer for native Planit format, wrapping a planit network writer and planit zoning writer in one
|
| PlanitIntermodalWriterFactory |
Factory for creating PLANit intermodal writers persisting both a network and zoning (useful for intermodal networks with pt element where transfer zones are part of the
zoning.
|
| PlanitIntermodalWriterSettings |
Settings for Planit intermodal writer
|
| PlanitJtsCrsUtils |
General geographic JTS utilities that rely on a known Coordinate Reference system (CRS).
|
| PlanitJtsIntersectEdgeVisitor<T extends Edge> |
An item visitor for quadtree spatial index to filter out the edges in a quadtree that truly intersect with the
given bounding box provided in the query.
|
| PlanitJtsIntersectOsmNodeVisitor |
An item visitor for quadtree spatial index to filter out osm nodes in a quadtree that truly intersect with the
given bounding box provided in the query.
|
| PlanitJtsIntersectZoneVisitor<T extends Zone> |
An item visitor for quadtree spatial index to filter out the zones in a quadtree that truly intersect with the
given bounding box provided in the query.
|
| PlanitJtsItemVisitor<T> |
An item visitor for quadtree spatial index to filter out planit entities in a quadtree that truly intersect with the
given bounding box provided in the query.
|
| PlanitJtsUtils |
General geographic related utils utilising the JTS API.
|
| PlanitLinkSegmentUtils |
Utilities regarding PLANit link segments useful when parsing OSM entities and converting them into
PLANit link segments or other PLANit entities that have something to do with link segments.
|
| PlanitLinkUtils |
Utilities regarding PLANit links useful when parsing OSM entities
|
| PlanitMatsimWriterSettings |
Base writer settings class to be used by all available matsim writer settings classes.
|
| PlanitNamespacePrefixMapper |
|
| PlanitNetworkLayerUtils |
Utilities regarding PLANit network layers with respect to parsing OSM netities for it
|
| PlanitNetworkReader |
Implementation of the network reader for the PLANit XML native format
|
| PlanitNetworkReaderFactory |
Factory for creating PLANitNetworkReaders
|
| PlanitNetworkReaderSettings |
Configurable settings for the PLANit network reader
|
| PlanitNetworkWriter |
Writer to persist a PLANit network to disk in the native PLANit format.
|
| PlanitNetworkWriterFactory |
Factory for creating PLANit Network writers
|
| PlanitNetworkWriterSettings |
configurable settings for the PLANit writer
|
| PlanitOpenGisUtils |
General geotools related utils.
|
| PlanitOsmNetwork |
Macroscopic network with additional OSM functionality
Disclaimer: The descriptions for the default OSM link segment types have been copied from the OSM Wiki
|
| PlanitOsmUtils |
Utilities in relation to parsing OSM data and constructing a PLANit model from it that are too general to
be moved to any of the more specific PlanitOSMXXXUtils classes.
|
| PlanItOutputFormatter |
The default output formatter of PlanIt
|
| PlanItProject |
PLANit project which is nothing more than a CustomPlanItProject without any custom configuration pre-embedded.
|
| PlanItProjectInput |
Class that holds all the input traffic components for a PLANit project.
|
| PlanitRoutedServicesReader |
Implementation of a routed service reader in the PLANit XML native format
|
| PlanitRoutedServicesReaderFactory |
Factory for creating PlanitRoutedServicesReaders
|
| PlanitRoutedServicesReaderSettings |
Configurable settings for the PLANit routed services reader
|
| PlanitSchema |
Helper class to deal with XSD schema related locations for the various XML components
|
| PlanitServiceNetworkReader |
Implementation of a service network reader in the PLANit XML native format
|
| PlanitServiceNetworkReaderFactory |
Factory for creating PlanitServiceNetworkReaders
|
| PlanitServiceNetworkReaderSettings |
Configurable settings for the PLANit service network reader
|
| PlanItSimpleProject |
Wrapper around PLANitProject with most common defaults automatically activated.
|
| PlanitTransferZoneUtils |
Static helper methods to support parsing/functionality of PLANit TransferZones
|
| PlanitWriterImpl<T> |
Common functionality for writing in the native PLANit format across different writers
|
| PlanitXmlJaxbParser<T> |
Serves as a base class for readers of PLANit XML files of which the root element is of type T
|
| PlanitXmlReaderSettings |
Settings relevant for a Planit Xml reader
|
| PlanitXmlWriterSettings |
Settings relevant for persisting Planit Xml output
|
| PlanitXmlWriterUtils |
Utilities for creating and using basic Java xml writers
|
| PlanitZipFileInputStream |
A wrapper around a ZipFile's InputStream that keeps the underlying file open while an entry is being streamed.
|
| PlanitZipInputStream |
A wrapper around a ZipInputStream that keeps the underlying input streams alive.
|
| PlanitZoningReader |
Class to parse zoning from native XML format
|
| PlanitZoningReaderFactory |
Factory class for creating zoning reader in the native PLANit format
|
| PlanitZoningReaderSettings |
Settings for the PLANit zoning reader
|
| PlanitZoningUtils |
Helper class for the OSM handlers with respect to the PLANit zoning, providing static helper methods to aid when populating the zoning
from an OSM data source
|
| PlanitZoningWriter |
A class that takes a PLANit zoning and persists it to file in the Planit native XML format.
|
| PlanitZoningWriterFactory |
Factory for creating PLANit Zoning Writers
|
| PlanitZoningWriterSettings |
Settings for the planit zoning writer
|
| PopulateComponentEvent |
A Populate component event for components for which no dedicated derived event is created and provides access to the component to populate and additional content as is without
additional type or contextual information.
|
| PopulateDemandsEvent |
A Populate demands event is fired when PLANit requests for a registered listener to populate the newly created demands instance.
|
| PopulateFundamentalDiagramEvent |
A Populate fundamental diagram component event is fired when PLANit requests for a registered listener to populate the newly created fundamental diagram component instance.
|
| PopulateGapFunctionEvent |
A Populate gap function event is fired when PLANit requests for a registered listener to populate the newly created gap function instance.
|
| PopulateInitialLinkSegmentCostEvent |
A Populate initial link segment cost event is fired when PLANit requests for a registered listener to populate these initial costs which relate to a specific network.
|
| PopulateNetworkEvent |
A Populate network event is fired when PLANit requests for a registered listener to populate the newly created network instance.
|
| PopulatePhysicalCostEvent |
A Populate physical cost event is fired when PLANit requests for a registered listener to populate the newly created physical cost component.
|
| PopulateRoutedServicesEvent |
A Populate routed services event is fired when PLANit requests for a registered listener to populate the newly created routed services instance.
|
| PopulateServiceNetworkEvent |
A Populate service network event is fired when PLANit requests for a registered listener to populate the newly created service network instance.
|
| PopulateUntypedComponentEvent |
A Populate component event is fired when PLANit requests for a registered listener to populate the provided PLANit component instance.
|
| PopulateZoningEvent |
A Populate zoning event is fired when PLANit requests for a registered listener to populate the newly created zoning instance.
|
| Precision |
compare doubles with a certain precision
|
| PredefinedMode |
|
| PredefinedModeImpl |
A mode that has predefined fixed values so it can easily be understood, or mapped
|
| PredefinedModeType |
While PLANit allows the user to come up with its own modes.
|
| ProjectAssignmentBuilders |
Container class for registered traffic assignments on PLANit projects
|
| ProjectDemands |
class for registered demands on project
|
| ProjectNetworks |
Internal class for registered physical networks
|
| ProjectOdPathSets |
class for registered od path sets
|
| ProjectRoutedServices |
class for registered routed services on project
|
| ProjectServiceNetworks |
class for registered service networks on project
|
| ProjectZonings |
Class for registered zonings on project
|
| QuadConsumer<T,U,V,W> |
Function Interface which can process four input objects.
|
| ReceivingFlowData |
POJO to store the sLTM variables used for receiving flow updates (Step 4) in network loading
|
| ReflectionUtils |
Reflection specific utility functions
|
| RelativeLegTiming |
Simple POJO class that refers to a service leg and its duration and dwell time on a scheduled routed trip
|
| ReleaseEvent |
A release event represents the arrival of a trigger event at the opposite link boundary from where it originated.
|
| ReleaseFlowEvent |
A release flow event represents a flow rate that is being released on a link boundary on the opposite border from where it was triggered through a trigger event.
|
| RemoveDirectedSubGraphListener |
A listener interface to be triggered whenever planit entities are removed from the network due to a sub graph being
removed.
|
| RemoveSubGraphEdgeEvent |
Event for when an edge has been removed from a (sub) graph
|
| RemoveSubGraphEdgeSegmentEvent |
Event for when an edge segment has been removed from a (sub) graph
|
| RemoveSubGraphEvent |
Event called after a portion (subgraph) of a graph has been removed
|
| RemoveSubGraphListener |
A listener interface to be triggered whenever PLANit entities are removed from the network due to a sub graph being
removed.
|
| RemoveSubGraphListenerImpl |
A base class implementation for remove sub graph listeners
|
| RemoveSubGraphVertexEvent |
Event for when a vertex has been removed from a (sub) graph
|
| ResourceUtils |
Utilities to access resources in the Java environment
|
| RoutedModeServices |
Interface for wrapper container class around RoutedModeServices for a particular mode.
|
| RoutedModeServicesImpl |
Implementation of the RoutedModeServices interface
|
| RoutedService |
Interface to reflect a routed service.
|
| RoutedServiceFactory |
Factory for creating routed service instances on underlying container
|
| RoutedServiceImpl |
Implementation of a RoutedService instance based on the RoutedService interface
|
| RoutedServices |
Routed services are service that follow a predefined paths (route) on a service network layer that are offered as a service of some sort, i.e., it either follows a schedule or a
frequency.
|
| RoutedServicesLayer |
Interface to reflect a routed services layer which in turn is to be managed by a container class that implements the RoutedServicesLayers interface.
|
| RoutedServicesLayerFactory |
Factory for creating routed services layer instances (on container)
|
| RoutedServicesLayerImpl |
Implementation of the RoutedServicesLayer interface
|
| RoutedServicesLayers |
Interface for wrapper container class around RoutedServiceLayer instances.
|
| RoutedServicesLayersImpl |
Implementation of the RoutedServicesLayers interface.
|
| RoutedServicesReader |
Interface to read a PLANit RoutedServices instance
|
| RoutedServiceTripInfo |
Interface to reflect one or more similar routed service trips by providing information on their route legs and schedule/frequencies.
|
| RoutedServiceTripInfoImpl |
Implementation of a RoutedServiceTripInfo interface
|
| RoutedTrip |
Base interface for routed trips.
|
| RoutedTripDeparture |
A representation of a departure within a routed trip
|
| RoutedTripDepartureFactory |
Factory for creating routed trip departure instances (on container)
|
| RoutedTripDepartures |
A container class for departures registered on a schedule based routed trip
|
| RoutedTripDeparturesImpl |
Class that manages all routed trip departures
|
| RoutedTripFactory<T extends RoutedTrip> |
Factory for creating routed trips of type T
|
| RoutedTripFrequency |
Interface for frequency based trips of a RoutedService.
|
| RoutedTripFrequencyFactory |
Factory for creating routed trips that are frequency based
|
| RoutedTripFrequencyImpl |
Implementation of a RoutedTripFrequency interface.
|
| RoutedTripImpl |
Implementation of a RoutedTrip interface.
|
| RoutedTrips<T extends RoutedTrip> |
Base class for routed trips container for some derived type of RoutedTrip (either schedule or frequency based for example).
|
| RoutedTripSchedule |
The schedule with on or more departures for a routed service as well as the relative timings of each leg for each departure.
|
| RoutedTripScheduleFactory |
Factory for creating routed trips that are schedule based
|
| RoutedTripScheduleImpl |
Implementation of a RoutedTripSchedule interface.
|
| RoutedTripsFrequency |
Interface for wrapper container class around RoutedTrip instances that define a frequency based schedule.
|
| RoutedTripsFrequencyImpl |
Implementation of the RoutedTripsFrequency interface.
|
| RoutedTripsImpl<T extends RoutedTrip> |
Base class for toued trips of some derived type (either schedule or frequency based for example).
|
| RoutedTripsSchedule |
Interface for wrapper container class around RoutedTrip instances that define an explicit schedule.
|
| RoutedTripsScheduleImpl |
Implementation of the RoutedTripsSchedule interface.
|
| RunIdOutputProperty |
|
| SendingFlowData |
POJO to store the sLTM variables used for sending flow updates (Step 2) in network loading
|
| ServiceLeg |
Service leg interface which extends the Edge interface.
|
| ServiceLegFactory |
Factory interface for creating service leg instances
|
| ServiceLegFactoryImpl |
Factory for creating service legs on service leg container
|
| ServiceLegImpl |
A service leg connects two service nodes.
|
| ServiceLegs |
Container around service legs with factory access
|
| ServiceLegSegment |
Interface for directed ServiceLegSegment part of non-directional ServiceLeg.
|
| ServiceLegSegmentFactory |
Factory interface for creating service leg segment instances
|
| ServiceLegSegmentFactoryImpl |
Factory for creating service leg segments on service leg segment container
|
| ServiceLegSegmentImpl |
A service leg segment implementation.
|
| ServiceLegSegments |
Container for service leg segments
|
| ServiceLegSegmentsImpl |
Implementation of ServiceLegSegments container.
|
| ServiceLegsImpl |
Container class for managing service legs within a service network
|
| ServiceNetwork |
A service network is a network built on top of a topological (physical) transport network providing services leveraging this underlying network.
|
| ServiceNetworkLayer |
Service network layer consisting of service nodes, legs and leg segments on top of a parent network layer with physical entities.
|
| ServiceNetworkLayerFactory |
Factory interface for creating service network layers
|
| ServiceNetworkLayerFactoryImpl |
Factory for creating service network layer instances
|
| ServiceNetworkLayerImpl |
A service network layer is built on top of a physical network (layer).
|
| ServiceNetworkLayers |
interface to manage service network layers, i.e., layers that contain service networks on top of other network layers
|
| ServiceNetworkLayersImpl |
Implementation of container and factory to manage service network layers.
|
| ServiceNetworkReader |
Interface to read a PLANit service network
|
| ServiceNode |
Service node is a vertex but not all vertices are service nodes.
|
| ServiceNodeFactory |
Factory interface for creating service node instances
|
| ServiceNodeFactoryImpl |
Factory for creating nodes on nodes container
|
| ServiceNodeImpl |
A ServiceNode is used in a ServiceNetwork where it holds a reference to a DirectedNode of the ServiceNetworkLayer's underlying physical network layer.
|
| ServiceNodes |
Service node container and factory
|
| ServiceNodesImpl |
ServiceNodes implementation.
|
| ShortestPathResult |
Interfaces that defines how to access results of a shortest path execution allowing one to extract paths or cost information
|
| ShortestPathResultImpl |
Class that stores the result of a shortest path execution allowing one to extract paths or cost information
Note that we must traverse a path from an origin to a destination in reversed order to extract the path
|
| SimpleUnit |
Simple unit that comprises a single unit
|
| SimulationData |
General simulation data that only are available during simulation
|
| Smoothing |
Smoothing class to smooth data, such as path flows or other types of flows or traffic data between iterations
|
| SmoothingConfigurator<T extends Smoothing> |
Base class for all smoothing configurator implementations
|
| SmoothingConfiguratorFactory |
factory for the smoothing configurator types supported directory by PLANit
|
| SpeedConnectoidTravelTimeCost |
Class to calculate the connectoid travel time using connectoid speed
|
| SpeedUnits |
|
| SpeedVirtualCostConfigurator |
Configurator for SpeedConnectoidTravelTimeCost implementation
|
| SplittingRateData |
Interface for the different implementations that track splitting rates during sLTM network loading.
|
| SplittingRateDataComplete |
Store the splitting rates used during sLTM loading updates (Step 1 and 5).
|
| SplittingRateDataPartial |
Store the splitting rates used during sLTM loading updates (Step 1 and 5).
|
| SrsUnit |
Unit class for all spatial reference system related units
|
| StackWalkerUtil |
Utils class warpping the Stackwalker API functionality in easy to use method calls.
|
| StaticLtm |
Static Link Transmission Model implementation (sLTM) for network loading based on solution method presented in Raadsen and Bliemer (2021) General solution scheme for the Static
Link Transmission Model .
|
| StaticLtmAssignmentStrategy |
Base class for dealing with different assignment solution methods within sLTM.
|
| StaticLtmBushStrategy |
Implementation to support a bush absed solution for sLTM
|
| StaticLtmConfigurator |
Configurator for sLTM.
|
| StaticLtmLinkOutputTypeAdapter |
Adapter providing access to the data of the StaticLtm class relevant for link outputs without exposing the internals of the traffic assignment class itself
|
| StaticLtmLoadingBush |
The bush based network loading scheme for sLTM
|
| StaticLtmLoadingPath |
The path based network loading scheme for sLTM
|
| StaticLtmLoadingScheme |
Defines the different types of solution scheme variations that exist and can be applied (progressively) during an sLTM network loading approach
|
| StaticLtmNetworkLoading |
Class exposing the various sLTM network loading solution method components of sLTM (not considering path choice, this is assumed to be given).
|
| StaticLtmNetworkLoadingConvergenceAnalyser |
Analyser that based on various inputs such as the iteration and previous gaps determines if the loading is converging or not using its configurable criteria
|
| StaticLtmPathStrategy |
Implementation to deal with a path based sLTM implementation
|
| StaticLtmSettings |
POJO Settings regarding the execution of the StaticLTM network loading instance it is used on
|
| StaticLtmSimulationData |
Class to hold variables specific to running an sLTM assignment
|
| StaticLtmTrafficAssignmentBuilder |
The sLTM traffic assignment builder.
|
| StaticTrafficAssignment |
A static traffic assignment class with some commonalities implemented shared across static assignment implementations
|
| SteadyStateTravelTimeConfigurator |
Configurator for SteadyStateTravelTimeCost implementation
|
| SteadyStateTravelTimeCost |
Cost computation for travel times based on the work of Raadsen and Bliemer (2019), Steady-state link travel time methods: Formulation, derivation, classification, and
unification.
|
| StochasticPathChoice |
Stochastic path choice component.
|
| StochasticPathChoiceBuilder |
All path choice instances are built using this or a derived version of this builder
|
| StochasticPathChoiceConfigurator |
Configurator for FixedConnectoidTravelTimeCost implementation
|
| StopCriterion |
StopCriterion class.
|
| StopCriterionConfigurator |
Base class for all stop criterion configurator implementations
|
| StringUtils |
Some simple string utilities
|
| SubOutputTypeEnum |
Marker interface to indicate enums that are of a subtype of OutputType
|
| SubwayMode |
the predefined subway mode
name: subway
maxspeed (km/h): 60
pcu: 6
vehicular type: VEHICULAR
motorisation: MOTORISED
track: RAIL
use: PUBLIC
|
| SyncXmlIdToIdBreakEdgeHandler |
Whenever edges are broken, these edges' XML ids remain the same and are no longer unique.
|
| SyncXmlIdToIdBreakEdgeSegmentHandler |
Whenever edge segments are broken, their edge segments' xml ids remain the same and are no longer unique.
|
| TampereNodeModel |
General First order node model implementation as proposed by Tampere et al.
|
| TampereNodeModelComponent |
Tampere node model traffic component signalling that the Tampere node model algorithm is to be used
|
| TampereNodeModelConfigurator |
Configurator for FixedConnectoidTravelTimeCost implementation
|
| TampereNodeModelFixedInput |
Inner class that holds the mapping of the inputs to/from the underlying physical network (if any).
|
| TampereNodeModelInput |
Inner class that allows the user to set all inputs for the TampereNodeModel, it takes fixed inputs and supplements it with the information of the variable inputs, meaning inputs
that can vary during the simulation such as turn sending flows (t_ab), and potentially receiving flows (r_b)
|
| TestOutputDto<A,B,C> |
Data Transfer Object used to store results in unit testing for PlanItIO
|
| TimePeriod |
Represents a time period within the day.
|
| TimePeriodExternalIdOutputProperty |
|
| TimePeriodIdOutputProperty |
|
| TimePeriodImpl |
Represents a time period within the day.
|
| TimePeriodUtils |
some utilities for the TimePeriod interface
|
| TimePeriodXmlIdOutputProperty |
|
| TimeUnit |
Unit class for all time related units.
|
| TimeUnits |
|
| TntpDemandsReader |
Demands reader component for TNTP data format
|
| TntpDemandsReaderSettings |
Settings for the TNTP demands reader
|
| TntpHeaderConstants |
Constants used in the header of TnTp files
|
| TntpInputBuilder |
Class which reads input from TNTP files
|
| TntpMain |
Main class for running TNTP models
|
| TntpNetworkReader |
Network reader component for TNTP data format
|
| TntpNetworkReaderSettings |
Settings for Tntp network reader
|
| TntpProject |
TNTP implementation of CustomPlanItProject
|
| TntpZoningReader |
Zoning reader component for TNTP data format
|
| TntpZoningReaderSettings |
Settings for the Tntp zoning reader
|
| TopologicalLayer |
An topological layer represents a layer suited for a number of modes that is topologically meaningful without enforcing the actual implemantation of
this topology.
|
| TopologicalLayerImpl |
An transport layer that is of a topological nature, i.e., it has node, links, etc.
|
| TopologicalLayerModifier |
Interface to define all layer wide modifications functionality to be exposed.
|
| TopologicalLayerNetwork<T extends TopologicalLayer,U extends TopologicalLayers<T>> |
A network with topological transport layers, meaning that apart from representing a physical reality the result is topologically meaningful, has nodes, links, and some
geographic notion via a coordinate reference system
|
| TopologicalLayers<T extends TopologicalLayer> |
interface to manage topological layers, i.e., layers that contain a topologically meaningful representation, without enforcing how this is implemented.
|
| TopologicalLayersImpl<T extends TopologicalLayer> |
implementation of the transport layers interface, without the createNew() method, but now with base layer class of TopologicalLayer
|
| TopologicalModifier |
Base modifier interface regarding topological changes to an underlying topological implementation, e.g.
|
| TrackModeType |
a mode utilises either the road or rail as means of propagation.
|
| TraditionalStaticAssignment |
Traditional static assignment traffic component.This is the class that conducts the actual assignment.
|
| TraditionalStaticAssignmentBuilder |
Builder for a traditional static assignment.
|
| TraditionalStaticAssignmentConfigurator |
Configurator for traditional static assignment.
|
| TraditionalStaticAssignmentLinkOutputTypeAdapter |
Adapter providing access to the data of the TraditionalStaticAssignment class relevant for link outputs without exposing the internals of the traffic assignment class itself
|
| TraditionalStaticAssignmentOdOutputTypeAdapter |
Adapter providing access to the data of the TraditionalStaticAssignment class relevant for origin-destination outputs without exposing the internals of the traffic assignment
class itself
|
| TraditionalStaticAssignmentSimulationData |
Simulation data which are specific to Traditional Static Assignment
|
| TraditionalStaticPathOutputTypeAdapter |
Adapter providing access to the data of the TraditionalStaticAssignment class relevant for OD path outputs without exposing the internals of the traffic assignment class itself
|
| TrafficAssignment |
Traffic assignment class which simultaneously is responsible for the loading hence it is also considered as a traffic assignment component of this type
|
| TrafficAssignmentBuilder<T extends TrafficAssignment> |
All traffic assignment instances require a network, demand, and (equilibrium) smoothing procedure, all of which should be registered via this generic builder.
|
| TrafficAssignmentBuilderFactory |
Traffic assignment builder factory for the assignment types supported directory by PLANit
|
| TrafficAssignmentComponentAccessee |
Accessee that can be accessed to obtain access to one or more traffic assignment components
|
| TrafficAssignmentComponentAccessor |
Implementing class requires access to one or more traffic assignment components.
|
| TrafficAssignmentConfigurator<T extends TrafficAssignment> |
Configurator class for traffic assignment.
|
| TrainMode |
the predefined train mode
name: train
maxspeed (km/h): 140
pcu: 10
vehicular type: VEHICULAR
motorisation: MOTORISED
track: RAIL
use: PUBLIC
|
| TramMode |
the predefined tram mode
name: tram
maxspeed (km/h): 40
pcu: 3
vehicular type: VEHICULAR
motorisation: MOTORISED
track: RAIL
use: PUBLIC
|
| TransferZone |
A zone where transfers between different network layers may occur.
|
| TransferZoneFactory |
Factory interface for directed connectoids
|
| TransferZoneFactoryImpl |
Factory for creating transfer zones (on container)
|
| TransferZoneGroup |
A group of transfer zones, can be used to represent for example train stations.
|
| TransferZoneGroupFactory |
A Factory for transfer zone groups to register on container
|
| TransferZoneGroupFactoryImpl |
Factory for creating transfer zone groups (on container)
|
| TransferZoneGroupHelper |
Class to provide functionality for parsing PLANit transfer zone groups from OSM entities
|
| TransferZoneGroupImpl |
A transfer zone group implementation.
|
| TransferZoneGroups |
A Container for transfer zone groups which also acts as a factory for creating new transfer zone groups
|
| TransferZoneGroupsImpl |
Container for transfer zone groups where each transfer zone group logically groups multiple transfer zones together.
|
| TransferZoneHelper |
Class to provide functionality for parsing transfer zones from OSM entities
|
| TransferZoneImpl |
A transfer zone
|
| TransferZones |
Container class for TransferZone instances
|
| TransferZonesImpl |
implementation of the Zones <T> interface for transfer zones
|
| TransferZoneType |
Types of transfer zones to more easily identify their purpose
|
| TransportLayer |
An infrastructure layer represents the infrastructure suited for a number of modes.
|
| TransportLayerImpl |
Implementation of TransportLayer interface with only barebones functionality to support ids and modes.
|
| TransportLayerNetwork<U extends TransportLayer,T extends TransportLayers<U>> |
A transport network with one or more layers.
|
| TransportLayers<T extends TransportLayer> |
interface to manage transport layers.
|
| TransportLayersImpl<T extends TransportLayer> |
Base implementation of the TransportLayer interface, without the createNew() method
|
| TransportModelNetwork |
Entire transport network that is being modeled including both the physical and virtual aspects of it as well as the zoning.
|
| TravelerType |
Traveler type is a placeholder for all different types of traveler characteristics that affect the user class in the path choice component of traffic assignment.
|
| TriConsumer<T,U,V> |
Function Interface which can process three input objects.
|
| TriFunction<R,S,T,U> |
Function Interface which can process three input objects and produce an output
Used in PlanItIO test cases.
|
| TriggerEvent |
A trigger event emanates from a link boundary (its source) with a particular cumulative value and time and potentially other information which should be constructed by
subclassing this class
|
| TriggerFlowEvent |
A trigger flow event represents a flow rate that is being triggered exogenously, typically by a node on either side of the link segment.
|
| TypeConversionUtil |
some utility functions for converting types easily
|
| UndirectedConnectoid |
An undirected connectoid is accessed through a referenced node where all incoming/outgoing
edges/edge segments potentially have access.
|
| UndirectedConnectoidFactory |
Factory interface for undirected connectoids
|
| UndirectedConnectoidFactoryImpl |
Factory for creating new undirected connectoids on container
|
| UndirectedConnectoidImpl |
Undirected connectoid connecting one or more (transfer/OD) zone(s) to the physical road network, each connection will yield a connectoid edge and two connectoid segments when
constructing the transport network internally based on the referenced node
|
| UndirectedConnectoids |
container and factory class for undirected connectoids
|
| UndirectedConnectoidsImpl |
Implementation of Connectoids class
|
| Unit |
Lightweight Unit interface to define units and allow for conversions between them
|
| UnitGroup |
|
| UnitType |
|
| UntypedDirectedGraph<V extends DirectedVertex,E extends DirectedEdge,ES extends EdgeSegment> |
Interface for a directed graph
|
| UntypedDirectedGraphImpl<V extends DirectedVertex,E extends DirectedEdge,ES extends EdgeSegment> |
A directed graph implementation consisting of directed vertices and directed edges
|
| UntypedDirectedGraphLayer<V extends DirectedVertex,E extends DirectedEdge,S extends EdgeSegment> |
Network layer comprising of containers with custom entity types.
|
| UntypedDirectedGraphLayerModifier<V extends DirectedVertex,E extends DirectedEdge,S extends EdgeSegment> |
|
| UntypedDirectedGraphLayers<L extends UntypedDirectedGraphLayer<?,?,?>> |
Interface to manage physical network layers, i.e., layers that contain a topologically meaningful representation in the form of nodes and links
|
| UntypedGraph<V extends Vertex,E extends Edge> |
A graph interface consisting of vertices and edges without specifying a concrete container type
to access them.
|
| UntypedGraphImpl<V extends Vertex,E extends Edge> |
A graph implementation consisting of vertices and edges
|
| UntypedLinkOutputTypeAdapter<T extends LinkSegment> |
Interface defining the methods required for a link output adapter
|
| UntypedLinkOutputTypeAdapterImpl<LS extends LinkSegment> |
Top-level abstract class which defines the common methods required by Link output type adapters
|
| UntypedNetworkLayerImpl<V extends DirectedVertex,E extends DirectedEdge,S extends EdgeSegment> |
Model free network layer consisting of containers for vertices, edges, and edge segments each of which can be typed separately.
|
| UntypedNetworkLayerModifierImpl<V extends DirectedVertex,E extends DirectedEdge,S extends EdgeSegment> |
Modifier class for model free network layer, generics used to allow derived classes to provide typed versions for containers and content of containers.
|
| UntypedPhysicalLayer<N extends Node,L extends Link,LS extends LinkSegment> |
Physical topological Network consisting of nodes, links and link segments
|
| UntypedPhysicalLayerImpl<N extends Node,L extends Link,LS extends LinkSegment> |
Model free Network consisting of managed nodes, links, and link segments, each of which can be iterated over.
|
| UntypedPhysicalNetwork<L extends UntypedPhysicalLayer<?,?,?>,LS extends UntypedPhysicalNetworkLayers<L>> |
A network that comprises physical topological transport network elements, i.e., roads, rail, etc.
|
| UntypedPhysicalNetworkLayers<L extends UntypedPhysicalLayer<?,?,?>> |
Interface to manage physical network layers, i.e., layers that contain a topologically meaningful representation in the form of nodes and links
|
| UntypedPhysicalNetworkLayersImpl<L extends UntypedPhysicalLayer<?,?,?>> |
Implementation of container and factory to manage physical network layers.
|
| UpdateConnectoidsOnVertexRemovalHandler |
A listener designed to deal with the situation that sub graphs are removed from the network which leaves connectoids in the zoning that reference these sub graph elements
invalid.
|
| UpdateDirectedConnectoidsOnBreakLinkSegmentHandler |
Whenever links are broken and these link are references by connectoids, it is possible we must update the access vertex/link segment of this connectoid.
|
| UpdateEntryLinksOutflowConsumer |
A functional class that consumes the result of a node model update in order to determine the next accepted outflows of incoming links of all nodes it is applied to
|
| UpdateExitLinkInflowsConsumer |
A functional class that consumes the result of a node model update in order to update the inflows of all the outgoing links of the nodes it is applied to *
|
| UpstreamNodeExternalIdOutputProperty |
|
| UpstreamNodeIdOutputProperty |
|
| UpstreamNodeLocationOutputProperty |
|
| UpstreamNodeXmlIdOutputProperty |
|
| UriUtils |
Uitilities to modify and deal with URIs
|
| UrlUtils |
Utilities to deal with Java URL instances
|
| UsabilityModeFeatures |
Class to highlight the use of a particular mode, i.e., is it a public or private mode, ride-share, etc.
|
| UsabilityModeFeaturesImpl |
Class to highlight the use of a particular mode, i.e., is it a public or private mode, ride-share, etc.
|
| UseOfModeType |
Indicates how a mode is used; part of usability features
|
| UserClass |
A user class defines a combination of one or more characteristics of users in an aggregate representation of traffic which partially dictate how they behave in traffic
assignment.
|
| VcRatioOutputProperty |
Calculate V/C ratio output property class
|
| VehiclesUnit |
Unit class for all vehicles related units.
|
| VehicularModeType |
A mode is either vehicular oriented or notmodeType; part of physical features
|
| Vertex |
Vertex representation connected to one or more edges and/or edge segments
|
| VertexFactory |
Factory interface for creating vertex instances
|
| VertexFactoryImpl |
Factory for creating vertices on vertices container
|
| VertexImpl |
Vertex representation connected to one or more entry and exit edges
|
| Vertices |
Container class for vertices and creating instances within this container via factory.
|
| VerticesImpl |
Vertices implementation container and factory access
|
| VirtualCost |
Interface to classify costs of virtual links
|
| VirtualCostConfigurator<T extends AbstractVirtualCost> |
Base class for all virtual cost configurator implementations
|
| VirtualCostConfiguratorFactory |
factory for the virtual cost types supported directory by PLANit
|
| VirtualNetwork |
Model free virtual network which is part of the zoning and holds all the virtual infrastructure connecting the zones to the physical road network.
|
| XmlMacroscopicNetworkLayerHelper |
Process the Infrastructure object populated with data from the XML file
|
| XmlTextFileOutputFormatter |
This interfaces defines behaviours which output formatters which generate an XML output file must
have.
|
| ZipUtils |
Utilities for accessing content in zip files
|
| Zone |
Zone represent a geographical area with a centroid which in turn represent the
single point of departure of all traffic in the zone
|
| ZoneFactoryImpl<Z extends Zone> |
Factory for creating od zones (on container)
|
| ZoneImpl |
Represents a zone base class.
|
| Zones<Z extends Zone> |
Interface to manage zones
|
| ZonesImpl<Z extends Zone> |
Partial implementation of the Zones <T> interface
|
| Zoning |
Zoning class which holds a particular zoning
|
| ZoningConverter |
Zoning converter class able to convert a zoning network from one source to another
|
| ZoningConverterFactory |
Factory class for creating zoning converters
|
| ZoningModificationEvent |
Interface for the group of events that are used around zoning modification
|
| ZoningModifier |
zoning modifier takes care of modifications that comprise multiple components across the zoning in an integrated fashion
|
| ZoningModifierEventProducer |
Interface dedicated to the ZoningModifier event related exposed methods.
|
| ZoningModifierEventType |
zoning modifier event type class.
|
| ZoningModifierImpl |
Implementation of the zoningModifier interface
|
| ZoningModifierListener |
To serve as base listener class for all zoning modification events, where its onX method provides any
zoning modification event as parameter
|
| ZoningReader |
interface to read a PLANit zoning
|
| ZoningWriter |
Interface to write a PLANit zoning to disk
|