PulseFinderTester.h

#ifndef PULSE_FINDER_TESTER_H
#define PULSE_FINDER_TESTER_H

#include "PulseFinder.h"

namespace marlintpc
{

class PulseFinderTester
{
 public:
  PulseFinderTester();

  ~PulseFinderTester();

  int runAllTests();


 protected:  
  struct IteratorProperties
  {
    // distances of iter1 and iter2 to the begin() iterator
    int iterator1Distance;
    int iterator2Distance;
    // values of *iter1 and *iter2
    float iterator1Value;
    float iterator2Value;
    bool  isSplit;
    
  IteratorProperties( int iter1Distance, int iter2Distance, float iter1Value, float iter2Value,
                      bool split=false)
  : iterator1Distance(iter1Distance), iterator2Distance(iter2Distance),
      iterator1Value(iter1Value), iterator2Value(iter2Value), isSplit(split) {}
  };
 
//  /** A reference consists of a vector of IteratorProperties structs and 
//   *  the corresponding begin and end iterators of the data vectors.
//   */
//  struct Reference
//  {
//    std::vector<IteratorProperties> iteratorPropertiesVec;
//    std::vector<float>::const_iterator beginIterator;
//    std::vector<float>::const_iterator endIterator;
//    
//    Reference( std::vector<float>::const_iterator begin,
//             std::vector<float>::const_iterator end)
//    : beginIterator(begin),  endIterator(end) {}
//  };

  struct CandidateProperties
  {
    size_t nSamples;
    float firstSample;
    float lastSample;
    float time;
    int quality;
    
    CandidateProperties(  size_t n, float first, float last, float t, int q)
    : nSamples(n), firstSample(first), lastSample(last), time(t), quality(q)
    {}
  
  };

  struct PulseProperties
  {
    size_t nSamples; //< to have something to check if the TrackerData is there
    //< if it is 0 the trackerData pointer should be NULL
    int quality;
    float time;
    float charge;

    
    PulseProperties( size_t n, // nSamples
                     int q, // quality
                     float t, // time
                     float c) //charge (q is already taken by quality)
    : nSamples(n), quality(q), time(t), charge(c)
    {}
  };

  bool evaluateBruteSearchResult( std::vector< std::pair<std::vector<float>::const_iterator, 
                                                     std::vector<float>::const_iterator> > const & bruteSearchResult,
                              std::vector<IteratorProperties> const & referenceValues ,
                              std::vector<float>::const_iterator beginIterator,
                              std::vector<float>::const_iterator endIterator );

  bool evaluateSplitResult(std::vector<PulseFinder::InternalSplitPulse>  const & splitResult,
                       std::vector<IteratorProperties> const & referenceValues ,
                       std::vector<float>::const_iterator beginIterator,
                       std::vector<float>::const_iterator endIterator );

  bool evaluatePulseCandidate(std::vector<std::pair<TrackerDataImpl *, int> > candidates,
                          std::vector<CandidateProperties> const & referenceCandidateProperties);

  bool evaluatePulses(std::vector<TrackerPulse *> const & pulses,
                  std::vector<PulseProperties> const & referencePulseProperties);

  bool evaluatePlateauCutoff(std::vector<TrackerPulse *> const & pulses,
                         std::vector<std::pair<size_t,size_t> > const & referencePositions,
                         EVENT::FloatVec const & referenceADCValues);

  PulseFinder * _pulseFinder;
  // a pulsefinder with pre and post samples and plateau cutoff
  PulseFinder * _pulseFinderPrePostPlateau;

  float _readoutFrequency; 

};

}

#endif //PULSE_FINDER_TESTER_H