org.matsim.lanes.Lanes java code examples

Common ways to obtain Lanes

private void myMethod () {
 Lanes l =Scenario scenario;scenario.getLanes()
Smart code suggestions by Codota
}

public LanesReader(Scenario scenario) {
  this.lanes = scenario.getLanes();
  this.factory = lanes.getFactory();
}

public void checkConsistency() {
  log.info("checking consistency...");
  List<Id<Link>> linksWithMalformedLanes = new LinkedList<>();
  for (LanesToLinkAssignment l2l : this.lanes.getLanesToLinkAssignments().values()){
    if (!isLaneOnLinkConsistent(l2l)){
      linksWithMalformedLanes.add(l2l.getLinkId());
    }
  }        
  
  if (this.removeMalformed){
    for (Id<Link> linkId : linksWithMalformedLanes) {
      this.lanes.getLanesToLinkAssignments().remove(linkId);
      log.info("remove lanes on link " + linkId);
    }
  }
  log.info("checked consistency. Lanes on " + linksWithMalformedLanes.size() + " links have been removed.");
}

private void createLanes(Lanes lanes) {
  LanesFactory factory = lanes.getFactory();
  lanes.addLanesToLinkAssignment(lanesForLink12);
  lanes.addLanesToLinkAssignment(lanesForLink65);

/**
 * Replaces the method that converted a lane from format 11 to format 20.
 * Use this when you have not defined an original lane of the link and when you have not set lane capacities yet.
 */
public static void createOriginalLanesAndSetLaneCapacities(Network network, Lanes lanes){
  LanesFactory factory = lanes.getFactory();
  for (LanesToLinkAssignment l2l : lanes.getLanesToLinkAssignments().values()){
    Link link = network.getLinks().get(l2l.getLinkId());
    Lane olLane = factory.createLane(Id.create(l2l.getLinkId().toString() + ".ol", Lane.class));
    l2l.addLane(olLane);
    for (Lane lane : l2l.getLanes().values()) {
      olLane.addToLaneId(lane.getId());
      //set capacity of the lane depending on link capacity and number of representative lanes
      LanesUtils.calculateAndSetCapacity(lane, true, link, network);
    }
    olLane.setNumberOfRepresentedLanes(link.getNumberOfLanes());
    olLane.setStartsAtMeterFromLinkEnd(link.getLength());
  }
}

this.lanes.addLanesToLinkAssignment(l2lAssignment);

private void createLanes() {
  Lanes ld = scenario.getLanes();
  LanesFactory f = ld.getFactory();
  LanesToLinkAssignment l2l = f.createLanesToLinkAssignment(Id.create(12, Link.class));
  ld.addLanesToLinkAssignment(l2l);
  Lane l = f.createLane(Id.create(121, Lane.class));
  l.setStartsAtMeterFromLinkEnd(300);
  l.addToLaneId(Id.create(122, Lane.class));
  l2l.addLane(l);
  l = f.createLane(Id.create(122, Lane.class));
  l.setStartsAtMeterFromLinkEnd(150);
  l.addToLinkId(Id.create(25, Link.class));
  l2l.addLane(l);
}

private static void createOneLane(Scenario scenario, int numberOfRepresentedLanes) {
  scenario.getConfig().qsim().setUseLanes(true);
  Lanes lanes = scenario.getLanes();
  LanesFactory builder = lanes.getFactory();
  //lanes for link 1
  LanesToLinkAssignment lanesForLink1 = builder.createLanesToLinkAssignment(Id.create(1, Link.class));
  Lane link1FirstLane = builder.createLane(Id.create("1.ol", Lane.class));
  link1FirstLane.addToLaneId(Id.create(1, Lane.class));
  link1FirstLane.setNumberOfRepresentedLanes(2.0);
  link1FirstLane.setStartsAtMeterFromLinkEnd(1005.0);
  link1FirstLane.setCapacityVehiclesPerHour(1800.0);
  lanesForLink1.addLane(link1FirstLane);
  
  Lane link1lane1 = builder.createLane(Id.create(1, Lane.class));
  link1lane1.addToLinkId(Id.create(2, Link.class));
  link1lane1.setStartsAtMeterFromLinkEnd(105.0);
  link1lane1.setNumberOfRepresentedLanes(numberOfRepresentedLanes);
  link1lane1.setCapacityVehiclesPerHour(numberOfRepresentedLanes * 900.0);
  lanesForLink1.addLane(link1lane1);
  lanes.addLanesToLinkAssignment(lanesForLink1);
}

public void registerNumberOfCarsMonitoringOnLane(Id<Link> linkId, Id<Lane> laneId) {
  Link link = this.network.getLinks().get(linkId);
  if (link == null){
    throw new IllegalStateException("Link with Id " + linkId + " is not in the network, can't register sensor");
  }
  if (this.laneDefinitions == null || this.laneDefinitions.getLanesToLinkAssignments().get(linkId) == null ||
      this.laneDefinitions.getLanesToLinkAssignments().get(linkId).getLanes().get(laneId) == null) {
    throw new IllegalStateException("No data found for lane  " + laneId + " on link  " + linkId + " is not in the network, can't register sensor");
  }
  if (! this.linkIdLaneIdSensorMap.containsKey(linkId)){
    this.linkIdLaneIdSensorMap.put(linkId, new HashMap<>());
  }
  if (! this.linkIdLaneIdSensorMap.get(linkId).containsKey(laneId)){
    Lane lane = this.laneDefinitions.getLanesToLinkAssignments().get(linkId).getLanes().get(laneId);
    this.linkIdLaneIdSensorMap.get(linkId).put(laneId, new LaneSensor(link, lane));
  }
}

/**
 * create a lane on link 1 representing the given number of lanes.
 * the lanes capacity is 900 times the number of represented lanes.
 *  
 */
private static void createOneLane(Scenario scenario, int numberOfRepresentedLanes) {
  scenario.getConfig().qsim().setUseLanes(true);
  Lanes lanes = scenario.getLanes();
  LanesFactory builder = lanes.getFactory();
  //lanes for link 1
  LanesToLinkAssignment lanesForLink1 = builder.createLanesToLinkAssignment(Id.create(1, Link.class));
  Lane link1FirstLane = builder.createLane(Id.create("1.ol", Lane.class));
  link1FirstLane.addToLaneId(Id.create(1, Lane.class));
  link1FirstLane.setNumberOfRepresentedLanes(2.0);
  link1FirstLane.setStartsAtMeterFromLinkEnd(25000.0);
  link1FirstLane.setCapacityVehiclesPerHour(1800.0);
  lanesForLink1.addLane(link1FirstLane);
  
  Lane link1lane1 = builder.createLane(Id.create(1, Lane.class));
  link1lane1.addToLinkId(Id.createLinkId(2));
  link1lane1.setStartsAtMeterFromLinkEnd(10000.0);
  link1lane1.setNumberOfRepresentedLanes(numberOfRepresentedLanes);
  link1lane1.setCapacityVehiclesPerHour(numberOfRepresentedLanes * 900.0);
  lanesForLink1.addLane(link1lane1);
  lanes.addLanesToLinkAssignment(lanesForLink1);
}

public void registerNumberOfCarsOnLaneInDistanceMonitoring(Id<Link> linkId, Id<Lane> laneId, Double distanceMeter) {
  Link link = this.network.getLinks().get(linkId);
  if (link == null){
    throw new IllegalStateException("Link with Id " + linkId + " is not in the network, can't register sensor");
  }
  if (this.laneDefinitions == null || this.laneDefinitions.getLanesToLinkAssignments().get(linkId) == null ||
      this.laneDefinitions.getLanesToLinkAssignments().get(linkId).getLanes().get(laneId) == null) {
    throw new IllegalStateException("No data found for lane  " + laneId + " on link  " + linkId + " is not in the network, can't register sensor");
  }
  if (! this.linkIdLaneIdSensorMap.containsKey(linkId)){
    this.linkIdLaneIdSensorMap.put(linkId, new HashMap<>());
  }
  if (! this.linkIdLaneIdSensorMap.get(linkId).containsKey(laneId)){
    Lane lane = this.laneDefinitions.getLanesToLinkAssignments().get(linkId).getLanes().get(laneId);
    this.linkIdLaneIdSensorMap.get(linkId).put(laneId, new LaneSensor(link, lane));
  }
  this.linkIdLaneIdSensorMap.get(linkId).get(laneId).registerDistanceToMonitor(distanceMeter);
}

private static void createThreeLanes(Scenario scenario) {
  scenario.getConfig().qsim().setUseLanes(true);
  Lanes lanes = scenario.getLanes();
  LanesFactory builder = lanes.getFactory();
  lanesForLink1.addLane(link1lane3);
  lanes.addLanesToLinkAssignment(lanesForLink1);

public void registerAverageNumberOfCarsPerSecondMonitoringOnLane(Id<Link> linkId, Id<Lane> laneId, double lookBackTime, double timeBucketCollectionDuration) {
  Link link = this.network.getLinks().get(linkId);
  //check if link is in the network
  if (link == null){
    throw new IllegalStateException("Link with Id " + linkId + " is not in the network, can't register sensor");
  }
  //check if lane exists
  if (this.laneDefinitions == null || this.laneDefinitions.getLanesToLinkAssignments().get(linkId) == null ||
      this.laneDefinitions.getLanesToLinkAssignments().get(linkId).getLanes().get(laneId) == null) {
    throw new IllegalStateException("No data found for lane  " + laneId + " on link  " + linkId + " is not in the network, can't register sensor");
  }
  //check if the sensor-map already contains an entry for this link
  if (! this.linkIdLaneIdSensorMap.containsKey(linkId)){
    this.linkIdLaneIdSensorMap.put(linkId, new HashMap<>());
  }
  //check if the entry in sensor-map for this link has already a value for this lane
  if (! this.linkIdLaneIdSensorMap.get(linkId).containsKey(laneId)){
    Lane lane = this.laneDefinitions.getLanesToLinkAssignments().get(linkId).getLanes().get(laneId);
    this.linkIdLaneIdSensorMap.get(linkId).put(laneId, new LaneSensor(link, lane));
  }
  //register AvgVehPerSecond monitor for this lane
  linkIdLaneIdSensorMap.get(linkId).get(laneId).registerAverageVehiclesPerSecondToMonitor(lookBackTime, timeBucketCollectionDuration);
}

scenario.getConfig().qsim().setUseLanes(true);
Lanes lanes = scenario.getLanes();
LanesFactory builder = lanes.getFactory();
lanesForLink1.addLane(link1lane3);
lanes.addLanesToLinkAssignment(lanesForLink1);

private int getNumberOfExpectedVehiclesOnLane(double now, Id<Link> linkId, Id<Lane> laneId) {
  if (lanes.getLanesToLinkAssignments().get(linkId).getLanes().size() == 1) {
    return getNumberOfExpectedVehiclesOnLink(now, linkId);
  } else {
    return this.sensorManager.getNumberOfCarsInDistanceOnLane(linkId, laneId, 0., now);
  }
}

  public static void overwriteLaneCapacitiesByNetworkCapacities(Network net, Lanes lanes) {
    for (LanesToLinkAssignment linkLanes : lanes.getLanesToLinkAssignments().values()) {
      double linkCap = net.getLinks().get(linkLanes.getLinkId()).getCapacity();
      for (Lane lane : linkLanes.getLanes().values()) {
        lane.setCapacityVehiclesPerHour(linkCap);
      }
    }
  }
}

private Map<Id<Link>, List<TurnInfo>> createTurnInfos(Lanes laneDefs) {
  Map<Id<Link>, List<TurnInfo>> inLinkIdTurnInfoMap = new HashMap<>();
  Set<Id<Link>> toLinkIds = new HashSet<>();
  for (LanesToLinkAssignment l2l : laneDefs.getLanesToLinkAssignments().values()) {
    toLinkIds.clear();
    for (Lane lane : l2l.getLanes().values()) {
      if (lane.getToLinkIds() != null
          && (lane.getToLaneIds() == null || lane.getToLaneIds().isEmpty())) { // make sure that it is a lane at the end of a link
        toLinkIds.addAll(lane.getToLinkIds());
      }
    }
    if (!toLinkIds.isEmpty()) {
      List<TurnInfo> turnInfoList = new ArrayList<TurnInfo>();
      for (Id<Link> toLinkId : toLinkIds) {
        turnInfoList.add(new TurnInfo(l2l.getLinkId(), toLinkId));
      }
      inLinkIdTurnInfoMap.put(l2l.getLinkId(), turnInfoList);
    }
  }

  return inLinkIdTurnInfoMap;
}

private double getAverageLaneArrivalRate(double now, Id<Link> linkId, Id<Lane> laneId) {
  if (lanes.getLanesToLinkAssignments().get(linkId).getLanes().size() > 1) {
    if (this.laemmerConfig.getLaneArrivalRate(linkId, laneId) != null) {
      return this.laemmerConfig.getLaneArrivalRate(linkId, laneId);
    } else {
      return this.sensorManager.getAverageArrivalRateOnLane(linkId, laneId, now);
    }
  } else {
    return getAverageArrivalRate(now, linkId);
  }
}

  public void getStepStats(StringBuilder builder, double now) {
    int totalN = 0;
    for (Signal signal : group.getSignals().values()) {
      if (signal.getLaneIds() != null && !signal.getLaneIds().isEmpty()
          && lanes.getLanesToLinkAssignments().get(signal.getLinkId()).getLanes().size() > 1) {
        for (Id<Lane> laneId : signal.getLaneIds()) {
          totalN += getNumberOfExpectedVehiclesOnLane(now, signal.getLinkId(), laneId);
        }
      } else {
        totalN += getNumberOfExpectedVehiclesOnLink(now, signal.getLinkId());
      }
    }
    builder.append(this.group.getState().name()+ ";")
        .append(this.index + ";")
        .append(this.determiningLoad + ";")
        .append(this.a + ";")
        .append(this.abortionPenalty + ";")
        .append(this.regulationTime + ";")
        .append(totalN + ";");
  }
}

  @Override
  public QLinkI createNetsimLink(Link link, QNodeI queueNode) {
    QLinkI ql = null;
    LanesToLinkAssignment l2l = this.laneDefinitions.getLanesToLinkAssignments().get(link.getId());
    if (l2l != null){
      List<ModelLane> lanes = LanesUtils.createLanes(link, l2l);
//            LinkSpeedCalculator linkSpeedCalculator = new DefaultLinkSpeedCalculator() ;
//            // yyyyyy I don't think that this was set correctly for this execution path before I refactored this.  kai, feb'18
//            ql = new QLinkLanesImpl(link, queueNode, lanes, context, netsimEngine, linkSpeedCalculator);
      QLinkLanesImpl.Builder builder = new QLinkLanesImpl.Builder(context, netsimEngine) ;
      ql = builder.build( link, queueNode, lanes ) ;
    }
    else {
      ql = this.delegate.createNetsimLink(link, queueNode);
    }
    return ql;
  }

