JEvtWeightFactorTFormula.hh

Go to the documentation of this file.

#ifndef __JAANET__JEVTWEIGHTFACTORTFORMULA__
#define __JAANET__JEVTWEIGHTFACTORTFORMULA__
 
#include <string>
 
#include "JLang/JException.hh"
#include "JLang/JLoadProperty.hh"
 
#include "Jeep/JProperties.hh"
 
#include "JAAnet/JEvtWeightFactor.hh"
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wall"
#include "TFormula.h"
#pragma GCC diagnostic pop
 
 
/**
 * \author bjung
 */
 
namespace JAANET {}
namespace JPP { using namespace JAANET; }
 
namespace JAANET {
 
  using JLANG::JLoadProperty;
  using JLANG::JValueOutOfRange;
  
  using JEEP::JProperties;
  
 
  /**
   * Base class implementation for reweighting factor for simulated events according to a specifiable ROOT TFormula.
   */
  class JEvtWeightFactorTFormula :
    public TFormula,
    public JEvtWeightFactor
  {
  public:
    
    /**
     * Default constructor.
     */
    JEvtWeightFactorTFormula() :
      buffer(*this)
    {}
 
 
    /**
     * Virtual destructor.
     */
    ~JEvtWeightFactorTFormula()
    {}
 
 
    /**
     * Get formula keyword.
     *
     * \return                 formula keyword
     */
    static const std::string getFormulaKey()
    {
      return "formula";
    }
    
 
    /**
     * Compile given formula.
     *
     * \param  formula         formula
     */
    void load(const char* const formula)
    {
      this->Clear();
      
      if (this->Compile(formula)) {
        THROW(JValueOutOfRange, "JEvtWeightFactorTFormula::load(): Could not compile formula: " << formula);    
      }
    }
 
 
    /**
     * Compile currently stored formula.
     */
    void load()
    {
      if (!buffer.empty()) {
        load(buffer.c_str());
      }
    }
 
 
    /**
     * Check whether this event-weight factor is valid.
     *
     * \return                 true if valid; else false
     */
    bool is_valid() const override
    {
      return this->IsValid();
    }
    
 
    /**
     * Get properties of this class.
     *
     * \param  eqpars          equation parameters
     */
    JProperties getProperties(const JEquationParameters& eqpars = JEvtWeightFactor::getEquationParameters()) override final
    {
      return JEvtWeightFactorTFormulaHelper(*this, eqpars);
    }
 
 
    /**
     * Get properties of this class.
     *
     * \param  eqpars          equation parameters
     */
    JProperties getProperties(const JEquationParameters& eqpars = JEvtWeightFactor::getEquationParameters()) const override final
    {
      return JEvtWeightFactorTFormulaHelper(*this, eqpars);
    }
 
 
    /**
     * Read event-weight factor from input.
     *
     * \param  in                 input stream
     * \return                    input stream
     */
    std::istream& read(std::istream& in) override final
    {
      using namespace std;
 
      this->Clear();
 
      const streampos         pos   = in.tellg();
      const ios_base::iostate state = in.rdstate();      
 
      JProperties properties = getProperties();
      in >> properties;
      
      this->load();
 
      in.clear(state);
      in.seekg(pos); // Rewind to read parameters
      
      properties = getProperties();
      
      in >> properties;
 
      check_validity();
      
      return in;      
    }
 
    
  private:
 
    /**
     * Auxiliary class for I/O of TFormula expression.
     */
    struct JEvtWeightFactorTFormulaExpression :
      public std::string
    {
      /**
       * Read event category from input.
       *
       * \param  in            input stream
       * \param  object        event category
       * \return               input stream
       */
      friend inline std::istream& operator>>(std::istream& in, JEvtWeightFactorTFormulaExpression& object)
      {
        if (in.peek() == (int) FORMULA_DELIMITER) {
          
          in.ignore();
 
          return std::getline(in, object, FORMULA_DELIMITER);
          
        } else {
          
          return in >> static_cast<std::string&>(object);
        }
      }
      
      
      /** 
       * Write event category to output.
       *
       * \param  out           output stream
       * \param  object        event  category
       * \return               output stream
       */
      friend inline std::ostream& operator<<(std::ostream& out, const JEvtWeightFactorTFormulaExpression& object)
      {
        return out << static_cast<const std::string&>(object);
      }
      
 
    private:
      
      static const char FORMULA_DELIMITER = '"'; //!< Formula string delimiter
    };
    
 
    /**
     * Auxiliary class for I/O of TFormula-based event-weight factor.
     */
    struct JEvtWeightFactorTFormulaHelper :
      public JProperties
    {
      /**
       * Constructor.
       *
       * \param  formula       TFormula-based event-weight factor
       * \param  eqpars        equation parameters 
       */
      template<class JEvtWeightFactorTFormula_t>
      JEvtWeightFactorTFormulaHelper(JEvtWeightFactorTFormula_t& formula,
                                     const JEquationParameters&  eqpars) :
        JProperties(eqpars, 1)
      {
        using namespace std;
 
        (*this)[JEvtWeightFactor::getTypeKey()] = "TFormula";
        (*this)[getFormulaKey()]                = formula.buffer;
 
        Double_t* parameters = formula.GetParameters();
        
        for (int i = 0; i < formula.GetNpar(); ++i) {
 
          const string parname = formula.GetParName(i);
        
          (*this)[parname] = parameters[i];
        }
      }
    };
 
 
    JLoadProperty<JEvtWeightFactorTFormula,
                  JEvtWeightFactorTFormulaExpression> buffer; //!< Formula expression
  };
}
 
#endif