JEvtWeightFileScannerSet.hh

Go to the documentation of this file.

#ifndef __JSUPPORT_JEVTWEIGHTFILESCANNERSET__
#define __JSUPPORT_JEVTWEIGHTFILESCANNERSET__

#include <set>
#include <vector>
#include <string>

#include "km3net-dataformat/offline/Head.hh"
#include "km3net-dataformat/offline/Evt.hh"

#include "JLang/JException.hh"
#include "JLang/JPredicate.hh"
#include "JLang/JComparator.hh"

#include "JAAnet/JHead.hh"
#include "JAAnet/JFlux.hh"
#include "JAAnet/JEvtWeightFactor.hh"
#include "JAAnet/JEvtWeightToolkit.hh"
#include "JAAnet/JEvtWeightFactorHelper.hh"
#include "JAAnet/JEvtWeightFactorMultiParticle.hh"

#include "JSupport/JMultipleFileScanner.hh"
#include "JSupport/JEvtWeightFileScanner.hh"
#include "JSupport/JMonteCarloFileSupportkit.hh"


/**
 * \author bjung
 */

namespace JSUPPORT {
  
  using JLANG::JValueOutOfRange;

  using JAANET::JHead;
  
  using JAANET::JFlux;
  using JAANET::JFluxHelper;
  using JAANET::JFluxMultiParticle;
  
  using JAANET::JEvtWeightFactor;
  using JAANET::JEvtWeightFactorHelper;
  using JAANET::JEvtWeightFactorMultiParticle;
  

  /**
   * Auxiliary class for organising Monte Carlo file scanners associated with event weighters.
   */
  template<class JFileScanner_t = JMultipleFileScanner<Evt>,
           class JComparator_t  = std::less<JHead> >
  struct JEvtWeightFileScannerSet :
    std::vector< JEvtWeightFileScanner<JFileScanner_t> >
  {
    typedef JEvtWeightFileScanner<JFileScanner_t>                      value_type;
    
    typedef typename std::vector<value_type>::const_iterator           const_iterator;
    typedef typename std::vector<value_type>::iterator                 iterator;
    typedef typename std::vector<value_type>::const_reverse_iterator   const_reverse_iterator;
    typedef typename std::vector<value_type>::reverse_iterator         reverse_iterator;
    
    typedef typename std::vector<value_type>::reference                reference;
    typedef typename std::vector<value_type>::const_reference          const_reference;

    
    /**
     * Default constructor.
     */
    JEvtWeightFileScannerSet()
    {}
    

    /**
     * Constructor.
     *
     * \param  input                       file list
     */
    JEvtWeightFileScannerSet(const JMultipleFileScanner_t& input)
    {
      put(input);
    }
    
    
    /**
     * Put file
     *
     * \param  input                       file list
     * \return                             number of added files
     */
    size_t put(const JMultipleFileScanner_t& input)
    {
      size_t n = 0;
      
      for (JMultipleFileScanner_t::const_iterator i = input.begin(); i != input.end(); ++i) {
        n += size_t(this->put(*i));
      }

      return n;
    }
    
    
    /**
     * Put file
     *
     * \param  input                       file name
     * \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 (typename vector<value_type>::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 JEvtWeightFileScanner<JFileScanner_t>& find(const JHead& head) const
    {
      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.
     *
     * Note that the given event-weighting factor will only be assigned to those files\n
     * whose header exclusively lists the given PDG code as primary.
     *
     * \param  type                        PDG code
     * \param  factor                      event-weight factor
     * \return                             number of modified event weighters
     */
    size_t setEvtWeightFactor(const int               type,
                              const JEvtWeightFactor& 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(type, factor);
      }

      return n;
    }


    /**
     * Set event-weight factor of all MC-files corresponding to a given set of PDG codes.
     * 
     * Note that the given event-weighting factor will only be assigned to those files\n
     * whose header lists < b>all< /b> of the specified PDG codes as primaries.
     *
     * \param  types                       set of PDG codes
     * \param  factor                      event-weight factor
     * \return                             number of modified event weighters
     */
    size_t setEvtWeightFactor(const std::set<int>&    types,
                              const JEvtWeightFactor& 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(types, factor);
      }
      
      return n;
    }


    /**
     * Set event-weight factor of all MC-files corresponding to a given multi-particle flux.
     * 
     * Note that the given event-weighting factors will only be assigned to those files\n
     * whose header lists < b>all< /b> of the PDG codes associated with the multi-particle event-weighting factor object as primaries.
     *
     * \param  multiParticleFactor        multi-particle event-weight factor
     * \return                            number of modified event weighters
     */
    size_t setEvtWeightFactor(const JEvtWeightFactorMultiParticle& multiParticleFactor)
    {
      using namespace std;
      using namespace JPP;

      size_t n = 0;
      
      for (iterator i = this->begin(); i != this->end(); ++i) {
        n += (size_t) i->setEvtWeightFactor(multiParticleFactor);       
      }
      
      return n;
    }
    

    /**
     * Set flux function for all MC-files corresponding to a given PDG code.
     *
     * Note that only the given flux function will only be assigned to those files\n
     * whose header exclusively lists the given PDG code as primary.
     *
     * \param  type                        PDG code
     * \param  function                    flux function
     * \return                             number of modified event weighters
     */
    size_t setFlux(const int    type,
                   const JFlux& function)
    {
      return setEvtWeightFactor(type, function);
    }


    /**
     * Set flux function of all MC-files corresponding to a given set of PDG codes.
     * 
     * Note that 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  types                       set of PDG codes
     * \param  function                    flux function
     * \return                             number of modified event weighters
     */
    size_t setFlux(const std::set<int>& types,
                   const JFlux&         function)
    {
      return setEvtWeightFactor(types, function);
    }


    /**
     * Set flux function of all MC-files corresponding to a given multi-particle flux.
     * 
     * Note that the given flux functions will only be assigned to those files\n
     * whose header lists < b>all< /b> of the PDG codes associated with the multi-particle flux as primaries.
     *
     * \param  multiParticleFlux          multi-particle flux object
     * \return                            number of modified event weighters
     */
    size_t setFlux(const JFluxMultiParticle& multiParticleFlux)
    {
      return setEvtWeightFactor(multiParticleFlux);
    }


    /**
     * Function object for comparison of headers.
     */
    JComparator_t compare;
  };


}

#endif