fastjet::ClusterSequenceArea Class Reference

General class for user to obtain ClusterSequence with additional area information. More...

#include <ClusterSequenceArea.hh>

Inheritance diagram for fastjet::ClusterSequenceArea:

Inheritance graph
fastjet::ClusterSequenceAreaBasefastjet::ClusterSequence
[legend]
Collaboration diagram for fastjet::ClusterSequenceArea:

Collaboration graph
fastjet::ClusterSequenceAreaBasefastjet::ClusterSequencefastjet::JetDefinitionfastjet::JetDefinition::DefaultRecombinerfastjet::JetDefinition::Recombinerfastjet::JetDefinition::PluginLimitedWarningfastjet::AreaDefinitionfastjet::VoronoiAreaSpecfastjet::GhostedAreaSpecfastjet::BasicRandom\< double \>
[legend]

List of all members.

Public Member Functions

template<class L >
 ClusterSequenceArea (const std::vector< L > &pseudojets, const JetDefinition &jet_def, const AreaDefinition &area_def_in)
 main constructor
template<class L >
 ClusterSequenceArea (const std::vector< L > &pseudojets, const JetDefinition &jet_def, const GhostedAreaSpec &ghost_spec)
 constructor with a GhostedAreaSpec
template<class L >
 ClusterSequenceArea (const std::vector< L > &pseudojets, const JetDefinition &jet_def, const VoronoiAreaSpec &voronoi_spec)
 constructor with a VoronoiAreaSpec
const AreaDefinition & area_def () const
 return a reference to the area definition
virtual double area (const PseudoJet &jet) const
 return the area associated with the given jet
virtual double area_error (const PseudoJet &jet) const
 return the error (uncertainty) associated with the determination of the area of this jet
virtual PseudoJet area_4vector (const PseudoJet &jet) const
 return the 4-vector area
virtual double empty_area (const RangeDefinition &range) const
 return the total area, in the given rap-phi range, that is free of jets
virtual double n_empty_jets (const RangeDefinition &range) const
 return something similar to the number of pure ghost jets in the given rap-phi range in an active area case.
virtual bool is_pure_ghost (const PseudoJet &jet) const
 true if a jet is made exclusively of ghosts
virtual bool has_explicit_ghosts () const
 true if this ClusterSequence has explicit ghosts
