AmountInWindowStrategy.cc

Go to the documentation of this file.

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

namespace MdMuonCounterAG {

  AmountInWindowStrategy::AmountInWindowStrategy(unsigned int windowSize, unsigned int nOnes) :
    fWindowSize(windowSize) ,
    fNumOnes(nOnes)
  {
  }
  
  unsigned int
  AmountInWindowStrategy::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) {
      // Window to accumulate the positive samples 
      // and the zeros following them (til next positive sample).
      typedef std::deque<std::pair<double, 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;
            // If there are not enought ones, no way: not detected.
            if (win.size() < fNumOnes) {
              detected = false;
              // 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();
            } else {
              // If there are more than what's required, then it's a muon for sure.
              detected = true;
            }
            /*
             * 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();
            }
          }
        }
      }
    }
    return nPatternMatchs;
  }

}