AccelerationContourPlot.java

  1. package org.opentrafficsim.graphs;

  2. import java.util.ArrayList;
  3. import java.util.List;

  4. import org.djunits.unit.AccelerationUnit;
  5. import org.djunits.unit.TimeUnit;
  6. import org.djunits.value.StorageType;
  7. import org.djunits.value.ValueException;
  8. import org.djunits.value.vdouble.scalar.DoubleScalar;
  9. import org.djunits.value.vdouble.vector.MutableAccelerationVector;
  10. import org.djunits.value.vdouble.vector.MutableTimeVector;
  11. import org.opentrafficsim.road.network.lane.Lane;
  12. import org.opentrafficsim.simulationengine.OTSSimulationException;

  13. /**
  14.  * Acceleration contour plot.
  15.  * <p>
  16.  * Copyright (c) 2013-2015 Delft University of Technology, PO Box 5, 2600 AA, Delft, the Netherlands. All rights reserved. <br>
  17.  * BSD-style license. See <a href="http://opentrafficsim.org/docs/license.html">OpenTrafficSim License</a>.
  18.  * <p>
  19.  * $LastChangedDate: 2015-09-03 13:38:01 +0200 (Thu, 03 Sep 2015) $, @version $Revision: 1378 $, by $Author: averbraeck $,
  20.  * initial version Jul 31, 2014 <br>
  21.  * @author <a href="http://www.tudelft.nl/pknoppers">Peter Knoppers</a>
  22.  */
  23. public class AccelerationContourPlot extends ContourPlot
  24. {
  25.     /** */
  26.     private static final long serialVersionUID = 20140731L;

  27.     /**
  28.      * Create a new AccelerationContourPlot.
  29.      * @param caption String; text to show above the AccelerationContourPlot
  30.      * @param path List&lt;Lane&gt;; the series of Lanes that will provide the data for this TrajectoryPlot
  31.      * @throws OTSSimulationException in case of problems initializing the graph
  32.      */
  33.     public AccelerationContourPlot(final String caption, final List<Lane> path) throws OTSSimulationException
  34.     {
  35.         super(caption, new Axis(INITIALLOWERTIMEBOUND, INITIALUPPERTIMEBOUND, STANDARDTIMEGRANULARITIES,
  36.             STANDARDTIMEGRANULARITIES[STANDARDINITIALTIMEGRANULARITYINDEX], "", "Time", "%.0fs"), path, -5d, 0d, 3d,
  37.             "acceleration %.1f m/s/s", "%.1f m/s/s", 1d);
  38.     }

  39.     /** Storage for the total time spent in each cell. */
  40.     private ArrayList<MutableTimeVector.Abs> cumulativeTimes;

  41.     /** Storage for the total acceleration executed in each cell. */
  42.     private ArrayList<MutableAccelerationVector> cumulativeAccelerations;

  43.     /** {@inheritDoc} */
  44.     @Override
  45.     public final Comparable<String> getSeriesKey(final int series)
  46.     {
  47.         return "acceleration";
  48.     }

  49.     /** {@inheritDoc} */
  50.     @Override
  51.     public final void extendXRange(final DoubleScalar<?> newUpperLimit)
  52.     {
  53.         if (null == this.cumulativeTimes)
  54.         {
  55.             this.cumulativeTimes = new ArrayList<MutableTimeVector.Abs>();
  56.             this.cumulativeAccelerations = new ArrayList<MutableAccelerationVector>();
  57.         }
  58.         int highestBinNeeded =
  59.             (int) Math.floor(this.getXAxis().getRelativeBin(newUpperLimit) * this.getXAxis().getCurrentGranularity()
  60.                 / this.getXAxis().getGranularities()[0]);
  61.         while (highestBinNeeded >= this.cumulativeTimes.size())
  62.         {
  63.             try
  64.             {
  65.                 this.cumulativeTimes.add(new MutableTimeVector.Abs(new double[this.getYAxis().getBinCount()],
  66.                     TimeUnit.SECOND, StorageType.DENSE));
  67.                 this.cumulativeAccelerations.add(new MutableAccelerationVector(
  68.                     new double[this.getYAxis().getBinCount()], AccelerationUnit.METER_PER_SECOND_2, StorageType.DENSE));
  69.             }
  70.             catch (ValueException exception)
  71.             {
  72.                 exception.printStackTrace();
  73.             }
  74.         }
  75.     }

  76.     /** {@inheritDoc} */
  77.     @Override
  78.     public final void incrementBinData(final int timeBin, final int distanceBin, final double duration,
  79.         final double distanceCovered, final double acceleration)
  80.     {
  81.         if (timeBin < 0 || distanceBin < 0 || 0 == duration || distanceBin >= this.getYAxis().getBinCount())
  82.         {
  83.             return;
  84.         }
  85.         MutableTimeVector.Abs timeValues = this.cumulativeTimes.get(timeBin);
  86.         MutableAccelerationVector accelerationValues = this.cumulativeAccelerations.get(timeBin);
  87.         try
  88.         {
  89.             timeValues.setSI(distanceBin, timeValues.getSI(distanceBin) + duration);
  90.             accelerationValues.setSI(distanceBin, accelerationValues.getSI(distanceBin) + acceleration * duration);
  91.         }
  92.         catch (ValueException exception)
  93.         {
  94.             System.err.println("Error in incrementData:");
  95.             exception.printStackTrace();
  96.         }
  97.     }

  98.     /** {@inheritDoc} */
  99.     @Override
  100.     public final double computeZValue(final int firstTimeBin, final int endTimeBin, final int firstDistanceBin,
  101.         final int endDistanceBin)
  102.     {
  103.         double cumulativeTimeInSI = 0;
  104.         double cumulativeAccelerationInSI = 0;
  105.         if (firstTimeBin >= this.cumulativeTimes.size())
  106.         {
  107.             return Double.NaN;
  108.         }
  109.         try
  110.         {
  111.             for (int timeBinIndex = firstTimeBin; timeBinIndex < endTimeBin; timeBinIndex++)
  112.             {
  113.                 if (timeBinIndex >= this.cumulativeTimes.size())
  114.                 {
  115.                     break;
  116.                 }
  117.                 MutableTimeVector.Abs timeValues = this.cumulativeTimes.get(timeBinIndex);
  118.                 MutableAccelerationVector accelerationValues = this.cumulativeAccelerations.get(timeBinIndex);
  119.                 for (int distanceBinIndex = firstDistanceBin; distanceBinIndex < endDistanceBin; distanceBinIndex++)
  120.                 {
  121.                     cumulativeTimeInSI += timeValues.getSI(distanceBinIndex);
  122.                     cumulativeAccelerationInSI += accelerationValues.getSI(distanceBinIndex);
  123.                 }
  124.             }
  125.         }
  126.         catch (ValueException exception)
  127.         {
  128.             System.err.println(String.format("Error in getZValue(timeBinRange=[%d-%d], distanceBinRange=[%d-%d]",
  129.                 firstTimeBin, endTimeBin, firstDistanceBin, endDistanceBin));
  130.             exception.printStackTrace();
  131.         }
  132.         if (0 == cumulativeTimeInSI)
  133.         {
  134.             return Double.NaN;
  135.         }
  136.         return cumulativeAccelerationInSI / cumulativeTimeInSI;
  137.     }

  138. }