virtual void get_median_rho_and_sigma (const std::vector< PseudoJet > &all_jets, const RangeDefinition &range, 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 compatibility between "range" and region in which ghosts are thrown.
virtual void get_median_rho_and_sigma (const RangeDefinition &range, bool use_area_4vector, double &median, double &sigma) const
 overload version of what's in the ClusterSequenceAreaBase class, which actually just does the same thing as the base version (but since we've overridden the 5-argument version above, we have to override the 4-argument version too.
virtual void get_median_rho_and_sigma (const RangeDefinition &range, 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 thing as the base version (but since we've overridden the multi-argument version above, we have to override the 5-argument version too.
virtual void parabolic_pt_per_unit_area (double &a, double &b, const RangeDefinition &range, double exclude_above=-1.0, bool use_area_4vector=false) const
 overload version of what's in the ClusterSequenceAreaBase class, which additionally checks compatibility between "range" and region in which ghosts are thrown.

Private Member Functions

void _warn_if_range_unsuitable (const RangeDefinition &range) const
 print a warning if the range is unsuitable for the current calculation of the area (e.g.
template<class L >
void initialize_and_run_cswa (const std::vector< L > &pseudojets, const JetDefinition &jet_def)

Private Attributes

std::auto_ptr
< ClusterSequenceAreaBase > 		_area_base
AreaDefinition _area_def

Static Private Attributes

static LimitedWarning _range_warnings

Detailed Description

General class for user to obtain ClusterSequence with additional area information.

Based on the area_def, it automatically dispatches the work to the appropriate actual ClusterSequenceAreaBase-derived-class to do the real work.

Definition at line 49 of file ClusterSequenceArea.hh.

Constructor & Destructor Documentation

template<class L >
fastjet::ClusterSequenceArea::ClusterSequenceArea ( const std::vector< L > &  pseudojets,
const JetDefinition &  jet_def,
const AreaDefinition &  area_def_in 
) [inline]

main constructor

Definition at line 53 of file ClusterSequenceArea.hh.

00055                                                : _area_def(area_def_in) {
00056     initialize_and_run_cswa(pseudojets, jet_def);
00057   }

template<class L >
fastjet::ClusterSequenceArea::ClusterSequenceArea ( const std::vector< L > &  pseudojets,
const JetDefinition &  jet_def,
const GhostedAreaSpec &  ghost_spec 
) [inline]

constructor with a GhostedAreaSpec

Definition at line 61 of file ClusterSequenceArea.hh.

00063                                                 : _area_def(ghost_spec){
00064     initialize_and_run_cswa(pseudojets, jet_def);
00065   }

template<class L >
fastjet::ClusterSequenceArea::ClusterSequenceArea ( const std::vector< L > &  pseudojets,
const JetDefinition &  jet_def,
const VoronoiAreaSpec &  voronoi_spec 
) [inline]

constructor with a VoronoiAreaSpec

Definition at line 69 of file ClusterSequenceArea.hh.

00071                                                   : _area_def(voronoi_spec){
00072     initialize_and_run_cswa(pseudojets, jet_def);
00073   }

Member Function Documentation

void fastjet::ClusterSequenceArea::_warn_if_range_unsuitable ( const RangeDefinition &  range  )  const [private]

print a warning if the range is unsuitable for the current calculation of the area (e.g.

print a warning if the range is unsuitable for the current calculation of the area (e.g.

because ghosts do not extend far enough).

because ghosts do not extend far enough).

Definition at line 10 of file ClusterSequenceArea.cc.

References _area_def, _range_warnings, fastjet::AreaDefinition::area_type(), fastjet::RangeDefinition::get_rap_limits(), fastjet::GhostedAreaSpec::ghost_maxrap(), fastjet::AreaDefinition::ghost_spec(), fastjet::JetDefinition::jet_algorithm(), fastjet::ClusterSequence::jet_def(), fastjet::kt_algorithm, fastjet::passive_area, fastjet::JetDefinition::R(), fastjet::voronoi_area, and LimitedWarning::warn().

00010                                                                                        {
00011   bool no_ghosts = (_area_def.area_type() == voronoi_area)
00012     || (_area_def.area_type() == passive_area
00013         && jet_def().jet_algorithm() == kt_algorithm);
00014   if (! no_ghosts) {
00015     double rapmin, rapmax;
00016     range.get_rap_limits(rapmin, rapmax);
00017     if (rapmin < -_area_def.ghost_spec().ghost_maxrap()+0.95*jet_def().R() ||
00018         rapmax >  _area_def.ghost_spec().ghost_maxrap()-0.95*jet_def().R()) {
00019       _range_warnings.warn("rapidity range for median (rho) extends beyond +-(ghost_maxrap - 0.95*R); this is likely to cause the results to be unreliable; safest option is to increase ghost_maxrap in the area definition");
00020     }
00021   }
00022 }

virtual double fastjet::ClusterSequenceArea::area ( const PseudoJet &  jet  )  const [inline, virtual]

return the area associated with the given jet

Reimplemented from fastjet::ClusterSequenceAreaBase.

Definition at line 80 of file ClusterSequenceArea.hh.

00080                                                           {
00081     return _area_base->area(jet);}

virtual PseudoJet fastjet::ClusterSequenceArea::area_4vector ( const PseudoJet &  jet  )  const [inline, virtual]

return the 4-vector area

Reimplemented from fastjet::ClusterSequenceAreaBase.

Definition at line 89 of file ClusterSequenceArea.hh.

00089                                                               {
00090     return _area_base->area_4vector(jet);}

const AreaDefinition& fastjet::ClusterSequenceArea::area_def (  )  const [inline]

return a reference to the area definition

Definition at line 76 of file ClusterSequenceArea.hh.

00076 {return _area_def;}

virtual double fastjet::ClusterSequenceArea::area_error ( const PseudoJet &  jet  )  const [inline, virtual]

return the error (uncertainty) associated with the determination of the area of this jet

Reimplemented from fastjet::ClusterSequenceAreaBase.

Definition at line 85 of file ClusterSequenceArea.hh.

00085                                                           {
00086     return _area_base->area_error(jet);}

virtual double fastjet::ClusterSequenceArea::empty_area ( const RangeDefinition &  range  )  const [inline, virtual]

return the total area, in the given rap-phi range, that is free of jets

Reimplemented from fastjet::ClusterSequenceAreaBase.

Definition at line 105 of file ClusterSequenceArea.hh.

00105                                                                  {
00106     return _area_base->empty_area(range);}

virtual void fastjet::ClusterSequenceArea::get_median_rho_and_sigma ( const RangeDefinition &  range,
bool  use_area_4vector,
double &  median,
double &  sigma,
double &  mean_area 
) const [inline, virtual]

overload version of what's in the ClusterSequenceAreaBase class, which actually just does the same thing as the base version (but since we've overridden the multi-argument version above, we have to override the 5-argument version too.

Reimplemented from fastjet::ClusterSequenceAreaBase.

Definition at line 158 of file ClusterSequenceArea.hh.

00161                                                                   {
00162     ClusterSequenceAreaBase::get_median_rho_and_sigma(range,use_area_4vector,
00163                                                       median,sigma, mean_area);
00164   }

virtual void fastjet::ClusterSequenceArea::get_median_rho_and_sigma ( const RangeDefinition &  range,
bool  use_area_4vector,
double &  median,
double &  sigma 
) const [inline, virtual]

overload version of what's in the ClusterSequenceAreaBase class, which actually just does the same thing as the base version (but since we've overridden the 5-argument version above, we have to override the 4-argument version too.

Reimplemented from fastjet::ClusterSequenceAreaBase.

Definition at line 147 of file ClusterSequenceArea.hh.

00149                                                                                {
00150     ClusterSequenceAreaBase::get_median_rho_and_sigma(range,use_area_4vector,
00151                                                       median,sigma);
00152   }

virtual void fastjet::ClusterSequenceArea::get_median_rho_and_sigma ( const std::vector< PseudoJet > &  all_jets,
const RangeDefinition &  range,
bool  use_area_4vector,
double &  median,
double &  sigma,
double &  mean_area,
bool  all_are_incl = false 
) const [inline, virtual]

overload version of what's in the ClusterSequenceAreaBase class, which additionally checks compatibility between "range" and region in which ghosts are thrown.

Reimplemented from fastjet::ClusterSequenceAreaBase.

Definition at line 131 of file ClusterSequenceArea.hh.

00136                                                                          {
00137     _warn_if_range_unsuitable(range);
00138     ClusterSequenceAreaBase::get_median_rho_and_sigma(
00139                                  all_jets, range, use_area_4vector,
00140                                  median, sigma, mean_area, all_are_incl);
00141   }

virtual bool fastjet::ClusterSequenceArea::has_explicit_ghosts (  )  const [inline, virtual]

true if this ClusterSequence has explicit ghosts

Reimplemented from fastjet::ClusterSequenceAreaBase.

Definition at line 123 of file ClusterSequenceArea.hh.

00123                                            {
00124     return _area_base->has_explicit_ghosts();
00125   }

template<class L >
void fastjet::ClusterSequenceArea::initialize_and_run_cswa ( const std::vector< L > &  pseudojets,
const JetDefinition &  jet_def 
) [inline, private]

Definition at line 198 of file ClusterSequenceArea.hh.

References _area_base, _area_def, fastjet::active_area, fastjet::active_area_explicit_ghosts, fastjet::AreaDefinition::area_type(), fastjet::AreaDefinition::ghost_spec(), fastjet::one_ghost_passive_area, fastjet::passive_area, fastjet::ClusterSequence::transfer_from_sequence(), fastjet::voronoi_area, and fastjet::AreaDefinition::voronoi_spec().

00201  {
00202   
00203   ClusterSequenceAreaBase * _area_base_ptr;
00204   switch(_area_def.area_type()) {
00205   case active_area:
00206     _area_base_ptr = new ClusterSequenceActiveArea(pseudojets, 
00207                                                    jet_def, 
00208                                                    _area_def.ghost_spec());
00209     break;
00210   case active_area_explicit_ghosts:
00211     _area_base_ptr = new ClusterSequenceActiveAreaExplicitGhosts(pseudojets, 
00212                                                    jet_def, 
00213                                                    _area_def.ghost_spec());
00214     break;
00215   case voronoi_area:
00216     _area_base_ptr = new ClusterSequenceVoronoiArea(pseudojets, 
00217                                                    jet_def, 
00218                                                    _area_def.voronoi_spec());
00219     break;
00220   case one_ghost_passive_area:
00221     _area_base_ptr = new ClusterSequence1GhostPassiveArea(pseudojets, 
00222                                                     jet_def, 
00223                                                     _area_def.ghost_spec());
00224     break;
00225   case passive_area:
00226     _area_base_ptr = new ClusterSequencePassiveArea(pseudojets, 
00227                                                     jet_def, 
00228                                                     _area_def.ghost_spec());
00229     break;
00230   default:
00231     std::cerr << "Error: unrecognized area_type in ClusterSequenceArea:" 
00232               << _area_def.area_type() << std::endl;
00233     exit(-1);
00234   }
00235   // now copy across the information from the area base class
00236   _area_base = std::auto_ptr<ClusterSequenceAreaBase>(_area_base_ptr);
00237   transfer_from_sequence(*_area_base);
00238 }

virtual bool fastjet::ClusterSequenceArea::is_pure_ghost ( const PseudoJet &  jet  )  const [inline, virtual]

true if a jet is made exclusively of ghosts

Reimplemented from fastjet::ClusterSequenceAreaBase.

Definition at line 118 of file ClusterSequenceArea.hh.

00118                                                           {
00119     return _area_base->is_pure_ghost(jet);
00120   }

virtual double fastjet::ClusterSequenceArea::n_empty_jets ( const RangeDefinition &  range  )  const [inline, virtual]

return something similar to the number of pure ghost jets in the given rap-phi range in an active area case.

For the local implementation we return empty_area/(0.55 pi R^2), based on measured properties of ghost jets with kt and cam. Note that the number returned is a double.

Reimplemented from fastjet::ClusterSequenceAreaBase.

Definition at line 113 of file ClusterSequenceArea.hh.

00113                                                                    {
00114     return _area_base->n_empty_jets(range);
00115   }

virtual void fastjet::ClusterSequenceArea::parabolic_pt_per_unit_area ( double &  a,
double &  b,
const RangeDefinition &  range,
double  exclude_above = -1.0,
bool  use_area_4vector = false 
) const [inline, virtual]

overload version of what's in the ClusterSequenceAreaBase class, which additionally checks compatibility between "range" and region in which ghosts are thrown.

Reimplemented from fastjet::ClusterSequenceAreaBase.

Definition at line 170 of file ClusterSequenceArea.hh.

00173                                                                              {
00174     _warn_if_range_unsuitable(range);
00175     ClusterSequenceAreaBase::parabolic_pt_per_unit_area(
00176                                 a,b,range, exclude_above, use_area_4vector);
00177   }

Member Data Documentation

std::auto_ptr<ClusterSequenceAreaBase> fastjet::ClusterSequenceArea::_area_base [private]

Definition at line 191 of file ClusterSequenceArea.hh.

Referenced by initialize_and_run_cswa().

AreaDefinition fastjet::ClusterSequenceArea::_area_def [private]

Definition at line 192 of file ClusterSequenceArea.hh.

Referenced by _warn_if_range_unsuitable(), and initialize_and_run_cswa().

LimitedWarning fastjet::ClusterSequenceArea::_range_warnings [static, private]

Definition at line 193 of file ClusterSequenceArea.hh.

Referenced by _warn_if_range_unsuitable().

The documentation for this class was generated from the following files:
Generated on Fri May 29 20:29:53 2009 for fastjet by  doxygen 1.5.7.1