/**
    * 
    */
   package org.opentrafficsim.water.statistics;
   
   import org.apache.poi.ss.usermodel.CellStyle;
   import org.apache.poi.ss.usermodel.DataFormat;
   import org.apache.poi.ss.usermodel.Row;
   import org.apache.poi.ss.usermodel.Sheet;
  
  import com.thoughtworks.xstream.annotations.XStreamAlias;
  import com.thoughtworks.xstream.annotations.XStreamOmitField;
  
  import nl.tudelft.simulation.dsol.simulators.DEVSSimulatorInterface;
  
  /**
   * <br>
   * Copyright (c) 2011-2013 TU Delft, Faculty of TBM, Systems and Simulation <br>
   * This software is licensed without restrictions to Nederlandse Organisatie voor Toegepast Natuurwetenschappelijk Onderzoek TNO
   * (TNO), Erasmus University Rotterdam, Delft University of Technology, Panteia B.V., Stichting Projecten Binnenvaart, Ab Ovo
   * Nederland B.V., Modality Software Solutions B.V., and Rijkswaterstaat - Dienst Water, Verkeer en Leefomgeving, including the
   * right to sub-license sources and derived products to third parties. <br>
   * @version Mar 24, 2013 <br>
   * @author <a href="http://tudelft.nl/averbraeck">Alexander Verbraeck </a>
   */
  @XStreamAlias("persistent")
  public class XPersistent extends XTally
  {
      /** */
      @XStreamOmitField
      private static final long serialVersionUID = 1L;
  
      /** */
      @XStreamOmitField
      private DEVSSimulatorInterface.TimeDoubleUnit simulator;
  
      /** startTime defines the time of the first event */
      @XStreamOmitField
      private double startTime = Double.NaN;
  
      /** elapsedTime tracks the elapsed time */
      private double elapsedTime = Double.NaN;
  
      /** lastvalue tracks the last value */
      @XStreamOmitField
      private double lastValue = Double.NaN;
  
      /**
       * @param description String; description of the statistic
       * @param simulator DEVSSimulatorInterface.TimeDoubleUnit; the simulator
       */
      public XPersistent(String description, DEVSSimulatorInterface.TimeDoubleUnit simulator)
      {
          super(description);
          this.simulator = simulator;
      }
  
      /** {@inheritDoc} */
      @Override
      public double getSampleMean()
      {
          if (super.n > 1 && this.elapsedTime > 0)
              return super.sum / elapsedTime;
          else
              return Double.NaN;
      }
  
      /** {@inheritDoc} */
      @Override
      public double getStdDev()
      {
          synchronized (this.semaphore)
          {
              if (super.n > 1)
              {
                  return Math.sqrt(super.varianceSum / this.elapsedTime);
              }
              return Double.NaN;
          }
      }
  
      /** {@inheritDoc} */
      @Override
      public double getSampleVariance()
      {
          synchronized (this.semaphore)
          {
              if (super.n > 1)
              {
                  return super.varianceSum / this.elapsedTime;
              }
              return Double.NaN;
          }
      }
  
      /** {@inheritDoc} */
      @Override
      public void initialize()
      {
         synchronized (this.semaphore)
         {
             super.initialize();
             this.elapsedTime = 0.0;
             this.lastValue = 0.0;
         }
     }
 
     /**
      * dstat
      * @param value double; value
      */
     public void persist(final double value)
     {
         if (!Double.isNaN(value))
         {
             synchronized (this.semaphore)
             {
                 double simTime = this.simulator.getSimulatorTime().si;
                 super.n++;
                 if (value < super.min)
                     super.min = value;
                 if (value > super.max)
                     super.max = value;
 
                 if (super.n == 1)
                     this.startTime = simTime;
                 else
                 {
                     double deltaTime = simTime - (this.elapsedTime + this.startTime);
                     if (deltaTime > 0.0)
                     {
                         super.sum += lastValue * deltaTime;
                         super.varianceSum += lastValue * lastValue * deltaTime;
                         this.elapsedTime = this.elapsedTime + deltaTime;
                     }
                 }
                 this.lastValue = value;
             }
         }
     }
 
     /**
      * @see org.opentrafficsim.water.statistics.XTally#writeToExcel(org.apache.poi.ss.usermodel.Sheet, int)
      */
     @Override
     public int writeToExcel(final Sheet sheet, final int startRow)
     {
         DataFormat format = sheet.getWorkbook().createDataFormat();
         CellStyle style = sheet.getWorkbook().createCellStyle();
         style.setDataFormat(format.getFormat("0.00"));
 
         int rownr = startRow;
         Row row = sheet.createRow(rownr);
 
         row.createCell(1).setCellValue(description);
         row.createCell(2).setCellValue("tijdgewogen [n, gem, stdev, min, max]");
         row.createCell(3).setCellValue(getN());
         if (getN() > 0)
         {
             row.createCell(4).setCellValue(getSampleMean());
             row.getCell(4).setCellStyle(style);
             if (getN() > 1 && !Double.isNaN(getStdDev()))
             {
                 row.createCell(5).setCellValue(getStdDev());
                 row.getCell(5).setCellStyle(style);
             }
             row.createCell(6).setCellValue(getMin());
             row.getCell(6).setCellStyle(style);
             row.createCell(7).setCellValue(getMax());
             row.getCell(7).setCellStyle(style);
         }
 
         return rownr + 1;
     }
 
 }