OTSRoadNetwork.java

  1. package org.opentrafficsim.road.network;

  2. import java.util.LinkedHashMap;
  3. import java.util.Map;

  4. import org.djutils.exceptions.Throw;
  5. import org.djutils.immutablecollections.Immutable;
  6. import org.djutils.immutablecollections.ImmutableHashMap;
  7. import org.djutils.immutablecollections.ImmutableMap;
  8. import org.opentrafficsim.core.compatibility.GTUCompatibility;
  9. import org.opentrafficsim.core.dsol.OTSSimulatorInterface;
  10. import org.opentrafficsim.core.gtu.GTUType;
  11. import org.opentrafficsim.core.network.LongitudinalDirectionality;
  12. import org.opentrafficsim.core.network.OTSNetwork;
  13. import org.opentrafficsim.road.gtu.lane.tactical.routesystem.RouteSystem;
  14. import org.opentrafficsim.road.network.lane.LaneType;

  15. /**
  16.  * OTSRoadNetwork adds a number of methods to the Network class that are specific for roads, such as the LaneTypes. <br>
  17.  * <br>
  18.  * Copyright (c) 2003-2022 Delft University of Technology, Jaffalaan 5, 2628 BX Delft, the Netherlands. All rights reserved. See
  19.  * for project information <a href="https://www.simulation.tudelft.nl/" target="_blank">www.simulation.tudelft.nl</a>. The
  20.  * source code and binary code of this software is proprietary information of Delft University of Technology.
  21.  * @author <a href="https://www.tudelft.nl/averbraeck" target="_blank">Alexander Verbraeck</a>
  22.  */
  23. public class OTSRoadNetwork extends OTSNetwork implements RoadNetwork
  24. {
  25.     /** */
  26.     private static final long serialVersionUID = 1L;

  27.     /** LaneTypes registered for this network. */
  28.     private Map<String, LaneType> laneTypeMap = new LinkedHashMap<>();
  29.    
  30.     /** Route system. */
  31.     private RouteSystem routeSystem;

  32.     /**
  33.      * Construction of an empty network.
  34.      * @param id String; the network id.
  35.      * @param addDefaultTypes add the default GTUTypes, LinkTypesand LaneTypes, or not
  36.      * @param simulator OTSSimulatorInterface; the DSOL simulator engine
  37.      */
  38.     public OTSRoadNetwork(final String id, final boolean addDefaultTypes, final OTSSimulatorInterface simulator)
  39.     {
  40.         super(id, addDefaultTypes, simulator);
  41.         if (addDefaultTypes)
  42.         {
  43.             addDefaultLaneTypes();
  44.         }
  45.         // TODO: not null once the route system works
  46.         this.routeSystem = null; //new DefaultRouteSystem();
  47.     }

  48.     /** {@inheritDoc} */
  49.     @Override
  50.     public void addDefaultLaneTypes()
  51.     {
  52.         GTUCompatibility<LaneType> noTrafficCompatibility = new GTUCompatibility<>((LaneType) null);
  53.         new LaneType("NONE", noTrafficCompatibility, this);
  54.         GTUCompatibility<LaneType> roadCompatibility = new GTUCompatibility<>((LaneType) null);
  55.         roadCompatibility.addAllowedGTUType(getGtuType(GTUType.DEFAULTS.ROAD_USER), LongitudinalDirectionality.DIR_BOTH);
  56.         LaneType twoWayLane = new LaneType("TWO_WAY_LANE", roadCompatibility, this);
  57.         new LaneType("RURAL_ROAD", twoWayLane, new GTUCompatibility<>(roadCompatibility), this);
  58.         new LaneType("URBAN_ROAD", twoWayLane, new GTUCompatibility<>(roadCompatibility), this);
  59.         new LaneType("RESIDENTIAL_ROAD", twoWayLane, new GTUCompatibility<>(roadCompatibility), this);
  60.         GTUCompatibility<LaneType> oneWayLaneCompatibility = new GTUCompatibility<>(roadCompatibility);
  61.         oneWayLaneCompatibility.addAllowedGTUType(getGtuType(GTUType.DEFAULTS.ROAD_USER), LongitudinalDirectionality.DIR_PLUS);
  62.         oneWayLaneCompatibility.addAllowedGTUType(getGtuType(GTUType.DEFAULTS.PEDESTRIAN), LongitudinalDirectionality.DIR_BOTH);
  63.         new LaneType("ONE_WAY_LANE", oneWayLaneCompatibility, this);
  64.         GTUCompatibility<LaneType> highwayLaneCompatibility = new GTUCompatibility<>(oneWayLaneCompatibility)
  65.                 .addAllowedGTUType(getGtuType(GTUType.DEFAULTS.PEDESTRIAN), LongitudinalDirectionality.DIR_NONE);
  66.         new LaneType("FREEWAY", highwayLaneCompatibility, this);
  67.         new LaneType("HIGHWAY", highwayLaneCompatibility, this);
  68.         GTUCompatibility<LaneType> busLaneCompatibility = new GTUCompatibility<>(roadCompatibility);
  69.         busLaneCompatibility.addAllowedGTUType(getGtuType(GTUType.DEFAULTS.BUS), LongitudinalDirectionality.DIR_BOTH);
  70.         busLaneCompatibility.addAllowedGTUType(getGtuType(GTUType.DEFAULTS.ROAD_USER), LongitudinalDirectionality.DIR_NONE);
  71.         new LaneType("BUS_LANE", busLaneCompatibility, this);
  72.         GTUCompatibility<LaneType> mopedAndBicycleLaneCompatibility = new GTUCompatibility<>(roadCompatibility);
  73.         mopedAndBicycleLaneCompatibility.addAllowedGTUType(getGtuType(GTUType.DEFAULTS.BICYCLE),
  74.                 LongitudinalDirectionality.DIR_BOTH);
  75.         mopedAndBicycleLaneCompatibility.addAllowedGTUType(getGtuType(GTUType.DEFAULTS.ROAD_USER),
  76.                 LongitudinalDirectionality.DIR_NONE);
  77.         new LaneType("MOPED_PATH", mopedAndBicycleLaneCompatibility, this);
  78.         GTUCompatibility<LaneType> bicycleOnlyCompatibility = new GTUCompatibility<>(mopedAndBicycleLaneCompatibility);
  79.         bicycleOnlyCompatibility.addAllowedGTUType(getGtuType(GTUType.DEFAULTS.MOPED), LongitudinalDirectionality.DIR_NONE);
  80.         new LaneType("BICYCLE_PATH", bicycleOnlyCompatibility, this);
  81.         GTUCompatibility<LaneType> pedestriansOnly = new GTUCompatibility<>(roadCompatibility);
  82.         pedestriansOnly.addAllowedGTUType(getGtuType(GTUType.DEFAULTS.ROAD_USER), LongitudinalDirectionality.DIR_NONE);
  83.         new LaneType("FOOTPATH", pedestriansOnly, this);
  84.     }

  85.     /** {@inheritDoc} */
  86.     @Override
  87.     public void addLaneType(final LaneType laneType)
  88.     {
  89.         this.laneTypeMap.put(laneType.getId(), laneType);
  90.     }

  91.     /** {@inheritDoc} */
  92.     @Override
  93.     public LaneType getLaneType(final String laneTypeId)
  94.     {
  95.         return this.laneTypeMap.get(laneTypeId);
  96.     }

  97.     /** {@inheritDoc} */
  98.     @Override
  99.     public LaneType getLaneType(final LaneType.DEFAULTS laneTypeEnum)
  100.     {
  101.         return this.laneTypeMap.get(laneTypeEnum.getId());
  102.     }

  103.     /** {@inheritDoc} */
  104.     @Override
  105.     public ImmutableMap<String, LaneType> getLaneTypes()
  106.     {
  107.         return new ImmutableHashMap<>(this.laneTypeMap, Immutable.WRAP);
  108.     }
  109.    
  110.     /**
  111.      * Sets the route system.
  112.      * @param routeSystem RouteSystem; route system
  113.      */
  114.     public void setRouteSystem(final RouteSystem routeSystem)
  115.     {
  116.         Throw.whenNull(routeSystem, "Route system may not be null.");
  117.         this.routeSystem = routeSystem;
  118.     }
  119.    
  120.     /**
  121.      * Returns the route system.
  122.      * @return RouteSystem; route system
  123.      */
  124.     public RouteSystem getRouteSystem()
  125.     {
  126.         return this.routeSystem;
  127.     }

  128. }