SUPERMODULE.hh

Go to the documentation of this file.

#ifndef __SUPERMODULE__
#define __SUPERMODULE__
 
#include <algorithm>
 
#include "SUPERPMT.hh"
 
 
//Jpp
#include "JDetector/JDetectorToolkit.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 SUPERMODULE class handles the relation of a SUPERMODULE with its source SUPERMODULEs 
 * and with its target SUPEMODULES.
 */
class SuperModule {
  
  JModule dom ;
  
  vector <SuperPMT*> ref_pmts ;
  
  vector <SuperPMT*> good_ref_pmts ;
  
  vector <SuperModule*> possible_srcs ;
  
  vector <SuperModule*> possible_tgts ;
  
  vector < pair < SuperModule* , vector < SuperPMT* > > >  sources ;
  
  vector < pair < SuperModule* , vector < SuperPMT* > > >  good_sources ;
 
  vector < pair < SuperModule* , vector < SuperPMT* > > > targets ;
 
  vector < pair < SuperModule* , vector < SuperPMT* > > > good_targets ;
 
  double mean_tot_refs , mean_tot_tgts , sigma_tot_refs , sigma_tot_tgts  ;
 
  
public :
  
  /**
   * Default constructor.
   */
  SuperModule(){} ;
 
 
  
  /**
   * Constructor.
   * This constructor initializes the SUPERMODULE with a JModule. 
   *
   * \param  dom_    A JModule.
   */
  SuperModule(JModule dom_): 
    mean_tot_refs (0),
    mean_tot_tgts (0),
    sigma_tot_refs (0),
    sigma_tot_tgts (0)
 
  {
    
    dom = dom_ ;
    
  }
 
 
 
  /**
   * Destructor.
   */
  ~SuperModule(){
 
    for (auto & spm : ref_pmts){
 
      delete(spm) ;
 
    }
 
    for (auto & src : sources){
 
      for (auto & spm : src.second){
 
        delete(spm) ;
 
      }
 
    }
 
  }
 
 
 
  /**
   * Checks if the SuperModule has good sources.
   *
   * \result true if the vector good_sources is not empty.
   */
  bool has_good_sources() {
  
    bool has = false ;
 
    if (good_sources.size() > 0) has = true ;
 
    return has ;
 
  }
 
 
 
  /**
   * Checks if the SuperModule has good targets.
   *
   * \result true if the vector good_targets is not empty.
   */
  bool has_good_targets() {
  
    bool has = false ;
 
    if (good_targets.size() > 0) has = true ;
 
    return has ;
 
  }
 
 
 
  /**
   * Get the mean ToT of the pulse of the nanobeacon in this supermodule detected by the pmts of this supermodule.
   *
   * \return mean ToT for the reference SuperPMTs
   */
  double getMeanToT_refs(){
 
    return mean_tot_refs ;
 
  } 
 
 
 
  /**
   * Get the mean ToT of the pulse of the nanobeacon in this supermodule detected by the pmts of the closest target supermodule.
   * 
   * \return mean ToT for the target SuperPMTs
   */
  double getMeanToT_tgts(){
 
    return mean_tot_tgts ;
  
  }
 
 
 
  /**
   * Get the standard deviation of ToT of the pulse of the nanobeacon in this supermodule detected by the pmts of this supermodule.
   * 
   * \return standard deviation of ToTs 
   */
  double getSigmaToT_refs(){
 
    return sigma_tot_refs ;
 
  } 
 
 
  
  /**
   *  Get the standard deviation of ToT of the pulse of the nanobeacon in this supermodule detected by the pmts of the closest target supermodule.
   * 
   * \return standard deviation of ToTs 
   */
  double getSigmaToT_tgts(){
 
    return sigma_tot_tgts ;
 
  } 
 
 
 
