GapStrategy.cc

Go to the documentation of this file.

#include "GapStrategy.h"
//
#include <mevt/ChannelRecData.h>
//
#include <utl/Trace.h>
//
#include <deque>

namespace MdMuonCounterAG {

  GapStrategy::GapStrategy(unsigned int windowSize, unsigned int nOnes, unsigned int nGaps, const std::string opt ) :
    fWindowSize(windowSize) ,
    fNumOnes(nOnes),
    fNumGaps(nGaps),
    fOpt( opt )
  {
  }
  
  unsigned int
  GapStrategy::operator()(const utl::TraceB& samples, mevt::ChannelRecData& recData)
    const
  {
    unsigned int nPatternMatchs = 0;
    /*
     * The sample has to contain at least fNumOnes samples.
     */
    if (samples.GetSize() >= fNumOnes+fNumGaps) {
      // Window to accumulate the positive samples 
      // and the zeros following them (til next positive sample).
      typedef std::deque<std::pair<unsigned int, unsigned int> > Window;
      typedef Window::const_iterator WinItor;
      Window win;
      // Global count of zeros within the current window.
      unsigned int nZeros = 0;
      for (utl::TraceB::SizeType sNumber = 0; sNumber < samples.GetSize();) {
        /*
         * Window updating.
         */ 
        if (samples[ sNumber ]) {
          // Register the bin and an own zero count.
          win.push_back(std::make_pair(sNumber, 0));
        } else if (! win.empty()){
          // If there's an open window, increase the zero count
          // (of the trailing element of the window),
          win.back().second++;
          // ... and increase the global count.
          ++nZeros;
        }
        // Advance to the next (or the samples are exhausted).
        ++sNumber;
        /*
         * Window checking.
         */ 
        // If not empty, then a window is being considered.
        if (! win.empty() ) {
          // Check if we ran out of samples, or the advanced-to sample lies outside the window.
          // In both cases we have to analyze what's in the window.
          if ( sNumber == samples.GetSize() || !(sNumber-win.front().first < fWindowSize) ) {
            bool detected=false;
            if (win.size() >= fNumOnes) {
              double sumOnes=0;
              double sumZeros=0;
              WinItor wIt = win.begin();
              for(; wIt!=win.end(); ++wIt){
                sumOnes+=1;
                if(sumOnes+sumZeros>=fNumOnes+fNumGaps)
                  break;
                sumZeros+=(*wIt).second;
              }
              if ( sumOnes>=fNumOnes ) {
                 /*
                  In the "strict" option the number of Zeros (or Gaps) in the signal is fixed by fNumGaps and by
                  definition the pattern has to be fulfilled at the beggining of a trace.
                  This means that only fNumGaps number of Zeros are allow in the signal. 
                  Thus the minimum patterns to be matched to fulfill the 1X1 condition is 111 or 101 
                  at a beginning of a muon trace within a fWindowSize window. 
                  Either 1001 or 11001 are not matched for the strict strategy. To relax this condition and 
                  to allow at most fNumGaps number of Zeros, use
                  "relax" option which implies that at most fNumGaps should be present in between the fNumOnes number of Ones.
                 */
                 if ( fOpt=="strict" ) {

                   if ( (sumZeros<=fNumGaps) && (sumOnes+sumZeros==fNumOnes+fNumGaps) ) 
                     detected=true;

                 } else {//relax 
                   //Continue with the sum of Zeros
                   for (bool first=true; wIt!=win.end(); ++wIt, first=false) {
                      if( !first) sumOnes+=1;//fisrt 1 already added in previous loop
                   }
                   double DeltaOnes = (win.back().first-win.front().first);

                   if ( (sumOnes+sumZeros <= fWindowSize) ){ //Sanity check: total amount of samples must not exceed the window
                     if( sumOnes > fNumOnes ) 
                       detected=true;
                     else  if ( (1<DeltaOnes)&&(DeltaOnes<(fNumGaps+1)) ) 
                       detected=true;
                   }//end sanity if
                 }//end relax condition 
              }//end if sumOnes>=fNumOnes
            }//end if win.size() >= fNumOnes
            /*
             * On-detection actions.
             */
            if (detected) {
              // The bin of detection is the start bin (note that with the strategy
              // here implemented the first bin is guaranteed to be correspond
              // to a one, but not the last).
              nZeros = 0;
              recData.AddPatternMatchBin(win.front().first);
              ++nPatternMatchs;
              // get rid of everything because we have already counted a muon.
              win.clear();
            } else {
              // Erase only the first element (reducing the quantity of ones):
              // it has been found that a window starting at this one is not good.
              // Before poping, substract the zeros from the to-be-eliminated one from 
              // the grand total.
              nZeros -= win.front().second;
              win.pop_front();
            }
          }
        }
      }
    }
    return nPatternMatchs;
  } 
}