JTimesliceL1.hh

Go to the documentation of this file.

#ifndef __JTRIGGER__JTIMESLICEL1__
#define __JTRIGGER__JTIMESLICEL1__
 
#include <vector>
#include <algorithm>
 
#include "km3net-dataformat/online/JDAQTimeslice.hh"
#include "JTrigger/JTimeslice.hh"
#include "JDetector/JModuleRouter.hh"
#include "JDetector/JDetectorToolkit.hh"
#include "JDetector/JTimeRange.hh"
#include "JTrigger/JTimesliceRouter.hh"
#include "JTrigger/JHitToolkit.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JTRIGGER {}
namespace JPP { using namespace JTRIGGER; }
 
namespace JTRIGGER {
 
  using KM3NETDAQ::JDAQTimeslice;
  using JDETECTOR::JModule;
  using JDETECTOR::JModuleRouter;
  using JDETECTOR::JTimeRange;
  using JDETECTOR::getTimeRange;
 
 
  /**
   * Auxiliary class to build JDAQTimeslice for L1 timeslice.
   */
  template<class JDAQTimeslice_t>
  class JTimesliceL1 :
    public JDAQTimeslice_t
  {
  public:
 
 
    /**
     * Default constructor.
     */
    JTimesliceL1() :
      JDAQTimeslice_t()
    {}
 
 
    /**
     * Constructor.
     *
     * The raw data referenced in the time slice router are sampled according 
     * the triggered time slice data and the given time window.\n
     * The status of each frame is taken from the raw data.
     *
     * \param  timeslice        triggered timeslice (e.g.\ L1)
     * \param  timesliceRouter  timeslice router
     * \param  moduleRouter     module    router
     * \param  TMaxLocal_ns     time window [ns]
     */
    template<class JHit_t>
    JTimesliceL1(const JTimeslice<JHit_t>& timeslice,
                 const JTimesliceRouter&   timesliceRouter,
                 const JModuleRouter&      moduleRouter,
                 const double              TMaxLocal_ns) :
      JDAQTimeslice_t()
    {
      using namespace std;
 
      this->setDAQChronometer(timeslice.getDAQChronometer());
 
      vector<JDAQHit> buffer;
     
      for (typename JTimeslice<JHit_t>::const_iterator frame = timeslice.begin(); frame != timeslice.end(); ++frame) {
 
        const JModule&   module     = moduleRouter.getModule(frame->getModuleID());
        const JTimeRange timeOffset = getTimeRange(JTimeRange(0,0), module);
 
        buffer.clear();
 
        for (typename JFrame<JHit_t>::const_iterator p = frame->begin(); p != frame->end(); ) {
 
          double Tmin = frame->getT(*p);
          double Tmax = Tmin  +  TMaxLocal_ns;
 
          while (++p != frame->end() && frame->getT(*p) <= Tmax) {
            Tmax = frame->getT(*p)  +  TMaxLocal_ns;
          }
 
          const JDAQFrameSubset& subset = timesliceRouter.getFrameSubset(frame->getModuleID(), JTimeRange(Tmin, Tmax).add(timeOffset));
 
          for (JDAQFrameSubset::const_iterator i = subset.begin(); i != subset.end(); ++i) {
 
            const JCalibration& calibration = module.getPMT(i->getPMT()).getCalibration();
            const double        t1          = getTime(*i, calibration);
 
            if (t1 >= Tmin && t1 <= Tmax) {
              buffer.push_back(*i);
            }
          }
        }
 
        this->push_back(JDAQSuperFrame(timesliceRouter.getSuperFrame(frame->getModuleID()).getDAQSuperFrameHeader()));
 
        this->rbegin()->add(buffer.size(), buffer.data());      
      }
    }
  };
}
 
#endif