  /**
   * Computes the mean and standard deviation of the ToT of the pulse of the nanobeacon in this supermodule detected by the pmts of this supermodule.
   */
  void compute_mean_tot_ref(){
 
    vector<double> tots ;
 
    double sum = 0 ;
 
    if (ref_pmts.size() == 0) return ;
 
    for (auto & spm : ref_pmts){
 
      double tot = spm->getNBPulse()->getMeanToT() ;
 
      sum += tot ;
 
      tots.push_back(tot);
 
    }
 
    mean_tot_refs = sum / tots.size() ;
 
  
    sigma_tot_refs = 0;
 
    for (auto & t : tots){
    
      sigma_tot_refs += pow((t - mean_tot_refs) , 2) ;
    
    }
 
    sigma_tot_refs = sqrt(sigma_tot_refs / tots.size());
 
  } 
 
 
 
  /**
   * Computes the mean and standard deviation of the ToT of the pulse of the nanobeacon in this supermodule detected by the pmts of the closest target supermodule.
   */
  void compute_mean_tot_tgt(){
 
    if (targets.size()==0) return ;
 
    pair < SuperModule* , vector < SuperPMT* > > tgt = targets[0] ;
 
    vector < SuperPMT* > tgt_pmts = tgt.second ;
 
    vector<double> tots ;
 
    double sum = 0 ;
 
    for (auto spm : targets[0].second){
 
      double tot = spm->getNBPulse()->getMeanToT() ;
 
      sum += tot ;
 
      tots.push_back(tot);
 
    }
 
    mean_tot_tgts = sum / tots.size() ;
 
  
    sigma_tot_tgts = 0;
 
    for (auto & t : tots){
    
      sigma_tot_tgts += pow((t - mean_tot_tgts) , 2) ;
    
    }
 
    sigma_tot_tgts= sqrt(sigma_tot_tgts / tots.size());
 
  } 
 
 
 
  /**
   * Get a pair containing a pointer to the closest source supermodule, and a vector of pointers to superpmts. 
   * Each of the superpmts contain the pulse from the closest source supermodule detected by the pmts in this supermodule.
   *
   * \return A pair consisting on a pointer to a SuperModule and the correspondint SuperPMTs
   */
  pair < SuperModule* , vector < SuperPMT* > > get_closest_source (){
 
    return sources[sources.size() - 1];
 
  }
 
 
 
  /**
   * Returns a pair containing a pointer to the closest target supermodule, and a vector of pointers to superpmts. 
   * Each of the superpmts contain the pulse from this supermodule detected by the pmts in the closest target supermodule.
   *
   * \return A pair consisting on a pointer to a SuperModule and the correspondint SuperPMTs
   */
  pair < SuperModule* , vector < SuperPMT* > > get_closest_target (){
 
    return targets[0];
 
  }
 
 
 
  /**
   * Returns a pair containing a pointer to the closest source supermodule from which pulses classified as good have been detected, and a vector of pointers to superpmts. 
   * Each of the superpmts contain the pulse from that supermodule detected by the pmts in this supermodule.
   *
   * \return A pair consisting on a pointer to a SuperModule and the correspondint SuperPMTs
   */
  pair < SuperModule* , vector < SuperPMT* > > get_closest_good_source (){
 
    return good_sources[good_sources.size() - 1];
 
  }
 
 
 
  /**
   * Returns a pair containing a pointer to the closest target supermodule that detected pulses from this supermodule that were classified as good, and a vector of pointers to superpmts. 
   * Each of the superpmts contain the pulse from this supermodule detected by the pmts in the closest target supermodule.
   *
   * \return A pair consisting on a pointer to a SuperModule and the correspondint SuperPMTs
   */
  pair < SuperModule* , vector < SuperPMT* > > get_closest_good_target (){
 
    return good_targets[0];
 
  }
 
 
 
