JInterDomCal_IO.hh

Go to the documentation of this file.

#ifndef __IO_CAL__
#define __IO_CAL__
 
//c++ standard library
#include <iostream>
#include <tuple>
 
// Jpp
#include "JDAQ/JDAQTimeslice.hh"
#include "JSupport/JMultipleFileScanner.hh"
#include "Jeep/JParser.hh"
#include "Jeep/JMessage.hh"
#include "JSupport/JMultipleFileScanner.hh"
#include "JDetector/JDetector.hh"
#include "JDetector/JModuleLocation.hh"
#include "JDetector/JPMTRouter.hh"
#include "JLang/JObjectID.hh"
 
#include "Detector.hh"
#include "Control_utils.hh"
 
#include "JDetector/JDetector.hh"
#include "JDetector/JModuleRouter.hh"
#include "JDetector/JDetectorToolkit.hh"
 
 
using namespace JDETECTOR ;
// namespaces
using namespace std;
using namespace JSUPPORT;   // for JFileScanner
using namespace JLANG;   // for JMultipleFileScanner
using namespace JDETECTOR; // for JModuleLocation
 
/**
 * \author rgruiz
 */
 
 
 
/**
 * Structure to store the different command line arguments for JInterDomCal. 
 */
struct IO{
 
  string detector_file ;
 
  string ofname_detx ;
 
  string ofname_checks ;
 
  string ofname_txt ;
 
  string ifname ; 
 
  int string_number ;
 
  int up_pmts ;
 
  int down_pmts ;
 
  int number_neighbors ;
 
  int analysis_level ;
 
  int ref_pmt ;
 
  int tgt_pmt ;
 
};
 
 
 
/**
 * Parses the command line options and fills an IO structure with them. 
 *
 * \param options an option structure
 * \param argc the number of command line arguments
 * \param argv the command line arguments
 *
 * \return 1 if works 2 if it doesn't work
 */
inline int read_options(IO &options, int argc, char **argv){
 
  int a = 0 ;
 
  try {
 
    JParser<string> zap;
 
    zap["c"] = make_field(options.ofname_checks) = "" ;
 
    zap["x"] = make_field(options.ofname_detx) = "out.detx" ;
 
    zap["t"] = make_field(options.ofname_txt) = "" ;
 
    zap["f"] = make_field(options.ifname) ; 
 
    zap["a"] = make_field(options.detector_file) ;
 
    zap["s"] = make_field(options.string_number) ;
 
    zap["u"] = make_field(options.up_pmts) = 1 ;
 
    zap["d"] = make_field(options.down_pmts) = 4 ;
 
    zap["n"] = make_field(options.number_neighbors) = 2 ;
 
    zap["l"] = make_field(options.analysis_level) = 0 ;
 
    zap["rpm"] = make_field(options.ref_pmt) = 0 ;
 
    zap["tpm"] = make_field(options.tgt_pmt) = 22 ;
 
    if (zap.read(argc, argv) != 0)
 
      a = 1;
 
  }
 
  catch(const exception &error) {
 
    ERROR(error.what() << endl);
 
    a = 2;
 
  }
 
  return a ;
 
}
 
 
/**
 * Writes a .detx file with a JDetector.
 *
 * \param filename path to the name of the .detx
 * \param detector the detector to be stored
 */
inline void write_output_det(string filename , const JDetector &detector){
 
  store(filename , detector) ;
 
  cout << endl << "New detector stored in file: " << endl ;
 
  cout << filename << endl ;
 
  cout << "------------------------------------" << endl << endl ;
 
}
 
 
 
/**
 * Writes a .txt with the comparison of the t0s in a given DU for two JDetectors.
 *
 * \param filename path to the name of the .txt
 * \param old_detector one JDetector
 * \param new_detector the other JDetector
 * \param string_number the number of the DU to compare
 * \param ref_pmt pmt in upper hemisphere used for the comparison
 * \param tgt_pmt pmt in lower hemisphere used for the comparsion
 */
