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