path;
try
{
path = GraphLaneUtil.createPath("Lane", new LaneDirection(getModel().getPath().get(0), GTUDirectionality.DIR_PLUS));
}
catch (NetworkException exception)
{
throw new RuntimeException("Could not create a path as a lane has no set speed limit.", exception);
}
RoadSampler sampler = new RoadSampler(getModel().getNetwork());
GraphPath.initRecording(sampler, path);
ContourDataSource dataPool = new ContourDataSource<>(sampler.getSamplerData(), path);
TablePanel charts = new TablePanel(3, 2);
SwingPlot plot = null;
plot = new SwingTrajectoryPlot(
new TrajectoryPlot("TrajectoryPlot", Duration.instantiateSI(10.0), simulator, sampler.getSamplerData(), path));
charts.setCell(plot.getContentPane(), 0, 0);
plot = new SwingContourPlot(new ContourPlotDensity("DensityPlot", simulator, dataPool));
charts.setCell(plot.getContentPane(), 1, 0);
plot = new SwingContourPlot(new ContourPlotSpeed("SpeedPlot", simulator, dataPool));
charts.setCell(plot.getContentPane(), 2, 0);
plot = new SwingContourPlot(new ContourPlotFlow("FlowPlot", simulator, dataPool));
charts.setCell(plot.getContentPane(), 1, 1);
plot = new SwingContourPlot(new ContourPlotAcceleration("AccelerationPlot", simulator, dataPool));
charts.setCell(plot.getContentPane(), 2, 1);
getAnimationPanel().getTabbedPane().addTab(getAnimationPanel().getTabbedPane().getTabCount(), "statistics ", charts);
}
/**
* Build the sequential model.
*
* Copyright (c) 2013-2020 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved.
*
* BSD-style license. See OpenTrafficSim License.
*
* $LastChangedDate: 2020-09-03 11:54:19 +0200 (Thu, 03 Sep 2020) $, @version $Revision: 6688 $, by $Author: averbraeck $,
* initial version 0 jan. 2015
* @author Peter Knoppers
*/
static class SequentialModel extends AbstractOTSModel implements UNITS
{
/** */
private static final long serialVersionUID = 20150130L;
/** The network. */
private final OTSRoadNetwork network = new OTSRoadNetwork("network", true, getSimulator());
/** The nodes of our network in the order that all GTUs will visit them. */
private List nodes = new ArrayList<>();
/** Strategical planner generator for cars. */
private LaneBasedStrategicalPlannerFactory strategicalPlannerGeneratorCars = null;
/** Strategical planner generator for trucks. */
private LaneBasedStrategicalPlannerFactory strategicalPlannerGeneratorTrucks = null;
/** Car parameters. */
private Parameters parametersCar;
/** Truck parameters. */
private Parameters parametersTruck;
/** The probability that the next generated GTU is a passenger car. */
private double carProbability;
/** The headway (inter-vehicle time). */
private Duration headway;
/** Number of cars created. */
private int carsCreated = 0;
/** Minimum distance. */
private Length minimumDistance = new Length(0, METER);
/** The Lane where newly created Cars initially placed on. */
private Lane initialLane;
/** Maximum distance. */
private Length maximumDistance = new Length(2001, METER);
/** The random number generator used to decide what kind of GTU to generate. */
private StreamInterface stream = new MersenneTwister(12345);
/** The sequence of Lanes that all vehicles will follow. */
private List path = new ArrayList<>();
/** The speedLimit on all Lanes. */
private Speed speedLimit;
/**
* @param simulator OTSSimulatorInterface; the simulator for this model
*/
SequentialModel(final OTSSimulatorInterface simulator)
{
super(simulator);
InputParameterHelper.makeInputParameterMapCarTruck(this.inputParameterMap, 1.0);
}
/**
* @return a newly created path (which all GTUs in this simulation will follow).
*/
public List getPath()
{
return new ArrayList<>(this.path);
}
/** {@inheritDoc} */
@Override
public final void constructModel() throws SimRuntimeException
{
this.speedLimit = new Speed(100, KM_PER_HOUR);
// TODO Bezier curves make 180 degree mistake when minus is true
boolean minus = false;
this.nodes = new ArrayList<>();
try
{
OTSPoint3D p2 = new OTSPoint3D(1020, 3);
OTSPoint3D p3 = new OTSPoint3D(2000, 197);
Direction dir23 = p2.horizontalDirection(p3);
OTSRoadNode n0 = new OTSRoadNode(this.network, "Node-0-(0,0)", new OTSPoint3D(0, 0), Direction.ZERO);
OTSRoadNode n1 = new OTSRoadNode(this.network, "Node-1-(1000,0)", new OTSPoint3D(1000, 0), Direction.ZERO);
OTSRoadNode n2 = new OTSRoadNode(this.network, "Node-2-(1020,3)", p2, dir23);
OTSRoadNode n3 = new OTSRoadNode(this.network, "Node-3-(2000,197)", p3, dir23);
OTSRoadNode n4 = new OTSRoadNode(this.network, "Node-4-(2020,200)", new OTSPoint3D(2020, 200), Direction.ZERO);
OTSRoadNode n5 = new OTSRoadNode(this.network, "Node-5-(2200,200)", new OTSPoint3D(2200, 200), Direction.ZERO);
this.nodes.addAll(Arrays.asList(new OTSRoadNode[] {n0, n1, n2, n3, n4, n5}));
LaneType laneType = this.network.getLaneType(LaneType.DEFAULTS.TWO_WAY_LANE);
// Now we can build a series of Links with one Lane on them
ArrayList links = new ArrayList<>();
OTSLine3D l01 = new OTSLine3D(n0.getPoint(), n1.getPoint());
OTSLine3D l12 = LaneFactory.makeBezier(n0, n1, n2, n3);
OTSLine3D l23 =
minus ? new OTSLine3D(n3.getPoint(), n2.getPoint()) : new OTSLine3D(n2.getPoint(), n3.getPoint());
OTSLine3D l34 = LaneFactory.makeBezier(n2, n3, n4, n5);
OTSLine3D l45 = new OTSLine3D(n4.getPoint(), n5.getPoint());
OTSLine3D[] lines = new OTSLine3D[] {l01, l12, l23, l34, l45};
for (int i = 1; i < this.nodes.size(); i++)
{
OTSRoadNode fromNode = this.nodes.get(i - 1);
OTSRoadNode toNode = this.nodes.get(i);
OTSLine3D line = lines[i - 1];
String linkName = fromNode.getId() + "-" + toNode.getId();
// LongitudinalDirectionality direction = line.equals(l23) && minus ? LongitudinalDirectionality.DIR_MINUS
// : LongitudinalDirectionality.DIR_PLUS;
Lane[] lanes = LaneFactory.makeMultiLane(this.network, linkName, fromNode, toNode, line.getPoints(), 1,
laneType, this.speedLimit, this.simulator);
if (i == this.nodes.size() - 1)
{
new SinkSensor(lanes[0], new Length(100.0, METER), Compatible.EVERYTHING, this.simulator);
}
this.path.add(lanes[0]);
links.add(lanes[0].getParentLink());
if (1 == i)
{
this.initialLane = lanes[0];
}
}
this.carProbability = (double) getInputParameter("generic.carProbability");
this.parametersCar = InputParameterHelper.getParametersCar(getInputParameterMap());
this.parametersTruck = InputParameterHelper.getParametersTruck(getInputParameterMap());
this.strategicalPlannerGeneratorCars = new LaneBasedStrategicalRoutePlannerFactory(
new LMRSFactory(new IDMPlusFactory(this.stream), new DefaultLMRSPerceptionFactory()));
this.strategicalPlannerGeneratorTrucks = new LaneBasedStrategicalRoutePlannerFactory(
new LMRSFactory(new IDMPlusFactory(this.stream), new DefaultLMRSPerceptionFactory()));
// 1500 [veh / hour] == 2.4s headway
this.headway = new Duration(3600.0 / 1500.0, SECOND);
// Schedule creation of the first car (it will re-schedule itself one headway later, etc.).
this.simulator.scheduleEventAbs(Time.ZERO, this, this, "generateCar", null);
}
catch (NamingException | NetworkException | OTSGeometryException | ParameterException | InputParameterException
| GTUException exception)
{
exception.printStackTrace();
}
}
/** {@inheritDoc} */
@Override
public OTSRoadNetwork getNetwork()
{
return this.network;
}
/**
* @return minimumDistance
*/
public final Length getMinimumDistance()
{
return this.minimumDistance;
}
/**
* @return maximumDistance
*/
public final Length getMaximumDistance()
{
return this.maximumDistance;
}
/**
* Generate cars at a fixed rate (implemented by re-scheduling this method).
*/
protected final void generateCar()
{
try
{
boolean generateTruck = this.stream.nextDouble() > this.carProbability;
Length vehicleLength = new Length(generateTruck ? 15 : 4, METER);
LaneBasedIndividualGTU gtu = new LaneBasedIndividualGTU("" + (++this.carsCreated),
this.network.getGtuType(GTUType.DEFAULTS.CAR), vehicleLength, new Length(1.8, METER),
new Speed(200, KM_PER_HOUR), vehicleLength.times(0.5), this.simulator, this.network);
gtu.setParameters(generateTruck ? this.parametersTruck : this.parametersCar);
gtu.setNoLaneChangeDistance(Length.ZERO);
gtu.setMaximumAcceleration(Acceleration.instantiateSI(3.0));
gtu.setMaximumDeceleration(Acceleration.instantiateSI(-8.0));
// strategical planner
LaneBasedStrategicalPlanner strategicalPlanner =
generateTruck ? this.strategicalPlannerGeneratorTrucks.create(gtu, null, null, null)
: this.strategicalPlannerGeneratorCars.create(gtu, null, null, null);
Set initialPositions = new LinkedHashSet<>(1);
Length initialPosition = new Length(20, METER);
initialPositions.add(new DirectedLanePosition(this.initialLane, initialPosition, GTUDirectionality.DIR_PLUS));
Speed initialSpeed = new Speed(100.0, KM_PER_HOUR);
gtu.init(strategicalPlanner, initialPositions, initialSpeed);
this.simulator.scheduleEventRel(this.headway, this, this, "generateCar", null);
}
catch (SimRuntimeException | NetworkException | GTUException | OTSGeometryException exception)
{
exception.printStackTrace();
}
}
/** {@inheritDoc} */
@Override
public Serializable getSourceId()
{
return "SequentialModel";
}
}
}