the FastJet namespace More...

Namespaces
namespace	gas
	namespace to hold default parameters for the active area spec
Classes
class	VoronoiAreaSpec
	Specification for the computation of the Voronoi jet area. More...
class	AreaDefinition
	class that holds a generic area definition More...
class	ClusterSequence
	deals with clustering More...
class	ClusterSequence1GhostPassiveArea
	Like ClusterSequence with computation of the passive jet area by adding a single ghost. More...
class	ClusterSequenceActiveArea
	Like ClusterSequence with computation of the active jet area. More...
class	ClusterSequenceActiveAreaExplicitGhosts
	Like ClusterSequence with computation of the active jet area with the addition of explicit ghosts. More...
class	ClusterSequenceArea
	General class for user to obtain ClusterSequence with additional area information. More...
class	ClusterSequenceAreaBase
	base class that sets interface for extensions of ClusterSequence that provide information about the area of each jet More...
class	ClusterSequencePassiveArea
	Like ClusterSequence with computation of the passive jet area. More...
class	ClusterSequenceStructure
	Contains any information related to the clustering that should be directly accessible to PseudoJet. More...
class	ClusterSequenceVoronoiArea
	Like ClusterSequence with computation of the Voronoi jet area. More...
class	CompositeJetStructure
	The structure for a jet made of pieces. More...
class	Error
	base class corresponding to errors that will be thrown by fastjet More...
class	FunctionOfPseudoJet
	base class providing interface for a generic function of a PseudoJet More...
class	GhostedAreaSpec
	Parameters to configure the computation of jet areas using ghosts. More...
class	JetDefinition
	class that is intended to hold a full definition of the jet clusterer More...
class	_NoInfo
	dummy class, used as a default template argument More...
class	NNHInfo
	template that will help initialise a BJ with a PseudoJet and extra information More...
class	NNHInfo< _NoInfo >
	Specialisation of NNHInfo for cases where there is no extra info. More...
class	NNH
	Help solve closest pair problems with generic interparticle and beam distance. More...
class	PseudoJet
	Class to contain pseudojets, including minimal information of use to jet-clustering routines. More...
class	PseudoJetStructureBase
	Contains any information related to the clustering that should be directly accessible to PseudoJet. More...
class	RangeDefinition
	class for holding a range definition specification, given by limits on rapidity and azimuth. More...
class	SelectorWorker
	default selector worker is an abstract virtual base class More...
class	Selector
	Class that encodes information about cuts and other selection criteria that can be applied to PseudoJet(s). More...
