fastjet: fastjet::ClusterSequenceArea Class Reference

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)
template<class L>
	ClusterSequenceArea (const std::vector< L > &pseudojets, const JetDefinition &jet_def, const GhostedAreaSpec &area_spec)
template<class L>
	ClusterSequenceArea (const std::vector< L > &pseudojets, const JetDefinition &jet_def, const VoronoiAreaSpec &area_spec)
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 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 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	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

Constructor & Destructor Documentation

template<class L>

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

Definition at line 46 of file ClusterSequenceArea.hh.

00048                                                : _area_def(area_def_in) {
00049     initialize_and_run_cswa(pseudojets, jet_def);
00050   }

template<class L>

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

Definition at line 53 of file ClusterSequenceArea.hh.

00055                                                : _area_def(area_spec){
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 VoronoiAreaSpec &	area_spec
	)			`[inline]`

Definition at line 60 of file ClusterSequenceArea.hh.

00062                                                : _area_def(area_spec){
00063     initialize_and_run_cswa(pseudojets, jet_def);
00064   }

Member Function Documentation

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

return a reference to the area definition

Definition at line 67 of file ClusterSequenceArea.hh.

00067 {return _area_def;}

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 71 of file ClusterSequenceArea.hh.

00071                                                           {
00072     return _area_base->area(jet);}

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 76 of file ClusterSequenceArea.hh.

00076                                                           {
00077     return _area_base->area_error(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 80 of file ClusterSequenceArea.hh.

00080                                                               {
00081     return _area_base->area_4vector(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 96 of file ClusterSequenceArea.hh.

00096                                                                  {
00097     return _area_base->empty_area(range);}

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 104 of file ClusterSequenceArea.hh.

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

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 109 of file ClusterSequenceArea.hh.

00109                                                           {
00110     return _area_base->is_pure_ghost(jet);
00111   }

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 additionally checks compatibility between "range" and region in which ghosts are thrown.

Reimplemented from fastjet::ClusterSequenceAreaBase.

Definition at line 116 of file ClusterSequenceArea.hh.

00119                                                                   {
00120     _warn_if_range_unsuitable(range);
00121     ClusterSequenceAreaBase::get_median_rho_and_sigma(range, use_area_4vector,
00122                                                       median, sigma, mean_area);
00123   }

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 129 of file ClusterSequenceArea.hh.

00131                                                                                {
00132     ClusterSequenceAreaBase::get_median_rho_and_sigma(range,use_area_4vector,
00133                                                       median,sigma);
00134   }

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 140 of file ClusterSequenceArea.hh.

00143                                                                              {
00144     _warn_if_range_unsuitable(range);
00145     ClusterSequenceAreaBase::parabolic_pt_per_unit_area(
00146                                 a,b,range, exclude_above, use_area_4vector);
00147   }

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.

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 }

template<class L>

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

Definition at line 168 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().

00171  {
00172   
00173   ClusterSequenceAreaBase * _area_base_ptr;
00174   switch(_area_def.area_type()) {
00175   case active_area:
00176     _area_base_ptr = new ClusterSequenceActiveArea(pseudojets, 
00177                                                    jet_def, 
00178                                                    _area_def.ghost_spec());
00179     break;
00180   case active_area_explicit_ghosts:
00181     _area_base_ptr = new ClusterSequenceActiveAreaExplicitGhosts(pseudojets, 
00182                                                    jet_def, 
00183                                                    _area_def.ghost_spec());
00184     break;
00185   case voronoi_area:
00186     _area_base_ptr = new ClusterSequenceVoronoiArea(pseudojets, 
00187                                                    jet_def, 
00188                                                    _area_def.voronoi_spec());
00189     break;
00190   case one_ghost_passive_area:
00191     _area_base_ptr = new ClusterSequence1GhostPassiveArea(pseudojets, 
00192                                                     jet_def, 
00193                                                     _area_def.ghost_spec());
00194     break;
00195   case passive_area:
00196     _area_base_ptr = new ClusterSequencePassiveArea(pseudojets, 
00197                                                     jet_def, 
00198                                                     _area_def.ghost_spec());
00199     break;
00200   default:
00201     std::cerr << "Error: unrecognized area_type in ClusterSequenceArea:" 
00202               << _area_def.area_type() << std::endl;
00203     exit(-1);
00204   }
00205   // now copy across the information from the area base class
00206   _area_base = std::auto_ptr<ClusterSequenceAreaBase>(_area_base_ptr);
00207   transfer_from_sequence(*_area_base);
00208 }

fastjet::ClusterSequenceArea Class Reference

Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation