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 "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>
   *       <oscprob_key>=<oscprob_value>[,<oscprob_key>=<oscprob_value>]...
   *
   *       oscprob.<oscprob_key>=<oscprob_value>[,oscprob.<oscprob_key>=<oscprob_value>]...
   *
   *       oscprob=<oscprob_file>
   *
   *       <oscprob_file>
   *
   *       <factor identifier> [<factor arguments> [& <factor identifier> [<factor arguments]]...];
   * </pre>
   * where
   *  - <oscprob_key> refers to an oscillation probability calculator configuration key;
   *  - <oscprob_value>      to an oscillation probability calculator configuration value;
   *  - <oscprob_file>       to an oscillation probability calculator configuration file;
   *  - <factor identifier>  to an event-weight factor identifier (c.f. `JAANET::JEvtWeighFactorDictionary::factors`); and
   *  - <factor arguments>   to the list of arguments for the corresponding event-weight factor
   * 
   */
  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);
 
      streampos pos = in.tellg();
 
      // Optional loading of data from file
 
      std::string buffer;
      in >> buffer;
 
      if (getFileStatus(buffer.c_str())) {
        
        ifstream ifs(buffer.c_str());
 
        read(ifs);
 
        ifs.close();
 
        return in;
        
      } else {
 
        in.clear();
        in.seekg(pos);
      }
 
      // Read optional oscillation probability calculator configuration     
 
      in >> oscProb;
 
      if (fail(in)) {
        
        in.clear();
        in.seekg(pos);
      }
 
      // Read event weight factors
      
      for (JToken<'&'> token; in >> 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", "./", "#"));
    }
    
 
  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