MdPatternFinder/ConsecutiveInWindowStrategy.cc

Go to the documentation of this file.

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

namespace MdPatternFinderAG {

  ConsecutiveInWindowStrategy::ConsecutiveInWindowStrategy(unsigned int windowSize, unsigned int nOnes) : 
      fWindowSize(windowSize) ,
      fNumOnes(nOnes)
  {
  }
  
  unsigned int
  ConsecutiveInWindowStrategy::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) {
      /*
       * This variables hold the index and time
       * of the first one (true) after a zero.
       * ie all the samples starting from this
       * index until the current one are true.
       * The bool variable indicates whether the
       * one was found, or not in which case theirs
       * values are meaningless.
       */   
      unsigned int firstOneIndex = 0;     // dummy init to please compilers.
      unsigned int firstOneBin   = 0;     // idem.
      bool firstOneFound         = false;
      /*
       * Inhibition window.
       * Start of the sampling window & whether
       * the time is valid (ie a window was found).
       * Curious: these two variables will properly 
       * initialized within the loop.
       */
      unsigned int sampleInitBin = 0;     // dummy init to please compilers. 
      bool vSampleInitBin  = false;
      for (utl::TraceB::SizeType currBin = 0; currBin < samples.GetSize(); ++currBin) {
        bool currSample = samples[ currBin ];

        // counting criteria: fOnes consecutive patterns & inhibtion window not enabled.
        if ( currSample && !vSampleInitBin ) {
          // Check the specific quantity: if only 1, don't care about previous history.
          // If more than one used the index of the leftiest one (without 0s in between).
          if (fNumOnes == 1 || (firstOneFound && currBin-firstOneIndex + 1 == fNumOnes) ) {
            // Register the pattern detection time: the first time of a one.
            recData.AddPatternMatchBin(firstOneBin);
            ++nPatternMatchs;
            // The windows starts on the leftiest one.
            sampleInitBin  = firstOneBin;
            vSampleInitBin = true; // enable inhibition window.
          }
        }
        // Previous values for lookup update.
        if (currSample) {
          //std::cout << " currBin " << currBin << " firstOneIndex " << firstOneIndex << " sampleInitBin " << sampleInitBin
          //        << " currBin-sampleInitBin+1=" << currBin-sampleInitBin+1  
          //        << " vSampleInitBin " << vSampleInitBin << " firstOneFound " << firstOneFound << std::endl;
          if (!firstOneFound) {
            // If the current is a 1 and we weren't 
            // having consecutive ones: this is the leftiest by
            // now.
            firstOneFound = true;
            firstOneIndex = currBin;
            firstOneBin   = currBin;
          }
        } else {
          // The current one is not a 1, then the consecutiveness is
          // broken.
          firstOneFound = false;
        }
        
        // Window criteria
        if (vSampleInitBin && fWindowSize <= (currBin-sampleInitBin)+1 ){
          // Current window ended.
          vSampleInitBin = false;
          firstOneFound  = false;
        }

      }
    }
    return nPatternMatchs;
  }

}