/afs/cern.ch/work/a/aaltunda/public/www/CMSSW_6_2_5/src/SimMuon/CSCDigitizer/src/CSCAnalogSignal.h

Go to the documentation of this file.

#ifndef MU_END_ANALOG_SIGNAL
#define MU_END_ANALOG_SIGNAL

#include <vector>
#include <iosfwd>
#include <cassert>

//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