JEvtCategoryMap.hh

Go to the documentation of this file.

#ifndef __JAANET__JEVTCATEGORYMAP__
#define __JAANET__JEVTCATEGORYMAP__
 
#include <map>
#include <vector>
 
#include "JSystem/JStat.hh"
 
#include "JLang/JToken.hh"
#include "JLang/JClonable.hh"
#include "JLang/JException.hh"
 
#include "Jeep/JPrint.hh"
#include "Jeep/JProperties.hh"
 
#include "JOscProb/JOscProbInterpolator.hh"
 
#include "JAAnet/JEvtCategory.hh"
#include "JAAnet/JEvtCategoryHelper.hh"
#include "JAAnet/JEvtCategoryToolkit.hh"
#include "JAAnet/JMuonBundleCategory.hh"
#include "JAAnet/JNeutrinoInteractionCategory.hh"
 
#include "JAAnet/JEvtWeightFactor.hh"
#include "JAAnet/JEvtWeightFactorProduct.hh"
#include "JAAnet/JEvtWeightFactorHelper.hh"
 
#include "JAAnet/JFlux.hh"
#include "JAAnet/JFluxHelper.hh"
#include "JAAnet/JFluxDictionary.hh"
 
 
/**
 * \author bjjung
 */
 
namespace JAANET {}
namespace JPP { using namespace JAANET; }
 
namespace JAANET {
 
  using JLANG::JClonable;
 
  using JEEP::JProperties;
 
