JSummarysliceSupportkit.hh

Go to the documentation of this file.

#ifndef __JSUPPORT__JSUMMARYSLICESUPPORTKIT__
#define __JSUPPORT__JSUMMARYSLICESUPPORTKIT__

#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/JPMTDefaultSimulatorInterface.hh"
#include "JDetector/JK40DefaultSimulatorInterface.hh"


/**
 * \file
 *
 * Auxiliaries for creation of summary data.
 * \author mdejong
 */
namespace JSUPPORT {}
namespace JPP { using namespace JSUPPORT; }

namespace JSUPPORT {

  using KM3NETDAQ::JDAQSummaryFrame;
  using KM3NETDAQ::JDAQSummaryslice;
  using KM3NETDAQ::JDAQChronometer;
  using JDETECTOR::JDetector;
  using JDETECTOR::JDetectorSimulator;
  using JDETECTOR::JK40DefaultSimulatorInterface;
  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 JDETECTOR;
      using namespace KM3NETDAQ;

      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 JDETECTOR;
      using namespace KM3NETDAQ;
      
      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