NBRun.hh

Go to the documentation of this file.

#ifndef __NBRUN__
#define __NBRUN__
 
#include "JDetector/JDetectorToolkit.hh"
#include "TFile.h"
#include "TVectorD.h"
#include "SUPERMODULE.hh"
#include "PMT_choice.hh"
 
using namespace std ;
 
using namespace JDETECTOR ;
 
/**
 * \author rgruiz
 */
 
 
/**
 * Class dedicated to the nanobeacon analyses, where the Modules in the detector are not regarded as single entities. Instead, they are related
 * to the rest of the DOMs in a DU through the emission of the nanobeacon pulses. A DOM can be emitter (source) of light that is detected by other DOMS, and 
 * it can also be a receiver (target) of the light emitted by the other DOMS. The SUPERRUN class is meant to own the different SUPERMODULEs in a DU, to coherently set their mutual rerefences and to analyze the signal produced by the different nanobeacons in the different PMTs of the DU.
 */
class NBRun {
  
  vector<int> topPMTs , bottomPMTs , srcPMTs , tgtPMTs;  
 
  int nSuperModules  ;
 
  int max_distance ;
  
  int string_number ;
 
  string filename ;
 
  int run_number ;
 
  double voltage ;
 
  JDetector detector ;
 
  vector<SuperModule*> SuperMods ;
 
public :
 
 
  /**
   * Default constructor.
   */
  NBRun (){} ;
 
 
 
  /**
   * Constructor.
   * It initializes the Structure of SuperModules and leaves it ready for analyzing it.  
   *
   * \param filename_ The name of a .root file containing the time vs ToT hit distributions for different PMTs in the DU 
   * \param detector_ A detector file with the DU that is going to be analyzed.
   * \param string_ String number of the string to be analyzed (as it appears in the detector file)
   * \param pmt_top Integer number representing the user's choice 
   * \param pmt_bottom Integer number representing the user's choice 
   * \param max_distance_ Integer number representing the maximum number of neighbors to for each module. 
   */
  NBRun (string filename_ , JDetector detector_ , int string_ , int pmt_top , int pmt_bottom , int max_distance_):
    nSuperModules (getNumberOfFloors(detector_)) 
  {
    
    filename = filename_ ;
    
    string_number = string_ ;
 
    max_distance = max_distance_ ;
 
    setDetector (detector_) ;
    
    initializeSuperModules () ;
 
    setPMTs (pmt_top , pmt_bottom) ;
 
    readFile() ;
    
  }
 
 
 
  /**
   * Destructor.
   */
  ~NBRun(){
 
    for (auto & sm : SuperMods){
 
      delete(sm) ;
    
    }
 
  };
 
 
 
  /**
   * Loops over all the SUPERMODULES to compute the mean ToT of the hits from the different nanobeacon pulses recorded by the different PMTs.
   */
  void computeMeanToTs(){
 
    for (auto & sm : SuperMods){
    
      sm->compute_mean_tot_ref() ;
 
      sm->compute_mean_tot_tgt() ;
 
    }
 
  }
 
 
 
  /**
   * Loops over all the SUPERMODULES. For each of them, it searches for good sources and good targets .
   */
  void find_good_couples(){
 
    for (auto & sm : SuperMods){
    
      sm->select_good_srcs() ;
 
      sm->select_good_tgts() ;
 
    }
 
  }
 
 
  /**
   * Loops over all the SUPERMODULES. Analyzes the nanobeacon pulses detected by the different PMTs. After they have been analyzed, the method find_good_couples is called. 
   *
   * \param option Level of analysis of the nanobeacon pulses. 0 for a fast analysis 1 for a fit to a model
   */
  void analyze(int option){
  
    for (auto & sm : SuperMods){
 
      switch(option){
 
      case 0 :
        
        sm->analyzeAll() ;
 
        break ;
 
      case 1 :
    
        sm->fitAll() ;
    
        break ;
 
      }
   
    } 
  
    find_good_couples();
 
  }
 
 
  /**
   * Reads a .root file containing the nanobeacon pulses observed by the different PMTs in the detector. 
   */
  void readFile (){
 
    TFile* file = TFile::Open(filename.c_str()) ;
 
    readBasicInfo (file) ;
 
    setRefs (file) ;
  
    setSrcs (file) ;
 
  } 
 
 
 
