aequilibrae.project.network package#
Subpackages#
- aequilibrae.project.network.osm package
Submodules#
aequilibrae.project.network.connector_creation module#
aequilibrae.project.network.gmns_builder module#
- class aequilibrae.project.network.gmns_builder.GMNSBuilder(net, link_path: str, node_path: str, uses_path: str | None = None, geom_path: str | None = None, srid: int = 4326)[source]#
Bases:
WorkerThread
aequilibrae.project.network.gmns_exporter module#
- class aequilibrae.project.network.gmns_exporter.GMNSExporter(net, path)[source]#
Bases:
WorkerThread
aequilibrae.project.network.haversine module#
aequilibrae.project.network.link module#
- class aequilibrae.project.network.link.Link(dataset, project)[source]#
Bases:
SafeClass
A Link object represents a single record in the links table
>>> from aequilibrae import Project >>> proj = Project.from_path("/tmp/test_project") >>> all_links = proj.network.links # Let's get a mode to work with >>> modes = proj.network.modes >>> car_mode = modes.get('c') # We can just get one link in specific >>> link1 = all_links.get(3) >>> link2 = all_links.get(17) # We can find out which fields exist for the links >>> which_fields_do_we_have = link1.data_fields() # And edit each one like this >>> link1.lanes_ab = 3 >>> link1.lanes_ba = 2 # we can drop a mode from the link >>> link1.drop_mode(car_mode) # or link1.drop_mode('c') # we can add a mode to the link >>> link2.add_mode(car_mode) # or link2.add_mode('c') # Or set all modes at once >>> link2.set_modes('cbtw') # We can just save the link >>> link1.save() >>> link2.save()
- set_modes(modes: str)[source]#
Sets the modes acceptable for this link
- Arguments:
modes (
str
): string with all mode_ids to be assigned to this link
- add_mode(mode: str | Mode)[source]#
Adds a new mode to this link
Raises a warning if mode is already allowed on the link, and fails if mode does not exist
- Arguments:
mode_id (
str
or Mode): Mode_id of the mode or mode object to be added to the link
aequilibrae.project.network.link_type module#
aequilibrae.project.network.link_types module#
- class aequilibrae.project.network.link_types.LinkTypes(net)[source]#
Bases:
object
Access to the API resources to manipulate the link_types table in the network.
>>> from aequilibrae import Project >>> p = Project.from_path("/tmp/test_project") >>> link_types = p.network.link_types # We can get a dictionary of link types in the model >>> all_link_types = link_types.all_types() # And do a bulk change and save it >>> for link_type_id, link_type_obj in all_link_types.items(): ... link_type_obj.beta = 1 # We can save changes for all link types in one go >>> link_types.save() # or just get one link_type in specific >>> default_link_type = link_types.get('y') # or just get it by name >>> default_link_type = link_types.get_by_name('default') # We can change the description of the link types >>> default_link_type.description = 'My own new description' # Let's say we are using alpha to store lane capacity during the night as 90% of the standard >>> default_link_type.alpha = 0.9 * default_link_type.lane_capacity # To save this link types we can simply >>> default_link_type.save() # We can also create a completely new link_type and add to the model >>> new_type = link_types.new('a') >>> new_type.link_type = 'Arterial' # Only ASCII letters and *_* allowed # other fields are not mandatory # We then save it to the database >>> new_type.save() # we can even keep editing and save it directly once we have added it to the project >>> new_type.lanes = 3 >>> new_type.lane_capacity = 1100 >>> new_type.save()
- get_by_name(link_type: str) LinkType [source]#
Get a link_type from the network by its link_type (i.e. name)
- fields() FieldEditor [source]#
Returns a FieldEditor class instance to edit the Link_Types table fields and their metadata
aequilibrae.project.network.links module#
- class aequilibrae.project.network.links.Links(net)[source]#
Bases:
BasicTable
Access to the API resources to manipulate the links table in the network
>>> from aequilibrae import Project >>> proj = Project.from_path("/tmp/test_project") >>> all_links = proj.network.links # We can just get one link in specific >>> link = all_links.get(1) # We can save changes for all links we have edited so far >>> all_links.save()
- sql = ''#
Query sql for retrieving links
- get(link_id: int) Link [source]#
Get a link from the network by its link_id
It raises an error if link_id does not exist
- Arguments:
link_id (
int
): Id of a link to retrieve- Returns:
link (
Link
): Link object for requested link_id
- new() Link [source]#
Creates a new link
- Returns:
link (
Link
): A new link object populated only with link_id (not saved in the model yet)
- copy_link(link_id: int) Link [source]#
Creates a copy of a link with a new id
It raises an error if link_id does not exist
- Arguments:
link_id (
int
): Id of the link to copy- Returns:
link (
Link
): Link object for requested link_id
- delete(link_id: int) None [source]#
Removes the link with link_id from the project
- Arguments:
link_id (
int
): Id of a link to delete
- refresh_fields() None [source]#
After adding a field one needs to refresh all the fields recognized by the software
- property data: DataFrame#
Returns all links data as a Pandas dataFrame
- Returns:
table (
DataFrame
): Pandas dataframe with all the links, complete with Geometry
aequilibrae.project.network.mode module#
aequilibrae.project.network.modes module#
- class aequilibrae.project.network.modes.Modes(net)[source]#
Bases:
object
Access to the API resources to manipulate the modes table in the network
>>> from aequilibrae import Project >>> p = Project.from_path("/tmp/test_project") >>> modes = p.network.modes # We can get a dictionary of all modes in the model >>> all_modes = modes.all_modes() # And do a bulk change and save it >>> for mode_id, mode_obj in all_modes.items(): ... mode_obj.beta = 1 ... mode_obj.save() # or just get one mode in specific >>> car_mode = modes.get('c') # or just get this same mode by name >>> car_mode = modes.get_by_name('car') # We can change the description of the mode >>> car_mode.description = 'personal autos only' # Let's say we are using alpha to store the PCE for a future year with much smaller cars >>> car_mode.alpha = 0.95 # To save this mode we can simply >>> car_mode.save() # We can also create a completely new mode and add to the model >>> new_mode = modes.new('k') >>> new_mode.mode_name = 'flying_car' # Only ASCII letters and *_* allowed # other fields are not mandatory # We then explicitly add it to the network >>> modes.add(new_mode) # we can even keep editing and save it directly once we have added it to the project >>> new_mode.description = 'this is my new description' >>> new_mode.save()
- property fields: FieldEditor#
Returns a FieldEditor class instance to edit the Modes table fields and their metadata
aequilibrae.project.network.network module#
- class aequilibrae.project.network.network.Network(project)[source]#
Bases:
WorkerThread
Network class. Member of an AequilibraE Project
- netsignal#
- req_link_flds = ['link_id', 'a_node', 'b_node', 'direction', 'distance', 'modes', 'link_type']#
- req_node_flds = ['node_id', 'is_centroid']#
- protected_fields = ['ogc_fid', 'geometry']#
- skimmable_fields()[source]#
Returns a list of all fields that can be skimmed
- Returns:
list
: List of all fields that can be skimmed
- list_modes()[source]#
Returns a list of all the modes in this model
- Returns:
list
: List of all modes
- create_from_osm(model_area: Polygon | None = None, place_name: str | None = None, modes=('car', 'transit', 'bicycle', 'walk'), clean=True) None [source]#
Downloads the network from Open-Street Maps
- Arguments:
area (
Polygon
, Optional): Polygon for which the network will be downloaded. If not provided, a place name would be requiredplace_name (
str
, Optional): If not downloading with East-West-North-South boundingbox, this is requiredmodes (
tuple
, Optional): List of all modes to be downloaded. Defaults to the modes in the parameter fileclean (
bool
, Optional): Keeps only the links that intersects the model area polygon. Defaults to True. Does not apply to networks downloaded with a place name
>>> from aequilibrae import Project >>> p = Project() >>> p.new("/tmp/new_project") # We now choose a different overpass endpoint (say a deployment in your local network) >>> par = Parameters() >>> par.parameters['osm']['overpass_endpoint'] = "http://192.168.1.234:5678/api" # Because we have our own server, we can set a bigger area for download (in M2) >>> par.parameters['osm']['max_query_area_size'] = 10000000000 # And have no pause between successive queries >>> par.parameters['osm']['sleeptime'] = 0 # Save the parameters to disk >>> par.write_back() # Now we can import the network for any place we want # p.network.create_from_osm(place_name="my_beautiful_hometown") >>> p.close()
- create_from_gmns(link_file_path: str, node_file_path: str, use_group_path: str | None = None, geometry_path: str | None = None, srid: int = 4326) None [source]#
Creates AequilibraE model from links and nodes in GMNS format.
- Arguments:
link_file_path (
str
): Path to a links csv file in GMNS formatnode_file_path (
str
): Path to a nodes csv file in GMNS formatuse_group_path (
str
, Optional): Path to a csv table containing groupings of uses. This helps AequilibraE know when a GMNS use is actually a group of other GMNS usesgeometry_path (
str
, Optional): Path to a csv file containing geometry information for a line object, if not specified in the link tablesrid (
int
, Optional): Spatial Reference ID in which the GMNS geometries were created
- export_to_gmns(path: str)[source]#
Exports AequilibraE network to csv files in GMNS format.
- Arguments:
path (
str
): Output folder path.
- build_graphs(fields: list | None = None, modes: list | None = None) None [source]#
Builds graphs for all modes currently available in the model
When called, it overwrites all graphs previously created and stored in the networks’ dictionary of graphs
- Arguments:
- fields (
list
, optional): When working with very large graphs with large number of fields in the database, it may be useful to specify which fields to use
- modes (
list
, optional): When working with very large graphs with large number of fields in the database, it may be useful to generate only those we need
- fields (
To use the fields parameter, a minimalistic option is the following
>>> from aequilibrae import Project >>> p = Project.from_path("/tmp/test_project") >>> fields = ['distance'] >>> p.network.build_graphs(fields, modes = ['c', 'w'])
- set_time_field(time_field: str) None [source]#
Set the time field for all graphs built in the model
- Arguments:
time_field (
str
): Network field with travel time information
- count_centroids() int [source]#
Returns the number of centroids in the model
- Returns:
int
: Number of centroids
aequilibrae.project.network.node module#
- class aequilibrae.project.network.node.Node(dataset, project)[source]#
Bases:
SafeClass
A Node object represents a single record in the nodes table
>>> from aequilibrae import Project >>> from shapely.geometry import Point >>> proj = Project.from_path("/tmp/test_project") >>> all_nodes = proj.network.nodes # We can just get one link in specific >>> node1 = all_nodes.get(7) # We can find out which fields exist for the links >>> which_fields_do_we_have = node1.data_fields() # It success if the node_id already does not exist >>> node1.renumber(998877) >>> node1.geometry = Point(1,2) # We can just save the node >>> node1.save()
- data_fields() list [source]#
lists all data fields for the node, as available in the database
- Returns:
data fields (
list
): list of all fields available for editing
- renumber(new_id: int)[source]#
Renumbers the node in the network
Logs a warning if another node already exists with this node_id
- Arguments:
new_id (
int
): New node_id
- connect_mode(area: Polygon, mode_id: str, link_types='', connectors=1, conn: Connection | None = None)[source]#
Adds centroid connectors for the desired mode to the network file
Centroid connectors are created by connecting the zone centroid to one or more nodes selected from all those that satisfy the mode and link_types criteria and are inside the provided area.
The selection of the nodes that will be connected is done simply by computing running the KMeans2 clustering algorithm from SciPy and selecting the nodes closest to each cluster centroid.
When there are no node candidates inside the provided area, is it progressively expanded until at least one candidate is found.
If fewer candidates than required connectors are found, all candidates are connected.
- Arguments:
area (
Polygon
): Initial area where AequilibraE will look for nodes to connectmode_id (
str
): Mode ID we are trying to connectlink_types (
str
, Optional): String with all the link type IDs that can be considered. eg: yCdR. Defaults to ALL link typesconnectors (
int
, Optional): Number of connectors to add. Defaults to 1
aequilibrae.project.network.nodes module#
- class aequilibrae.project.network.nodes.Nodes(net)[source]#
Bases:
BasicTable
Access to the API resources to manipulate the links table in the network
>>> from aequilibrae import Project >>> proj = Project.from_path("/tmp/test_project") >>> all_nodes = proj.network.nodes # We can just get one link in specific >>> node = all_nodes.get(21) # We can save changes for all nodes we have edited so far >>> all_nodes.save()
- sql = ''#
Query sql for retrieving nodes
- get(node_id: int) Node [source]#
Get a node from the network by its node_id
It raises an error if node_id does not exist
- Arguments:
node_id (
int
): Id of a node to retrieve- Returns:
node (
Node
): Node object for requested node_id
- refresh_fields() None [source]#
After adding a field one needs to refresh all the fields recognized by the software
- new_centroid(node_id: int) Node [source]#
Creates a new centroid with a given ID
- Arguments:
node_id (
int
): Id of the centroid to be created
- property data: DataFrame#
Returns all nodes data as a Pandas DataFrame
- Returns:
table (
DataFrame
): Pandas DataFrame with all the nodes, complete with Geometry
- property lonlat: DataFrame#
Returns all nodes lon/lat coords as a Pandas DataFrame
- Returns:
table (
DataFrame
): Pandas DataFrame with all the nodes, with geometry as lon/lat
aequilibrae.project.network.period module#
- class aequilibrae.project.network.period.Period(dataset, project)[source]#
Bases:
SafeClass
A Period object represents a single record in the periods table
>>> from aequilibrae import Project >>> proj = Project.from_path("/tmp/test_project") >>> all_periods = proj.network.periods # We can just get one link in specific >>> period1 = all_periods.get(1) # We can find out which fields exist for the period >>> which_fields_do_we_have = period1.data_fields() # It succeeds if the period_id already does not exist >>> period1.renumber(998877) # We can just save the period >>> period1.save()
aequilibrae.project.network.periods module#
- class aequilibrae.project.network.periods.Periods(net)[source]#
Bases:
BasicTable
Access to the API resources to manipulate the links table in the network
>>> from aequilibrae import Project >>> proj = Project.from_path("/tmp/test_project") >>> all_periods = proj.network.periods # We can just get one link in specific >>> period = all_periods.get(21) # We can save changes for all periods we have edited so far >>> all_periods.save()
- sql = ''#
Query sql for retrieving periods
- extent()[source]#
Queries the extent of the layer included in the model
- Returns:
Shapely polygon with the bounding box of the layer.
- Return type:
model extent (
Polygon
)
- get(period_id: int) Period [source]#
Get a period from the network by its period_id
It raises an error if period_id does not exist
- Arguments:
period_id (
int
): Id of a period to retrieve- Returns:
period (
Period
): Period object for requested period_id
- refresh_fields() None [source]#
After adding a field one needs to refresh all the fields recognized by the software
- new_period(period_id: int, start: int, end: int, description: str | None = None) Period [source]#
Creates a new period with a given ID
- Arguments:
period_id (
int
): Id of the centroid to be created start (int
): Start time of the period to be created end (int
): End time of the period to be created description (str
): Optional human readable description of the time period e.g. ‘1pm - 5pm’
- property data: DataFrame#
Returns all periods data as a Pandas DataFrame
- Returns:
table (
DataFrame
): Pandas DataFrame with all the periods