JSummaryslice.hh

Go to the documentation of this file.

#ifndef __JSUMMARYSLICE__JSUMMARYSLICE__
#define __JSUMMARYSLICE__JSUMMARYSLICE__
 
#include "JDAQ/JDAQ.hh"
#include "JDAQ/JDAQSummaryslice.hh"
#include "JDAQ/JDAQChronometer.hh"
 
#include "JLang/JObjectIterator.hh"
#include "JDetector/JDetector.hh"
#include "JDetector/JDetectorSimulator.hh"
#include "JDetector/JPMTIdentifier.hh"
#include "JDetector/JPMTDefaultSimulatorInterface.hh"
#include "JDetector/JK40DefaultSimulatorInterface.hh"
 
 
/**
 * \file
 *
 * Auxiliaries for creation of summary data.
 * \author mdejong
 */
namespace KM3NETDAQ {
 
  using JDETECTOR::JDetector;
  using JDETECTOR::JDetectorSimulator;
  using JDETECTOR::JPMTDefaultSimulatorInterface;
  using JLANG::JObjectIterator;
 
 
  /**
   * Auxiliary class to create summary data.
   */
  struct JSummaryslice :
    public JDAQSummaryslice
  {
    /**
     * Default constructor.
     */
    JSummaryslice()
    {}
 
    
    /**
     * Constructor.
     *
     * This constructor blends multiple KM3NETDAQ::JDAQSummaryslice's from an incomplete detector to
     * a single KM3NETDAQ::JDAQSummaryslice for a complete detector.
     *
     * \param  chronometer    DAQ chronometer
     * \param  input          summary data
     * \param  detector       detector
     */
    JSummaryslice(const JDAQChronometer&             chronometer,
                  JObjectIterator<JDAQSummaryslice>& input,
                  const JDetector&                   detector) :
      JDAQSummaryslice(chronometer)
    {
      for (JDetector::const_iterator module = detector.begin(); module != detector.end() && input.hasNext(); ) {
 
        const JDAQSummaryslice* summary = input.next();
        
        for (const_iterator i = summary->begin(); i != summary->end() && module != detector.end(); ++i, ++module) {
 
          push_back(*i);
 
          rbegin()->setModuleIdentifier(module->getID());
        }
      }
    }
 
 
    /**
     * Constructor.
     *
     * This constructor directly creates a KM3NETDAQ::JDAQSummaryslice for a given detector simulation
     * (i.e. without the need to create first a KM3NETDAQ::JDAQTimeslice).
     *
     * \param  chronometer    chronometer
     * \param  simbad         detector simulator
     */
    JSummaryslice(const JDAQChronometer&    chronometer,
                  const JDetectorSimulator& simbad) :
      JDAQSummaryslice()
    {
      using namespace JPP;
 
      setDAQChronometer(chronometer);
 
      try {
 
        const JPMTDefaultSimulatorInterface& pmtSimulator = dynamic_cast<const JPMTDefaultSimulatorInterface&>(simbad.getPMTSimulator());
        const JK40DefaultSimulatorInterface& k40Simulator = dynamic_cast<const JK40DefaultSimulatorInterface&>(simbad.getK40Simulator());
 
        for (JDetector::const_iterator module = simbad->begin(); module != simbad->end(); ++module) {
 
          push_back(JDAQSummaryFrame(module->getID()));
          
          for (int pmt = 0; pmt != NUMBER_OF_PMTS; ++pmt) {
 
            const JPMTIdentifier id(module->getID(), pmt);
 
            bool   status  = pmtSimulator.getPMTstatus(id);
            double rate_Hz = k40Simulator.getSinglesRate(id);
 
            rate_Hz *= pmtSimulator.getPMTSignalProcessor(id).getSurvivalProbability(NPE);
 
            this->rbegin()->setHighRateVeto(pmt, !status);
            this->rbegin()->setRate        (pmt, rate_Hz);
          }
        }
      }
      catch(const std::exception& error) {};
    }
 
    
    /**
     * Correct measured singles rates for the probability that a hit survives the simulation of the PMT.
     *
     * \param  simulator         PMT simulator
     */
    void correct(const JPMTDefaultSimulatorInterface& simulator)
    {
      using namespace JPP;
 
      for (iterator i = this->begin(); i != this->end(); ++i) {
        
        for (int pmt = 0; pmt != NUMBER_OF_PMTS; ++pmt) {
          
          const JPMTIdentifier id(i->getModuleID(), pmt);
          
          const double P = simulator.getPMTSignalProcessor(id).getSurvivalProbability(NPE);
          
          if (P > 0.0) 
            (*i)[pmt].div(P);
          else
            (*i)[pmt].setValue(0.0);
        }
      }
    }
 
    static const int NPE = 1;    //!< Number of photo-electrons corresponding to singles rate.
  };
}
 
#endif