  /**
   * Searches in the .root file for histograms corresponding to pulses produced in one target supermodule, by all the possible sources.
   *
   * \param sm supermodule
   * \param file root file
   */
  void findSrcs(SuperModule* sm , TFile* file){
 
    int thisfloor = sm->getFloor () ;
 
    int thisstring = sm->getString () ;
 
    vector<SuperModule*> possible_srcs = sm->get_possible_srcs () ;
  
    for (auto & src : possible_srcs){
 
      int thatfloor = src->getFloor () ;
    
      int thatstring = src->getString () ;
 
      vector<SuperPMT*> spms ;
 
      char name[250] ;
    
      for (auto & pm : bottomPMTs){
      
        sprintf(name , "S%dF%d/S%dF%dPMT%d_beaconS%dF%d" , thisstring , thisfloor, thisstring , thisfloor , pm , thatstring , thatfloor);
      
        if (file -> Get (name) ){
        
          TH2D* h = (TH2D*)file -> Get(name) ;
        
          h->SetDirectory(0) ;
        
          JPMT pmt = sm->getPMT ( pm ) ;
        
          SuperPMT* p = new SuperPMT ( pmt , h , pm) ;
        
          spms.push_back (p) ;
        
        }       
      
      }
   
      if(spms.size()>0){
      
        pair < SuperModule* , vector<SuperPMT*> > src_pair (src , spms) ;
 
        pair < SuperModule* , vector<SuperPMT*> > tgt_pair (sm , spms) ;
 
        sm->add_src (src_pair) ;
 
        src->add_tgt (tgt_pair) ;
 
      }
 
    } 
  
  }
 
 
 
  /**
   * Loops over all the SuoperModules in the DU. For each supermodule, it calls the findSrcs method.
   *
   * \param file root file
   */
  void setSrcs (TFile* file){
 
    for(auto & sm : SuperMods){
    
      findSrcs (sm , file) ;
 
    }
 
  }
 
 
 
  /**
   * Loops over all the SuoperModules in the DU. For each supermodule, it calls the findRefs method.
   *
   * \param file root file
   */
  void setRefs (TFile* file){
 
    for (auto & sm : SuperMods){
 
      findRefs (sm , file) ;
 
    }
 
  }
 
 
 
  /**
   * Searches in the .root file for histograms corresponding to pulses produced in one supermodule, by its own nanobeacon.
   *
   * \param sm supermodule
   * \param file root file
   */
  void findRefs (SuperModule* sm , TFile* file ){
 
    int floor = sm->getFloor () ;
 
    int string = sm->getString () ;
 
    char name[250] ;
 
    for (auto & pm : topPMTs){
  
      sprintf(name , "S%dF%d/S%dF%dPMT%d_beaconS%dF%d" , string , floor, string , floor , pm , string , floor);
 
      if (file -> Get (name) ){
 
        TH2D* h = (TH2D*)file -> Get(name) ;
 
        h->SetDirectory(0) ;
 
        JPMT pmt = sm->getPMT ( pm ) ;
        
        SuperPMT* p = new SuperPMT (pmt , h , pm) ;
 
        sm->add_ref_pmt(p) ;
 
      }
    
    }
 
  }
 
 
 
  /**
   * Get the SuperModules in the DU.
   *
   * \return Vector of SuperModules
   */
  vector <SuperModule*> getSuperModules(){
  
    return SuperMods ;
  
  } 
 
 
 
  /**
   * Select the PMTs in the upper and lower hemispheres of a DOM.
   *
   * \param top_option user choice
   * \param bottom_option user choice
   */
  void setPMTs (int top_option , int bottom_option){
 
    topPMTs = setTopPMTs (top_option) ;
 
    bottomPMTs = setBottomPMTs (bottom_option) ;
  
  }
 
 
  /**
   * Sets the references between the different SuperModules in the DU
   */
  void initializeSuperModules(){
 
    SuperMods.resize(nSuperModules) ;
 
    for (int i = 0 ; i < (int)SuperMods.size() ; i++){
 
      JModule m = detector.getModule(JModuleLocation(string_number , i+1)) ;
 
      SuperModule* s_m = new SuperModule (m) ;
 
      for (int j = i+1 ; (j < i + 1 + max_distance) && (j<(int)nSuperModules) ; j++){
      
        s_m->add_possible_tgt(SuperMods[j]) ;
      
      }
 
      for (int j = max(i - max_distance , 0) ; j<i ; j++){
 
        s_m->add_possible_src(SuperMods[j]) ;
 
      }
 
      SuperMods[i] = s_m ;
 
    }
 
  }
 
 
 
  /**
   * Sets the detector
   *
   * \param detector_ a JDetector
   */
  void setDetector(JDetector detector_){
 
    detector = detector_ ;
 
  }
 
 
  /**
   * Get the detector
   *
   * \return a JDetector
   */
  JDetector getDetector(){
  
    return detector ;
 
  }
 
 
 
  /**
   * Reads the basic info from the .root file such as the run number and the nanobeacon voltage
   *
   * \param file root file
   */
  void readBasicInfo(TFile* file){
  
    filename = file->GetName() ;
 
    TVectorD* run_info = (TVectorD*)file->Get("Run_Info") ;
 
    run_number = (*run_info)(0) ;
 
    voltage = (*run_info)(1) ;
  
  }
 
 
  /**
   * Get run number
   *
   * \return run number
   */
  int getRunNumber(){
 
    return run_number ;
 
  }
 
 
  /**
   * Get nanobeacon voltage
   *
   * \return nanobeacon voltage
   */
  double getVoltage(){
  
    return voltage ;
 
  }
 
 
};
 
#endif