CSCAnalogSignal.h

Go to the documentation of this file.

#ifndef MU_END_ANALOG_SIGNAL
#define MU_END_ANALOG_SIGNAL
 
#include <cassert>
#include <iosfwd>
#include <vector>
 
// TODO remove
#include <iostream>
 
class CSCAnalogSignal {
public:
  inline CSCAnalogSignal() : theElement(0), invBinSize(0.), theBinValues(0), theTotal(0), theTimeOffset(0.) {}
 
  inline CSCAnalogSignal(
      int element, float binSize, std::vector<float> &binValues, float total = 0., float timeOffset = 0.)
      : theElement(element), invBinSize(1. / binSize), theBinValues(), theTotal(total), theTimeOffset(timeOffset) {
    theBinValues.swap(binValues);
  }
 
  //  CSCAnalogSignal(int element, const CSCAnalogSignal& shape, float time,
  //  float total);
 
  inline int getElement() const { return theElement; };
  inline void setElement(int element) { theElement = element; };
  inline float getBinValue(int i) const {
    return (i >= static_cast<int>(theBinValues.size()) || i < 0) ? 0. : theBinValues[i];
  }
 
  inline float getValue(float t) const {
    // interpolate between bins, if necessary
    float retval = 0.;
    float f = (t - theTimeOffset) * invBinSize + 0.000000001;
    if (f >= 0.) {
      int i = static_cast<int>(f);
      f -= static_cast<float>(i);
      retval = (1. - f) * getBinValue(i) + f * getBinValue(i + 1);
    }
    return retval;
  }
 
  //  inline void  setBinValue(int i, float value) {
  //    if( i >= 0 && i < theBinValues.size() )
  //      theBinValues[i] = value;
  //  }
 
  inline int getSize() const { return theBinValues.size(); };
  inline float getBinSize() const { return 1. / invBinSize; };
  inline float getTotal() const { return theTotal; };
  inline float getTimeOffset() const { return theTimeOffset; };
  inline void setTimeOffset(float offset) { theTimeOffset = offset; };
 
  inline void superimpose(const CSCAnalogSignal &signal2) {
    size_t n = theBinValues.size();
    for (size_t i = 0; i < n; ++i) {
      float t = i / invBinSize + theTimeOffset;
      theBinValues[i] += signal2.getValue(t);
    }
    theTotal += signal2.theTotal;
  }
 
  inline void operator+=(float offset) {
    for (int i = 0; i < getSize(); ++i) {
      theBinValues[i] += offset;
    }
  }
 
  inline void operator*=(float scaleFactor) {
    for (int i = 0; i < getSize(); ++i) {
      theBinValues[i] *= scaleFactor;
    }
    theTotal *= scaleFactor;
  }
 
  friend std::ostream &operator<<(std::ostream &, const CSCAnalogSignal &);
 
  float &operator[](int i) {
    assert(i >= 0 && i < getSize());
    return theBinValues[i];
  }
 
  const float &operator[](int i) const {
    assert(i >= 0 && i < getSize());
    return theBinValues[i];
  }
 
  float peakTime() const;
  unsigned size() const { return theBinValues.size(); }
 
private:
  int theElement;
  float invBinSize;
  std::vector<float> theBinValues;
  float theTotal;
  float theTimeOffset;
};
 
#endif