JEvtWeightFileScannerSet.hh

Go to the documentation of this file.

#ifndef __JSUPPORT_JEVTWEIGHTFILESCANNERSET__
#define __JSUPPORT_JEVTWEIGHTFILESCANNERSET__
 
#include <vector>
#include <string>
 
#include "km3net-dataformat/offline/Head.hh"
#include "km3net-dataformat/offline/Evt.hh"
 
#include "JLang/JException.hh"
#include "JLang/JComparator.hh"
 
#include "JAAnet/JHead.hh"
 
#include "JAAnet/JEvtCategory.hh"
#include "JAAnet/JEvtCategoryHelper.hh"
#include "JAAnet/JEvtCategoryMap.hh"
#include "JAAnet/JEvtCategoryToolkit.hh"
 
#include "JAAnet/JEvtWeight.hh"
#include "JAAnet/JEvtWeightHelper.hh"
 
#include "JAAnet/JEvtWeightFactor.hh"
#include "JAAnet/JEvtWeightFactorHelper.hh"
#include "JAAnet/JFluxHelper.hh"
 
#include "JSupport/JSupport.hh"
#include "JSupport/JMultipleFileScanner.hh"
#include "JSupport/JEvtWeightFileScanner.hh"
#include "JSupport/JMonteCarloFileSupportkit.hh"
 
 
/**
 * \author bjung
 */
 
namespace JSUPPORT {}
namespace JPP { using namespace JSUPPORT; }
 
namespace JSUPPORT {
 
  using JAANET::JHead;
 
  using JAANET::JEvtCategoryHelper;
  using JAANET::JEvtCategorySet;
  using JAANET::JEvtCategoryMap;
 
