JKexing2D.cc

Go to the documentation of this file.

#include <string>
#include <iostream>
#include <fstream>
#include <iomanip>
#include <vector>
 
#include "TROOT.h"
#include "TFile.h"
#include "TH2D.h"
#include "TF1.h"
#include "TParameter.h"
 
#include "JROOT/JMinimizer.hh"
 
#include "JDAQ/JDAQEvaluator.hh"
 
#include "JDetector/JDetector.hh"
#include "JDetector/JDetectorToolkit.hh"
 
#include "JROOT/JManager.hh"
 
#include "JROOT/JROOTClassSelector.hh"
 
#include "JSupport/JMultipleFileScanner.hh"
#include "JSupport/JTreeScanner.hh"
#include "JSupport/JAutoTreeScanner.hh"
#include "JSupport/JSupport.hh"
#include "JSupport/JMeta.hh"
 
#include "JLang/JObjectMultiplexer.hh"
#include "JMath/JMathSupportkit.hh"
 
#include "Jeep/JPrint.hh"
#include "Jeep/JParser.hh"
#include "Jeep/JMessage.hh"
 
#include "JTools/JCombinatorics.hh"
#include "JTools/JQuantile.hh"
 
#include "km3net-dataformat/online/JDAQHit.hh"
 
#include "JTrigger/JHit.hh"
#include "JTrigger/JHitR0.hh"
#include "JTrigger/JSuperFrame2D.hh"
#include "JTrigger/JDAQHitToTSelector.hh"
 
#include "JSupernova/JSupernova.hh"
#include "JSupernova/JKexing2D.hh"
 
 
using namespace std;
using namespace JPP;
using namespace KM3NETDAQ;
using namespace JSUPERNOVA;
using namespace JROOT;
 
/**
 * \author mlincett
 * \file
 * Example application to analyse intra-run supernova background
 */
