JKaboom.cc File Reference

#include <string>
#include <iostream>
#include <fstream>
#include <iomanip>
#include <vector>
#include "TROOT.h"
#include "TFile.h"
#include "TTree.h"
#include "JDAQ/JDAQEvaluator.hh"
#include "km3net-dataformat/offline/Evt.hh"
#include "JDetector/JDetector.hh"
#include "JDetector/JDetectorToolkit.hh"
#include "JROOT/JROOTClassSelector.hh"
#include "JSupport/JMultipleFileScanner.hh"
#include "JSupport/JTreeScanner.hh"
#include "JSupport/JAutoTreeScanner.hh"
#include "JSupport/JSupport.hh"
#include "Jeep/JPrint.hh"
#include "Jeep/JParser.hh"
#include "Jeep/JMessage.hh"
#include "JTrigger/JDAQHitToTSelector.hh"
#include "JSupernova.hh"

Go to the source code of this file.

Functions
int	initialize_root_tree (JCoincidenceSN &obs, int *frame_number, TTree *tr)
	Initialize the output ROOT file with CCSN candidate information. More...
int	main (int argc, char **argv)

Detailed Description

Authors

selhedri,iagoos

Application to analyse buffered L1 timeslices for the online CCSN analysis

Definition in file JKaboom.cc.

Function Documentation

initialize_root_tree()

int initialize_root_tree ( JCoincidenceSN &  obs, int *  frame_number, TTree *  tr  )

inline

Initialize the output ROOT file with CCSN candidate information.

Parameters

obs	Single-DOM observables
frame_number	Timeslice frame number
tr	Output ROOT tree

Definition at line 50 of file JKaboom.cc.

                                                                                  {
    tr->Branch("dom_id", &obs.moduleID, "dom_id/I");
    tr->Branch("vetoIndex", &obs.vetoIndex, "vetoIndex/I");
    tr->Branch("event_time", &obs.time, "event_time/D");
    tr->Branch("timeslice_time_s", &obs.timeslice_time, "timeslice_time_s/D");
    tr->Branch("frame_number", frame_number, "frame_number/I");
    tr->Branch("multiplicity", &(obs.multiplicity), "multiplicity/I");
    return 0;
}

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 60 of file JKaboom.cc.

{
 
  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;
  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)          = "kaboom.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['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);
  }
 
  cout.tie(&cerr);
 
  JDetector detector;
 
  try {
    load(detectorFile, detector);
  }
  catch(const JException& error) {
    FATAL(error);
  }
 
  TTree *tr = new TTree("singledom", "SN coincidence info");
  JCoincidenceSN SNdata(0,0,0);
  int frame_number;
  initialize_root_tree(SNdata, &frame_number, tr);
 
  // -----------------------------------
  // 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);
 
  // detector routers
 
  const JModuleRouter moduleRouter(detector);
 
  const JDAQHitRouter hitRouter(detector);
 
 
  // -----------------------------------
  // 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);
 
  //-----------------------------
  // STEP 2: timeslice processing
  // ----------------------------
 
  counter_type counter = 0;
 
  TFile *out = new TFile(outputFile.c_str(), "RECREATE");
  tr->SetDirectory(out);
 
  for ( ; pts->hasNext() && counter != inputFile.getLimit(); ++counter) {
 
    STATUS("timeslice: " << setw(10) << counter << '\r'); DEBUG(endl);
 
    const JDAQTimeslice* timeslice = pts->next();
 
    frame_number = timeslice->getFrameIndex();
 
    if (counter == 0) {
      NOTICE("Start frame index  = " << frame_number << " @ T " << timeslice->getTimesliceStart() << endl);
    }
 
    JVetoSet veto;
 
    if (triggeredEvents.count(frame_number)) {
      veto = triggeredEvents.at(frame_number);
    }
 
    // 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(preTriggerThreshold, NUMBER_OF_PMTS);
 
    // 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);
 
    JDAQUTCExtended tstart = timeslice->getTimesliceStart();
    double event_time = tstart.getTimeNanoSecond() * 1e-9;
 
    for(auto &p: trigger){
          SNdata = p.getPeak();
          SNdata.vetoIndex = trgA1(p) ? (trgAV(p) ? 0 : 2) : (trgAV(p) ? 1 : 3); // 0 if no veto, 1 if only DOM correlation veto, 2 if only muon veto, 3 if both
          SNdata.timeslice_time = event_time;
          tr->Fill();
    }
  }
 
  //-------------------------------------
  // STEP 3: Writing data
  // ------------------------------------
 
    tr->Write();
    out->Close();
}