  using JAANET::JEvtWeightFactorHelper;
  using JAANET::JFluxHelper;
  
 
  /**
   * Auxiliary class for organising Monte Carlo file scanners associated with event weighters.
   *
   * Note: The template class `JFileScanner_t` must be derived from JMultipleFileScanner<Evt>.
   */
  template<class JFileScanner_t = JMultipleFileScanner<Evt>,
           class JComparator_t  = std::less<JHead> >
  struct JEvtWeightFileScannerSet :
    public std::vector< JEvtWeightFileScanner<JFileScanner_t> >
  {
    typedef JEvtWeightFileScannerSet<JFileScanner_t, JComparator_t>          filescannerset_type;
    typedef JEvtWeightFileScanner<JFileScanner_t>                            filescanner_type;
 
    typedef typename filescanner_type::input_type                            input_type;
 
    typedef typename std::vector<filescanner_type>::value_type               value_type;
    typedef typename std::vector<filescanner_type>::reference                reference;
    typedef typename std::vector<filescanner_type>::const_reference          const_reference;
 
    typedef typename std::vector<filescanner_type>::const_iterator           const_iterator;
    typedef typename std::vector<filescanner_type>::iterator                 iterator;
    typedef typename std::vector<filescanner_type>::const_reverse_iterator   const_reverse_iterator;
    typedef typename std::vector<filescanner_type>::reverse_iterator         reverse_iterator;
    
 
    
    /**
     * Default constructor.
     */
    JEvtWeightFileScannerSet()
    {}
    
 
    /**
     * Constructor.
     *
     * \param  input                       input files
     */
    JEvtWeightFileScannerSet(const input_type& input)
    {
      put(input);
    }
    
    
    /**
     * Put files
     *
     * \param  input                       input files
     * \return                             number of added files
     */
    size_t put(const input_type& input)
    {
      size_t n = 0;
      
      for (typename input_type::const_iterator i = input.begin(); i != input.end(); ++i) {
        n += size_t(this->put(*i));
      }
 
      return n;
    }
    
    
    /**
     * Put file
     *
     * \param  input                       input file
     * \return                             true if successfully added; else false.
     */
    bool put(const std::string& input)
    {
      using namespace std;
      using namespace JPP;
      
      const JHead& head = getHeader(input);
 
      iterator i = lower_bound(this->begin(),  this->end(),  head,
                               make_comparator(&JHead::getHeader, compare));
 
      if (i == this->end() || !i->getHeader().match(head)) {
        i = this->insert(i, value_type(getEventWeighter(head)));
      }
 
      return i->put(input);
    }
 
 
    /**
     * Get unique identifier for a file-scanner contained within this set of event-weighter-associated file-scanners.
     *
     * \param  p                           iterator to contained file-scanner
     * \return                             unique identifier of contained file-scanner
     */
    std::string getUniqueIdentifier(const_iterator p) const
    {
      using namespace std;
      using namespace JPP;
 
      static const char SEPARATOR = '.';
 
      string name  = p->getProgramName();
      int    index = 0;
      
      for (const_iterator i = this->cbegin(); i != this->cend() && i != p; ++i) {
        if (i->getProgramName() == name) {
          ++index;
        }
      }
      
      return MAKE_STRING(name << SEPARATOR << index);
    }
    
 
    /**
     * Find file scanner compatible with a given header.
     *
     * \param  head                        header
     * \return                             file scanner
     */
    const_reference find(const JHead& head) const
    {
      using namespace JPP;
      
      for (const_iterator i = this->begin(); i != this->end(); ++i) {
        if (i->match(head)) {
          return *i;
        }
      }
 
      THROW(JValueOutOfRange, "JEvtWeightFileScannerSet::get(): No corresponding scanner found for given header.");
    }
    
 
    /**
     * Set event-weighting factor for all MC-files corresponding to a given PDG code.
     *
     * \param  category                    event category
     * \param  factor                      event-weight factor
     * \return                             number of modified event weighters
     */
    size_t setEvtWeightFactor(const JEvtCategoryHelper&     category,
                              const JEvtWeightFactorHelper& factor)
    {
      using namespace std;
      using namespace JPP;
 
      size_t n = 0;
        
      for (iterator i = this->begin(); i != this->end(); ++i) {
        n += (size_t) i->setEvtWeightFactor(category, factor);
      }
 
      return n;
    }
 
 
    /**
     * Set event-weight factor of all MC-files corresponding to a given set of event categories.
     *
     * If the boolean `requireAll` argument is set to `true`,\n
     * the given event-weighting factor will only be assigned to those files\n
     * whose header matches < b>all< /b> of the specified event categories.
     *
     * \param  categories                  set of event categories
     * \param  factor                      event-weight factor
     * \param  requireAll                  toggle requirement that the file headers match all given event categories
     * \return                             number of modified event weighters
     */
    size_t setEvtWeightFactor(const JEvtCategorySet&        categories,
                              const JEvtWeightFactorHelper& factor,
                              const bool                    requireAll = false)
    {
      using namespace std;
      using namespace JPP;
 
      size_t n = 0;
 
      if (requireAll) {
 
        for (iterator i = this->begin(); i != this->end(); ++i) {
          n += (size_t) i->setEvtWeightFactor(categories, factor);
        }
        
      } else {
 
        for (iterator i = this->begin(); i != this->end(); ++i) {
 
          bool isSet = false;
          
          for (JEvtCategorySet::const_iterator j = categories.cbegin(); j != categories.cend() && !isSet; ++j) {
            isSet = i->setEvtWeightFactor(*j, factor);
          }
 
          n += (size_t) isSet;
        }
      }
      
      return n;
    }
 
 
    /**
     * Set event-weight factor of all MC-files according to a given map between event categories and event-weight factors.
     *
     * The template argument refers either to the class `JAANET::JEvtWeightFactorHelper` or `JAANET::JFluxHelper`.
     *
     * If the boolean `requireAll` argument is set to `true`,\n
     * the given event-weighting factor will only be assigned to those files\n
     * whose header matches < b>all< /b> of the specified event categories.
     *
     * \param  object                      map between event categories and event-weight factors
     * \param  requireAll                  toggle requirement that the file headers match all given event categories
     * \return                             number of modified event weighters
     */
    template<class JEvtWeightFactorHelper_t>
    size_t setEvtWeightFactor(const JEvtCategoryMap<JEvtWeightFactorHelper_t>& object,
                              const bool                                       requireAll = false)
    {
      using namespace std;
      using namespace JPP;
 
      size_t n = 0;
 
      if (requireAll) {
 
        for (iterator i = this->begin(); i != this->end(); ++i) {
          n += (size_t) i->template setEvtWeightFactor<JEvtWeightFactorHelper_t>(object);
        }
        
      } else {
 
        for (iterator i = this->begin(); i != this->end(); ++i) {
 
          bool isSet = false;
          
          for (typename JEvtCategoryMap<JEvtWeightFactorHelper_t>::const_iterator j = object.cbegin(); j != object.cend() && !isSet; ++j) {
            isSet = i->setEvtWeightFactor(j->first, j->second);
          }
 
          n += (size_t) isSet;
        }
      }
      
      return n;
    }
    
 
    /**
     * Set flux function for all MC-files corresponding to a given event category.
     *
     * \param  category                    event category
     * \param  flux                        flux function
     * \return                             number of modified event weighters
     */
    size_t setFlux(const JEvtCategoryHelper& category,
                   const JFluxHelper&        flux)
    {
      return setEvtWeightFactor(category, flux);
    }
 
 
    /**
     * Set flux function of all MC-files corresponding to a given set of event categories.
     * 
     * If the boolean `requireAll` argument is set to `true`,
     * the given flux function will only be assigned to those files\n
     * whose header lists < b>all< /b> of the specified PDG codes as primaries.
     *
     * \param  categories                  set of event categories
     * \param  flux                        flux function
     * \param  requireAll                  toggle requirement that each file header must contain every given PDG code.
     * \return                             number of modified event weighters
     */
    size_t setFlux(const JEvtCategorySet& categories,
                   const JFluxHelper&     flux,
                   const bool             requireAll = false)
    {
      return setEvtWeightFactor(categories, flux, requireAll);
    }
 
 
    /**
     * Set event-weight factor of all MC-files according to a given map between event categories and event-weight factors.
     * 
     * If the boolean `requireAll` argument is set to `true`, 
     * the given flux function will only be assigned to those files\n
     * whose header matches < b>all< /b> of the specified event categories.
     *
     * \param  object                      map between event categories and flux functions
     * \param  requireAll                  toggle requirement that the file headers match all given event categories
     * \return                             number of modified event weighters
     */
    size_t setFlux(const JEvtCategoryMap<JFluxHelper>& object,
                   const bool                          requireAll = false)
    {
      return setEvtWeightFactor(object, requireAll);
    }
 
 
    /**
     * Function object for comparison of headers.
     */
    JComparator_t compare;
  };
 
 
}
 
#endif