JSummaryFileRouter.hh

Go to the documentation of this file.

#ifndef __JSUPPORT__JSUMMARYFILEROUTER__
#define __JSUPPORT__JSUMMARYFILEROUTER__
 
#include <string>
 
#include "JTools/JRouter.hh"
#include "JDAQ/JDAQSummaryslice.hh"
#include "JDAQ/JDAQHeader.hh"
#include "JDAQ/JDAQEvaluator.hh"
#include "JDAQ/JDAQPMTIdentifier.hh"
#include "JSupport/JTreeScanner.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JSUPPORT {}
namespace JPP { using namespace JSUPPORT; }
 
namespace JSUPPORT {
 
  using KM3NETDAQ::JDAQSummaryslice;
  using KM3NETDAQ::JDAQSummaryFrame;
  using KM3NETDAQ::JDAQEvaluator;
  using KM3NETDAQ::JDAQHeader;
  using KM3NETDAQ::JDAQModuleIdentifier;
  using KM3NETDAQ::JDAQPMTIdentifier;
  
 
  /**
   * File router for fast addressing of summary data.
   *
   * The member method update should be used to update the internal router for a given event.\n
   * The member method getRate can then be used to obtain the measured singles rate for a given PMT.
   */
  class JSummaryFileRouter :
    public JTreeScanner<JDAQSummaryslice, JDAQEvaluator>
  {
  public:
    /**
     * Constructor.
     *
     * \param  file_name       file name
     * \param  rate_Hz         default singles rate [Hz]
     */
    JSummaryFileRouter(const std::string& file_name,
                       const double       rate_Hz) :
      JTreeScanner<JDAQSummaryslice, JDAQEvaluator>(file_name),
      rate_Hz(rate_Hz),
      router (-1),
      summary(NULL)
    {}
 
 
    /**
     * Get default rate.
     *
     * \return                 rate [Hz]
     */
    double getRate() const
    {
      return rate_Hz;
    }
 
 
    /**
     * Update router.
     *
     * \param  header          header
     */
    void update(const JDAQHeader& header)
    {
      static Long64_t previous = -1;
 
      const  Long64_t index    = this->find(header);
 
      if (index != -1) {
 
        if (index != previous) {
 
          previous = index;
 
          // reset internal router
 
          if (summary != NULL) {
            for (JDAQSummaryslice::const_iterator i = summary->begin(); i != summary->end(); ++i) {
              router.put(i->getModuleID(), router.getDefaultAddress());
            }
          }
      
          summary = this->getEntry(index);
 
          if (summary != NULL) {
 
            // set internal router
 
            for (JDAQSummaryslice::const_iterator i = summary->begin(); i != summary->end(); ++i) {
              router.put(i->getModuleID(), distance(summary->begin(), i));
            }
          }
        }
      }
    }
 
 
    /**
     * Get address of module.
     *
     * \param  module          module
     * \return                 address
     */
    const int getAddress(const JDAQModuleIdentifier& module) const
    {
      return router.get(module.getModuleID());
    }
    
 
    /**
     * Get summary frame.
     *
     * \param  module          module
     * \return                 summary frame
     */
    const JDAQSummaryFrame& getSummaryFrame(const JDAQModuleIdentifier& module) const
    {
      return (*summary)[getAddress(module)];
    }
    
 
    /**
     * Has summary frame.
     *
     * \param  module          module
     * \return                 true if module present; else false
     */
    bool hasSummaryFrame(const JDAQModuleIdentifier& module) const
    {
      return router.has(module.getModuleID());
    }
 
 
    /**
     * Get rate.
     *
     * \param  id              PMT identifier
     * \return                 rate [Hz]
     */
    double getRate(const JDAQPMTIdentifier& id) const
    {
      if (this->hasSummaryFrame(id.getModuleIdentifier())) 
        return this->getSummaryFrame(id.getModuleIdentifier()).getRate(id.getPMTAddress());
      else
        return rate_Hz;
    }
 
  protected:
    double rate_Hz;
 
  private:
    JTOOLS::JRouter<int>    router;
    const JDAQSummaryslice* summary;
  };
}
 
#endif