JCalibrateToT.cc File Reference

#include <string>
#include <iostream>
#include <iomanip>
#include <limits>
#include "TROOT.h"
#include "TFile.h"
#include "TH2D.h"
#include "JDAQ/JDAQ.hh"
#include "JDAQ/JDAQTimeslice.hh"
#include "JDetector/JDetector.hh"
#include "JDetector/JDetectorToolkit.hh"
#include "JDetector/JModuleRouter.hh"
#include "JTrigger/JHitR0.hh"
#include "JTrigger/JMatchL0.hh"
#include "JTrigger/JSuperFrame1D.hh"
#include "JTrigger/JSuperFrame2D.hh"
#include "JTrigger/JPreprocessor.hh"
#include "JSupport/JMultipleFileScanner.hh"
#include "JSupport/JSupport.hh"
#include "JSupport/JMeta.hh"
#include "JGizmo/JManager.hh"
#include "JMath/JMathToolkit.hh"
#include "JROOT/JROOTClassSelector.hh"
#include "JROOT/JRootToolkit.hh"
#include "JLang/JObjectMultiplexer.hh"
#include "JTrigger/JTriggerParameters.hh"
#include "JSupport/JTriggerParametersSupportkit.hh"
#include "JCalibrate/JCalibrateToT.hh"
#include "Jeep/JPrint.hh"
#include "Jeep/JParser.hh"
#include "Jeep/JMessage.hh"

Go to the source code of this file.

Functions
int	main (int argc, char **argv)

Detailed Description

Monitoring of PMT time-over-threshold distributions.

Author

mkarel

Definition in file JCalibrateToT.cc.

Function Documentation

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 44 of file JCalibrateToT.cc.

