JRunByRun.hh

Go to the documentation of this file.

#ifndef __JTRIGGER__JRUNBYRUN__
#define __JTRIGGER__JRUNBYRUN__

#include <sstream>

#include "km3net-dataformat/online/JDAQSummaryslice.hh"
#include "JSupport/JRandomSampler.hh"
#include "JSupport/JMultipleFileSampler.hh"
#include "JLang/JMultiEquals.hh"
#include "JLang/JStringStream.hh"
#include "Jeep/JProperties.hh"
#include "JSystem/JStat.hh"


/**
 * \author mdejong
 */

namespace JTRIGGER {}
namespace JPP { using namespace JTRIGGER; }

namespace JTRIGGER {
 
  using KM3NETDAQ::JDAQSummaryslice;
  using JSUPPORT::JRandomSampler;
  using JSUPPORT::JMultipleFileScanner;
  using JSUPPORT::JMultipleFileSampler;
  using JLANG::JMultiEquals;
  using JLANG::JTYPELIST;


  /**
   * Auxiliary class to handle run by run options.
   *
   * This class is used in e.g. JTriggerEfficiency.cc in run-by-run mode to select summary data 
   * (KM3NETDAQ::JDAQSummaryslice) from the specified raw data file(s).\n
   * The two parameters of the JSUPPORT::JRandomSampler class should therefore be set
   * to sufficiently cover the contents of raw data file(s) and to minimise possible biases.\n
   * The values can also be tuned to reduce the overhead of accessing the data in the input file(s).\n
   *
   * The range of acceptable rates (JRunByRun::range_Hz) was originally used to define "working" PMTs.\n
   * With the use of the hardware high-rate veto and FIFO (almost) full information, this criterion is redundant.\n
   * Note that the range is applied to the rate of photo-electrons (i.e.\ before the application of QE, etc.).\n
   * It is therefore recommended to set this range sufficiently wide to avoid interference 
   * with the simulation of the PMT response.
   */
  struct JRunByRun :
    public JMultipleFileSampler<JDAQSummaryslice, JRandomSampler>,
    public JMultiEquals<JRunByRun, JTYPELIST< JMultipleFileScanner<> >::typelist>
  {
    /**
     * Default constructor.
     */
    JRunByRun() :
      JMultipleFileSampler<JDAQSummaryslice, JRandomSampler>()
    {}


    /**
     * Check validity of run by run options.
     *
     * \return            true if okay; else false
     */
    inline bool is_valid()
    {
      return !this->template get<JMultipleFileScanner<>,true>().empty();
    }


    /**
     * Read run by run options from input.
     *
     * \param  in         input stream
     * \param  object     run by run options
     * \return            input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JRunByRun& object)
    {
      using namespace std;
      using namespace JPP;
      
      JStringStream is(in);

      if (getFileStatus(is.str().c_str())) {
        is.load();
      }

      getProperties(object).read(is);

      return in;
    }


    /**
     * Write run by run options to output.
     *
     * \param  out        output stream
     * \param  object     run by run options
     * \return            output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JRunByRun& object)
    {
      return getProperties(object).write(out);
    }
    
  protected:
    /**
     * Get properties of this class.
     *
     * \return            properties
     */
    template<class T>
    static inline JProperties getProperties(T& object) 
    {
      JProperties properties;

      properties["file"]     = object.template get<JMultipleFileScanner<>,true>();
      properties["sampler"]  = object.getSampler();

      return properties;
    }
  };
}

#endif