JWeightKM3BUU.hh

Go to the documentation of this file.

#ifndef __JAANET__JWEIGHTKM3BUU__
#define __JAANET__JWEIGHTKM3BUU__

#include "km3net-dataformat/offline/Head.hh"
#include "km3net-dataformat/offline/Evt.hh"

#include "JLang/JException.hh"
#include "JLang/JClonable.hh"

#include "JAAnet/JHead.hh"
#include "JAAnet/JFlux.hh"
#include "JAAnet/JFluxHelper.hh"
#include "JAAnet/JHeadToolkit.hh"
#include "JAAnet/JWeightEvent.hh"

/**
 * \author bjung
 */

namespace JAANET {

  using JLANG::JClonable;
  using JLANG::JIndexOutOfRange;
  using JLANG::JNullPointerException;
  

  /**
   * Implementation of event weighting for KM3BUU data.
   */
  struct JWeightKM3BUU :
    public JClonable<JWeightEvent, JWeightKM3BUU>,
    public JFluxHelper
  {
    /**
     * Default constructor.
     */
    JWeightKM3BUU() :
      JFluxHelper(),
      W(0.0)
    {}
    
    
    /** 
     * Constructor.
     *
     * \param header            header
     */
    JWeightKM3BUU(const JHead& header) :
      JFluxHelper()
    {
      configure(header);
    }


    /** 
     * Constructor.
     *
     * \param  header            header
     * \param  flux              flux
     */
    JWeightKM3BUU(const JHead& header,
                  const JFlux& flux)
    {
      configure(header);
      JFluxHelper::configure(flux);
    }


    /**
     * Copy constructor.
     *
     * \param  object           original object
     */
    JWeightKM3BUU(const JWeightKM3BUU& object)
    {
      this->W = object.W;
      JFluxHelper::configure(*(object.get()));
    }


    /**
     * Weight configuration.
     *
     * \param  header            header
     */
    void configure(const JHead& header) override
    {
      const double N  = header.genvol.numberOfEvents;
      const double dt = (header.time_interval.t2 - header.time_interval.t1 > 0.0 ?
                         header.time_interval.t2 - header.time_interval.t1       :
                         header.tgen.numberOfSeconds);
      
      if (check(header) && N > 0.0 && dt > 0.0) {
        
        W = 1.0 / N / dt;
        
      } else {

        THROW(JValueOutOfRange, "JWeightKM3BUU::configure(): Provided header is inconsistent with KM3BUU.");
      }
    }


    /**
     * Check whether header is consistent with this event weighter.
     *
     * \param  header            header
     * \return                   true if consistent; else false
     */
    bool check(const JHead& header) const override
    {
      return is_km3buu(header);
    }

    
    /**
     * Get weight of given event.
     *
     * \param  evt               event
     * \return                   weight        [Hz]
     */
    double getWeight(const Evt& evt) const override
    {
      if (is_valid() && evt.w.size() > 1) {
        
        return W * evt.w[1] * getFlux(evt);
        
      } else if (evt.w.size() > 2) {

        return W * evt.w[2];
        
      } else {

        if (!is_valid()) {
          THROW(JNullPointerException, "JWeightKM3BUU::getWeight(): Unspecified flux function.");
        } else {
          THROW(JIndexOutOfRange,      "JWeightKM3BUU::getWeight(): Empty " << (evt.w.size() < 3 ? "w2-" : "w3-") << "weight.");
        }
      }
    }

    
  private:
    
    double W;
  };
}

#endif