();
if (output instanceof CompoundProperty)
{
CompoundProperty outputProperties = (CompoundProperty) output;
for (Property ap : outputProperties.getValue())
{
if (ap instanceof BooleanProperty)
{
BooleanProperty bp = (BooleanProperty) ap;
if (bp.getValue())
{
graphs.add(bp);
}
}
}
}
else
{
throw new Error("output properties should be compound");
}
int graphCount = graphs.size();
int columns = (int) Math.ceil(Math.sqrt(graphCount));
int rows = 0 == columns ? 0 : (int) Math.ceil(graphCount * 1.0 / columns);
TablePanel charts = new TablePanel(columns, rows);
for (int i = 0; i < graphCount; i++)
{
String graphName = graphs.get(i).getKey();
Container container = null;
LaneBasedGTUSampler graph;
int pos = graphName.indexOf(' ') + 1;
String laneNumberText = graphName.substring(pos, pos + 1);
int lane = Integer.parseInt(laneNumberText) - 1;
if (graphName.contains("Trajectories"))
{
Duration sampleInterval = graphName.contains("Variable Sample Rate") ? null : new Duration(0.2, SECOND);
TrajectoryPlot tp = new TrajectoryPlot(graphName, sampleInterval, this.model.getPath(lane), simulator);
tp.setTitle("Trajectory Graph");
tp.setExtendedState(Frame.MAXIMIZED_BOTH);
graph = tp;
container = tp.getContentPane();
}
else
{
ContourPlot cp;
if (graphName.contains("Density"))
{
cp = new DensityContourPlot(graphName, this.model.getPath(lane));
cp.setTitle("Density Contour Graph");
}
else if (graphName.contains("Speed"))
{
cp = new SpeedContourPlot(graphName, this.model.getPath(lane));
cp.setTitle("Speed Contour Graph");
}
else if (graphName.contains("Flow"))
{
cp = new FlowContourPlot(graphName, this.model.getPath(lane));
cp.setTitle("Flow Contour Graph");
}
else if (graphName.contains("Acceleration"))
{
cp = new AccelerationContourPlot(graphName, this.model.getPath(lane));
cp.setTitle("Acceleration Contour Graph");
}
else
{
throw new Error("Unhandled type of contourplot: " + graphName);
}
graph = cp;
container = cp.getContentPane();
}
// Add the container to the matrix
charts.setCell(container, i % columns, i / columns);
this.model.getPlots().add(graph);
}
addTab(getTabCount(), "statistics", charts);
}
/** {@inheritDoc} */
@Override
public final String shortName()
{
return "Circular Road simulation";
}
/** {@inheritDoc} */
@Override
public final String description()
{
return "Circular Road simulation
" + "Vehicles are unequally distributed over a two lane ring road.
"
+ "When simulation starts, all vehicles begin driving, some lane changes will occurr and some "
+ "shockwaves should develop.
"
+ "Trajectories and contourplots are generated during the simulation for both lanes.";
}
/**
* Simulate traffic on a circular, two-lane road.
*
* Copyright (c) 2013-2018 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved.
*
* BSD-style license. See OpenTrafficSim License.
*
* $LastChangedDate$, @version $Revision$, by $Author$,
* initial version 1 nov. 2014
* @author Peter Knoppers
*/
class RoadSimulationModel implements OTSModelInterface, UNITS
{
/** */
private static final long serialVersionUID = 20141121L;
/** The simulator. */
private DEVSSimulatorInterface.TimeDoubleUnit simulator;
/** Number of cars created. */
private int carsCreated = 0;
/** The car following model, e.g. IDM Plus for cars. */
private GTUFollowingModelOld carFollowingModelCars;
/** The car following model, e.g. IDM Plus for trucks. */
private GTUFollowingModelOld carFollowingModelTrucks;
/** The probability that the next generated GTU is a passenger car. */
private double carProbability;
/** The lane change model. */
private AbstractLaneChangeModel laneChangeModel;
/** Minimum distance. */
private Length minimumDistance = new Length(0, METER);
/** The speed limit. */
private Speed speedLimit = new Speed(100, KM_PER_HOUR);
/** The plots. */
private List plots = new ArrayList<>();
/** User settable properties. */
private List> properties = null;
/** The sequence of Lanes that all vehicles will follow. */
private List> paths = new ArrayList<>();
/** The random number generator used to decide what kind of GTU to generate etc. */
private StreamInterface stream = new MersenneTwister(12345);
/** Strategical planner generator for cars. */
private LaneBasedStrategicalPlannerFactory strategicalPlannerGeneratorCars = null;
/** Strategical planner generator for cars. */
private LaneBasedStrategicalPlannerFactory strategicalPlannerGeneratorTrucks = null;
/** The OTSNetwork. */
private final OTSNetwork network = new OTSNetwork("network");
/**
* @param properties ArrayList<AbstractProperty<?>>; the properties
*/
RoadSimulationModel(final List> properties)
{
this.properties = properties;
}
/**
* @param index int; the rank number of the path
* @return List<Lane>; the set of lanes for the specified index
*/
public List getPath(final int index)
{
return this.paths.get(index);
}
/** {@inheritDoc} */
@Override
public void constructModel(final SimulatorInterface theSimulator)
throws SimRuntimeException
{
final int laneCount = 2;
for (int laneIndex = 0; laneIndex < laneCount; laneIndex++)
{
this.paths.add(new ArrayList());
}
this.simulator = (DEVSSimulatorInterface.TimeDoubleUnit) theSimulator;
double radius = 6000 / 2 / Math.PI;
double headway = 40;
double headwayVariability = 0;
try
{
// Get car-following model name
String carFollowingModelName = null;
CompoundProperty propertyContainer = new CompoundProperty("", "", "", this.properties, false, 0);
Property cfmp = propertyContainer.findByKey("CarFollowingModel");
if (null == cfmp)
{
throw new Error("Cannot find \"Car following model\" property");
}
if (cfmp instanceof SelectionProperty)
{
carFollowingModelName = ((SelectionProperty) cfmp).getValue();
}
else
{
throw new Error("\"Car following model\" property has wrong type");
}
// Get car-following model parameter
for (Property ap : new CompoundProperty("", "", "", this.properties, false, 0))
{
if (ap instanceof CompoundProperty)
{
CompoundProperty cp = (CompoundProperty) ap;
System.out.println("Checking compound property " + cp);
if (ap.getKey().contains("IDM"))
{
System.out.println("Car following model name appears to be " + ap.getKey());
Acceleration a = IDMPropertySet.getA(cp);
Acceleration b = IDMPropertySet.getB(cp);
Length s0 = IDMPropertySet.getS0(cp);
Duration tSafe = IDMPropertySet.getTSafe(cp);
GTUFollowingModelOld gtuFollowingModel = null;
if (carFollowingModelName.equals("IDM"))
{
gtuFollowingModel = new IDMOld(a, b, s0, tSafe, 1.0);
}
else if (carFollowingModelName.equals("IDM+"))
{
gtuFollowingModel = new IDMPlusOld(a, b, s0, tSafe, 1.0);
}
else
{
throw new Error("Unknown gtu following model: " + carFollowingModelName);
}
if (ap.getKey().contains("Car"))
{
this.carFollowingModelCars = gtuFollowingModel;
}
else if (ap.getKey().contains("Truck"))
{
this.carFollowingModelTrucks = gtuFollowingModel;
}
else
{
throw new Error("Cannot determine gtu type for " + ap.getKey());
}
}
}
}
// Get lane change model
cfmp = propertyContainer.findByKey("LaneChanging");
if (null == cfmp)
{
throw new Error("Cannot find \"Lane changing\" property");
}
if (cfmp instanceof SelectionProperty)
{
String laneChangeModelName = ((SelectionProperty) cfmp).getValue();
if ("Egoistic".equals(laneChangeModelName))
{
this.laneChangeModel = new Egoistic();
}
else if ("Altruistic".equals(laneChangeModelName))
{
this.laneChangeModel = new Altruistic();
}
else
{
throw new Error("Lane changing " + laneChangeModelName + " not implemented");
}
}
else
{
throw new Error("\"Lane changing\" property has wrong type");
}
// Get remaining properties
for (Property ap : new CompoundProperty("", "", "", this.properties, false, 0))
{
if (ap instanceof SelectionProperty)
{
SelectionProperty sp = (SelectionProperty) ap;
if ("TacticalPlanner".equals(sp.getKey()))
{
String tacticalPlannerName = sp.getValue();
if ("MOBIL/IDM".equals(tacticalPlannerName))
{
this.strategicalPlannerGeneratorCars =
new LaneBasedStrategicalRoutePlannerFactory(new LaneBasedCFLCTacticalPlannerFactory(
this.carFollowingModelCars, this.laneChangeModel));
this.strategicalPlannerGeneratorTrucks =
new LaneBasedStrategicalRoutePlannerFactory(new LaneBasedCFLCTacticalPlannerFactory(
this.carFollowingModelTrucks, this.laneChangeModel));
}
else if ("DIRECTED/IDM".equals(tacticalPlannerName))
{
this.strategicalPlannerGeneratorCars = new LaneBasedStrategicalRoutePlannerFactory(
new LaneBasedGTUFollowingDirectedChangeTacticalPlannerFactory(
this.carFollowingModelCars));
this.strategicalPlannerGeneratorTrucks = new LaneBasedStrategicalRoutePlannerFactory(
new LaneBasedGTUFollowingDirectedChangeTacticalPlannerFactory(
this.carFollowingModelTrucks));
}
else if ("LMRS".equals(tacticalPlannerName))
{
// provide default parameters with the car-following model
this.strategicalPlannerGeneratorCars = new LaneBasedStrategicalRoutePlannerFactory(
new LMRSFactory(new IDMPlusFactory(this.stream), new DefaultLMRSPerceptionFactory()));
this.strategicalPlannerGeneratorTrucks = new LaneBasedStrategicalRoutePlannerFactory(
new LMRSFactory(new IDMPlusFactory(this.stream), new DefaultLMRSPerceptionFactory()));
}
else if ("Toledo".equals(tacticalPlannerName))
{
this.strategicalPlannerGeneratorCars =
new LaneBasedStrategicalRoutePlannerFactory(new ToledoFactory());
this.strategicalPlannerGeneratorTrucks =
new LaneBasedStrategicalRoutePlannerFactory(new ToledoFactory());
}
else
{
throw new Error("Don't know how to create a " + tacticalPlannerName + " tactical planner");
}
}
}
else if (ap instanceof ProbabilityDistributionProperty)
{
ProbabilityDistributionProperty pdp = (ProbabilityDistributionProperty) ap;
if (ap.getKey().equals("TrafficComposition"))
{
this.carProbability = pdp.getValue()[0];
}
}
else if (ap instanceof IntegerProperty)
{
IntegerProperty ip = (IntegerProperty) ap;
if ("TrackLength".equals(ip.getKey()))
{
radius = ip.getValue() / 2 / Math.PI;
}
}
else if (ap instanceof ContinuousProperty)
{
ContinuousProperty cp = (ContinuousProperty) ap;
if (cp.getKey().equals("MeanDensity"))
{
headway = 1000 / cp.getValue();
}
if (cp.getKey().equals("DensityVariability"))
{
headwayVariability = cp.getValue();
}
}
else if (ap instanceof CompoundProperty)
{
if (ap.getKey().equals("OutputGraphs"))
{
continue; // Output settings are handled elsewhere
}
}
}
GTUType gtuType = CAR;
LaneType laneType = LaneType.TWO_WAY_LANE;
OTSNode start = new OTSNode(this.network, "Start", new OTSPoint3D(radius, 0, 0));
OTSNode halfway = new OTSNode(this.network, "Halfway", new OTSPoint3D(-radius, 0, 0));
OTSPoint3D[] coordsHalf1 = new OTSPoint3D[127];
for (int i = 0; i < coordsHalf1.length; i++)
{
double angle = Math.PI * (1 + i) / (1 + coordsHalf1.length);
coordsHalf1[i] = new OTSPoint3D(radius * Math.cos(angle), radius * Math.sin(angle), 0);
}
Lane[] lanes1 = LaneFactory.makeMultiLane(this.network, "FirstHalf", start, halfway, coordsHalf1, laneCount,
laneType, this.speedLimit, this.simulator);
OTSPoint3D[] coordsHalf2 = new OTSPoint3D[127];
for (int i = 0; i < coordsHalf2.length; i++)
{
double angle = Math.PI + Math.PI * (1 + i) / (1 + coordsHalf2.length);
coordsHalf2[i] = new OTSPoint3D(radius * Math.cos(angle), radius * Math.sin(angle), 0);
}
Lane[] lanes2 = LaneFactory.makeMultiLane(this.network, "SecondHalf", halfway, start, coordsHalf2, laneCount,
laneType, this.speedLimit, this.simulator);
for (int laneIndex = 0; laneIndex < laneCount; laneIndex++)
{
this.paths.get(laneIndex).add(lanes1[laneIndex]);
this.paths.get(laneIndex).add(lanes2[laneIndex]);
}
// Put the (not very evenly spaced) cars on the track
double variability = (headway - 20) * headwayVariability;
System.out.println("headway is " + headway + " variability limit is " + variability);
Random random = new Random(12345);
for (int laneIndex = 0; laneIndex < laneCount; laneIndex++)
{
double lane1Length = lanes1[laneIndex].getLength().getSI();
double trackLength = lane1Length + lanes2[laneIndex].getLength().getSI();
for (double pos = 0; pos <= trackLength - headway - variability;)
{
Lane lane = pos >= lane1Length ? lanes2[laneIndex] : lanes1[laneIndex];
// Actual headway is uniformly distributed around headway
double laneRelativePos = pos > lane1Length ? pos - lane1Length : pos;
double actualHeadway = headway + (random.nextDouble() * 2 - 1) * variability;
// System.out.println(lane + ", len=" + lane.getLength() + ", pos=" + laneRelativePos);
generateCar(new Length(laneRelativePos, METER), lane, gtuType);
pos += actualHeadway;
}
}
// Schedule regular updates of the graph
this.simulator.scheduleEventAbs(new Time(9.999, TimeUnit.BASE_SECOND), this, this, "drawGraphs", null);
}
catch (SimRuntimeException | NamingException | NetworkException | GTUException | OTSGeometryException
| PropertyException exception)
{
exception.printStackTrace();
}
}
/**
* Notify the contour plots that the underlying data has changed.
*/
protected final void drawGraphs()
{
for (LaneBasedGTUSampler plot : this.plots)
{
plot.reGraph();
}
// Re schedule this method
try
{
this.simulator.scheduleEventAbs(
new Time(this.simulator.getSimulatorTime().getSI() + 10, TimeUnit.BASE_SECOND), this, this,
"drawGraphs", null);
}
catch (SimRuntimeException exception)
{
exception.printStackTrace();
}
}
/**
* Generate one car.
* @param initialPosition Length; the initial position of the new cars
* @param lane Lane; the lane on which the new cars are placed
* @param gtuType GTUType<String>; the type of the new cars
* @throws NamingException on ???
* @throws SimRuntimeException cannot happen
* @throws NetworkException on network inconsistency
* @throws GTUException when something goes wrong during construction of the car
* @throws OTSGeometryException when the initial position is outside the center line of the lane
*/
protected final void generateCar(final Length initialPosition, final Lane lane, final GTUType gtuType)
throws NamingException, NetworkException, SimRuntimeException, GTUException, OTSGeometryException
{
// GTU itself
boolean generateTruck = this.stream.nextDouble() > this.carProbability;
Length vehicleLength = new Length(generateTruck ? 15 : 4, METER);
LaneBasedIndividualGTU gtu =
new LaneBasedIndividualGTU("" + (++this.carsCreated), gtuType, vehicleLength, new Length(1.8, METER),
new Speed(200, KM_PER_HOUR), vehicleLength.multiplyBy(0.5), this.simulator, this.network);
gtu.setNoLaneChangeDistance(Length.ZERO);
// strategical planner
LaneBasedStrategicalPlanner strategicalPlanner;
Route route = null;
if (!generateTruck)
{
strategicalPlanner = this.strategicalPlannerGeneratorCars.create(gtu, route, null, null);
}
else
{
strategicalPlanner = this.strategicalPlannerGeneratorTrucks.create(gtu, route, null, null);
}
// init
Set initialPositions = new LinkedHashSet<>(1);
initialPositions.add(new DirectedLanePosition(lane, initialPosition, GTUDirectionality.DIR_PLUS));
Speed initialSpeed = new Speed(0, KM_PER_HOUR);
gtu.initWithAnimation(strategicalPlanner, initialPositions, initialSpeed, DefaultCarAnimation.class,
CircularRoad.this.getColorer());
// Check that the gtu is indeed at the expected position
/*-
Lane actualLane = gtu.getLanes().keySet().iterator().next();
if (actualLane != lane)
{
System.out.println("Newly created GTU already switched from lane" + lane + " to " + actualLane);
}
else
{
Length actualPosition = gtu.position(lane, gtu.getReference());
if (Math.abs(actualPosition.si - initialPosition.si) > 0.5)
{
System.out.println("Newly created GTU jumped from " + initialPosition + " to " + actualPosition);
}
DirectedPoint actualLocation = gtu.getLocation();
DirectedPoint expectedLocation =
lane.getCenterLine().extract(initialPosition, initialPosition.plus(new Length(0.0001, LengthUnit.METER)))
.getLocation();
double distance = actualLocation.distance(expectedLocation);
if (distance > 0.5)
{
System.out.println("Actual location of new GTU is " + actualLocation + ", expectedLocation is "
+ expectedLocation + " difference is " + distance + "m");
}
}
*/
}
/** {@inheritDoc} */
@Override
public SimulatorInterface getSimulator()
{
return this.simulator;
}
/** {@inheritDoc} */
@Override
public OTSNetwork getNetwork()
{
return this.network;
}
/**
* @return plots
*/
public final List getPlots()
{
return this.plots;
}
/**
* @return minimumDistance
*/
public final Length getMinimumDistance()
{
return this.minimumDistance;
}
/**
* Stop simulation and throw an Error.
* @param theSimulator DEVSSimulatorInterface.TimeDoubleUnit; the simulator
* @param errorMessage String; the error message
*/
public void stopSimulator(final DEVSSimulatorInterface.TimeDoubleUnit theSimulator, final String errorMessage)
{
System.out.println("Error: " + errorMessage);
try
{
if (theSimulator.isRunning())
{
theSimulator.stop();
}
}
catch (SimRuntimeException exception)
{
exception.printStackTrace();
}
throw new Error(errorMessage);
}
}
}