inline void write_output_compare(string filename , const JDetector &old_detector, const JDetector &new_detector , int string_number , int ref_pmt , int tgt_pmt){
 
  if (filename.length()==0){
 
    cout << "Omitting comparison with old detector" << endl ;
 
    return ;
 
  }else{
 
    cout << "Writing comparison between new and old detx in file: " << endl ;
 
    cout << filename << endl ;
 
    cout << "------------------------------------" << endl << endl ;
 
    vector<double> t0_diff_new = getDetFile_t0_differences(string_number , new_detector , ref_pmt , tgt_pmt) ;
    
    vector<double> t0_diff_old = getDetFile_t0_differences(string_number , old_detector , ref_pmt , tgt_pmt) ;
 
    vector < tuple <double , double , double> > t0_vs_depth_new = get_t0_offsets_vs_depth(string_number , new_detector) ;
 
    vector < tuple <double , double , double> > t0_vs_depth_old = get_t0_offsets_vs_depth(string_number , old_detector) ;
    
    ofstream txtfile;
 
    txtfile.open (filename);
 
    txtfile << "# Comparison between detector files: column 1 = Delta_t0 new detx , column 2 = Delta_t0 old detx , column 3 = column1 - column 2" << endl;
  
    for(int i=0 ; i<(int)t0_diff_new.size() ; i++){
      
      txtfile << t0_diff_new[i] << "\t" << t0_diff_old[i] << "\t" << t0_diff_new[i] - t0_diff_old[i] << endl;
      
    }
  
    txtfile << "\n# t0 vs depth: column 1 = floor , columns 2,3,4 = depth_new, mean_centered_t0_new , error_new , columns 5,6,7 = depth_old, mean_centered_t0_old , error_old , column 8 = t0_old - t0_new " << endl ;
 
    for (int i=0 ; i < (int)t0_vs_depth_new.size() ; i++){
 
      txtfile << i+1 << "\t" 
              << get<0>(t0_vs_depth_new[i]) << "\t" 
              << get<1>(t0_vs_depth_new[i]) << "\t" 
              << get<2>(t0_vs_depth_new[i]) << "\t" 
              << get<0>(t0_vs_depth_old[i]) << "\t" 
              << get<1>(t0_vs_depth_old[i]) << "\t" 
              << get<2>(t0_vs_depth_old[i]) << "\t"
              << get<1>(t0_vs_depth_new[i]) - get<1>(t0_vs_depth_old[i]) << endl ; 
    }   
 
  }
 
}
 
 
 
/**
 * Writes a .root file with some objects that can be used to check the calibration.
 *
 * \param filename path to the name of the .root
 * \param run The nanobeacon calibration run
 */
inline void write_output_checks(string filename , NBRun& run){
 
  if (filename.length()==0){
 
    cout << "Omitting calibration checks..." << endl ;
 
    return ;
 
  }else{
 
    cout << "Writing calibration checks in file: " << endl ;
 
    cout << filename << endl ;
 
    cout << "------------------------------------" << endl << endl ;
 
    TFile outfile(filename.c_str() , "recreate") ;
    
    outfile.cd() ;
    
    TH2D* srcs = srcs_th2(&run) ;
    TH2D* tgts = tgts_th2(&run) ;
    TH2D* refs = good_refs_th2(&run) ;
    TH2D* tgt_pmts = good_tgt_pmts_th2(&run) ;
 
    srcs->Write() ;
    tgts->Write() ;
    refs->Write() ;
    tgt_pmts->Write();
 
    outfile.mkdir("REF/Good") ;
    outfile.mkdir("REF/Weak") ;
    outfile.mkdir("REF/Saturated") ;
    
    outfile.mkdir("TGT/Good") ;
    outfile.mkdir("TGT/Weak") ;
    outfile.mkdir("TGT/Saturated") ;
 
    vector <SuperModule*> SuperMods = run.getSuperModules() ;
 
      
    for (auto & sm : SuperMods){
 
      for (auto & spm : sm->get_ref_pmts()){
   
        if (spm->getNBPulse()->IsGood()==true) outfile.cd("REF/Good") ;
      
        if (spm->getNBPulse()->IsSaturatedHit()==true) outfile.cd("REF/Saturated") ;
      
        if (spm->getNBPulse()->IsWeak()==true) outfile.cd("REF/Weak") ;
      
        spm->getNBPulse()->getHtime_full()->Write() ;
      
        if (spm->getNBPulse()->IsFitted()==true){
        
          RooWorkspace w = spm->getNBPulse()->getWorkspace() ;
        
          TH1D* h = spm->getNBPulse()->getHtime_full() ;
        
          TCanvas* c1 = RooCanvas(w , h) ;
        
          c1->Write() ;
        
          w.Write() ;
        
        }
      
        outfile.cd() ;
      
      }
             
      for (auto & sms : sm->get_sources()){
 
        for (auto & spm : sms.second){
   
          if (spm->getNBPulse()->IsGood()==true)  outfile.cd("TGT/Good") ;
            
          if (spm->getNBPulse()->IsSaturatedHit()==true) outfile.cd("TGT/Saturated") ;
            
          if (spm->getNBPulse()->IsWeak()==true) outfile.cd("TGT/Weak") ;
        
          spm->getNBPulse()->getHtime_full()->Write() ;
        
          if (spm->getNBPulse()->IsFitted()==true){
          
            RooWorkspace w = spm->getNBPulse()->getWorkspace() ;
 
            TH1D* h = spm->getNBPulse()->getHtime_full() ;
 
            TCanvas* c1 = RooCanvas(w , h) ;
 
            c1->Write() ;
 
            w.Write() ;
 
          }
        
          outfile.cd() ;
 
        }
 
      }
 
    }
 
    outfile.Close() ;
 
  }
 
}
 
 
#endif