MdPatternFinder.cc

Go to the documentation of this file.

#include "MdPatternFinder.h"

#include "ConsecutiveInWindowStrategy.h"

#include <fwk/CentralConfig.h>
#include <det/VManager.h>
#include <mdet/MDetector.h>
#include <mevt/Counter.h>

#include <utl/ConsecutiveEnumFactory.h>
#include <utl/Trace.h>
#include <utl/AugerUnits.h>
#include <utl/Branch.h>
#include <utl/ConfigUtils.h>

#include <utl/ErrorLogger.h>
#include <utl/Verbosity.h>

#include <sstream>
#include <cassert>

using namespace fwk;
using std::cout;
using std::endl;


namespace MdPatternFinderAG {

  const char* const MdPatternFinder::kStrategyTags[] = { "Consecutive" };

  VModule::ResultFlag
  MdPatternFinder::Init()
  {
    // Configuration reading.
    utl::Branch config = fwk::CentralConfig::GetInstance()->GetTopBranch("MdPatternFinder");
    fUnits.SetTimeDefault(utl::ns, "ns");
    fUnits.Configure(config);
    fLog.Configure(config);
    std::string tag;
    LoadConfig(config, "strategy", tag, kStrategyTags[0]);
    fStrategy = utl::ConsecutiveEnumFactory<Strategy, eConsecutive, kStrategyTags>::Create(tag);

    // Init according to selected strategy.
    switch (fStrategy) {
    case eConsecutive:
      LoadConfig(config, "windowSize", fWindowSize, 18);
      LoadConfig(config, "nOnes", fNOnes, 4);
      fFinder.reset(new ConsecutiveInWindowStrategy(fWindowSize, fNOnes));
      fLog("#Window size", 1)
        (fWindowSize)("-")
        ("Number of ones")(fNOnes)("-")
        ("Strategy")(kStrategyTags[ fStrategy ])(".");
      break;
    }

    return eSuccess;
  }


  VModule::ResultFlag
  MdPatternFinder::Run(evt::Event& event)
  {
    if (!event.HasMEvent()) {
      WARNING("\n+++++++++\nEvent without MEvent: nothing to be done. Skipping to next event.\n++++++++++\n");
      return eContinueLoop;
    }

    mevt::MEvent& me = event.GetMEvent();
    const mdet::MDetector& theMdDetector = det::Detector::GetInstance().GetMDetector();

    std::ostringstream os;
    for (mevt::MEvent::CounterIterator ic = me.CountersBegin(), ec = me.CountersEnd(); ic != ec; ++ic) {

      mevt::Counter& counter = *ic;
      const int counterId = counter.GetId();
      const mdet::Counter& mdetCounter     = theMdDetector.GetCounter(counterId);

      if (counter.IsRejected()) {
         os.str("");
         os << "Skipping the rejected counter " << counterId;
         INFO(os);
         continue;
      }

      os.str("");
      os << "Processing counter " << counterId;
      INFO(os);

      for (mevt::Counter::ModuleIterator im = counter.ModulesBegin(), em = counter.ModulesEnd(); im != em; ++im) {

        mevt::Module& module = *im;
        const int moduleId = module.GetId();
        const mdet::Module&  mdetModule = mdetCounter.GetModule(moduleId);
        
        os.str("");
        os << "Processing module " << moduleId;
        INFO(os);

        // Check if module was flagged as rejected (by a selector) or, in the case of real data, if T1 from SD was not matched
        // this should imply an empty (all "0s" ) module traces
        if (module.IsRejected()) {
           os.str("");
           os << "Module " << module.GetId() << " of counter " << counterId;
           os << " discarded because flagged as: " << module.GetRejectionReason();
           WARNING(os);
           continue;
        }
        
        unsigned int nTotalChannelsOn = 0; // total number of channels with at least one pattern match
        
        for (mevt::Module::ChannelIterator ch = module.ChannelsBegin(), ech = module.ChannelsEnd(); ch != ech; ++ch) {
          mevt::Channel& channel = *ch;

          const unsigned int nRecPatternMatches = FillChannelRecData(channel, mdetModule);

          os.str("");
          os << "counter " << counterId << ": "
             << "module "  << module.GetId() << "  "
             << "channel " << channel.GetId() << "  "
             << nRecPatternMatches <<  " pattern(s) match(es) was(were) found ";
          os << PrintPatternMatchBins(channel);

          if ( nRecPatternMatches ) {
            fLog( os.str(), 5 );
            nTotalChannelsOn +=1;
          }
        }

        if (!module.HasRecData())
          module.MakeRecData();

        mevt::ModuleRecData& mRecData = module.GetRecData();

        const size_t segmentation = module.GetNumberOfActiveChannels();
        mRecData.SetSegmentation(segmentation);
        mRecData.SetWindowSize(fWindowSize);
        assert(nTotalChannelsOn <= 64);
        mRecData.SetTotalNumberOfChannelsOn(nTotalChannelsOn);

      } // end module loop

    } // end counter loop

    return eSuccess;
  }


