JWeightFileScannerSet.hh

Go to the documentation of this file.

#ifndef __JSUPPORT_JWEIGHTFILESCANNERSET__
#define __JSUPPORT_JWEIGHTFILESCANNERSET__

#include <vector>
#include <functional>

#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 "JSupport/JMultipleFileScanner.hh"
#include "JSupport/JWeightFileScanner.hh"

#include "JAAnet/JHead.hh"
#include "JAAnet/JFlux.hh"
#include "JAAnet/JFluxHelper.hh"
#include "JAAnet/JMultiParticleFlux.hh"
#include "JAAnet/JWeightEventToolkit.hh"

/**
 * \author bjung
 */

namespace JSUPPORT {

  using JAANET::JHead;
  using JAANET::JFlux;
  using JAANET::JFluxHelper;
  using JAANET::JMultiParticleFlux;
  
  using JLANG::JValueOutOfRange;
  

  /**
   * Auxiliary class for organising Monte Carlo file scanners.
   */
  template<class JFileScanner_t = JMultipleFileScanner<Evt>,
           class JComparator_t  = std::less<JHead> >
  struct JWeightFileScannerSet :
    std::vector< JWeightFileScanner<JFileScanner_t> >
  {
    typedef JWeightFileScanner<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;

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

    /**
     * Constructor.
     *
     * \param  input         file list
     * \param  limit         limit
     */
    JWeightFileScannerSet(JMultipleFileScanner_t& input,
                          JLimit&                 limit = JLimit())
    {
      put     (input);
      setLimit(limit);
    }
    
    
    /**
     * Put file
     *
     * \param  input              file list
     */
    void put(JMultipleFileScanner_t& input)
    {
      for (JMultipleFileScanner_t::const_iterator i = input.begin(); i != input.end(); ++i) {
        this->put(*i);
      }
    }
    
    
    /**
     * Put file
     *
     * \param  input              file name
     */
    void 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)));
      }

      i->put(input);
    }
    

    /**
     * Find file scanner compatible with a given header.
     *
     * \param  head          header
     * \return               file scanner
     */
    const JWeightFileScanner<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, "JWeightFileScannerSet::get(): No corresponding scanner found for given header.");
    }
    

    /**
     * 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)
    {
      using namespace std;
      using namespace JPP;

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

        const JHead& header = i->getHeader();

        vector<JAANET::flux>::const_iterator j = find_if(header.flux.cbegin(),
                                                         header.flux.cend(),
                                                         make_predicate(&flux::type, type));
        
        if (header.primary.type == type || (header.flux.size() == 1 && j != header.flux.end())) {
          
          JFluxHelper* helper = dynamic_cast<JFluxHelper*>(i->get());
          
          if (helper != NULL) {
            
            helper->configure(function);
            ++n;
          }
        }
      }

      return n;
    }


    /**
     * 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)
    {
      using namespace std;
      using namespace JPP;

      size_t n = 0;

      for (iterator i = this->begin(); i != this->end(); ++i) {

        bool matching = (!types.empty());
        
        const JHead& header = i->getHeader();
        
        for (set<int>::const_iterator j = types.cbegin(); j != types.cend() && matching; ++j) {
          
          vector<JAANET::flux>::const_iterator flux = find_if(header.flux.cbegin(),
                                                              header.flux.cend(),
                                                              make_predicate(&flux::type, *j));
          
          matching = (flux != header.flux.cend());
        }
        
        if (matching) {
          
          JFluxHelper* helper = dynamic_cast<JFluxHelper*>(i->get());
          
          if (helper != NULL) {
            
            helper->configure(function);
            ++n;
          }
        }
      }
      
      return n;
    }


    /**
     * 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  multiFlux     multi-particle flux object
     * \return               number of modified event weighters
     */
    size_t setFlux(const JMultiParticleFlux& multiFlux)
    {
      using namespace std;
      using namespace JPP;

      size_t n = 0;
      
      for (iterator i = this->begin(); i != this->end(); ++i) {
        
        bool matching = (!multiFlux.empty());
        
        const JHead& header = i->getHeader();
      
        for (JMultiParticleFlux::const_iterator j = multiFlux.cbegin(); j != multiFlux.cend() && matching; ++j) {
          
          vector<JAANET::flux>::const_iterator flux = find_if(header.flux.cbegin(),
                                                              header.flux.cend(),
                                                              make_predicate(&flux::type, j->first));
          
          matching = (flux != header.flux.cend());
        }
        
        if (matching) {
          
          JFluxHelper* helper = dynamic_cast<JFluxHelper*>(i->get());
          
          if (helper != NULL) {
            
            helper->configure(multiFlux);
            ++n;
          }
        }
      }
      
      return n;
    }
    

    /**
     * Set limit.
     *
     * \param  limit         limit
     */
    void setLimit(const JLimit& limit)
    {
      for (iterator i = this->begin(); i != this->end(); ++i) {
        i->setLimit(limit);
      }
    }


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

#endif