  using JOSCPROB::JOscProbInterpolator;
  
 
  /**
   * Auxiliary class for reading a map of event categories.
   *
   * The template argument corresponds to the mapped value type.
   */
  template<class T>
  class JEvtCategoryMap :
    public std::map<JEvtCategoryHelper, T>
  {
  public:
 
    typedef JEvtCategoryMap<T>                  JEvtCategoryMap_t;
    
    typedef std::map<JEvtCategoryHelper, T>     map_type;
    
    typedef typename map_type::iterator         iterator;    
    typedef typename map_type::const_iterator   const_iterator;
   
    
    /**
     * Default constructor.
     */
    JEvtCategoryMap() :
      map_type()
    {}
 
    
    /**
     * Constructor.
     *
     * \param  category                event category
     * \param  value                   value
     */
    JEvtCategoryMap(const JEvtCategoryHelper& category,
                    const T&                  value) :
      map_type()
    {
      insert(category, value);
    }
                    
    
 
    /**
     * Constructor.
     *
     * \param  category                event category
     * \param  value                   value
     * \param  args                    remaining pairs of event categories and values
     */
    template<class ...Args>
    JEvtCategoryMap(const JEvtCategoryHelper& category,
                    const T&                  value,
                    const Args&            ...args) :
      map_type()
    {
      insert(category, value, args...);
    }
    
 
    /**
     * Insert pair of event category and value.
     *
     * \param  category                event category
     * \param  value                   value
     */
    void insert(const JEvtCategoryHelper& category,
                const T&                  value)
    {
      map_type::insert(std::make_pair(category, value));
    }
 
 
    /**
     * Insert pairs of event categories and values.
     *
     * \param  category                event category
     * \param  value                   value
     * \param  args                    remaining pairs of event categories and values
     */
    template<class ...Args>
    void insert(const JEvtCategoryHelper& category,
                const T&                  value,
                const Args&            ...args)
    {
      insert(category, value);
      insert(args...);
    }
  };
 
 
  /**
   * Template specialisation for a map between event categories and event-weight factor products.
   *
   * 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>
   *
   *       <PDG type>                             [ & <PDG type>]...;                             <factor identifier> [<factor arguments> [& <factor identifier> [<factor arguments]]...];
   *
   *       <key>=<value>[,<key>=<value>]... [ & <key>=<value>[,<key>=<value>]...]...; <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;
   *  - <PDG type>           to a PDG identifier;
   *  - <key>                to one of the data members of a data structure derived from `JAANET::JEvtCategory`;
   *  - <value>              to the corresponding value;
   *  - <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.
   * Multiple event categories and flux factors can be specified, separated by the '&' character.   
   */
  template<>
  class JEvtCategoryMap<JEvtWeightFactorProduct> final :
    public std::map<JEvtCategoryHelper, JEvtWeightFactorProduct>,
    public JClonable<JEvtWeightFactor, JEvtCategoryMap<JEvtWeightFactorProduct> >  
  {
  public:
 
    typedef JEvtCategoryMap<JEvtWeightFactorProduct>                JEvtCategoryMap_t;
    
    typedef std::map<JEvtCategoryHelper, JEvtWeightFactorProduct>   map_type;
    
    typedef typename map_type::iterator                             iterator;    
    typedef typename map_type::const_iterator                       const_iterator;
   
    
    /**
     * Default constructor.
     */
    JEvtCategoryMap() :
      map_type(),
      oscProb(JOscProbInterpolator<>())
    {}
 
 
    /**
     * Constructor.
     *
     * \param  oscProb        oscillation probability calculator
     */
    JEvtCategoryMap(const JOscProbHelper& oscProb) :
      map_type(),
      oscProb(oscProb)
    {}
 
    
    /**
     * Constructor.
     *
     * \param  oscProb        oscillation probability calculator
     * \param  category       event category
     * \param  factor         event-weight factor
     */
    JEvtCategoryMap(const JOscProbHelper&         oscProb,
                    const JEvtCategoryHelper&     category,
                    const JEvtWeightFactorHelper& factor) :
      map_type(),
      oscProb(oscProb)
    {
      insert(category, factor);
    }
                    
    
 
    /**
     * Constructor.
     *
     * \param  oscProb        oscillation probability calculator
     * \param  category       event category
     * \param  factor         event-weight factor
     * \param  args           remaining pairs of event categories and event-weight factors
     */
    template<class ...Args>
    JEvtCategoryMap(const JOscProbHelper&         oscProb,
                    const JEvtCategoryHelper&     category,
                    const JEvtWeightFactorHelper& factor,
                    const Args&                ...args) :
      map_type(),
      oscProb(oscProb)
    {
      insert(category, factor, args...);
    }
 
    
    /**
     * Constructor.
     *
     * \param  category       event category
     * \param  factor         event-weight factor
     */
    JEvtCategoryMap(const JEvtCategoryHelper&     category,
                    const JEvtWeightFactorHelper& factor) :
      map_type(),
      oscProb()
    {
      insert(category, factor);
    }
                    
    
 
    /**
     * Constructor.
     *
     * \param  category       event category
     * \param  factor         event-weight factor
     * \param  args           remaining pairs of event categories and event-weight factors
     */
    template<class ...Args>
    JEvtCategoryMap(const JEvtCategoryHelper&     category,
                    const JEvtWeightFactorHelper& factor,
                    const Args&                ...args) :
      map_type(),
      oscProb()
    {
      insert(category, factor, args...);
    }
 
 
    /**
     * Insert pair of an event category and a product of event-weight factors.
     *
     * \param  category       pointer to event category
     * \param  product        product of event-weight factors
     */
    void insert(const JEvtCategoryHelper&      category,
                const JEvtWeightFactorProduct& product)
    {
      iterator i = this->find(category);
 
      if (i != this->end()) {
        i->second.join(product);
      } else {
        map_type::insert(std::make_pair(category, product));
      }
    }
    
 
    /**
     * Insert event category.
     *
     * \param  category       event category
     * \param  factor         event-weight factor
     */
    void insert(const JEvtCategoryHelper&     category,
                const JEvtWeightFactorHelper& factor)
    {
      iterator i = this->find(category);
 
      if (i == this->end()) {
        
        const JEvtWeightFactorProduct product(oscProb, factor);
        
        map_type::insert(std::make_pair(category, product));
                
      } else {
 
        i->second.push_back(factor);
      }
    }
    
    
    /**
     * Insert pairs of event categories and event-weight factors.
     *
     * \param  category       event category
     * \param  factor         event-weight factor
     * \param  args           remaining pairs of event categories and event-weight factors
     */
    template<class ...Args>
    void insert(const JEvtCategoryHelper&     category,
                const JEvtWeightFactorHelper& factor,
                const Args&                ...args)
    {
      insert(category, factor);
      insert(args...);
    }
 
 
    /**
     * Join this map between event categories and weight factors with a given map between event categories and weight factors.
     *
     * \param  object         map between event categories and fluxes
     * \return                joined map between event categories and fluxes
     */
    JEvtCategoryMap_t& join(const JEvtCategoryMap_t& object)
    {
      for (const_iterator i = object.cbegin(); i != object.cend(); ++i) {
        
        iterator j = this->find(i->first);
        
        if (j != this->end()) {
          j->second.join(i->second);
        } else {
          this->insert(j->first, j->second);
        }
      }
      
      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) {
          n += i->second.setOscProb(oscProb);
        }
      
        return n;
      
      } else {
        
        THROW(JNullPointerException, "JEvtCategoryMap<JFluxHelper>::setOscProb(): Given oscillation probability function is invalid.");
      }
    }
    
 
    /**
     * Get weight factor of given event.
     *
     * \param  evt               event
     * \return                   weight-factor for given event
     */
    double getFactor(const Evt& evt) const override final
    {
      using namespace JPP;
 
      for (typename map_type::const_iterator i = this->cbegin(); i != this->cend(); ++i) {
        if (i->first.match(evt)) {
          return i->second.getFactor(evt);
        }
      }
      
      THROW(JValueOutOfRange, "JEvtCategoryMap<JEvtWeightFactorHelper>::getFactor(): No event-weight factor for given event.");
    }
 
 
    /**
     * Check whether this event-weight factor is valid.
     *
     * \return                 true if valid; else false
     */
    bool is_valid() const override final
    {
      for (typename map_type::const_iterator i = this->cbegin(); i != this->cend(); ++i) {
        if (!i->second.is_valid()) { return false; }
      }
 
      return true;
    }
 
 
    /**
     * Get properties of this class.
     *
     * \param  eqpars          equation parameters
     */
    JProperties getProperties(const JEquationParameters& eqpars) override final
    {
      return JEvtCategoryMapHelper(*this, eqpars);
    }
 
 
    /**
     * Get properties of this class.
     *
     * \param  eqpars          equation parameters
     */
    JProperties getProperties(const JEquationParameters& eqpars) const override final
    {
      return JEvtCategoryMapHelper(*this, eqpars);
    }
 
 
    /**
     * Read map between event categories and event-weight factors
     *
     * \param  in                 input stream
     * \return                    input stream
     */
    std::istream& read(std::istream& in) override final
    {
      using namespace std;
      using namespace JPP;
 
      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);
      }
      
      for (JToken<';'> token1, token2; in >> token1 >> token2; ) {
 
        istringstream iss1(token1); // Read event categories
 
        JEvtCategorySet categories;
 
        iss1 >> categories;
        
        istringstream iss2(token2); // Read event-weight factors
        
        JEvtWeightFactorProduct factors(oscProb);
 
        iss2 >> factors;
 
        if (!fail(iss2)) {
 
          for (JEvtCategorySet::const_iterator i = categories.cbegin(); i != categories.cend(); ++i) {
            this->insert(*i, factors);
          }
        }
      }
      
      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 map of event categories and weight factors.
     */
    struct JEvtCategoryMapHelper :
      public JProperties
    {
      /**
       * Constructor.
       *
       * \param  map           event category map
       * \param  eqpars        equation parameters 
       */
      template<class JEvtCategoryMap_type>
      JEvtCategoryMapHelper(JEvtCategoryMap_type&     map,
                           const JEquationParameters& eqpars) :
        JProperties(eqpars, 1)
      {
        using namespace std;
        using namespace JPP;
 
        for (typename map_type::const_iterator i = map.cbegin(); i != map.cend(); ++i) {
 
          const int index = 1 + distance(map.cbegin(), i);
 
          const string key = MAKE_STRING("category" << index);
          
          JProperties properties1 = i->first .getProperties(eqpars);
          JProperties properties2 = i->second.getProperties(eqpars);
 
          (*this)[key] = properties1.join(properties2);
        }
      }
    };
 
    JOscProbHelper oscProb; //!< oscillation probability calculator
  };
 
  using JEvtWeightFactorMap = JEvtCategoryMap<JEvtWeightFactorProduct>;
  
 
  /**
   * Template specialisation for a map between event categories and flux 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>
   *
   *       <PDG type> [<PDG type>]...;           <flux identifier> [<flux arguments>];
   *
   *       <key>=<value>[,<key>=<value>]...; <flux identifier> [<flux 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;
   *  - <PDG type>           to a PDG identifier;
   *  - <key>                to one of the data members of a data structure derived from `JAANET::JEvtCategory`;
   *  - <value>              to the corresponding value;
   *  - <flux identifier>    to a flux identifier (c.f. `JAANET::JFluxDictionary`) and
   *  - <flux arguments>     to the list of arguments of the corresponding flux factor.
   */
  template<>
  class JEvtCategoryMap<JFluxHelper> final :
    public std::map<JEvtCategoryHelper, JFluxHelper>,
    public JClonable<JFlux, JEvtCategoryMap<JFluxHelper> >  
  {
  public:
 
    typedef JEvtCategoryMap<JFluxHelper>                JEvtCategoryMap_t;
    
    typedef std::map<JEvtCategoryHelper, JFluxHelper>   map_type;
 
    typedef typename map_type::iterator                 iterator;    
    typedef typename map_type::const_iterator           const_iterator;
    
   
    
    /**
     * Default constructor.
     */
    JEvtCategoryMap() :
      map_type(),
      oscProb(JOscProbInterpolator<>())
    {}
 
 
    /**
     * Constructor.
     *
     * \param  oscProb           oscillation probability calculator
     */
    JEvtCategoryMap(const JOscProbHelper& oscProb) :
      map_type(),
      oscProb(oscProb)
    {}
 
    
    /**
     * Constructor.
     *
     * \param  oscProb           oscillation probability calculator
     * \param  category          event category
     * \param  factor            event-weight factor
     */
    JEvtCategoryMap(const JOscProbHelper&     oscProb,
                    const JEvtCategoryHelper& category,
                    const JFluxHelper&        factor) :
      map_type(),
      oscProb(oscProb)
    {
      insert(category, factor);
    }
    
 
    /**
     * Constructor.
     *
     * \param  oscProb           oscillation probability calculator
     * \param  category          event category
     * \param  factor            event-weight factor
     * \param  args              remaining pairs of event categories and event-weight factors
     */
    template<class ...Args>
    JEvtCategoryMap(const JOscProbHelper&     oscProb,
                    const JEvtCategoryHelper& category,
                    const JFluxHelper&        factor,
                    const Args&            ...args) :
      map_type(),
      oscProb(oscProb)
    {
      insert(category, factor, args...);
    }
 
    
    /**
     * Constructor.
     *
     * \param  category          event category
     * \param  flux              flux function
     */
    JEvtCategoryMap(const JEvtCategoryHelper& category,
                    const JFluxHelper&        flux) :
      map_type(),
      oscProb()
    {
      insert(category, flux);
    }
                    
    
 
    /**
     * Constructor.
     *
     * \param  category          event category
     * \param  flux              flux function
     * \param  args              remaining pairs of event categories and flux functions
     */
    template<class ...Args>
    JEvtCategoryMap(const JEvtCategoryHelper& category,
                    const JFluxHelper&        flux,
                    const Args&            ...args) :
      map_type()
    {
      insert(category, flux, args...);
    }
    
 
    /**
     * Insert pair of an event category and a flux function.
     *
     * \param  category          event category
     * \param  flux              flux function
     */
    void insert(const JEvtCategoryHelper& category,
                const JFluxHelper&        flux)
    {
      map_type::insert(std::make_pair(category, flux));
    }
 
 
    /**
     * Insert pairs of event categories and flux functions.
     *
     * \param  category          event category
     * \param  flux              flux function
     * \param  args              remaining pairs of event categories and flux functions
     */ 
    template<class ...Args>
    void insert(const JEvtCategoryHelper& category,
                const JFluxHelper&        flux,
                const Args&            ...args)
    {
      insert(category, flux);
      insert(args...);
    }
 
 
    /**
     * Get oscillation probability calculator.
     *
     * \return                   oscillation probability calculator
     */
    const JOscProbHelper& getOscProb() const
    {
      return oscProb;
    }
 
 
    /**
     * Set oscillation probability calculator for all compatible flux 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) {
        
          JOscFlux* p = dynamic_cast<JOscFlux*>(&(i->second.getFlux()));
        
          if (p != NULL) {
            p->setOscProb(oscProb);
            ++n;
          }
        }
      
        return n;
        
      } else {
 
        THROW(JNullPointerException, "JEvtCategoryMap<JFluxHelper>::setOscProb(): Given oscillation probability function is invalid.");
      }
    }
    
 
    /**
     * Get weight factor of given event.
     *
     * \param  evt               event
     * \return                   weight-factor for given event
     */
    double getFactor(const Evt& evt) const override final
    {
      using namespace JPP;
 
      for (typename map_type::const_iterator i = this->cbegin(); i != this->cend(); ++i) {
        if (i->first.match(evt)) {
          return i->second.getFactor(evt);
        }
      }
      
      THROW(JValueOutOfRange, "JEvtCategoryMap<JFluxHelper>::getFactor(): No flux factor for given event.");
    }
 
 
    /**
     * Check whether this flux factor is valid.
     *
     * \return                   true if valid; else false
     */
    bool is_valid() const override final
    {
      for (typename map_type::const_iterator i = this->cbegin(); i != this->cend(); ++i) {
        if (!(i->second.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 JEvtCategoryMapHelper(*this, eqpars);
    }
 
 
    /**
     * Get properties of this class.
     *
     * \param  eqpars            equation parameters
     */
    JProperties getProperties(const JEquationParameters& eqpars = JEvtWeightFactor::getEquationParameters()) const override final
    {
      return JEvtCategoryMapHelper(*this, eqpars);
    }
    
    
    /**
     * Read map between event categories and flux factors.
     *
     * \param  in                input stream
     * \return                   input stream
     */
    std::istream& read(std::istream& in) override final
    {
      using namespace std;
      using namespace JPP;
 
      static const JFluxDictionary 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);
      }
      
      for (JToken<';'> token1, token2; in >> token1 >> token2; ) {
 
        istringstream iss1(token1); // Read event categories
 
        JEvtCategorySet categories;
 
        iss1 >> categories;
        
        istringstream iss2(token2); // Read event-weight factors
        
        int fluxID = 0;
        
        if (iss2 >> fluxID) {
          
          JFluxHelper helper(dictionary.at(fluxID).getFlux());
 
          JFlux& flux = helper.getFlux();
 
          iss2 >> flux;
 
          if (!fail(iss2)) {
            for (JEvtCategorySet::const_iterator i = categories.cbegin(); i != categories.cend(); ++i) {
              this->insert(*i, 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 map of event categories and weight factors.
     */
    struct JEvtCategoryMapHelper :
      public JProperties
    {
      /**
       * Constructor.
       *
       * \param  map             event category map
       * \param  eqpars          equation parameters 
       */
      template<class JEvtCategoryMap_type>
      JEvtCategoryMapHelper(JEvtCategoryMap_type&     map,
                           const JEquationParameters& eqpars) :
        JProperties(eqpars, 1)
      {
        using namespace std;
        using namespace JPP;
        
        for (typename map_type::const_iterator i = map.cbegin(); i != map.cend(); ++i) {
 
          const int index = 1 + distance(map.cbegin(), i);
 
          const string key = MAKE_STRING("category" << index);
 
          JProperties sub1 = i->first .getProperties(eqpars);
          JProperties sub2 = i->second.getProperties(eqpars);
 
          (*this)[key] = sub1.join(sub2);
        }
      }
    };
    
    JOscProbHelper oscProb; //!< oscillation probability calculator
  };
 
  using JFluxMap = JEvtCategoryMap<JFluxHelper>; //!< Type alias for flux maps
}
 
#endif