Selector.h

// -*- C++ -*-
//
// Selector.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 1999-2019 Leif Lonnblad
//
// ThePEG is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef ThePEG_Selector_H
#define ThePEG_Selector_H
// This is the declaration of the Selector class.
 
#include "ThePEG/Config/ThePEG.h"
#include <stdexcept>
#include <algorithm>
#include <stdexcept>
 
namespace ThePEG {
 
template <typename T, typename WeightType = double>
class Selector {
 
public:
 
  typedef map<WeightType, T, less<WeightType> > MapType;
 
  typedef typename MapType::const_iterator const_iterator;
 
  typedef typename MapType::iterator iterator;
 
  typedef typename MapType::size_type size_type;
 
public:
 
  Selector() : theSum(WeightType()) {}
 
  void swap(Selector & s) 
  {
    theMap.swap(s.theMap);
    std::swap(theSum, s.theSum);
  }
 
  WeightType insert(WeightType d, const T & t) {
    typedef typename MapType::value_type value_type;
    WeightType newSum = theSum + d;
    if ( newSum <= theSum ) return d;
    theMap.insert(theMap.end(), value_type((theSum = newSum), t));
    return theSum;
  }
 
  WeightType reweight(WeightType d, const T & t)
  {
    erase(t);
    return insert(d, t);
  }
 
  WeightType erase(const T &);
 
  void replace(const T & oldObject, const T & newObject) {
    for ( iterator it = theMap.begin(); it != theMap.end(); ++it )
      if ( it->second == oldObject ) it->second = newObject;
  }
 
  T & select(double rnd, double * remainder = 0);
 
  T & operator[](double rnd) { return select(rnd); }
 
  const T & select(double rnd, double * remainder = 0) const;
 
  const T & operator[](double rnd) const { return select(rnd); } 
 
  template <typename RNDGEN>
  T & select(RNDGEN & rnd) {
    double rem = 0.0;
    T & t = select(rnd(), &rem);
    rnd.push_back(rem);
    return t;
  }
 
  template <typename RNDGEN>
  const T & select(RNDGEN & rnd) const {
    double rem = 0.0;
    const T & t = select(rnd(), &rem);
    rnd.push_back(rem);
    return t;
  }
 
  WeightType sum() const { return theSum; }
 
  const_iterator begin() const { return theMap.begin(); }
 
  const_iterator end() const { return theMap.end(); }
 
  bool empty() const { return theMap.empty(); }
 
  size_type size() const { return theMap.size(); }
 
  void clear() { theMap.clear(); theSum = WeightType(); }
 
  template <typename OStream>
  void output(OStream &, DimensionT) const;
 
  template <typename IStream>
  void input(IStream &, DimensionT);
 
  template <typename OStream>
  void output(OStream &, StandardT) const;
 
  template <typename IStream>
  void input(IStream &, StandardT);
 
private:
 
  MapType theMap;
 
  WeightType theSum;
 
};
 
template <typename OStream, typename T, typename WeightType>
OStream & operator<<(OStream & os, const Selector<T,WeightType> & s)
{
  s.output(os, typename TypeTraits<WeightType>::DimType());
  return os;
}
 
template <typename IStream, typename T, typename WeightType>
IStream & operator>>(IStream & is, Selector<T,WeightType> & s)
{
  s.input(is, typename TypeTraits<WeightType>::DimType());
  return is;
}
 
 
}
 
#ifndef ThePEG_TEMPLATES_IN_CC_FILE
#include "Selector.tcc"
#endif
 
#endif /* ThePEG_Selector_H */