JModuleL0.hh

Go to the documentation of this file.

#ifndef __JRECONSTRUCTION__JMODULEL0__
#define __JRECONSTRUCTION__JMODULEL0__
 
#include <vector>
#include <set>
 
#include "km3net-dataformat/online/JDAQSummaryFrame.hh"
#include "km3net-dataformat/online/JDAQPMTIdentifier.hh"
 
#include "JDetector/JModule.hh"
#include "JPhysics/JK40Rates.hh"
#include "JTrigger/JHitR0.hh"
#include "JTrigger/JHitL0.hh"
#include "JTrigger/JTriggerToolkit.hh"
#include "JFit/JFitToolkit.hh"
#include "JFit/JTimeRange.hh"
#include "JReconstruction/JHitW0.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JRECONSTRUCTION {}
namespace JPP { using namespace JRECONSTRUCTION; }
 
namespace JRECONSTRUCTION {
 
  using KM3NETDAQ::JDAQEvent;
  using KM3NETDAQ::JDAQSummaryFrame;
  using JDETECTOR::JModule;
  using JDETECTOR::JPosition3D;
  using JDETECTOR::JPMT;
  using JTRIGGER::JHitR0;
  using JPHYSICS::JRateL0_t;
  using JPHYSICS::JRateL1_t;
  using JFIT::JTimeRange;
 
 
  /**
   * Auxiliary class for handling module response.
   */
  struct JModuleL0 :
    std::vector<JHitR0>
  {
    /**
     * Default constructor.
     */
    JModuleL0()
    {}
 
 
    /**
     * Constructor.
     *
     * \param  module             module
     * \param  frame              frame
     * \param  data               data
     */
    JModuleL0(const JModule&             module,
              const JDAQSummaryFrame&    frame,
              const std::vector<JHitR0>& data) :
      std::vector<JHitR0>(data),
      module(module),
      frame (frame)
    {}
 
 
    /**
     * Smart pointer.
     *
     * \return                    module
     */
    const JModule* operator->() const
    {
      return &module;
    }
 
 
    /**
     * Get status of PMT.
     *
     * \param  pmt                PMT
     * \return                    true is valid; else false
     */
    bool getStatus(const int pmt) const
    {
      using namespace JPP;
 
      return (getDAQStatus(frame, module, pmt)   &&
              getPMTStatus(frame, module, pmt)   &&
              frame[pmt].is_valid()              &&
              !module.getPMT(pmt).has(PMT_DISABLE));
    }
 
 
    /**
     * Get probability of response in optical module due to random background.
     *
     * \param  R_Hz                 multiples rates [Hz]
     * \param  T_ns                 time window [ns]
     * \return                      probability
     */
    inline double getProbability(const JRateL1_t&  R_Hz,
                                 const JTimeRange& T_ns) const
    {
      using namespace std;
      using namespace JPP;
 
      multiset<size_t> top;
 
      for (const_iterator hit = this->begin(); hit != this->end(); ++hit) {
        if (T_ns(hit->getT())) {
          top.insert(hit->getPMT());
        }
      }
      
      size_t N = 0;         // number of active PMTs
      size_t M = 0;         // multiplicity
      double R = 0.0;       // total rate
 
      for (size_t i = 0; i != module.size(); ++i) {
        if (getStatus(i)) {
          N += 1;
          M += top.count(i);
          R += frame.getRate(i);
        }
      }
 
      if (N != 0)
        return JFIT::getProbability(N, M, JK40Rates(R/N, R_Hz), (T_ns.getUpperLimit() - T_ns.getLowerLimit()));
      else
        return (M == 0 ? 1.0 : 0.0);
    }
 
    JModule          module;
    JDAQSummaryFrame frame;
  };
}
 
#endif