{
  using namespace std;
  using namespace JPP;
  using namespace KM3NETDAQ;
 
  JMultipleFileScanner<JDAQTimesliceTypes_t> inputFile;
  JLimit_t&          numberOfEvents = inputFile.getLimit();
  string             outputFile;
  string             detectorFile;
  JRange<double>     T_ns;
  double             ctMax;
  JRange<int>        multiplicity;
  double             deadTime_us;
  JROOTClassSelector selector;
  JPreprocessor      option;
  int                debug;
 
  try { 
 
    JParser<> zap("Monitoring of PMT time-over-threshold distributions.");
 
    zap['f'] = make_field(inputFile,      "input file.");
    zap['o'] = make_field(outputFile,     "output file.")                                 = "calibrate_tot.root";
    zap['n'] = make_field(numberOfEvents)                                                 = JLimit::max();
    zap['a'] = make_field(detectorFile,   "detector file.");
    zap['T'] = make_field(T_ns,           "time window [ns].")                            = JRange<double>(10.0, 25.0);
    zap['c'] = make_field(ctMax,          "maximal cosine space angle between PMT axes.") =   0.0;
    zap['M'] = make_field(multiplicity,   "multiplicity range of hits on DOM.")           = JRange<int>(1, 2);
    zap['D'] = make_field(deadTime_us,    "L0 dead time (us)")                            = 10;
    zap['C'] = make_field(selector,       "timeslice selector, e.g. JDAQTimesliceL1.")    = getROOTClassSelection<JDAQTimesliceTypes_t>();
    zap['O'] = make_field(option,         "hit pre-processing option.")                   = JPreprocessor::getOptions();
    zap['d'] = make_field(debug,          "debug flag.")                                  = 1;
 
    zap(argc, argv);
  }
  catch(const exception &error) {
    FATAL(error.what() << endl);
  }
 
  cout.tie(&cerr);
  
  //-----------------------------------------------------------
  // check the input parameters
  //-----------------------------------------------------------
  
  if (!T_ns.is_valid()) {
    FATAL("Invalid time window [ns] " << T_ns << endl);
  }
 
  if (selector == JDAQTimeslice  ::Class_Name() ||
      selector == JDAQTimesliceL1::Class_Name()) {
 
    JTriggerParameters parameters;
 
    try {
      parameters = getTriggerParameters(inputFile);
    }
    catch(const JException& error) {
      FATAL("No trigger parameters from input." << endl);
    }
 
    if ((selector == JDAQTimeslice  ::Class_Name() && parameters.writeL1.prescale > 0) ||
        (selector == JDAQTimesliceL1::Class_Name())) {
 
      if (parameters.TMaxLocal_ns < T_ns.getUpperLimit()) {
        FATAL("Option -T <T_ns> = " << T_ns.getUpperLimit() << " is larger than in the trigger " << parameters.TMaxLocal_ns << endl);
      }
    }
  }
  
  if (!multiplicity.is_valid())          { FATAL("Invalid multiplicity " << multiplicity << endl); }
  if ( multiplicity.getLowerLimit() < 1) { FATAL("Invalid multiplicity " << multiplicity << endl); }
  
  //-----------------------------------------------------------
  // load detector file
  //-----------------------------------------------------------
  
  JDetector detector;
 
  try {
    load(detectorFile, detector);
  }
  catch(const JException& error) {
    FATAL(error);
  }
 
  if (detector.empty()) {
    FATAL("Empty detector." << endl);
  }
 
  const JModuleRouter router(detector);
 
  //-----------------------------------------------------------
  // initialise histograms
  //-----------------------------------------------------------
 
  const double zmin =   -0.5;   // [ns]
  const double zmax =  256.5;   // [ns]
  const int    nz   = (int) ((zmax-zmin) / 1.0);
 
  JManager<int, TH2D> manager(new TH2D(MAKE_CSTRING("%" << _2SToT), NULL, NUMBER_OF_PMTS, -0.5, NUMBER_OF_PMTS-0.5, nz, zmin, zmax));
 
  typedef JHitR0        hit_type;
  typedef JSuperFrame2D<hit_type>   JSuperFrame2D_t;
  typedef JSuperFrame1D<hit_type>   JSuperFrame1D_t;
 
  const JMatchL0<hit_type> match(T_ns.getUpperLimit());     // time window self-coincidences [ns]
 
  const double deadTime_ns  =  deadTime_us * 1e3;
 
  JObjectMultiplexer<JDAQTimesliceTypes_t, JDAQTimeslice> in(inputFile, selector);
 
  counter_type counter = 0;
  
  for ( ; in.hasNext() && counter != inputFile.getLimit(); ++counter) {
 
    STATUS("event: " << setw(10) << counter << '\r'); DEBUG(endl);
 
    const JDAQTimeslice* timeslice = in.next();
 
    for (JDAQTimeslice::const_iterator frame = timeslice->begin(); frame != timeslice->end(); ++frame) {
 
      if (router.hasModule(frame->getModuleID())) {
 
        TH2D*          h2     = manager[frame->getModuleID()];
        const JModule& module = router.getModule(frame->getModuleID());
        
        JSuperFrame2D_t& buffer = JSuperFrame2D_t::demultiplex(*frame, module);
 
        buffer.preprocess(option, match);
 
        JSuperFrame1D_t& data = JSuperFrame1D_t::multiplex(buffer);
 
        vector<double> t0(NUMBER_OF_PMTS, -numeric_limits<double>::max());
 
        for (JSuperFrame1D_t::const_iterator p = data.begin(), __end = data.end() - 1; p != __end; ) {
 
          JSuperFrame1D_t::const_iterator q = p;
 
          double ct_max = -1.0;
          double dt_min =  numeric_limits<double>::max();
          
          while (++q != __end && q->getT() - p->getT() < T_ns.getUpperLimit()) {
 
            const double ct = getDot(module.getPMT(p->getPMT()), module.getPMT(q->getPMT()));
            const double dt = q->getT() - p->getT();
 
            if (ct > ct_max) {
              ct_max = ct;
            }
 
            if (dt < dt_min) {
              dt_min = dt;
            }
          }
          
          if (multiplicity(distance(p,q)) && ct_max < ctMax && dt_min > T_ns.getLowerLimit()) {
 
            for (JSuperFrame1D_t::const_iterator __p = p; __p != q; ++__p) {
            
              if (__p->getT() > t0[__p->getPMT()] + deadTime_ns) {
                h2->Fill(__p->getPMT(), __p->getToT());
              }
              
              t0[__p->getPMT()] = __p->getT();
            }
          }
          
          p = q;
        }
      }
    }
  }
  
  STATUS(endl);
  
  //---------------------------------------------
  // store histograms
  //---------------------------------------------
 
  TFile out(outputFile.c_str(), "recreate");
 
  putObject(&out, JMeta(argc, argv));
 
  out << manager;
 
  out.Close();
  out.Write();
}