FastJet  3.1.3
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Modules Pages
ClusterSequenceArea.hh
1 //FJSTARTHEADER
2 // $Id: ClusterSequenceArea.hh 3484 2014-07-29 21:39:39Z soyez $
3 //
4 // Copyright (c) 2006-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 #ifndef __FASTJET_CLUSTERSEQUENCEAREA_HH__
32 #define __FASTJET_CLUSTERSEQUENCEAREA_HH__
33 
34 #include "fastjet/ClusterSequenceAreaBase.hh"
35 #include "fastjet/ClusterSequenceActiveArea.hh"
36 #include "fastjet/ClusterSequenceActiveAreaExplicitGhosts.hh"
37 #include "fastjet/ClusterSequencePassiveArea.hh"
38 #include "fastjet/ClusterSequenceVoronoiArea.hh"
39 #include "fastjet/AreaDefinition.hh"
40 
41 FASTJET_BEGIN_NAMESPACE
42 
43 /// @ingroup area_classes
44 /// \class ClusterSequenceArea
45 /// General class for user to obtain ClusterSequence with additional
46 /// area information.
47 ///
48 /// Based on the area_def, it automatically dispatches the work to the
49 /// appropriate actual ClusterSequenceAreaBase-derived-class to do the
50 /// real work.
52 public:
53  /// main constructor
54  template<class L> ClusterSequenceArea
55  (const std::vector<L> & pseudojets,
56  const JetDefinition & jet_def_in,
57  const AreaDefinition & area_def_in) : _area_def(area_def_in) {
58  initialize_and_run_cswa(pseudojets, jet_def_in);
59  }
60 
61  /// constructor with a GhostedAreaSpec
62  template<class L> ClusterSequenceArea
63  (const std::vector<L> & pseudojets,
64  const JetDefinition & jet_def_in,
65  const GhostedAreaSpec & ghost_spec) : _area_def(ghost_spec){
66  initialize_and_run_cswa(pseudojets, jet_def_in);
67  }
68 
69  /// constructor with a VoronoiAreaSpec
70  template<class L> ClusterSequenceArea
71  (const std::vector<L> & pseudojets,
72  const JetDefinition & jet_def_in,
73  const VoronoiAreaSpec & voronoi_spec) : _area_def(voronoi_spec){
74  initialize_and_run_cswa(pseudojets, jet_def_in);
75  }
76 
77  /// return a reference to the area definition
78  const AreaDefinition & area_def() const {return _area_def;}
79 
80 
81  /// return the area associated with the given jet
82  virtual double area (const PseudoJet & jet) const {
83  return _area_base->area(jet);}
84 
85  /// return the error (uncertainty) associated with the determination
86  /// of the area of this jet
87  virtual double area_error (const PseudoJet & jet) const {
88  return _area_base->area_error(jet);}
89 
90  /// return the 4-vector area
91  virtual PseudoJet area_4vector(const PseudoJet & jet) const {
92  return _area_base->area_4vector(jet);}
93 
94  // /// return the total area, up to |y|<maxrap, that is free of jets
95  // virtual double empty_area(double maxrap) const {
96  // return _area_base->empty_area(maxrap);}
97  //
98  // /// return something similar to the number of pure ghost jets
99  // /// in the given rapidity range in an active area case.
100  // /// For the local implementation we return empty_area/(0.55 pi R^2),
101  // /// based on measured properties of ghost jets with kt and cam. Note
102  // /// that the number returned is a double.
103  // virtual double n_empty_jets(double maxrap) const {
104  // return _area_base->n_empty_jets(maxrap);
105 
106  /// return the total area, corresponding to the given selector, that
107  /// is free of jets
108  ///
109  /// The selector needs to have a finite area and be applicable jet by
110  /// jet (see the BackgroundEstimator and Subtractor tools for more
111  /// advanced usage)
112  virtual double empty_area(const Selector & selector) const {
113  return _area_base->empty_area(selector);}
114 
115  /// return something similar to the number of pure ghost jets
116  /// in the given rap-phi range in an active area case.
117  /// For the local implementation we return empty_area/(0.55 pi R^2),
118  /// based on measured properties of ghost jets with kt and cam. Note
119  /// that the number returned is a double.
120  ///
121  /// The selector needs to have a finite area and be applicable jet by
122  /// jet (see the BackgroundEstimator and Subtractor tools for more
123  /// advanced usage)
124  virtual double n_empty_jets(const Selector & selector) const {
125  return _area_base->n_empty_jets(selector);
126  }
127 
128  /// true if a jet is made exclusively of ghosts
129  virtual bool is_pure_ghost(const PseudoJet & jet) const {
130  return _area_base->is_pure_ghost(jet);
131  }
132 
133  /// true if this ClusterSequence has explicit ghosts
134  virtual bool has_explicit_ghosts() const {
135  return _area_base->has_explicit_ghosts();
136  }
137 
138 
139  /// overload version of what's in the ClusterSequenceAreaBase class, which
140  /// additionally checks compatibility between "selector" and region in which
141  /// ghosts are thrown.
142  ///
143  /// The selector needs to have a finite area and be applicable jet by
144  /// jet (see the BackgroundEstimator and Subtractor tools for more
145  /// advanced usage)
146  virtual void get_median_rho_and_sigma(const std::vector<PseudoJet> & all_jets,
147  const Selector & selector,
148  bool use_area_4vector,
149  double & median, double & sigma,
150  double & mean_area,
151  bool all_are_incl = false) const {
152  _warn_if_range_unsuitable(selector);
153  ClusterSequenceAreaBase::get_median_rho_and_sigma(
154  all_jets, selector, use_area_4vector,
155  median, sigma, mean_area, all_are_incl);
156  }
157 
158  /// overload version of what's in the ClusterSequenceAreaBase class,
159  /// which actually just does the same thing as the base version (but
160  /// since we've overridden the 5-argument version above, we have to
161  /// override the 4-argument version too.
162  virtual void get_median_rho_and_sigma(const Selector & selector,
163  bool use_area_4vector,
164  double & median, double & sigma) const {
165  ClusterSequenceAreaBase::get_median_rho_and_sigma(selector,use_area_4vector,
166  median,sigma);
167  }
168 
169  /// overload version of what's in the ClusterSequenceAreaBase class,
170  /// which actually just does the same thing as the base version (but
171  /// since we've overridden the multi-argument version above, we have to
172  /// override the 5-argument version too.
173  virtual void get_median_rho_and_sigma(const Selector & selector,
174  bool use_area_4vector,
175  double & median, double & sigma,
176  double & mean_area) const {
177  ClusterSequenceAreaBase::get_median_rho_and_sigma(selector,use_area_4vector,
178  median,sigma, mean_area);
179  }
180 
181 
182  /// overload version of what's in the ClusterSequenceAreaBase class, which
183  /// additionally checks compatibility between "range" and region in which
184  /// ghosts are thrown.
185  virtual void parabolic_pt_per_unit_area(double & a, double & b,
186  const Selector & selector,
187  double exclude_above=-1.0,
188  bool use_area_4vector=false) const {
189  _warn_if_range_unsuitable(selector);
190  ClusterSequenceAreaBase::parabolic_pt_per_unit_area(
191  a,b,selector, exclude_above, use_area_4vector);
192  }
193 
194 
195 private:
196 
197  /// print a warning if the range is unsuitable for the current
198  /// calculation of the area (e.g. because ghosts do not extend
199  /// far enough).
200  void _warn_if_range_unsuitable(const Selector & selector) const;
201 
202  template<class L> void initialize_and_run_cswa (
203  const std::vector<L> & pseudojets,
204  const JetDefinition & jet_def);
205 
206  std::auto_ptr<ClusterSequenceAreaBase> _area_base;
207  AreaDefinition _area_def;
208  static LimitedWarning _range_warnings;
209  static LimitedWarning _explicit_ghosts_repeats_warnings;
210 
211 };
212 
213 //----------------------------------------------------------------------
214 template<class L> void ClusterSequenceArea::initialize_and_run_cswa(
215  const std::vector<L> & pseudojets,
216  const JetDefinition & jet_def_in)
217  {
218 
219  ClusterSequenceAreaBase * _area_base_ptr;
220  switch(_area_def.area_type()) {
221  case active_area:
222  _area_base_ptr = new ClusterSequenceActiveArea(pseudojets,
223  jet_def_in,
224  _area_def.ghost_spec());
225  break;
226  case active_area_explicit_ghosts:
227  if (_area_def.ghost_spec().repeat() != 1)
228  _explicit_ghosts_repeats_warnings.warn("Requested active area with explicit ghosts with repeat != 1; only 1 set of ghosts will be used");
229  _area_base_ptr = new ClusterSequenceActiveAreaExplicitGhosts(pseudojets,
230  jet_def_in,
231  _area_def.ghost_spec());
232  break;
233  case voronoi_area:
234  _area_base_ptr = new ClusterSequenceVoronoiArea(pseudojets,
235  jet_def_in,
236  _area_def.voronoi_spec());
237  break;
238  case one_ghost_passive_area:
239  _area_base_ptr = new ClusterSequence1GhostPassiveArea(pseudojets,
240  jet_def_in,
241  _area_def.ghost_spec());
242  break;
243  case passive_area:
244  _area_base_ptr = new ClusterSequencePassiveArea(pseudojets,
245  jet_def_in,
246  _area_def.ghost_spec());
247  break;
248  default:
249  std::ostringstream err;
250  err << "Error: unrecognized area_type in ClusterSequenceArea:"
251  << _area_def.area_type();
252  throw Error(err.str());
253  //exit(-1);
254  }
255  // now copy across the information from the area base class
256  _area_base = std::auto_ptr<ClusterSequenceAreaBase>(_area_base_ptr);
257  transfer_from_sequence(*_area_base);
258 }
259 
260 FASTJET_END_NAMESPACE
261 
262 #endif // __FASTJET_CLUSTERSEQUENCEAREA_HH__
263 
264 
virtual void get_median_rho_and_sigma(const std::vector< PseudoJet > &all_jets, const Selector &selector, bool use_area_4vector, double &median, double &sigma, double &mean_area, bool all_are_incl=false) const
overload version of what's in the ClusterSequenceAreaBase class, which additionally checks compatibil...
const AreaDefinition & area_def() const
return a reference to the area definition
virtual double empty_area(const Selector &selector) const
return the total area, corresponding to the given selector, that is free of jets
virtual double n_empty_jets(const Selector &selector) const
return something similar to the number of pure ghost jets in the given rap-phi range in an active are...
General class for user to obtain ClusterSequence with additional area information.
virtual bool is_pure_ghost(const PseudoJet &jet) const
true if a jet is made exclusively of ghosts
virtual void parabolic_pt_per_unit_area(double &a, double &b, const Selector &selector, double exclude_above=-1.0, bool use_area_4vector=false) const
overload version of what's in the ClusterSequenceAreaBase class, which additionally checks compatibil...
class that holds a generic area definition
virtual double area(const PseudoJet &jet) const
return the area associated with the given jet
class to provide facilities for giving warnings up to some maximum number of times and to provide glo...
Specification for the computation of the Voronoi jet area.
base class that sets interface for extensions of ClusterSequence that provide information about the a...
virtual void get_median_rho_and_sigma(const Selector &selector, bool use_area_4vector, double &median, double &sigma) const
overload version of what's in the ClusterSequenceAreaBase class, which actually just does the same th...
Class that encodes information about cuts and other selection criteria that can be applied to PseudoJ...
Definition: Selector.hh:149
virtual PseudoJet area_4vector(const PseudoJet &jet) const
return the 4-vector area
Parameters to configure the computation of jet areas using ghosts.
virtual void get_median_rho_and_sigma(const Selector &selector, bool use_area_4vector, double &median, double &sigma, double &mean_area) const
overload version of what's in the ClusterSequenceAreaBase class, which actually just does the same th...
Class to contain pseudojets, including minimal information of use to jet-clustering routines...
Definition: PseudoJet.hh:67
class that is intended to hold a full definition of the jet clusterer
virtual PseudoJet area_4vector() const
return the jet 4-vector area.
Definition: PseudoJet.cc:732
virtual double area_error(const PseudoJet &jet) const
return the error (uncertainty) associated with the determination of the area of this jet ...
virtual bool has_explicit_ghosts() const
true if this ClusterSequence has explicit ghosts