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.
   *
   * The input syntax follows the following scheme:
   *
   * <tt>[oscillation probabilities configuration] <factor>+</tt>,
   *
   * in which:
   *   - <tt>oscillation probabilities configuration</tt> refers to an optional specification
   *     of the oscillation parameters, which can be given according to one of the following formats:
   *       1. <tt><oscprob_file></tt>,
   *       2. <tt>oscprob=<oscprob_file></tt>,
   *       3. <tt><oscprob_key>=<oscprob_value>[<end of line> <oscprob_key>=<oscprob_value>]+</tt> or
   *       4. <tt>oscprob.<oscprob_key>=<oscprob_value>[<end of line> oscprob.<oscprob_key>=<oscprob_value>]+</tt>,
   *     where:
   *       - <tt>oscprob_key</tt>       refers to an oscillation probability calculator configuration key;
   *       - <tt>oscprob_value</tt>            to an oscillation probability calculator configuration value and
   *       - <tt>oscprob_file</tt>             to an oscillation probability calculator configuration file with key-value pairs,
   *   - <tt>factor</tt> refers to a weighting factor, which needs to be specified according to the following format:
   *       1. <tt><factor identifier> [<factor arguments> [ & <factor identifier> [<factor arguments] ]+ ];</tt>,
   *     where:
   *       - <tt>factor identifier</tt> refers to an event-weight factor identifier (c.f. `JAANET::JEvtWeighFactorDictionary::factors`); and
   *       - <tt>factor arguments</tt>         to the list of arguments for the corresponding event-weight factor,
   *   - multiple weighting factors can be combined into one when specified as a group separated by the '&' character.
   */
  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 oscillation probability calculator.
     *
     * \return                   oscillation probability calculator
     */
    const JOscProbHelper& getOscProb() const
    {
      return oscProb;
    }
 
 
    /**
     * Set oscillation probability calculator for all compatible event weight factors.
     *
     * \param  oscProb           oscillation probability calculator
     * \return                   number of modified event weighters
     */
    size_t setOscProb(const JOscProbHelper& oscProb)
    {
      using namespace JPP;
      
      if (oscProb) {
      
        size_t n = 0;
      
        this->oscProb = oscProb;
 
        for (iterator i = this->begin(); i != this->end(); ++i) {
 
          JEvtWeightFactorHelper& factor = *i;
 
          if (!factor) { continue; }
          
          JOscFlux* p = dynamic_cast<JOscFlux*>(factor.get());
          
          if (p != NULL) {
            
            p->setOscProb(oscProb);
            ++n;
            
          } else {
 
            JOscProbHelper* q = dynamic_cast<JOscProbHelper*>(factor.get());
 
            if (q != NULL) {
              *q = oscProb;
              ++n;
            }
          }
        }
      
        return n;
        
      } else {
 
        THROW(JNullPointerException, "JEvtWeightFactorProduct::setOscProb(): Given oscillation probability function is invalid.");
      }
    }
    
    
    /**
     * 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
     * \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();
      }
 
      // Read event weight factors
      
      for (JToken<'&'> token; is >> token; ) {
 
        int factorID = 0;
 
        istringstream iss(token);
        
        const streampos poss = iss.tellg();
 
        if (!(iss >> factorID)) { // Check if token corresponds to oscillation parameter set
 
          iss.clear();
          iss.seekg(poss);
 
          iss >> oscProb;
 
          if (fail(iss)) {
            continue;
          }
        }
 
        const JEvtWeightFactorHelper helper = dictionary[factorID];
        
        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", "./", "#"));
    }
    
 
  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;
        }
      }
    };
 
    JOscProbHelper oscProb; //!< Oscillation probability calculator
  };
}
 
#endif