  VModule::ResultFlag
  MdPatternFinder::Finish()
  {
    return eSuccess;
  }


  // Private methods

  unsigned int
  MdPatternFinder::FillChannelRecData(mevt::Channel& channel, const mdet::Module& mdetModule)
  {
    if (!channel.HasTrace())
      return 0;

    const utl::TraceB trace = channel.GetTrace();

    if (channel.HasRecData()) {
      if (channel.GetRecData().GetNumberOfPatternMatchs()) {
        fLog("Clearing", 35)
          (channel.GetRecData().GetNumberOfPatternMatchs())
          ("preexisting muons for channel=")(channel.GetId())(':')
          ("in rec info.");
        channel.GetRecData().ClearPatternMatchBins();
      }
    } else
      channel.MakeRecData();

    mevt::ChannelRecData& rData = channel.GetRecData();
    // reconstructed muons
    const unsigned int nRecPatternMatches = (*fFinder)(trace, rData);

    /*Reconstructed trace. Values means: 0- no signal
     *                                   1- identified first bin of given pattern match
     *                                   2- inhibited bin
     */
     if (channel.HasRecData() && !channel.IsMasked()) {  // use unmasked channels only
       const unsigned int numberOfSamples = mdetModule.IsSiPM() ?
         mdetModule.GetFrontEndSiPM().GetBufferLength() :
         mdetModule.GetFrontEnd().GetBufferLength();

       if (!rData.HasTrace())
         rData.MakeTrace();

       utl::TraceUI& traceRec = rData.GetTrace();
       traceRec.Clear();

       for ( size_t bin = 0; bin < numberOfSamples; ++bin )
          traceRec.PushBack(0);//no signal

        for (mevt::ChannelRecData::PatternMatchBinIterator pIt = rData.PatternMatchBinsBegin(),
             end = rData.PatternMatchBinsEnd(); pIt != end; ++pIt) {
          traceRec.At(*pIt) = 1; //Starting bin of a pattern match
          for ( size_t bin = 1; bin < fWindowSize && *pIt+bin<numberOfSamples; ++bin )
             traceRec.At(*pIt+bin) = 2;//inhibited bins
        }

        //Print values for debugging
        const unsigned int debugLevel = 30;
        if (nRecPatternMatches && fLog.GetLevel() >= debugLevel ) {
          fLog("Channel", debugLevel, false)(channel.GetId())(":");
          for ( size_t bin = 0; bin < numberOfSamples || fLog("|", debugLevel); ++bin )
             if( traceRec.At(bin) ) fLog("|",debugLevel,false)(traceRec.At(bin))(":")(bin);
        }

     }

    return nRecPatternMatches;
  }


  std::string
  MdPatternFinder::PrintPatternMatchBins(const mevt::Channel& channel)
    const
  {
    std::ostringstream os;
    os.str("");
    os << "at bin(s) ";

      if (channel.HasRecData() && !channel.IsMasked()) {  // use unmasked channels only
        for (mevt::ChannelRecData::PatternMatchBinIterator mut = channel.GetRecData().PatternMatchBinsBegin(),
             end = channel.GetRecData().PatternMatchBinsEnd(); mut != end; ++mut) {
          os << "  " << (*mut);
        }
      }
    return os.str();
  }

}