LaemmerSignal(SignalGroup signalGroup) {
  this.group = signalGroup;
  
  // calculate outflow capacity once (in reality one also has to initialize this value and cannot update it every second)
  for (Signal signal : group.getSignals().values()) {
    if (signal.getLaneIds() != null && !signal.getLaneIds().isEmpty()
        && lanes.getLanesToLinkAssignments().get(signal.getLinkId()).getLanes().size() > 1) {
      for (Id<Lane> laneId : signal.getLaneIds()) {
        double laneOutflow = lanes.getLanesToLinkAssignments().get(signal.getLinkId()).getLanes()
            .get(laneId).getCapacityVehiclesPerHour() * config.qsim().getFlowCapFactor() / 3600;
        laneOutflowCapacitiesPerS.put(laneId, laneOutflow);
        signalOutflowCapacityPerS += laneOutflow;
      }
    } else {
      double linkOutflowPerS = network.getLinks().get(signal.getLinkId()).getCapacity()
          * config.qsim().getFlowCapFactor() / 3600;
      linkOutflowCapacitiesPerS.put(signal.getLinkId(), linkOutflowPerS);
      signalOutflowCapacityPerS += linkOutflowPerS;
    }
  }
}

Javadoc

Top level container for lanes within MATSim. See package-info for documentation.

Most used methods

addLanesToLinkAssignment
Adds a LanesToLinkAssignment to the container.
getFactory
getLanesToLinkAssignments

Popular in Java

Running tasks concurrently on multiple threads
getContentResolver (Context)
requestLocationUpdates (LocationManager)
putExtra (Intent)
FlowLayout (java.awt)
A flow layout arranges components in a left-to-right flow, much like lines of text in a paragraph. F
System (java.lang)
Provides access to system-related information and resources including standard input and output. Ena
Locale (java.util)
A Locale object represents a specific geographical, political, or cultural region. An operation that
ResourceBundle (java.util)
Resource bundles contain locale-specific objects. When your program needs a locale-specific resource
Timer (java.util)
A facility for threads to schedule tasks for future execution in a background thread. Tasks may be s
Stream (java.util.stream)
A sequence of elements supporting sequential and parallel aggregate operations. The following exampl

How to useLanes in org.matsim.lanes

Best Java code snippets using org.matsim.lanes.Lanes (Showing top 20 results out of 315)

How to use
Lanes
in
org.matsim.lanes