  /**
   * Searches for sources that have produced pulses classified as good in this supermodule.
   */
  void select_good_srcs(){
  
    for (auto & src : sources){
    
      vector<SuperPMT*> good_pulses ;
 
      for (auto & spm: src.second){
 
        if (spm->getNBPulse()->IsGood()==true) good_pulses.push_back(spm) ;
 
      }
 
      if(good_pulses.size()>0){
 
        pair < SuperModule* , vector<SuperPMT*> > good_pair (src.first , good_pulses) ;
 
        good_sources.push_back (good_pair) ;
      
      }
 
    }
 
  }
 
 
  /**
   * Searches for sources that have produced pulses classified as good in this supermodule.
   */
  void select_good_refs(){
    
    for (auto & spm : ref_pmts){
      
      if (spm->getNBPulse()->IsGood()==true) good_ref_pmts.push_back(spm) ;
      
    }
    
  }
  
 
 
  /**
   * Searches for target supermodules that have detected good pulses from this supermodule.
   */
  void select_good_tgts(){
  
    for (auto & tgt : targets){
    
      vector<SuperPMT*> good_pulses ;
 
      for (auto & spm: tgt.second){
 
        if (spm->getNBPulse()->IsGood()==true) good_pulses.push_back(spm) ;
 
      }
 
      if(good_pulses.size()>0){
 
        pair < SuperModule* , vector<SuperPMT*> > good_pair (tgt.first , good_pulses) ;
 
        good_targets.push_back (good_pair) ;
      
      }
 
    }
 
  }
 
 
 
  /**
   * Performs a fast analysis of all the SUPERPMTs related with this SUPERMODULE.
   */
  void analyzeAll(){
 
    analyzeRefs() ;
 
    analyzeSrcs() ;
 
    analyzeTgts() ;
 
  }
 
 
 
  /**
   * Performs a fit of the time distribution of all the SUPERPMTs related with this SUPERMODULE.
   */
  void fitAll(){
 
    fitRefs() ;
 
    fitSrcs() ;
 
    fitTgts() ;
 
  }
 
 
 
  /**
   * Performs a fast analysis of the NBPulses of the SUPERPMTs from this supermodule that detected the pulse emited by this supermodule.
   */
  void analyzeRefs(){
 
    for (auto & spm : ref_pmts){
 
      spm->analyzeFast() ;
    
    }
 
  } 
 
 
 
  /**
   * Performs a fit of the NBPulses of the SUPERPMTs from this supermodule.
   */
  void fitRefs(){
 
    for (auto & spm : ref_pmts){
 
      spm->fit() ;
    
    }
 
  } 
 
 
 
  /**
   * Performs a fast analysis of the NBPulses of the SUPERPMTs from this supermodule corresponding to the nanobeacon signal emitted by other supermodules.
   */
  void analyzeSrcs(){
 
    for (auto & src : sources){
 
      for (auto & spm : src.second){
 
        spm->analyzeFast() ;
 
      }
 
    }
 
  } 
 
 
 
  /**
   * Performs a fit of the NBPulses of the SUPERPMTs from this supermodule corresponding to the nanobeacon signal emitted by other supermodules.
   */
  void fitSrcs(){
 
    for (auto & src : sources){
 
      for (auto & spm : src.second){
 
        spm->fit() ;
 
      }
 
    }
 
  }  
 
 
 
  /**
   * Performs a fast analysis of the NBPulses of the SUPERPMTs from other supermodules corresponding to the nanobeacon signal emitted by this supermodule.
   */
  void analyzeTgts(){
 
    for (auto & tgt : targets){
 
      for (auto & spm : tgt.second){
 
        spm->analyzeFast() ;
        
      }
 
    }
 
  }  
 
 
 
  /**
   * Performs a fit of the NBPulses of the SUPERPMTs from other supermodules corresponding to the nanobeacon signal emitted by this supermodule.
   */
  void fitTgts(){
 
    for (auto & tgt : targets){
 
      for (auto & spm : tgt.second){
 
        spm->fit() ;
 
      }
 
    }
 
  }  
 
 
 
  /**
   * Get a vector of targets.
   *
   * \return A vector of pairs consisting on a pointer to a SuperModule and the correspondint SuperPMTs
   */
  vector < pair < SuperModule* , vector < SuperPMT*  >  >  > get_targets(){
 
    return targets ;
 
  }
 
 
 
