FastJet  3.3.0
GhostedAreaSpec.hh
1 //FJSTARTHEADER
2 // $Id: GhostedAreaSpec.hh 4074 2016-03-08 09:09:25Z soyez $
3 //
4 // Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
5 //
6 //----------------------------------------------------------------------
7 // This file is part of FastJet.
8 //
9 // FastJet is free software; you can redistribute it and/or modify
10 // it under the terms of the GNU General Public License as published by
11 // the Free Software Foundation; either version 2 of the License, or
12 // (at your option) any later version.
13 //
14 // The algorithms that underlie FastJet have required considerable
15 // development. They are described in the original FastJet paper,
16 // hep-ph/0512210 and in the manual, arXiv:1111.6097. If you use
17 // FastJet as part of work towards a scientific publication, please
18 // quote the version you use and include a citation to the manual and
19 // optionally also to hep-ph/0512210.
20 //
21 // FastJet is distributed in the hope that it will be useful,
22 // but WITHOUT ANY WARRANTY; without even the implied warranty of
23 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 // GNU General Public License for more details.
25 //
26 // You should have received a copy of the GNU General Public License
27 // along with FastJet. If not, see <http://www.gnu.org/licenses/>.
28 //----------------------------------------------------------------------
29 //FJENDHEADER
30 
31 
32 #ifndef __FASTJET_GHOSTEDAREASPEC_HH__
33 #define __FASTJET_GHOSTEDAREASPEC_HH__
34 
35 #include<vector>
36 #include<string>
37 #include "fastjet/PseudoJet.hh"
38 #include "fastjet/internal/BasicRandom.hh"
39 #include "fastjet/Selector.hh"
40 #include "fastjet/LimitedWarning.hh"
41 #include "fastjet/internal/deprecated.hh"
42 
43 //
44 #define STATIC_GENERATOR 1
45 
46 FASTJET_BEGIN_NAMESPACE // defined in fastjet/internal/base.hh
47 
48 /// namespace to hold default parameters for the active area spec
49 namespace gas {
50  const double def_ghost_maxrap = 6.0;
51  const int def_repeat = 1;
52  const double def_ghost_area = 0.01;
53  const double def_grid_scatter = 1.0;
54  const double def_pt_scatter = 0.1;
55  const double def_mean_ghost_pt = 1e-100;
56 }
57 
58 //----------------------------------------------------------------------
59 /// @ingroup area_classes
60 /// \class GhostedAreaSpec
61 /// Parameters to configure the computation of jet areas using ghosts
62 ///
63 /// Class that defines the parameters that go into the measurement
64 /// of active jet areas.
66 public:
67  /// default constructor
68  GhostedAreaSpec(): _ghost_maxrap (gas::def_ghost_maxrap),
69  _ghost_rap_offset(0.0),
70  _repeat (gas::def_repeat),
71  _ghost_area (gas::def_ghost_area),
72  _grid_scatter (gas::def_grid_scatter),
73  _pt_scatter (gas::def_pt_scatter),
74  _mean_ghost_pt(gas::def_mean_ghost_pt),
75  _fj2_placement(false) {_initialize();}
76 
77  /// explicit constructor
78  explicit GhostedAreaSpec(double ghost_maxrap_in,
79  int repeat_in = gas::def_repeat,
80  double ghost_area_in = gas::def_ghost_area,
81  double grid_scatter_in = gas::def_grid_scatter,
82  double pt_scatter_in = gas::def_pt_scatter,
83  double mean_ghost_pt_in = gas::def_mean_ghost_pt
84  ):
85  _ghost_maxrap(ghost_maxrap_in),
86  _ghost_rap_offset(0.0),
87  _repeat(repeat_in),
88  _ghost_area(ghost_area_in),
89  _grid_scatter(grid_scatter_in),
90  _pt_scatter(pt_scatter_in),
91  _mean_ghost_pt(mean_ghost_pt_in),
92  _fj2_placement(false) {_initialize();}
93 
94  /// explicit constructor
95  explicit GhostedAreaSpec(double ghost_minrap_in,
96  double ghost_maxrap_in,
97  int repeat_in = gas::def_repeat,
98  double ghost_area_in = gas::def_ghost_area,
99  double grid_scatter_in = gas::def_grid_scatter,
100  double pt_scatter_in = gas::def_pt_scatter,
101  double mean_ghost_pt_in = gas::def_mean_ghost_pt
102  ):
103  _ghost_maxrap (0.5*(ghost_maxrap_in - ghost_minrap_in)),
104  _ghost_rap_offset(0.5*(ghost_maxrap_in + ghost_minrap_in)),
105  _repeat(repeat_in),
106  _ghost_area(ghost_area_in),
107  _grid_scatter(grid_scatter_in),
108  _pt_scatter(pt_scatter_in),
109  _mean_ghost_pt(mean_ghost_pt_in),
110  _fj2_placement(false) {_initialize();}
111 
112 
113  /// constructor based on a Selector
114  explicit GhostedAreaSpec(const Selector & selector,
115  int repeat_in = gas::def_repeat,
116  double ghost_area_in = gas::def_ghost_area,
117  double grid_scatter_in = gas::def_grid_scatter,
118  double pt_scatter_in = gas::def_pt_scatter,
119  double mean_ghost_pt_in = gas::def_mean_ghost_pt
120  );
121 
122 
123  /// does the initialization of actual ghost parameters
124  void _initialize();
125 
126  // for accessing values set by the user
127  inline double ghost_rapmax () const {return _ghost_maxrap;}
128  inline double ghost_maxrap () const {return _ghost_maxrap;}
129  inline double ghost_etamax () const {return _ghost_maxrap;}
130  inline double ghost_maxeta () const {return _ghost_maxrap;}
131  inline double ghost_area () const {return _ghost_area ;}
132  inline double grid_scatter () const {return _grid_scatter;}
133  inline double pt_scatter () const {return _pt_scatter ;}
134  inline double mean_ghost_pt() const {return _mean_ghost_pt ;}
135  inline int repeat () const {return _repeat ;}
136  inline bool fj2_placement() const {return _fj2_placement;}
137 
138  inline double kt_scatter () const {return _pt_scatter ;}
139  inline double mean_ghost_kt() const {return _mean_ghost_pt ;}
140 
141  // for accessing values
142  inline double actual_ghost_area() const {return _actual_ghost_area;}
143  inline int n_ghosts() const {return _n_ghosts;}
144 
145  // when explicitly modifying values, sometimes call the initializer
146  inline void set_ghost_area (double val) {_ghost_area = val; _initialize();}
147  inline void set_ghost_rapmax (double val) {_ghost_maxrap = val; _initialize();}
148  inline void set_ghost_maxrap (double val) {_ghost_maxrap = val; _initialize();}
149  inline void set_ghost_etamax (double val) {_ghost_maxrap = val; _initialize();}
150  inline void set_ghost_maxeta (double val) {_ghost_maxrap = val; _initialize();}
151  inline void set_grid_scatter (double val) {_grid_scatter = val; }
152  inline void set_pt_scatter (double val) {_pt_scatter = val; }
153  inline void set_mean_ghost_pt(double val) {_mean_ghost_pt = val; }
154  inline void set_repeat (int val) {_repeat = val; }
155 
156  inline void set_kt_scatter (double val) {_pt_scatter = val; }
157  inline void set_mean_ghost_kt(double val) {_mean_ghost_pt = val; }
158 
159  /// if val is true, set ghost placement as it was in FastJet 2.X. The
160  /// main differences between FJ2 and FJ3 ghost placement are
161  ///
162  /// - in FJ2 the rapidity spacing was
163  /// ceil((maxrap-minrap)/sqrt(area)), while in FJ3 it is
164  /// int((maxrap-minrap)/sqrt(area) + 0.5) [similarly for phi].
165  /// The FJ3 option offers more stability when trying to specify a
166  /// spacing that exactly fits the extent.
167  ///
168  /// - in FJ2, the ghosts are placed at the corners of grid cells
169  /// (i.e. extending up to maxrap), while in FJ3 they are placed at
170  /// the centres of grid cells (i.e. extending roughly up to
171  /// maxrap-sqrt(area)). The FJ2 behaviour effectively skews the
172  /// total area coverage when maxrap is small, by an amount
173  /// sqrt(area)/(2*maxrap).
174  ///
175  /// FJ2 placement is now deprecated.
176  FASTJET_DEPRECATED_MSG("This is deprecated since we strongly recomment to use the new ghost placement instead")
177  void set_fj2_placement(bool val);
178 
179  /// return nphi (ghosts layed out (-nrap, 0..nphi-1), (-nrap+1,0..nphi-1),
180  /// ... (nrap,0..nphi-1)
181  inline int nphi() const {return _nphi;}
182  inline int nrap() const {return _nrap;}
183 
184  /// get all relevant information about the status of the
185  /// random number generator, so that it can be reset subsequently
186  /// with set_random_status.
187  inline void get_random_status(std::vector<int> & __iseed) const {
188  _random_generator.get_status(__iseed);}
189 
190  /// set the status of the random number generator, as obtained
191  /// previously with get_random_status. Note that the random
192  /// generator is a static member of the class, i.e. common to all
193  /// instances of the class --- so if you modify the random for this
194  /// instance, you modify it for all instances.
195  inline void set_random_status(const std::vector<int> & __iseed) {
196  _random_generator.set_status(__iseed);}
197 
198  inline void checkpoint_random() {get_random_status(_random_checkpoint);}
199  inline void restore_checkpoint_random() {set_random_status(_random_checkpoint);}
200 
201  /// for a summary
202  std::string description() const;
203 
204  /// push a set of ghost 4-momenta onto the back of the vector of
205  /// PseudoJets
206  void add_ghosts(std::vector<PseudoJet> & ) const;
207 
208  /// very deprecated public access to a random number
209  /// from the internal generator
210  inline double random_at_own_risk() const {return _our_rand();}
211  /// very deprecated public access to the generator itself
212  inline BasicRandom<double> & generator_at_own_risk() const {
213  return _random_generator;}
214 
215 private:
216 
217  // quantities that determine nature and distribution of ghosts
218  double _ghost_maxrap;
219  double _ghost_rap_offset;
220  int _repeat ;
221  double _ghost_area ;
222  double _grid_scatter;
223  double _pt_scatter ;
224  double _mean_ghost_pt;
225  bool _fj2_placement;
226 
227  Selector _selector;
228 
229  // derived quantities
230  double _actual_ghost_area, _dphi, _drap;
231  int _n_ghosts, _nphi, _nrap;
232 
233 
234  std::vector<int> _random_checkpoint;
235  static BasicRandom<double> _random_generator;
236  //mutable BasicRandom<double> _random_generator;
237 
238  static LimitedWarning _warn_fj2_placement_deprecated;
239 
240  inline double _our_rand() const {return _random_generator();}
241 
242 };
243 
244 /// just provide a typedef for backwards compatibility with programs
245 /// based on versions 2.0 and 2.1 of fastjet. Since there is no
246 /// easy way of telling people this is deprecated at compile or run
247 /// time, we should be careful before removing this in the future.
249 
250 
251 FASTJET_END_NAMESPACE
252 
253 #endif // __FASTJET_GHOSTEDAREASPEC_HH__
BasicRandom< double > & generator_at_own_risk() const
very deprecated public access to the generator itself
GhostedAreaSpec(double ghost_maxrap_in, int repeat_in=gas::def_repeat, double ghost_area_in=gas::def_ghost_area, double grid_scatter_in=gas::def_grid_scatter, double pt_scatter_in=gas::def_pt_scatter, double mean_ghost_pt_in=gas::def_mean_ghost_pt)
explicit constructor
void get_random_status(std::vector< int > &__iseed) const
get all relevant information about the status of the random number generator, so that it can be reset...
GhostedAreaSpec(double ghost_minrap_in, double ghost_maxrap_in, int repeat_in=gas::def_repeat, double ghost_area_in=gas::def_ghost_area, double grid_scatter_in=gas::def_grid_scatter, double pt_scatter_in=gas::def_pt_scatter, double mean_ghost_pt_in=gas::def_mean_ghost_pt)
explicit constructor
GhostedAreaSpec()
default constructor
class to provide facilities for giving warnings up to some maximum number of times and to provide glo...
int nphi() const
return nphi (ghosts layed out (-nrap, 0..nphi-1), (-nrap+1,0..nphi-1), ...
Class that encodes information about cuts and other selection criteria that can be applied to PseudoJ...
Definition: Selector.hh:149
void set_random_status(const std::vector< int > &__iseed)
set the status of the random number generator, as obtained previously with get_random_status.
Parameters to configure the computation of jet areas using ghosts.
double random_at_own_risk() const
very deprecated public access to a random number from the internal generator