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 "JLang/JStringStream.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.
   *
   * The input syntax follows the following scheme:
   *
   * <tt>[oscillation probabilities configuration] (<categories> <factors>)+</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>categories</tt> refers to a set of event categories, which can be specified according to one of the following formats:
   *       1. <tt><PDG type> [ & <PDG type>]+;</tt>
   *       2. <tt><key>=<value>[<end of line> <key>=<value>]+ [ & <key>=<value>[<end of line> <key>=<value>]+ ]+;</tt>
   *     where:
   *       - <tt>PDG type</tt>          refers to a PDG identifier;
   *       - <tt>key</tt>                      to one of the data members of a data structure derived from `JAANET::JEvtCategory` and
   *       - <tt>value</tt>                    to the corresponding value;
   *   - <tt>factors</tt> refers to a set of weighting factors, 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,
   *   - each set of arguments for the oscillation probabilities, an event category or weighting factor needs to be separated by a semi-colon (';') and   
   *   - multiple event categories and weight factors can be specified as a group, 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 weight factors
     * \return                joined map between event categories and weight factors
     */
    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<JEvtWeightFactorHelper>::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;
 
      JStringStream is(in);
 
      if (getFileStatus(is.str().c_str())) {
        is.load();
      }
 
      const streampos         pos   = is.tellg();
      const ios_base::iostate state = is.rdstate();
      
      // Read optional oscillation probability calculator configuration
 
      JToken<';'> token;
      is >> token;
        
      istringstream iss(token);
      iss >> oscProb;
 
      if (fail(iss)) {
        is.clear(state);
        is.seekg(pos);
      }
 
      for (JToken<';'> token1, token2; is >> 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.
   *
   * The input syntax follows the following scheme:
   *
   * <tt>[oscillation probabilities configuration] (<categories> <flux>)+</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>categories</tt> refers to a set of event categories, which can be specified according to one of the following formats:
   *       1. <tt><PDG type> [ & <PDG type>]+;</tt>
   *       2. <tt><key>=<value>[<end of line> <key>=<value>]+ [ & <key>=<value>[<end of line> <key>=<value>]+ ]+;</tt>
   *     where:
   *       - <tt>PDG type</tt>        refers to a PDG identifier;
   *       - <tt>key</tt>                    to one of the data members of a data structure derived from `JAANET::JEvtCategory` and
   *       - <tt>value</tt>                  to the corresponding value;
   *   - <tt>flux</tt> refers to a flux, which needs to be specified according to the following format:
   *       1. <tt><flux identifier> [<flux arguments>];</tt>,
   *     where:
   *       - <tt>flux identifier</tt> refers to an event-weight flux identifier (c.f. `JAANET::JFluxDictionary::factors`); and
   *       - <tt>flux arguments</tt>         to the list of arguments for the corresponding flux,
   *   - each set of arguments for the oscillation probabilities, an event category or flux needs to be separated by a semi-colon (';') and
   *   - multiple event categories can be specified as a group, separated by the '&' character.   
   */
  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);
 
      JStringStream is(in);
 
      if (getFileStatus(is.str().c_str())) {
        is.load();
      }
 
      const streampos         pos   = is.tellg();
      const ios_base::iostate state = is.rdstate();
      
      // Read optional oscillation probability calculator configuration
 
      JToken<';'> token;
      is >> token;
        
      istringstream iss(token);
      iss >> oscProb;
 
      if (fail(iss)) {
        is.clear(state);
        is.seekg(pos);
      }
      
      for (JToken<';'> token1, token2; is >> 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) {
          
          const JFluxHelper helper = dictionary[fluxID];
 
          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