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