int main(int argc, char **argv)
{
 
  typedef JRange<int> JRange_t;
  typedef JRange<JDAQHit::JTOT_t>    JToTRange_t;
 
  JMultipleFileScanner<> inputFile;
  JLimit_t&              numberOfEvents = inputFile.getLimit();
  string                 outputFile;
  string                 detectorFile;
  double                 TMax_ns;
  double                 TVeto_ns;
  JToTRange_t            totRange_ns;
  JDAQHitToTSelector     totSelector_ns;
  JROOTClassSelector     selector;
  bool                   timeDifferences;
  int                    debug;
  int                    preTriggerThreshold;
 
  // Check input parameters
 
  try { 
 
    JParser<> zap("Example application to study supernova detection background");
    
    zap['f'] = make_field(inputFile);
    zap['o'] = make_field(outputFile)          = "kexing2D.root";
    zap['n'] = make_field(numberOfEvents)      = JLimit::max();
    zap['a'] = make_field(detectorFile);
    zap['T'] = make_field(TMax_ns)             = 10.0;
    zap['V'] = make_field(TVeto_ns)            = 1000.0;  
    zap['D'] = make_field(timeDifferences);
    zap['C'] = make_field(selector)            = getROOTClassSelection<JDAQTimesliceTypes_t>();
    zap['d'] = make_field(debug)               = 1;
    zap['P'] = make_field(preTriggerThreshold) = 4;
    zap['t'] = make_field(totSelector_ns) = JDAQHitToTSelector(4, 255);
    
    zap(argc, argv);
  }
  catch(const exception &error) {
    FATAL(error.what() << endl);
  }
 
 
  JDetector detector;
 
  try {
    load(detectorFile, detector);
  }
  catch(const JException& error) {
    FATAL(error);
  }
 
  // -----------------------------------
  // STEP 0: prepare
  // -----------------------------------
 
  // configure input streams
 
  JTreeScanner<>::debug = debug;
 
  JAutoTreeScanner<JDAQTimeslice, JDAQEvaluator> zmap = JType<JDAQTimesliceTypes_t>();
 
  JTreeScannerInterface<JDAQTimeslice>* pts = zmap[selector]; 
 
  pts->configure(inputFile);
 
  // detect input stream size
 
  
  int    fEnd   = pts->rbegin()->getFrameIndex();
  int    fStart = pts->begin( )->getFrameIndex(); 
 
 
  // crop histogram if -n is specified
  if (fEnd > inputFile.getUpperLimit()) {
    fEnd = fStart + inputFile.getUpperLimit();
  }
 
  int fLength = 1 + fEnd - fStart;
 
  NOTICE("begin | end | length = " << fStart << " | " << fEnd << " | " << fLength << endl);
 
 
  if (fStart > fEnd) {
    FATAL("FATAL: inconsistent TTree indexing" << endl);
  }  
 
  // detector routers
 
  const JModuleRouter moduleRouter(detector);
  
  const JDAQHitRouter hitRouter(detector);
 
  // data structures
 
  const int    nx   = fLength;
  const double xmin = fStart;
  const double xmax = fEnd + 1;
 
  const int    ny   = NUMBER_OF_PMTS + 1; 
  const double ymin = -0.5;
  const double ymax = ymin + ny;
 
  typedef JManager <string, TH2D>  JManager2D_t;
  typedef JManager <string, TH1D>  JManager1D_t;
 
  JManager2D_t MT(new TH2D(mul_p   , NULL, nx, xmin, xmax, ny, ymin, ymax));
  JManager1D_t ST(new TH1D(status_p, NULL, nx, xmin, xmax));
 
  // -----------------------------------
  // STEP 1: building vetoes from events
  // -----------------------------------
 
  int runNumber = 0;
 
  TH1D* h_vtr = new TH1D("VetoTimeRange","VetoTimeRange", 10000, 0, 10000);
 
  JTreeScanner<JDAQEvent, JDAQEvaluator> evIn(inputFile);
 
  map<int, JVetoSet> triggeredEvents; 
 
  for (; evIn.hasNext(); ) {
 
    STATUS("event: " << setw(10) << evIn.getCounter() << '\r'); DEBUG(endl);
    
    JDAQEvent* event = evIn.next();
 
    if (!runNumber) { runNumber = event->getRunNumber(); }
 
    JVeto vp(*event, hitRouter);
 
    triggeredEvents[event->getFrameIndex()].push_back(vp);
 
    h_vtr->Fill(vp.getLength());
 
  } 
 
  STATUS(triggeredEvents.size() << " JDAQEvents loaded in veto buffer." << endl);
 
  TParameter<int> RUNNR("RUNNR", runNumber);
  // TParameter<int> TSTART("TSTART", tStart)
 
  //-----------------------------
  // STEP 2: timeslice processing
  // ----------------------------
 
  counter_type counter = 0;
 
  for ( ; pts->hasNext() && counter != inputFile.getLimit(); ++counter) {
 
    STATUS("timeslice: " << setw(10) << counter << '\r'); DEBUG(endl);
 
    const JDAQTimeslice* timeslice = pts->next();
 
    int fIndex = timeslice->getFrameIndex();
 
    if (counter == 0) {
      NOTICE("Start frame index  = " << fIndex << " @ T " << timeslice->getTimesliceStart() << endl);
    }
        
    JVetoSet veto;
    
    if (triggeredEvents.count(fIndex)) { 
      veto = triggeredEvents.at(fIndex);
    }
 
    // L0-L1 processing
 
    typedef JHitR0 hit_type;
      
    typedef JSuperFrame2D<hit_type> JSuperFrame2D_t;
 
    typedef JSuperFrame1D<hit_type> JSuperFrame1D_t;
 
    const JMatchL0<hit_type> match(TMax_ns);
 
    double fractionActivePMTs = 0;
    
    int nDOMs = timeslice->size();
 
    for (JDAQTimeslice::const_iterator frame = timeslice->begin(); frame != timeslice->end(); ++frame) {
 
      int moduleID = frame->getModuleID();
 
      fractionActivePMTs += ((double) frame->countActiveChannels());
 
      JSuperFrame2D_t& buffer = JSuperFrame2D_t::demultiplex(*frame,
                                                             moduleRouter.getModule(moduleID));
      //                                                               totSelector_ns);
 
      buffer.preprocess(JPreprocessor::join_t, match);
 
      JSuperFrame1D_t& data = JSuperFrame1D_t::multiplex(buffer);
 
      // sort(data.begin(), data.end()); // JSuperFrame1D is sorted
 
      // histogram for time differences, may not be used
 
      TH1D* h2dt = new TH1D("H2DT", "H2DT", 100, -TMax_ns, +TMax_ns); 
        
      for (vector<JHitR0>::const_iterator p = data.begin(); p != data.end(); ) {
 
        vector<JHitR0>::const_iterator q = p;
        
        while (++q != data.end() && q->getT() - p->getT() <= TMax_ns) {}
            
        int m = distance(p, q);
 
        // raw multiplicity count //
 
        MT["RAW"]->Fill(fIndex, m);
 
        // time difference distribution
            
        if (selector != "JDAQTimesliceSN" && timeDifferences && m > 1) { 
          const double W = factorial(m, 2);
          for (vector<JHitR0>::const_iterator __p = p; __p != q; ++__p) {
            for (vector<JHitR0>::const_iterator __q = __p; ++__q != q; ) {
              double dt = JCombinatorics::getSign(__p->getPMT(), __q->getPMT()) * (__q->getT() - __p->getT());
              h2dt->Fill(dt, 1.0/W);
            }
          }
        }
          
        // slide iterator
          
        p = q;
            
      } // end hit processing
        
      if (h2dt->GetEntries() > 0) {
          
        TF1 f("f", "[0]*exp(-0.5*(x-[1])*(x-[1])/([2]*[2]))/(TMath::Sqrt(2*TMath::Pi())*[2]) + [3]");
 
        f.SetParameter(0, h2dt->GetMaximum());
        f.SetParameter(1, h2dt->GetMean());
        f.SetParameter(2, h2dt->GetRMS() * 0.25);
        f.SetParameter(3, h2dt->GetMinimum());
          
        h2dt->Fit(&f, "Q", "same");
 
        double nb = h2dt->GetNbinsX();
        double bg_v = f.GetParameter(3) * nb;
        double sg = h2dt->GetSumOfWeights() - bg_v;
          
        // inclusive 2-fold after subtraction of fitted background //
          
        MT["FIT"]->Fill(fIndex, 2, sg);
          
      }
 
      delete h2dt;
 
    }
 
    // end timeslice processing
 
    fractionActivePMTs /= (NUMBER_OF_PMTS * nDOMs);
 
    ST["PMT"]->Fill(fIndex, fractionActivePMTs);
 
    // STANDARD PROCESSING
 
    JDataSN preTrigger(TMax_ns, preTriggerThreshold);// totSelector_ns); 
 
    preTrigger(timeslice, moduleRouter, totSelector_ns);
 
    JTriggerSN trigger(TVeto_ns);
 
    trigger(preTrigger);
 
    // generate and configure event-based veto
    
    // count trigger
 
    JRange_t A = JRange_t(4,31);
 
    // select single-module clusters with max multiplicity in range A
    JSNFilterM  trgA1(A, 1);
 
    // select non-vetoed clusters with max multiplicity in range A
    JSNFilterMV trgAV(A, veto);
    
    vector<double> m_a1 = trigger.getMultiplicities(trgA1);
 
    for (vector<double>::const_iterator p = m_a1.begin(); p != m_a1.end(); p++) {
      MT["TA1"]->Fill(fIndex, *p);
    }
 
    vector<double> m_av = trigger.getMultiplicities(trgAV);
 
    for (vector<double>::const_iterator p = m_av.begin(); p != m_av.end(); p++) {
      MT["TAV"]->Fill(fIndex, *p);
    }
    
  }
 
  //-------------------------------------
  // STEP 3: generating trigger summaries
  // ------------------------------------
 
  if (outputFile != "") {
 
    TFile out(outputFile.c_str(), "RECREATE");
 
    putObject(out, JMeta(argc,argv));
 
    RUNNR.Write();
    // TSTART.Write();
 
    h_vtr->Write();
        
    MT.Write(out);
    ST.Write(out);
 
    out.Close();
 
  }
 
}