JHitsExtractor.cc

Go to the documentation of this file.

#include <string>
#include <iostream>
#include <iomanip>
#include <vector>
#include <set>
#include <algorithm>
#include <limits>
#include <map>
#include <memory>
 
#include "TFile.h"
#include "TTree.h"
 
#include "JDAQ/JDAQEventIO.hh"
#include "JDAQ/JDAQTimesliceIO.hh"
#include "JDAQ/JDAQSummarysliceIO.hh"
 
#include "JTrigger/JHitL0.hh"
#include "JTrigger/JBuildL0.hh"
 
#include "JDetector/JDetector.hh"
#include "JDetector/JDetectorToolkit.hh"
#include "JDetector/JModuleRouter.hh"
#include "JDetector/JPMTParametersMap.hh"
 
#include "JDynamics/JDynamics.hh"
 
#include "JSupport/JSingleFileScanner.hh"
#include "JSupport/JMultipleFileScanner.hh"
#include "JSupport/JSummaryFileRouter.hh"
 
#include "JReconstruction/JHitW0.hh"
 
#include "Jeep/JParser.hh"
 
 
namespace {
 
  /**
   * Auxiliary data structure for sorting of hits.
   */
  static const struct {
    /**
     * Compare hits by PMT identifier and time.
     *
     * \param  first         first  hit
     * \param  second        second hit
     * \return               true if first before second; else false
     */
    template<class T>
    bool operator()(const T& first, const T& second) const
    {
      if (first.getPMTIdentifier() == second.getPMTIdentifier())
        return first.getT()             < second.getT();
      else
        return first.getPMTIdentifier() < second.getPMTIdentifier();
    }
  } compare;
}
 
 
 
/**
 * \file
 *
 * Program to extract information about hits and all PMTs in the detector for water property studies using I/O of JFIT::JEvt data.
 */