class	SharedPtr
	an implementation of C++0x shared pointers (or boost's) More...
class	WrappedStructure
	This wraps a (shared) pointer to an underlying structure. More...
class	EtaPhi
	Shortcut for dealing with eta-phi coordinates. More...
class	BackgroundRescalingYPolynomial
	A background rescaling that is a simple polynomial in y. More...
class	BackgroundJetPtDensity
	Class that implements pt/area_4vector.perp() for background estimation. More...
class	BackgroundJetScalarPtDensity
	Class that implements (scalar pt sum of jet)/(scalar area of jet) for background estimation. More...
class	BackgroundJetPtMDensity
	Class that implements $\frac{1}{A} \sum_{i \in jet} (\sqrt{p_{ti}^2+m^2} - p_{ti})$ for background estimation. More...
class	BackgroundEstimator
	Class to estimate the density of the background per unit area. More...
class	Boost
	Class to boost a PseudoJet. More...
class	Unboost
	Class to un-boost a PseudoJet. More...
class	CASubJetTagger
	clean (almost parameter-free) tagger searching for the element in the clustering history that maximises a chosen distance More...
class	CASubJetStructure
	the structure returned by a CASubJetTagger More...
class	Filter
	Class that helps perform filtering/trimming on jets, and optionally subtraction (if rho > 0). More...
class	FilterStructure
	Class to contain structure information for a filtered jet. More...
class	MassDropTagger
	Class that helps perform 2-pronged boosted tagging using the "mass-drop" technique. More...
class	MassDropStructure
	the structure returned by the MassDropTagger transformer. More...
class	NSubjettinessTagger
	Class that helps perform 2-pronged boosted tagging using N-subjettiness. More...
class	NSubjettinessStructure
	the structure returned by the NSubjettinessTagger transformer. More...
class	Subtractor
	Class that helps performing jet background subtraction. More...
class	Transformer
	Base (abstract) class for a jet transformer. More...
class	ATLASConePlugin
	Implementation of the ATLAS Cone (plugin for fastjet v2.4 upwards) More...
class	CMSIterativeConePlugin
	Implementation of the CMS Iterative Cone (plugin for fastjet v2.4 upwards) More...
class	CDFJetCluPlugin
	Implementation of the JetClu algorithm from CDF (plugin for fastjet-v2.1 upwards) More...
class	CDFMidPointPlugin
	Implementation of the MidPoint algorithm from CDF (plugin for fastjet-v2.1 upwards) More...
class	D0RunIIConePlugin
	Implementation of the D0 Run II Cone (plugin for fastjet v2.1 upwards) More...
class	D0RunIBaseConePlugin
	D0RunIConePlugin is a plugin for fastjet (v2.4 upwards) that provides an interface to the D0 version of Run-I cone algorithm. More...
class	D0RunIConePlugin
	A plugin for fastjet (v2.4 upwards) that provides an interface to the D0 version of Run-I cone algorithm. More...
class	D0RunIpre96ConePlugin
	A plugin for fastjet (v2.4 upwards) that provides an interface to the pre 1996 D0 version of Run-I cone algorithm. More...
class	EECambridgePlugin
	Implementation of the e+e- Cambridge algorithm (plugin for fastjet v2.4 upwards) More...
class	JadePlugin
	Implementation of the e+e- Jade algorithm (plugin for fastjet v2.4 upwards) More...
class	NestedDefsPlugin
	Plugin to run multiple jet definitions successively (plugin for fastjet v2.4 upwards) More...
class	SISConeBaseExtras
	Class that provides extra information about a SISCone clustering. More...
class	SISConePlugin
	Implementation of the SISCone algorithm (plugin for fastjet v2.1 upwards) More...
class	SISConeExtras
	Class that provides extra information about a SISCone clustering. More...
class	SISConeSphericalPlugin
	Implementation of the spherical version of the SISCone algorithm (plugin for fastjet v2.1 upwards) More...
class	SISConeSphericalExtras
	Class that provides extra information about a SISCone clustering. More...
class	PxConePlugin
	Implementation of the PxCone algorithm (plugin for fastjet v2.1 upwards) More...
class	TrackJetPlugin
	Implementation of the TrackJet algorithm (plugin for fastjet v2.4 upwards) More...
Typedefs
typedef ClusterSequenceActiveAreaExplicitGhosts	ClustSeqActAreaEG
typedef ClusterSequenceVoronoiArea::VoronoiAreaCalc	VAC
typedef GhostedAreaSpec	ActiveAreaSpec
	just provide a typedef for backwards compatibility with programs based on versions 2.0 and 2.1 of fastjet
typedef ClusterSequenceAreaBase	ClusterSequenceWithArea
typedef JetAlgorithm	JetFinder
	make standard Les Houches nomenclature JetAlgorithm (algorithm is general recipe without the parameters) backward-compatible with old JetFinder
typedef integral_type< bool, true >	true_type
	the bool 'true' value promoted to a type
typedef integral_type< bool, false >	false_type
	the bool 'false' value promoted to a type
typedef char(&	__yes_type )[1]
typedef char(&	__no_type )[2]
typedef CGAL::Triangulation_vertex_base_with_info_2 < InitialisedInt, K >	Vbb
typedef CGAL::Triangulation_hierarchy_vertex_base_2 < Vbb >	Vb
typedef CGAL::Triangulation_face_base_2 < K >	Fb
typedef CGAL::Triangulation_data_structure_2 < Vb, Fb >	Tds
typedef CGAL::Delaunay_triangulation_2 < K, Tds >	Dt
typedef CGAL::Triangulation_hierarchy_2 < Dt >	Triangulation
typedef Triangulation::Vertex_handle	Vertex_handle
typedef Triangulation::Point	Point
typedef Triangulation::Vertex_circulator	Vertex_circulator
	CGAL Point structure.
typedef Triangulation::Face_circulator	Face_circulator
typedef Triangulation::Face_handle	Face_handle
Enumerations
enum	AreaType { invalid_area = -1, active_area = 0, active_area_explicit_ghosts = 1, one_ghost_passive_area = 10, passive_area = 11, voronoi_area = 20 }
	the different types of area that are supported
enum	Strategy { N2MinHeapTiled = -4, N2Tiled = -3, N2PoorTiled = -2, N2Plain = -1, N3Dumb = 0, Best = 1, NlnN = 2, NlnN3pi = 3, NlnN4pi = 4, NlnNCam4pi = 14, NlnNCam2pi2R = 13, NlnNCam = 12, plugin_strategy = 999 }
	the various options for the algorithmic strategy to adopt in clustering events with kt and cambridge style algorithms. More...
enum	JetAlgorithm { kt_algorithm = 0, cambridge_algorithm = 1, antikt_algorithm = 2, genkt_algorithm = 3, cambridge_for_passive_algorithm = 11, genkt_for_passive_algorithm = 13, ee_kt_algorithm = 50, ee_genkt_algorithm = 53, plugin_algorithm = 99, undefined_jet_algorithm = 999 }
	the various families of jet-clustering algorithm More...
enum	RecombinationScheme { E_scheme = 0, pt_scheme = 1, pt2_scheme = 2, Et_scheme = 3, Et2_scheme = 4, BIpt_scheme = 5, BIpt2_scheme = 6, external_scheme = 99 }
	the various recombination schemes More...
Functions
int	__default_random_generator (int *__iseed)
string	fastjet_version_string ()
	return a string containing information about the release
Selector	operator> (const FunctionOfPseudoJet< double > &fn, const double &cut)
	'larger than' operator
Selector	operator< (const FunctionOfPseudoJet< double > &fn, const double &cut)
	'smaller than' operator
Selector	operator>= (const FunctionOfPseudoJet< double > &fn, const double &cut)
	'larger or equal' operator
Selector	operator<= (const FunctionOfPseudoJet< double > &fn, const double &cut)
	'smaller or equal' operator
PseudoJet	join (const vector< PseudoJet > &pieces, const JetDefinition::Recombiner &recombiner)
PseudoJet	join (const PseudoJet &j1, const JetDefinition::Recombiner &recombiner)
	build a "CompositeJet" from a single PseudoJet with an extended structure of type T derived from CompositeJetStructure
PseudoJet	join (const PseudoJet &j1, const PseudoJet &j2, const JetDefinition::Recombiner &recombiner)
	build a "CompositeJet" from two PseudoJet with an extended structure of type T derived from CompositeJetStructure
PseudoJet	join (const PseudoJet &j1, const PseudoJet &j2, const PseudoJet &j3, const JetDefinition::Recombiner &recombiner)
	build a "CompositeJet" from 3 PseudoJet with an extended structure of type T derived from CompositeJetStructure
PseudoJet	join (const PseudoJet &j1, const PseudoJet &j2, const PseudoJet &j3, const PseudoJet &j4, const JetDefinition::Recombiner &recombiner)
	build a "CompositeJet" from 4 PseudoJet with an extended structure of type T derived from CompositeJetStructure
PseudoJet	operator+ (const PseudoJet &jet1, const PseudoJet &jet2)
PseudoJet	operator- (const PseudoJet &jet1, const PseudoJet &jet2)
PseudoJet	operator* (double coeff, const PseudoJet &jet)
PseudoJet	operator* (const PseudoJet &jet, double coeff)
PseudoJet	operator/ (const PseudoJet &jet, double coeff)
bool	operator== (const PseudoJet &, const PseudoJet &)
	returns true if the 4 momentum components of the two PseudoJets are identical and all the internal indices (user, cluster_history) + structure and user-info shared pointers are too
bool	operator== (const PseudoJet &jet, const double val)
	Can only be used with val=0 and tests whether all four momentum components are equal to val (=0.0)
bool	have_same_momentum (const PseudoJet &jeta, const PseudoJet &jetb)
	returns true if the momenta of the two input jets are identical
PseudoJet	PtYPhiM (double pt, double y, double phi, double m)
	return a pseudojet with the given pt, y, phi and mass
void	sort_indices (vector< int > &indices, const vector< double > &values)
template<class T >
vector< T >	objects_sorted_by_values (const vector< T > &objects, const vector< double > &values)
	given a vector of values with a one-to-one correspondence with the vector of objects, sort objects into an order such that the associated values would be in increasing order
vector< PseudoJet >	sorted_by_pt (const vector< PseudoJet > &jets)
	return a vector of jets sorted into decreasing kt2
vector< PseudoJet >	sorted_by_rapidity (const vector< PseudoJet > &jets)
	return a vector of jets sorted into increasing rapidity
vector< PseudoJet >	sorted_by_E (const vector< PseudoJet > &jets)
	return a vector of jets sorted into decreasing energy
vector< PseudoJet >	sorted_by_pz (const vector< PseudoJet > &jets)
	return a vector of jets sorted into increasing pz
PseudoJet	join (const vector< PseudoJet > &pieces)
PseudoJet	join (const PseudoJet &j1)
	build a "CompositeJet" from a single PseudoJet with an extended structure of type T derived from CompositeJetStructure
PseudoJet	join (const PseudoJet &j1, const PseudoJet &j2)
	build a "CompositeJet" from two PseudoJet with an extended structure of type T derived from CompositeJetStructure
PseudoJet	join (const PseudoJet &j1, const PseudoJet &j2, const PseudoJet &j3)
	build a "CompositeJet" from 3 PseudoJet with an extended structure of type T derived from CompositeJetStructure
PseudoJet	join (const PseudoJet &j1, const PseudoJet &j2, const PseudoJet &j3, const PseudoJet &j4)
	build a "CompositeJet" from 4 PseudoJet with an extended structure of type T derived from CompositeJetStructure
Selector	SelectorIdentity ()
Selector	operator! (const Selector &s)
	logical not applied on a selector
Selector	operator&& (const Selector &s1, const Selector &s2)
	logical and between two selectors
Selector	operator\|\| (const Selector &s1, const Selector &s2)
	logical or between two selectors
Selector	operator* (const Selector &s1, const Selector &s2)
	successive application of 2 selectors
Selector	SelectorPtMin (double ptmin)
	select objects with pt >= ptmin
Selector	SelectorPtMax (double ptmax)
	select objects with pt <= ptmax
Selector	SelectorPtRange (double ptmin, double ptmax)
	select objects with ptmin <= pt <= ptmax
Selector	SelectorEtMin (double Etmin)
	select objects with Et >= Etmin
Selector	SelectorEtMax (double Etmax)
	select objects with Et <= Etmax
Selector	SelectorEtRange (double Etmin, double Etmax)
	select objects with Etmin <= Et <= Etmax
Selector	SelectorEMin (double Emin)
	select objects with E >= Emin
Selector	SelectorEMax (double Emax)
	select objects with E <= Emax
Selector	SelectorERange (double Emin, double Emax)
	select objects with Emin <= E <= Emax
Selector	SelectorMMin (double Mmin)
	select objects with M >= Mmin
Selector	SelectorMMax (double Mmax)
	select objects with M <= Mmax
Selector	SelectorMRange (double Mmin, double Mmax)
	select objects with Mmin <= M <= Mmax
Selector	SelectorRapMin (double rapmin)
	select objects with rap >= rapmin
Selector	SelectorRapMax (double rapmax)
	select objects with rap <= rapmax
Selector	SelectorRapRange (double rapmin, double rapmax)
	select objects with rapmin <= rap <= rapmax
Selector	SelectorAbsRapMin (double absrapmin)
	select objects with \|rap\| >= absrapmin
Selector	SelectorAbsRapMax (double absrapmax)
	select objects with \|rap\| <= absrapmax
Selector	SelectorAbsRapRange (double absrapmin, double absrapmax)
	select objects with absrapmin <= \|rap\| <= absrapmax
Selector	SelectorEtaMin (double etamin)
	select objects with eta >= etamin
Selector	SelectorEtaMax (double etamax)
	select objects with eta <= etamax
Selector	SelectorEtaRange (double etamin, double etamax)
	select objects with etamin <= eta <= etamax
Selector	SelectorAbsEtaMin (double absetamin)
	select objects with \|eta\| >= absetamin
Selector	SelectorAbsEtaMax (double absetamax)
	select objects with \|eta\| <= absetamax
Selector	SelectorAbsEtaRange (double absetamin, double absetamax)
	select objects with absetamin <= \|eta\| <= absetamax
Selector	SelectorPhiRange (double phimin, double phimax)
	select objects with phimin <= phi <= phimax
Selector	SelectorRapPhiRange (double rapmin, double rapmax, double phimin, double phimax)
	select objects with rapmin <= rap <= rapmax && phimin <= phi <= phimax
Selector	SelectorNHardest (unsigned int n)
	select the n hardest objects
Selector	SelectorCircle (const double &radius)
	select objets within a distance 'radius' from the location of the reference jet, set by Selector::set_reference(...)
Selector	SelectorDoughnut (const double &radius_in, const double &radius_out)
	select objets with distance from the reference jet is between 'radius_in' and 'radius_out'; the reference jet is set by Selector::set_reference(...)
Selector	SelectorStrip (const double &half_width)
	select objets within a rapidity distance 'half_width' from the location of the reference jet, set by Selector::set_reference(...)
Selector	SelectorRectangle (const double &half_rap_width, const double &half_phi_width)
	select objets within rapidity distance 'half_rap_width' from the reference jet and azimuthal-angle distance within 'half_phi_width'; the reference jet is set by Selector::set_reference(...)
Selector	SelectorPtFractionMin (double fraction)
	select objects that carry at least a fraction "fraction" of the reference jet.
Selector	SelectorIsPureGhost ()
	select objects that are (or are only made of) ghosts.
int	scomp (const void p1, const void p2)
template<typename T >
PseudoJet	join (const std::vector< PseudoJet > &pieces)
	build a "CompositeJet" from the vector of its pieces with an extended structure of type T derived from CompositeJetStructure
template<typename T >
PseudoJet	join (const std::vector< PseudoJet > &pieces, const JetDefinition::Recombiner &recombiner)
	build a "CompositeJet" from the vector of its pieces with an extended structure of type T derived from CompositeJetStructure
bool	operator!= (const PseudoJet &a, const PseudoJet &b)
	inequality test which is exact opposite of operator==
bool	operator!= (const PseudoJet &a, const double &val)
	Can only be used with val=0 and tests whether at least one of the four momentum components is different from val (=0.0)
double	dot_product (const PseudoJet &a, const PseudoJet &b)
std::vector< PseudoJet >	sorted_by_pt (const std::vector< PseudoJet > &jets)
	return a vector of jets sorted into decreasing transverse momentum
std::vector< PseudoJet >	sorted_by_rapidity (const std::vector< PseudoJet > &jets)
	return a vector of jets sorted into increasing rapidity
std::vector< PseudoJet >	sorted_by_E (const std::vector< PseudoJet > &jets)
	return a vector of jets sorted into decreasing energy
std::vector< PseudoJet >	sorted_by_pz (const std::vector< PseudoJet > &jets)
	return a vector of jets sorted into increasing pz
void	sort_indices (std::vector< int > &indices, const std::vector< double > &values)
	sort the indices so that values[indices[0->n-1]] is sorted into increasing order
template<class T >
std::vector< T >	objects_sorted_by_values (const std::vector< T > &objects, const std::vector< double > &values)
	given a vector of values with a one-to-one correspondence with the vector of objects, sort objects into an order such that the associated values would be in increasing order (but don't actually touch the values vector in the process).
template<class T , class U >
bool	operator== (SharedPtr< T > const &t, SharedPtr< U > const &u)
	comparison: equality
template<class T , class U >
bool	operator!= (SharedPtr< T > const &t, SharedPtr< U > const &u)
	comparison: difference
template<class T , class U >
bool	operator< (SharedPtr< T > const &t, SharedPtr< U > const &u)
	comparison: orgering
template<class T >
void	swap (SharedPtr< T > &a, SharedPtr< T > &b)
	swapping
template<class T >
T *	get_pointer (SharedPtr< T > const &t)
	getting the pointer
bool	floor_ln2_less (unsigned x, unsigned y)
	returns true if floor(ln_base2(x)) < floor(ln_base2(y)), using Chan's neat trick...
template<class B , class D >
B *	cast_if_derived (D *d)
	a little helper that returns a pointer to d of type B* if D is derived from B and NULL otherwise
double	norm (const Point p)
	norm of a vector
double	vector_product (const Point &p1, const Point &p2)
	2D vector product
double	scalar_product (const Point &p1, const Point &p2)
	scalar product
template<class T >
T	deltaPhi (T phi1, T phi2)
template<class T >
T	deltaR2 (T eta1, T phi1, T eta2, T phi2)
Variables
BasicRandom< int >	_G_random_int
BasicRandom< double >	_G_random_double
const unsigned int	huge_unsigned = 4294967295U
const unsigned int	twopow31 = 2147483648U
const JetAlgorithm	aachen_algorithm = cambridge_algorithm
	provide other possible names for the Cambridge/Aachen algorithm?
const JetAlgorithm	cambridge_aachen_algorithm = cambridge_algorithm
const double	MaxRap = 1e5
	Used to protect against parton-level events where pt can be zero for some partons, giving rapidity=infinity.
const double	pseudojet_invalid_phi = -100.0
	default value for phi, meaning it (and rapidity) have yet to be calculated)
const double	pi = 3.141592653589793238462643383279502884197
const double	twopi = 6.283185307179586476925286766559005768394
const double	pisq = 9.869604401089358618834490999876151135314
const double	zeta2 = 1.644934066848226436472415166646025189219
const double	zeta3 = 1.202056903159594285399738161511449990765
const double	eulergamma = 0.577215664901532860606512090082402431042
const double	ln2 = 0.693147180559945309417232121458176568076
const int	INFINITE_VERTEX = -1
const int	NEW_VERTEX = -2
const double	HUGE_DOUBLE = 1e300

Detailed Description

the FastJet namespace

Order(N^2) clustering.

all the fastjet-related material is put under that namespace

Works for any class BJ that satisfies certain minimal requirements (which are ...?)

need to have _bj_set_jetinfo
need to have _bj_dist
should contain members kt2 (=energy^2), NN, NN_dist, _jets_index

Enumeration Type Documentation

enum fastjet::Strategy

the various options for the algorithmic strategy to adopt in clustering events with kt and cambridge style algorithms.

Enumerator:

N2MinHeapTiled	fastest form about 500..10^4
N2Tiled	fastest from about 50..500
N2PoorTiled	legacy
N2Plain	fastest below 50
N3Dumb	worse even than the usual N^3 algorithms
Best	automatic selection of the best (based on N)
NlnN	best of the NlnN variants -- best overall for N>10^4. (Does not work for R>=2pi)
NlnN3pi	legacy N ln N using 3pi coverage of cylinder. (Does not work for R>=2pi)
NlnN4pi	legacy N ln N using 4pi coverage of cylinder
NlnNCam4pi	Chan's closest pair method (in a variant with 4pi coverage), for use exclusively with the Cambridge algorithm. (Does not work for R>=2pi)
NlnNCam2pi2R	Chan's closest pair method (in a variant with 2pi+2R coverage), for use exclusively with the Cambridge algorithm. (Does not work for R>=2pi)
NlnNCam	Chan's closest pair method (in a variant with 2pi+minimal extra variant), for use exclusively with the Cambridge algorithm. (Does not work for R>=2pi)
plugin_strategy	the plugin has been used...

Definition at line 50 of file JetDefinition.hh.

              {
  /// fastest form about 500..10^4
  N2MinHeapTiled   = -4, 
  /// fastest from about 50..500
  N2Tiled     = -3, 
  /// legacy
  N2PoorTiled = -2, 
  /// fastest below 50
  N2Plain     = -1, 
  /// worse even than the usual N^3 algorithms
  N3Dumb      =  0, 
  /// automatic selection of the best (based on N)
  Best        =  1, 
  /// best of the NlnN variants -- best overall for N>10^4.
  /// (Does not work for R>=2pi)
  NlnN        =  2, 
  /// legacy N ln N using 3pi coverage of cylinder.
  /// (Does not work for R>=2pi)
  NlnN3pi     =  3, 
  /// legacy N ln N using 4pi coverage of cylinder
  NlnN4pi     =  4,
  /// Chan's closest pair method (in a variant with 4pi coverage),
  /// for use exclusively with the Cambridge algorithm.
  /// (Does not work for R>=2pi)
  NlnNCam4pi   = 14,
  /// Chan's closest pair method (in a variant with 2pi+2R coverage),
  /// for use exclusively with the Cambridge algorithm.
  /// (Does not work for R>=2pi)
  NlnNCam2pi2R = 13,
  /// Chan's closest pair method (in a variant with 2pi+minimal extra
  /// variant), for use exclusively with the Cambridge algorithm. 
  /// (Does not work for R>=2pi)
  NlnNCam      = 12, // 2piMultD
  /// the plugin has been used...
  plugin_strategy = 999
};

enum fastjet::JetAlgorithm

the various families of jet-clustering algorithm

Enumerator:

kt_algorithm	the longitudinally invariant kt algorithm
cambridge_algorithm	the longitudinally invariant variant of the cambridge algorithm (aka Aachen algoithm).
antikt_algorithm	like the k_t but with distance measures dij = min(1/kti^2,1/ktj^2) Delta R_{ij}^2 / R^2 diB = 1/kti^2
genkt_algorithm	like the k_t but with distance measures dij = min(kti^{2p},ktj^{2p}) Delta R_{ij}^2 / R^2 diB = 1/kti^{2p} where p = extra_param()
cambridge_for_passive_algorithm	a version of cambridge with a special distance measure for particles whose pt is < extra_param()
genkt_for_passive_algorithm	a version of genkt with a special distance measure for particles whose pt is < extra_param() [relevant for passive areas when p<=0]
ee_kt_algorithm	the e+e- kt algorithm
ee_genkt_algorithm	the e+e- genkt algorithm (R > 2 and p=1 gives ee_kt)
plugin_algorithm	any plugin algorithm supplied by the user
undefined_jet_algorithm	the value for the jet algorithm in a JetDefinition for which no algorithm has yet been defined

Definition at line 91 of file JetDefinition.hh.

                  {
  /// the longitudinally invariant kt algorithm
  kt_algorithm=0,
  /// the longitudinally invariant variant of the cambridge algorithm
  /// (aka Aachen algoithm).
  cambridge_algorithm=1,
  /// like the k_t but with distance measures 
  ///       dij = min(1/kti^2,1/ktj^2) Delta R_{ij}^2 / R^2
  ///       diB = 1/kti^2
  antikt_algorithm=2, 
  /// like the k_t but with distance measures 
  ///       dij = min(kti^{2p},ktj^{2p}) Delta R_{ij}^2 / R^2
  ///       diB = 1/kti^{2p}
  /// where p = extra_param()
  genkt_algorithm=3, 
  /// a version of cambridge with a special distance measure for particles
  /// whose pt is < extra_param()
  cambridge_for_passive_algorithm=11,
  /// a version of genkt with a special distance measure for particles
  /// whose pt is < extra_param() [relevant for passive areas when p<=0]
  genkt_for_passive_algorithm=13, 
  //.................................................................
  /// the e+e- kt algorithm
  ee_kt_algorithm=50,
  /// the e+e- genkt algorithm  (R > 2 and p=1 gives ee_kt)
  ee_genkt_algorithm=53,
  //.................................................................
  /// any plugin algorithm supplied by the user
  plugin_algorithm = 99,
  //.................................................................
  /// the value for the jet algorithm in a JetDefinition for which
  /// no algorithm has yet been defined
  undefined_jet_algorithm = 999
};

enum fastjet::RecombinationScheme

the various recombination schemes

Enumerator:

E_scheme	summing the 4-momenta
pt_scheme	pt weighted recombination of y,phi (and summing of pt's) with preprocessing to make things massless by rescaling E=\| p\|
pt2_scheme	pt^2 weighted recombination of y,phi (and summing of pt's) with preprocessing to make things massless by rescaling E=\| p\|
Et_scheme	pt weighted recombination of y,phi (and summing of pt's) with preprocessing to make things massless by rescaling \| p\|->=E
Et2_scheme	pt^2 weighted recombination of y,phi (and summing of pt's) with preprocessing to make things massless by rescaling \| p\|->=E
BIpt_scheme	pt weighted recombination of y,phi (and summing of pt's), with no preprocessing
BIpt2_scheme	pt^2 weighted recombination of y,phi (and summing of pt's) no preprocessing
external_scheme	for the user's external scheme

Definition at line 136 of file JetDefinition.hh.

                         {
  /// summing the 4-momenta
  E_scheme=0,
  /// pt weighted recombination of y,phi (and summing of pt's)
  /// with preprocessing to make things massless by rescaling E=|\vec p|
  pt_scheme=1,
  /// pt^2 weighted recombination of y,phi (and summing of pt's)
  /// with preprocessing to make things massless by rescaling E=|\vec p|
  pt2_scheme=2,
  /// pt weighted recombination of y,phi (and summing of pt's)
  /// with preprocessing to make things massless by rescaling |\vec p|->=E
  Et_scheme=3,
  /// pt^2 weighted recombination of y,phi (and summing of pt's)
  /// with preprocessing to make things massless by rescaling |\vec p|->=E
  Et2_scheme=4,
  /// pt weighted recombination of y,phi (and summing of pt's), with 
  /// no preprocessing
  BIpt_scheme=5,
  /// pt^2 weighted recombination of y,phi (and summing of pt's)
  /// no preprocessing
  BIpt2_scheme=6,
  /// for the user's external scheme
  external_scheme = 99
};

Function Documentation

Selector fastjet::operator>	(	const FunctionOfPseudoJet< double > &	fn,
		const double &	cut
	)

'larger than' operator

Select jets for which the given function returns a reult larger than the specified constant

Definition at line 64 of file FunctionOfPseudoJet.cc.

                                                                               {
  return Selector(new SW_FofPJ_larger(fn, ref));
}

Selector fastjet::operator<	(	const FunctionOfPseudoJet< double > &	fn,
		const double &	cut
	)

'smaller than' operator

Select jets for which the given function returns a reult larger than the specified constant

Definition at line 95 of file FunctionOfPseudoJet.cc.

                                                                               {
  return Selector(new SW_FofPJ_smaller(fn, ref));
}

Selector fastjet::operator>=	(	const FunctionOfPseudoJet< double > &	fn,
		const double &	cut
	)

'larger or equal' operator

Select jets for which the given function returns a reult larger than the specified constant

Definition at line 125 of file FunctionOfPseudoJet.cc.

                                                                                {
  return Selector(new SW_FofPJ_larger_equal(fn, ref));
}

Selector fastjet::operator<=	(	const FunctionOfPseudoJet< double > &	fn,
		const double &	cut
	)

'smaller or equal' operator

Select jets for which the given function returns a reult larger than the specified constant

Definition at line 156 of file FunctionOfPseudoJet.cc.

                                                                                {
  return Selector(new SW_FofPJ_smaller_equal(fn, ref));
}

PseudoJet fastjet::join	(	const PseudoJet &	j1,
		const JetDefinition::Recombiner &	recombiner
	)

build a "CompositeJet" from a single PseudoJet with an extended structure of type T derived from CompositeJetStructure

build a MergedJet from a single PseudoJet

Definition at line 302 of file JetDefinition.cc.

                                                          {
  return join(vector<PseudoJet>(1,j1), recombiner);
}

PseudoJet fastjet::join	(	const PseudoJet &	j1,
		const PseudoJet &	j2,
		const JetDefinition::Recombiner &	recombiner
	)

build a "CompositeJet" from two PseudoJet with an extended structure of type T derived from CompositeJetStructure

build a MergedJet from 2 PseudoJet

Definition at line 308 of file JetDefinition.cc.

                                                          {
  vector<PseudoJet> pieces;
  pieces.push_back(j1);
  pieces.push_back(j2);
  return join(pieces, recombiner);
}

PseudoJet fastjet::join	(	const PseudoJet &	j1,
		const PseudoJet &	j2,
		const PseudoJet &	j3,
		const JetDefinition::Recombiner &	recombiner
	)

build a "CompositeJet" from 3 PseudoJet with an extended structure of type T derived from CompositeJetStructure

build a MergedJet from 3 PseudoJet

Definition at line 317 of file JetDefinition.cc.

                                                          {
  vector<PseudoJet> pieces;
  pieces.push_back(j1);
  pieces.push_back(j2);
  pieces.push_back(j3);
  return join(pieces, recombiner);
}

PseudoJet fastjet::join	(	const PseudoJet &	j1,
		const PseudoJet &	j2,
		const PseudoJet &	j3,
		const PseudoJet &	j4,
		const JetDefinition::Recombiner &	recombiner
	)

build a "CompositeJet" from 4 PseudoJet with an extended structure of type T derived from CompositeJetStructure

build a MergedJet from 4 PseudoJet

Definition at line 327 of file JetDefinition.cc.

                                                          {
  vector<PseudoJet> pieces;
  pieces.push_back(j1);
  pieces.push_back(j2);
  pieces.push_back(j3);
  pieces.push_back(j4);
  return join(pieces, recombiner);
}

PseudoJet fastjet::join ( const PseudoJet & j1 )

build a "CompositeJet" from a single PseudoJet with an extended structure of type T derived from CompositeJetStructure

build a MergedJet from a single PseudoJet

Definition at line 797 of file PseudoJet.cc.

                                    {
  return join(vector<PseudoJet>(1,j1));
}

PseudoJet fastjet::join	(	const PseudoJet &	j1,
		const PseudoJet &	j2
	)

build a "CompositeJet" from two PseudoJet with an extended structure of type T derived from CompositeJetStructure

build a MergedJet from 2 PseudoJet

Definition at line 802 of file PseudoJet.cc.

References fastjet::PseudoJet::pieces().

                                                          {
  vector<PseudoJet> pieces;
  pieces.push_back(j1);
  pieces.push_back(j2);
  return join(pieces);
}

PseudoJet fastjet::join	(	const PseudoJet &	j1,
		const PseudoJet &	j2,
		const PseudoJet &	j3
	)

build a "CompositeJet" from 3 PseudoJet with an extended structure of type T derived from CompositeJetStructure

build a MergedJet from 3 PseudoJet

Definition at line 810 of file PseudoJet.cc.

References fastjet::PseudoJet::pieces().

                                                                                {
  vector<PseudoJet> pieces;
  pieces.push_back(j1);
  pieces.push_back(j2);
  pieces.push_back(j3);
  return join(pieces);
}

PseudoJet fastjet::join	(	const PseudoJet &	j1,
		const PseudoJet &	j2,
		const PseudoJet &	j3,
		const PseudoJet &	j4
	)

build a "CompositeJet" from 4 PseudoJet with an extended structure of type T derived from CompositeJetStructure

build a MergedJet from 4 PseudoJet

Definition at line 819 of file PseudoJet.cc.

References fastjet::PseudoJet::pieces().

                                                                                                      {
  vector<PseudoJet> pieces;
  pieces.push_back(j1);
  pieces.push_back(j2);
  pieces.push_back(j3);
  pieces.push_back(j4);
  return join(pieces);
}

template<typename T >

PseudoJet fastjet::join ( const std::vector< PseudoJet > & pieces )

build a "CompositeJet" from the vector of its pieces with an extended structure of type T derived from CompositeJetStructure

build a "CompositeJet" from the vector of its pieces

In this case, E-scheme recombination is assumed to compute the total momentum

Definition at line 137 of file CompositeJetStructure.hh.

References fastjet::PseudoJet::set_structure_shared_ptr().

                                                                        {
  PseudoJet result(0.0,0.0,0.0,0.0);
  for (unsigned int i=0; i<pieces.size(); i++){
    const PseudoJet it = pieces[i];
    result += it;
  }

  T *cj_struct = new T(pieces);
  result.set_structure_shared_ptr(SharedPtr<PseudoJetStructureBase>(cj_struct));

  return result;
}

template<typename T >

PseudoJet fastjet::join	(	const std::vector< PseudoJet > &	pieces,
		const JetDefinition::Recombiner &	recombiner
	)

build a "CompositeJet" from the vector of its pieces with an extended structure of type T derived from CompositeJetStructure

build a "CompositeJet" from the vector of its pieces

In this case, E-scheme recombination is assumed to compute the total momentum

Definition at line 200 of file CompositeJetStructure.hh.

References fastjet::JetDefinition::Recombiner::plus_equal(), and fastjet::PseudoJet::set_structure_shared_ptr().

                                                                               {
  PseudoJet result;
  if (pieces.size()>0){
    result = pieces[0];
    for (unsigned int i=1; i<pieces.size(); i++){
      recombiner.plus_equal(result, pieces[i]);
    }
  }

  T *cj_struct = new T(pieces, &recombiner);
  result.set_structure_shared_ptr(SharedPtr<PseudoJetStructureBase>(cj_struct));

  return result;
}

template<class T >

std::vector<T> fastjet::objects_sorted_by_values	(	const std::vector< T > &	objects,
		const std::vector< double > &	values
	)

given a vector of values with a one-to-one correspondence with the vector of objects, sort objects into an order such that the associated values would be in increasing order (but don't actually touch the values vector in the process).

bool fastjet::floor_ln2_less	(	unsigned	x,
		unsigned	y
	)		`[inline]`

returns true if floor(ln_base2(x)) < floor(ln_base2(y)), using Chan's neat trick...

Definition at line 220 of file ClosestPair2D.hh.

References floor_ln2_less().

Referenced by floor_ln2_less().

                                                   {
  if (x>y) return false;
  return (x < (x^y)); // beware of operator precedence...
}

Variable Documentation

const double fastjet::MaxRap = 1e5

Used to protect against parton-level events where pt can be zero for some partons, giving rapidity=infinity.

KtJet fails in those cases.

Definition at line 52 of file PseudoJet.hh.

Referenced by fastjet::PseudoJet::pseudorapidity().

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Enumeration Type Documentation

Function Documentation

Variable Documentation