TEvtGen/HepMC/WeightContainer.h

   1 //--------------------------------------------------------------------------
   2 #ifndef HEPMC_WEIGHT_CONTAINER_H
   3 #define HEPMC_WEIGHT_CONTAINER_H
   4
   5 //////////////////////////////////////////////////////////////////////////
   6 // Matt.Dobbs@Cern.CH, November 2000, refer to:
   7 // M. Dobbs and J.B. Hansen, "The HepMC C++ Monte Carlo Event Record for
   8 // High Energy Physics", Computer Physics Communications (to be published).
   9 //
  10 // Container for the Weights associated with an event or vertex.
  11 //
  12 // This implementation adds a map-like interface in addition to the
  13 // vector-like interface.
  14 //////////////////////////////////////////////////////////////////////////
  15
  16 #include <iostream>
  17 #include <vector>
  18 #include <string>
  19 #include <map>
  20
  21 namespace HepMC {
  22
  23     //! Container for the Weights associated with an event or vertex.
  24
  25     ///
  26     /// \class  WeightContainer
  27     /// This class has both map-like and vector-like functionality.
  28     /// Named weights are now supported.
  29     class WeightContainer {
  30         friend class GenEvent;
  31
  32     public:
  33         /// defining the size type used by vector and map
  34         typedef std::size_t size_type;
  35         /// iterator for the weight container
  36         typedef std::vector<double>::iterator iterator;
  37         /// const iterator for the weight container
  38         typedef std::vector<double>::const_iterator const_iterator;
  39
  40         /// default constructor
  41         explicit WeightContainer( size_type n = 0, double value = 0. );
  42         /// construct from a vector of weights
  43         WeightContainer( const std::vector<double>& weights );
  44         /// copy
  45         WeightContainer( const WeightContainer& in );
  46         ~WeightContainer();
  47
  48         /// swap
  49         void swap( WeightContainer & other);
  50         /// copy assignment
  51         WeightContainer& operator=( const WeightContainer& );
  52         /// alternate assignment using a vector of doubles
  53         WeightContainer& operator=( const std::vector<double>& in );
  54
  55         /// print weights
  56         void          print( std::ostream& ostr = std::cout ) const;
  57         /// write weights in a readable table
  58         void          write( std::ostream& ostr = std::cout ) const;
  59
  60         /// size of weight container
  61         size_type     size() const;
  62         /// return true if weight container is empty
  63         bool          empty() const;
  64         /// push onto weight container
  65         void          push_back( const double& );
  66         /// pop from weight container
  67         void          pop_back();
  68         /// clear the weight container
  69         void          clear();
  70
  71         /// check to see if a name exists in the map
  72         bool          has_key( const std::string& s ) const;
  73
  74         /// access the weight container
  75         double&       operator[]( size_type n );  // unchecked access
  76         /// access the weight container
  77         const double& operator[]( size_type n ) const;
  78         /// access the weight container
  79         double&       operator[]( const std::string& s );  // unchecked access
  80         /// access the weight container
  81         const double& operator[]( const std::string& s ) const;
  82
  83         /// equality
  84         bool operator==( const WeightContainer & ) const;
  85         /// inequality
  86         bool operator!=( const WeightContainer & ) const;
  87
  88         /// returns the first element
  89         double&       front();
  90         /// returns the first element
  91         const double& front() const;
  92         /// returns the last element
  93         double&       back();
  94         /// returns the last element
  95         const double& back() const;
  96
  97         /// begining of the weight container
  98         iterator            begin();
  99         /// end of the weight container
 100         iterator            end();
 101         /// begining of the weight container
 102         const_iterator      begin() const;
 103         /// end of the weight container
 104         const_iterator      end() const;
 105
 106     private:
 107         // for internal use only
 108
 109         /// maplike iterator for the weight container
 110         /// for internal use only
 111         typedef std::map<std::string,size_type>::iterator       map_iterator;
 112         /// const iterator for the weight container
 113         /// for internal use only
 114         typedef std::map<std::string,size_type>::const_iterator const_map_iterator;
 115         /// begining of the weight container
 116         /// for internal use only
 117         map_iterator            map_begin();
 118         /// end of the weight container
 119         /// for internal use only
 120         map_iterator            map_end();
 121         /// begining of the weight container
 122         /// for internal use only
 123         const_map_iterator      map_begin() const;
 124         /// end of the weight container
 125         /// for internal use only
 126         const_map_iterator      map_end() const;
 127
 128         /// used by the constructors to set initial names
 129         /// for internal use only
 130         void set_default_names( size_type n );
 131
 132     private:
 133         std::vector<double>          m_weights;
 134         std::map<std::string,size_type> m_names;
 135     };
 136
 137     ///////////////////////////
 138     // INLINES               //
 139     ///////////////////////////
 140
 141     inline WeightContainer::WeightContainer( const WeightContainer& in )
 142         : m_weights(in.m_weights), m_names(in.m_names)
 143     {}
 144
 145     inline WeightContainer::~WeightContainer() {}
 146
 147     inline void WeightContainer::swap( WeightContainer & other)
 148     {
 149         m_weights.swap( other.m_weights );
 150         m_names.swap( other.m_names );
 151     }
 152
 153     inline WeightContainer& WeightContainer::operator=
 154     ( const WeightContainer& in ) {
 155         /// best practices implementation
 156         WeightContainer tmp( in );
 157         swap( tmp );
 158         return *this;
 159     }
 160
 161     inline WeightContainer& WeightContainer::operator=
 162     ( const std::vector<double>& in ) {
 163         /// best practices implementation
 164         WeightContainer tmp( in );
 165         swap( tmp );
 166         return *this;
 167     }
 168
 169     inline WeightContainer::size_type WeightContainer::size() const { return m_weights.size(); }
 170
 171     inline bool WeightContainer::empty() const { return m_weights.empty(); }
 172
 173     inline void WeightContainer::clear()
 174     {
 175         m_weights.clear();
 176         m_names.clear();
 177     }
 178
 179     inline double& WeightContainer::operator[]( size_type n )
 180     { return m_weights[n]; }
 181
 182     inline const double& WeightContainer::operator[]( size_type n ) const
 183     { return m_weights[n]; }
 184
 185     inline double& WeightContainer::front() { return m_weights.front(); }
 186
 187     inline const double& WeightContainer::front() const
 188     { return m_weights.front(); }
 189
 190     inline double& WeightContainer::back() { return m_weights.back(); }
 191
 192     inline const double& WeightContainer::back() const
 193     { return m_weights.back(); }
 194
 195     inline WeightContainer::iterator WeightContainer::begin()
 196     { return m_weights.begin(); }
 197
 198     inline WeightContainer::iterator WeightContainer::end()
 199     { return m_weights.end(); }
 200
 201     inline WeightContainer::const_iterator WeightContainer::begin() const
 202     { return m_weights.begin(); }
 203
 204     inline WeightContainer::const_iterator WeightContainer::end() const
 205     { return m_weights.end(); }
 206
 207     inline WeightContainer::map_iterator WeightContainer::map_begin()
 208     { return m_names.begin(); }
 209
 210     inline WeightContainer::map_iterator WeightContainer::map_end()
 211     { return m_names.end(); }
 212
 213     inline WeightContainer::const_map_iterator WeightContainer::map_begin() const
 214     { return m_names.begin(); }
 215
 216     inline WeightContainer::const_map_iterator WeightContainer::map_end() const
 217     { return m_names.end(); }
 218
 219 } // HepMC
 220
 221 #endif  // HEPMC_WEIGHT_CONTAINER_H
 222 //--------------------------------------------------------------------------
 223
 224
 225