  /**
   * Get a vector of sources.
   *
   * \return A vector of pairs consisting on a pointer to a SuperModule and the correspondint SuperPMTs
   */
  vector < pair < SuperModule* , vector < SuperPMT*  >  >  > get_sources(){
 
    return sources ;
 
  }
 
 
 
  /**
   * Returns a vector of good targets.
   *
   * \return A vector of pairs consisting on a pointer to a SuperModule and the correspondint SuperPMTs
   */
  vector < pair < SuperModule* , vector < SuperPMT*  >  >  > get_good_targets(){
 
    return good_targets ;
 
  }
 
 
 
  /**
   * Returns a vector of good sources.
   *
   * \return A vector of pairs consisting on a pointer to a SuperModule and the correspondint SuperPMTs
   */
  vector < pair < SuperModule* , vector < SuperPMT*  >  >  > get_good_sources(){
 
    return good_sources ;
 
  }
 
 
 
  /**
   * Adds a target.
   */
  void add_tgt(pair < SuperModule* , vector < SuperPMT* > > p){
 
    targets.push_back(p) ;
 
  }
 
 
 
  /**
   * Adds a source.
   */
  void add_src(pair < SuperModule* , vector < SuperPMT* > > p){
 
    sources.push_back(p) ;
 
  }
 
 
 
  /**
   * Returns a vector of SUPERPMTs with the pulses from the nanobeacon in this supermodule detected by the pmts of this supermodule.
   *
   * \return A vector of SuperPMTs
   */
  vector<SuperPMT*> get_ref_pmts (){
 
    return ref_pmts ;
 
  }
 
 
 
  /**
   * Returns a JPMT from this supermodule.
   *
   * \param  i  A number from 0 to 30
   */
  JPMT getPMT (int i){
 
    return dom.getPMT(i) ;
 
  }
 
 
 
  /**
   * Returns the floor of this supermodule.
   *
   * \return floor number
   */
  int getFloor(){
 
    return dom.getFloor() ;
 
  }
 
 
 
  /**
   * Returns the string of this supermodule.
   *
   * \return string number
   */
  int getString(){
 
    return dom.getString() ;
 
  }
 
 
 
  /**
   * Returns the JModule corresponding to this supermodule.
   *
   * \return the corresponding JModule
   */
  JModule getDom(){
 
    return dom ;
 
  }
 
 
 
  /**
   * Returns vector with pointers to all the supermodules above this one in the DU.
   *
   * \return vector of SuperModules
   */
  vector<SuperModule*> get_possible_tgts(){
 
    return possible_tgts ;
 
  }
 
 
 
  /**
   * Returns vector with pointers to all the supermodules below this one in the DU.
   *
   * \return vector of SuperModules
   */
  vector<SuperModule*> get_possible_srcs(){
 
    return possible_srcs ;
 
  }
 
 
 
  /**
   * Sets the JModule from this supermodule.
   *
   * \param  dom_  The JModule to be set.
   */
  void setDom(JModule dom_){
 
    dom = dom_ ;
 
  }
 
 
 
  /**
   * Adds a reference SUPERPMT to this supermodule.
   *
   * \param  superPM  A superPMT.
   */
  void add_ref_pmt (SuperPMT* superPM){
 
    ref_pmts.push_back(superPM) ;
 
  }
 
 
 
  /**
   * Adds a SUPERMODULE to the list of possible sources of this supermodule.
   *
   * \param  super_m  A SUPERMODULE.
   */
  void add_possible_src (SuperModule* super_m){
 
    possible_srcs.push_back(super_m) ;
 
  }
 
 
 
  /**
   * Adds a SUPERMODULE to the list of possible targets of this supermodule.
   *
   * \param  super_m  A SUPERMODULE.
   */
  void add_possible_tgt (SuperModule* super_m){
 
    possible_tgts.push_back(super_m) ;
 
  }
 
 
};
 
#endif