int main(int argc, char **argv)
{
 
  using namespace std;
  using namespace JPP;
  using namespace KM3NETDAQ;
 
  typedef JMultipleFileScanner<calibration_types>                JCalibration_t;
  typedef JSingleFileScanner< JDAQEvent >                        JSingleFileScanner_t;
  typedef JSingleFileScanner_t::pointer_type                     pointer_type;
 
        
  JSingleFileScanner<JDAQEvent>   inputFile;
  string                          outputFile;
  JLimit_t&                       numberOfEvents = inputFile.getLimit();
  string                          detectorFile;
  JCalibration_t                  calibrationFile;
  double                          Tmax_s;
  double                          rate_Hz;
  JPMTParametersMap               pmtParameters;
  int                             debug;
  
  try { 
 
    JParser<> zap("Program to extract information about hits and all PMTs in the detector for water property studies");
    
    zap['f'] = make_field(inputFile);
    zap['o'] = make_field(outputFile)          = "hits_pmts.root";
    zap['n'] = make_field(numberOfEvents)      = JLimit::max();
    zap['a'] = make_field(detectorFile);
    zap['+'] = make_field(calibrationFile)     = JPARSER::initialised();
    zap['T'] = make_field(Tmax_s)              = 100;
    zap['P'] = make_field(pmtParameters)       = JPARSER::initialised();
    zap['B'] = make_field(rate_Hz)             = 6.0e3;
    zap['d'] = make_field(debug)               = 1;
    
    zap(argc, argv);
  }
  catch(const exception& error) {
    FATAL(error.what() << endl);
  }
 
 
  JDetector detector;
 
  try {
    load(detectorFile, detector);
  }
  catch(const JException& error) {
    FATAL(error);
  }
 
  unique_ptr<JDynamics> dynamics;
 
  try {
    dynamics.reset(new JDynamics(detector, Tmax_s));
    dynamics->load(calibrationFile);
  }
  catch(const exception& error) {
    if (!calibrationFile.empty()) {
      FATAL(error.what());
    }
  }
 
  TFile *out;
  try {
    out = new TFile(outputFile.c_str(), "RECREATE");
  }
  catch(const exception& error){
    FATAL(error.what() << endl);
  }
      
    
      
    
  // Create tree to store information about hits: first hit or not, PMT QE for this hit, PMT rate for this hit, PMT status for this hit, HRV 
  TTree *hits_tree = new TTree("Hits","Tree with hits");
  vector<float> hit_rate, hit_QE, hit_pos_x, hit_pos_y, hit_pos_z, hit_dir_x, hit_dir_y, hit_dir_z, hit_time, hit_tot;
  vector<int> hit_first, hit_HRV, hit_status, hit_dom_id, hit_channel_id;
  hits_tree->Branch("first",&hit_first);
  hits_tree->Branch("QE",&hit_QE);
  hits_tree->Branch("rate",&hit_rate);
  hits_tree->Branch("status",&hit_status);
  hits_tree->Branch("HRV",&hit_HRV);
  hits_tree->Branch("pos_x",&hit_pos_x);
  hits_tree->Branch("pos_y",&hit_pos_y);
  hits_tree->Branch("pos_z",&hit_pos_z);
  hits_tree->Branch("dir_x",&hit_dir_x);
  hits_tree->Branch("dir_y",&hit_dir_y);
  hits_tree->Branch("dir_z",&hit_dir_z);
  hits_tree->Branch("time",&hit_time);
  hits_tree->Branch("tot",&hit_tot);
  hits_tree->Branch("channel_id",&hit_channel_id);
  hits_tree->Branch("dom_id",&hit_dom_id);
 
  // Create tree to store information about all PMTs of the detector
  TTree *pmts_tree = new TTree("PMTs","Tree with PMTs");
  vector<float> pmt_pos_x, pmt_pos_y, pmt_pos_z, pmt_dir_x, pmt_dir_y, pmt_dir_z, pmt_QE, pmt_rate;
  vector<int> pmt_channel_id, pmt_dom_id, pmt_status, pmt_HRV;
  pmts_tree->Branch("pos_x",&pmt_pos_x);
  pmts_tree->Branch("pos_y",&pmt_pos_y);
  pmts_tree->Branch("pos_z",&pmt_pos_z);
  pmts_tree->Branch("dir_x",&pmt_dir_x);
  pmts_tree->Branch("dir_y",&pmt_dir_y);
  pmts_tree->Branch("dir_z",&pmt_dir_z);
  pmts_tree->Branch("QE",&pmt_QE);
  pmts_tree->Branch("channel_id",&pmt_channel_id);
  pmts_tree->Branch("dom_id",&pmt_dom_id);
  pmts_tree->Branch("rate",&pmt_rate);
  pmts_tree->Branch("status",&pmt_status);
  pmts_tree->Branch("HRV",&pmt_HRV);
 
    
  const JModuleRouter router(dynamics ? dynamics->getDetector() : detector);
 
  JSummaryFileRouter summary(inputFile);
    
  JTreeScanner<JDAQEvent, JDAQEvaluator> in(inputFile, inputFile.getLimit());
 
  typedef vector<JHitL0>  JDataL0_t;
    
  const JBuildL0<JHitL0>  buildL0;
    
  while (in.hasNext()) {
 
    STATUS("event: " << setw(10) << in.getCounter() << '\r'); DEBUG(endl);
 
    pointer_type ps  = in.next();
 
    JDAQEvent*   tev = ps;
 
    summary.update(*tev);
        
    if (dynamics) {
      dynamics->update(*tev);
    } 
 
    JDataL0_t dataL0;
 
    buildL0(*tev, router, true, back_inserter(dataL0));
 
    sort(dataL0.begin(), dataL0.end(), JHitL0::compare);
 
    int module_id_last = -1;
    int channel_id_last = -1;
      
    // Loop over hits      
    for (JDataL0_t::const_iterator i = dataL0.begin(); i != dataL0.end(); ++i) {
 
      const JPMTIdentifier id(i->getModuleID(), i->getPMTAddress());
 
      const JPMTParameters& wip = pmtParameters.getPMTParameters(id);
 
      const int    type = wip.getType();
      const double QE   = wip.QE;
      const double R_Hz = summary.getRate(i->getPMTIdentifier(), rate_Hz);
 
      JHitW0 hit(*i, type, QE, R_Hz);
 
      // Positions
      hit_pos_x.push_back(hit.getX());
      hit_pos_y.push_back(hit.getY());
      hit_pos_z.push_back(hit.getZ());
      // Directions
      hit_dir_x.push_back(hit.getDX());
      hit_dir_y.push_back(hit.getDY());
      hit_dir_z.push_back(hit.getDZ());
      // Time and ToT
      hit_time.push_back(hit.getT());
      hit_tot.push_back(hit.getToT());
      // DOM and channel IDs
      hit_dom_id.push_back(hit.getModuleID());
      hit_channel_id.push_back(hit.getPMTAddress());
        
 
      const JPMT& pmt = router.getPMT(JPMTIdentifier(hit.getModuleID(), hit.getPMTAddress()));
 
      hit_status.push_back(pmt.getStatus<JStatus::status_type>());                                       // PMT status
      hit_QE.push_back(hit.getQE());                                                                     // PMT QE
 
      const JDAQSummaryFrame& SummaryFrame = summary.getSummaryFrame(hit.getModuleID());
 
      hit_HRV.push_back(SummaryFrame.testHighRateVeto(hit.getPMTAddress()) ||
                        SummaryFrame.testFIFOStatus(hit.getPMTAddress()));                               // Flag for PMT in HRV
 
      hit_rate.push_back(hit.getR());                                                                    // PMT rate
 
      // Check if the hit is the first one on the channel (1 means first one)
      if ((hit.getModuleID()==module_id_last) && (hit.getPMTAddress()==channel_id_last)){
        hit_first.push_back(0);
      }
      else{
        hit_first.push_back(1);
      }
      module_id_last = hit.getModuleID();
      channel_id_last = hit.getPMTAddress();
 
            
    }
        
 
    // Loop over all PMTs
    for (JDetector::const_iterator i = detector.begin(); i != detector.end(); ++i) {
 
      JModule module = *i;
 
      for (size_t pmt = 0; pmt != module.size(); ++pmt) {
 
        pmt_pos_x.push_back(module[pmt].getX());
        pmt_pos_y.push_back(module[pmt].getY());
        pmt_pos_z.push_back(module[pmt].getZ());
 
        pmt_dir_x.push_back(module[pmt].getDX());
        pmt_dir_y.push_back(module[pmt].getDY());
        pmt_dir_z.push_back(module[pmt].getDZ());
 
        pmt_status.push_back(router.getPMT(JPMTIdentifier(module.getID(), pmt)).getStatus<JStatus::status_type>());
 
        pmt_QE.push_back(pmtParameters.getQE(JPMTIdentifier(module.getID(), pmt)));
          
        pmt_channel_id.push_back(pmt);
        pmt_dom_id.push_back(module.getID());
 
        const JDAQSummaryFrame& SummaryFrame = summary.getSummaryFrame(module.getID());
        pmt_HRV.push_back(SummaryFrame.testHighRateVeto(pmt));
          
        pmt_rate.push_back(summary.getRate(JDAQPMTIdentifier(module.getID(), pmt)));      
 
      }
    }
 
      
    hits_tree->Fill();
    hit_first.clear();
    hit_QE.clear();
    hit_rate.clear();
    hit_status.clear();
    hit_HRV.clear();
    hit_pos_x.clear();
    hit_pos_y.clear();
    hit_pos_z.clear();
    hit_dir_x.clear();
    hit_dir_y.clear();
    hit_dir_z.clear();
    hit_time.clear();
    hit_tot.clear();
    hit_dom_id.clear();
    hit_channel_id.clear();
      
      
    pmts_tree->Fill();
    pmt_pos_x.clear();
    pmt_pos_y.clear();
    pmt_pos_z.clear();
    pmt_dir_x.clear();
    pmt_dir_y.clear();
    pmt_dir_z.clear();
    pmt_channel_id.clear();
    pmt_dom_id.clear();
    pmt_QE.clear();
    pmt_rate.clear();
    pmt_status.clear();
    pmt_HRV.clear();
        
  }
 
  STATUS(endl);
  out->Write();
  out->Close();
}