JEvtWeightFactorProduct.hh

Go to the documentation of this file.

#ifndef __JAANET__JEVTWEIGHTFACTORPRODUCT__
#define __JAANET__JEVTWEIGHTFACTORPRODUCT__
 
#include <vector>
 
#include "km3net-dataformat/offline/Evt.hh"
 
#include "JSystem/JStat.hh"
 
#include "JLang/JToken.hh"
#include "JLang/JClonable.hh"
#include "JLang/JStringStream.hh"
 
#include "Jeep/JPrint.hh"
#include "Jeep/JProperties.hh"
 
#include "JOscProb/JOscProbHelper.hh"
 
#include "JAAnet/JEvtWeightFactorHelper.hh"
#include "JAAnet/JEvtWeightFactorDictionary.hh"
 
 
/**
 * \author bjung
 */
 
namespace JAANET {}
namespace JPP { using namespace JAANET; }
 
namespace JAANET {
 
  using JLANG::JClonable;
 
  using JEEP::JProperties;
 
  using JOSCPROB::JOscProbHelper;
  
  
  /**
   * Class for product of event-weight factors.
   *
   * Input syntax as follows:
   * <pre>
   *       <factor identifier> [<factor arguments> [& <factor identifier> [<factor arguments]]...];
   * </pre>
   * where
   *  - <factor identifier> corresponds to an event-weight factor identifier (c.f. `JAANET::JEvtWeighFactorDictionary::factors`); and
   *  - <factor arguments>              to the list of arguments for the corresponding event-weight fact
   * 
   */
  struct JEvtWeightFactorProduct :
    public std::vector<JEvtWeightFactorHelper>,
    public JClonable<JEvtWeightFactor, JEvtWeightFactorProduct>
  {
    /**
     * Default constructor.
     */
    JEvtWeightFactorProduct() :
      oscProb()
    {}
 
 
    /**
     * Constructor.
     *
     * \param  oscProb           oscillation probability calculator
     */
    JEvtWeightFactorProduct(const JOscProbHelper& oscProb) :
      oscProb(oscProb)
    {}
    
 
    /**
     * Constructor.
     *
     * \param  oscProb           oscillation probability calculator
     * \param  factor            event-weight factor
     */
    JEvtWeightFactorProduct(const JOscProbHelper&         oscProb,
                            const JEvtWeightFactorHelper& factor) :
      oscProb(oscProb)
    {
      this->push_back(factor);
    }
 
 
    /**
     * Constructor.
     *
     * \param  oscProb           oscillation probability calculator
     * \param  factor            event-weight factor
     * \param  args              remaining event-weight factors
     */
    template<class ...Args>
    JEvtWeightFactorProduct(const JOscProbHelper&         oscProb,
                            const JEvtWeightFactorHelper& factor,
                            const Args&                ...args) :
      oscProb(oscProb)
    {
      this->push_back(factor, args...);
    }
    
 
 
    /**
     * Constructor.
     *
     * \param  factor            event-weight factor
     */
    JEvtWeightFactorProduct(const JEvtWeightFactorHelper& factor) :
      oscProb()
    {
      this->push_back(factor);
    }
 
 
    /**
     * Constructor.
     *
     * \param  factor            event-weight factor
     * \param  args              remaining event-weight factors
     */
    template<class ...Args>
    JEvtWeightFactorProduct(const JEvtWeightFactorHelper& factor,
                            const Args&                ...args) :
      oscProb()
    {
      this->push_back(factor, args...);
    }
 
 
    /**
     * Put event-weight factor.
     *
     * \param  factor            event-weight factor
     */
    void push_back(const JEvtWeightFactorHelper& factor)
    {
      const JEvtWeightFactorProduct* p = dynamic_cast<const JEvtWeightFactorProduct*>(factor.get());
 
      if (p != NULL) {
        this->insert(this->end(), p->begin(), p->end());
      } else {
        std::vector<JEvtWeightFactorHelper>::push_back(factor);
      }
    }
 
 
    /**
     * Put event-weight factor.
     *
     * \param  factor            event-weight factor
     * \param  args              remaining event-weight factors
     */
    template<class ...Args>
    void push_back(const JEvtWeightFactorHelper& factor,
                   const Args&                ...args)
    {
      push_back(factor);
      push_back(args...);
    }
 
 
    /**
     * Join this product of event-weight factors with a given product of event-weight factors.
     *
     * \param  product           product of event-weight factors
     * \return                   joined product of event-weight factors
     */
    JEvtWeightFactorProduct& join(const JEvtWeightFactorProduct& product)
    {
      this->insert(this->end(), product.begin(), product.end());
 
      return (*this);
    }
    
    
    /**
     * Get multiplication factor of given event.
     *
     * \param  evt               event
     * \return                   multiplication factor
     */
    double getFactor(const Evt& evt) const override final
    {
      using namespace std;
      
      double factor = 1.0;
 
      for (vector<JEvtWeightFactorHelper>::const_iterator i = this->cbegin(); i != this->cend(); ++i) {
        factor *= i->getFactor(evt);
      }
      
      return factor;
    }
 
 
    /**
     * Check whether this event-weight factor is valid.
     *
     * \return                 true if valid; else false
     */
    bool is_valid() const override final
    {
      for (const_iterator i = this->cbegin(); i != this->cend(); ++i) {
        if (!(i->is_valid())) { return false; }
      }
 
      return true;
    }
 
 
    /**
     * Get properties of this class.
     *
     * \param  eqpars          equation parameters
     */
    JProperties getProperties(const JEquationParameters& eqpars = JEvtWeightFactor::getEquationParameters()) override final
    {
      return JEvtWeightFactorProductHelper(*this, eqpars);
    }
 
 
    /**
     * Get properties of this class.
     *
     * \param  eqpars          equation parameters
     */
    JProperties getProperties(const JEquationParameters& eqpars = JEvtWeightFactor::getEquationParameters()) const override final
    {
      return JEvtWeightFactorProductHelper(*this, eqpars);
    }
    
 
 
    /**
     * Read event-weight factor product from stream.
     *
     * \param  in            input stream
     * \param  object        event-weight factor product
     * \return               input stream
     */
    std::istream& read(std::istream& in) override final
    {
      using namespace std;
      using namespace JPP;
 
      static const JEvtWeightFactorDictionary dictionary(oscProb);      
 
      JStringStream is(in);
 
      if (getFileStatus(is.str().c_str())) {
        is.load();
      }
      
      for (JToken<'&'> token; is >> token; ) {
 
        int factorID = 0;
        
        istringstream iss(token);
 
        if (!(iss >> factorID)) { continue; }
 
        const JEvtWeightFactorHelper helper(dictionary.at(factorID).getFactor());
        
        JEvtWeightFactor& factor = helper.getFactor();
        
        iss >> factor;
 
        push_back(helper);
      }
      
      return in;
    }
 
 
    /**
     * Write event-weight factor to output
     *
     * \param  out                output stream
     * \return                    output stream
     */
    std::ostream& write(std::ostream& out) const override final
    {
      return out << getProperties(JEquationParameters("=", "\n", "./", "#"));
    }
 
    
    JOscProbHelper oscProb; //!< Oscillation probability calculator
 
 
  private:
 
    /**
     * Auxiliary class for I/O of product of event-weight factors.
     */
    struct JEvtWeightFactorProductHelper :
      public JProperties
    {
      /**
       * Constructor.
       *
       * \param  product       product of event-weight factors
       * \param  eqpars        equation parameters 
       */
      template<class JEvtWeightFactorProduct_t>
      JEvtWeightFactorProductHelper(JEvtWeightFactorProduct_t& product,
                                    const JEquationParameters& eqpars) :
        JProperties(eqpars, 1)
      {
        using namespace std;
        using namespace JPP;
 
        (*this)[JEvtWeightFactor::getTypeKey()] = "product";
 
        JProperties factors(eqpars, 1);
 
        for (typename JEvtWeightFactorProduct_t::const_iterator i = product.cbegin(); i != product.cend(); ++i) {
 
          const int index = 1 + distance(product.cbegin(), i);
 
          const string key = MAKE_STRING("factor" << index);
 
          JProperties sub = i->getProperties(eqpars);
 
          (*this)[key] = sub;
        }
      }
    };
  };
}
 
#endif