JEvtWeightFactorConstant.hh

Go to the documentation of this file.

#ifndef __JAANET__JEVTWEIGHTFACTORCONSTANT__
#define __JAANET__JEVTWEIGHTFACTORCONSTANT__
 
#include "JLang/JManip.hh"
#include "JLang/JClonable.hh"
#include "JLang/JComparable.hh"
 
#include "Jeep/JProperties.hh"
 
#include "JAAnet/JEvtWeightFactor.hh"
 
 
/**
 * \author bjung
 */
 
namespace JAANET {}
namespace JPP { using namespace JAANET; }
 
namespace JAANET {
 
  using JLANG::JClonable;
  using JLANG::JComparable;
 
  using JEEP::JProperties;  
 
 
  /**
   * Class for constant event-weight factors.
   *
   * The template argument refers to the type of event-weighter.
   */
  template<class JEvtWeightFactor_t>
  struct JEvtWeightFactorConstant :
    public JComparable<JEvtWeightFactorConstant<JEvtWeightFactor_t> >,
    public JClonable<JEvtWeightFactor_t, JEvtWeightFactorConstant<JEvtWeightFactor_t> >
  {
    typedef JEvtWeightFactorConstant<JEvtWeightFactor_t>   JEvtWeightFactorConstant_t;
 
    
    /**
     * Default constructor.
     */
    JEvtWeightFactorConstant() :
      constant(1.0)
    {}
    
    
    /**
     * Constructor.
     *
     * \param  constant        constant
     */
    JEvtWeightFactorConstant(const double constant) :
      constant(constant)
    {
      this->check_validity();
    }
 
 
    /**
     * Check whether this constant event-weight factor is valid.
     *
     * \return                 true if valid; else false
     */
    bool is_valid() const override final
    {
      return constant > 0.0;
    }
    
    
    /**
     * Get event-weight factor of given event.
     *
     * \param  evt             event
     * \return                 event-weight factor
     */
    double getFactor(const Evt& evt) const override final
    {
      return constant;
    }
 
 
    /**
     * Check if this event-weight constant is less than given event-weight constant.
     *
     * \param  object          event-weight constant
     * \return                 true if this event-weight constant is less than given event-weight constant; else false
     */
    bool less(const JEvtWeightFactorConstant_t& object) const
    {
      return this->constant < object.constant;
    }
 
 
    /**
     * Get properties of this class.
     *
     * \param  eqpars          equation parameters
     */
    JProperties getProperties(const JEquationParameters& eqpars = JEvtWeightFactor::getEquationParameters()) override final
    {
      return JEvtWeightFactorConstantHelper(*this, eqpars);
    }
 
 
    /**
     * Get properties of this class.
     *
     * \param  eqpars          equation parameters
     */
    JProperties getProperties(const JEquationParameters& eqpars = JEvtWeightFactor::getEquationParameters()) const override final
    {
      return JEvtWeightFactorConstantHelper(*this, eqpars);      
    }
    
    
    /**
     * Stream input.
     *
     * \param  in              input stream
     * \return                 input stream
     */
    std::istream& read(std::istream& in) override final
    {
      using namespace std;
 
      const streampos         pos   = in.tellg();
      const ios_base::iostate state = in.rdstate();
      
      if (!(in >> constant)) {
 
        in.clear(state);
        in.seekg(pos);
 
        JProperties properties = getProperties();
 
        in >> properties;
      }
 
      this->check_validity();
 
      return in;
    }
 
 
    /**
     * Write event-weight factor to output
     *
     * \param  out                output stream
     * \return                    output stream
     */
    std::ostream& write(std::ostream& out) const override final
    {
      using namespace JPP;
      
      return out << FIXED(10,3) << constant;
    }
    
 
  private:
 
    /**
     * Auxiliary class for I/O of constant event-weight factor.
     */
    struct JEvtWeightFactorConstantHelper :
      public JProperties
    {
      /**
       * Constructor.
       *
       * \param  factor        constant event-weight factor
       * \param  eqpars        equation parameters 
       */
      template<class JEvtWeightFactorConstant_T>
      JEvtWeightFactorConstantHelper(JEvtWeightFactorConstant_T& factor,
                                     const JEquationParameters&  eqpars) :
        JProperties(eqpars, 1)
      {
        (*this)[JEvtWeightFactor::getTypeKey()] = "constant";
        
        this->insert(gmake_property(factor.constant));
      }
    };
 
    
    double constant; //!< constant value
  };
}
 
#endif