Class that helps perform filtering/trimming on jets, and optionally subtraction (if rho > 0). More...

#include <Filter.hh>

Inheritance diagram for fastjet::Filter:

Collaboration diagram for fastjet::Filter:

Public Types
typedef FilterStructure	StructureType
	information about the associated structure type
Public Member Functions
	Filter ()
	trivial ctor Note: this is just for derived classes a Filter initialised through this constructor will not work!
	Filter (JetDefinition subjet_def, Selector selector, double rho=0.0)
	define a filter that decomposes a jet into subjets using a generic JetDefinition and then keeps only a subset of these subjets according to a Selector.
	Filter (double Rfilt, Selector selector, double rho=0.0)
	Same as the full constructor (see above) but just specifying the radius By default, Cambridge-Aachen is used.
	Filter (FunctionOfPseudoJet< double > *Rfilt_func, Selector selector, double rho=0.0)
	Same as the full constructor (see above) but just specifying a filtering radius that will depend on the jet being filtered As for teh previous case, Cambridge-Aachen is used.
virtual	~Filter ()
	default dtor
virtual PseudoJet	result (const PseudoJet &jet) const
	runs the filtering and sets kept and rejected to be the jets of interest (with non-zero rho, they will have been subtracted).
virtual std::string	description () const
	class description
Protected Member Functions
void	_set_filtered_elements (const PseudoJet &jet, std::vector< PseudoJet > &filtered_elements) const
	sets filtered_elements to be all the subjets on which filtering will work [NB: this routine is work in progress as part of a transition to a Filter that also works on jet collections]
PseudoJet	_finalise (const PseudoJet &jet, std::vector< PseudoJet > &kept, std::vector< PseudoJet > &rejected) const
	gather the information about what is kept and rejected under the form of a PseudoJet with a special ClusterSequenceInfo
bool	_check_ca (const PseudoJet &jet) const
	check if one can apply the simplified trick for C/A subjets
bool	_recursively_check_ca (const PseudoJet &jet, std::vector< PseudoJet > &cumulative_pieces) const
	check if the jet is obtained from C/A or a superposition of C/A pieces
void	_set_filtered_elements_cafilt (const PseudoJet &jet, std::vector< PseudoJet > &filtered_elements, double Rfilt) const
	set the filtered elements in the simple case of C/A+C/A
void	_set_filtered_elements_generic_unsubtracted (const PseudoJet &jet, std::vector< PseudoJet > &filtered_elements) const
	set the filtered elements in the generic re-clustering case (wo subtraction)
void	_set_filtered_elements_generic_subtracted (const PseudoJet &jet, std::vector< PseudoJet > &filtered_elements) const
	set the filtered elements in the generic re-clustering case (with subtraction)
Protected Attributes
JetDefinition	_subjet_def
	the jet definition to use to extract the subjets
FunctionOfPseudoJet< double > *	_Rfiltfunc
	a dynamic filtering radius function of the jet being filtered
Selector	_selector
	the subjet selection criterium
double	_rho
	the background density (used for subtraction when possible)

Detailed Description

Class that helps perform filtering/trimming on jets, and optionally subtraction (if rho > 0).

Though the original version was applied on Cambridge/Aachen jets, this one takes any jet (that has constituents) and reclusters it with a given algorithm. A user-provided Selector is applied to decide which of the subjets are kept to produce the filtered jet (others are discarded).

Options

The constructor has the following arguments:

The first argument is the jet definition to be used to recluster the constituents of the jet to be filtered.
The second argument is a Selector specifying the condition for a subjet to be kept. If the selector takes a reference, the jet being filtered is used.
As an optional 3rd argument, one can pass a value of rho (the estimated background per unit area) in which case, every subjet is subtracted before the selection condition is applied.

Input conditions

the original jet must have constituents
if rho>0, the jet must be the result of a Clustering with active area with explicit ghosts support or a merging of such pieces

Output/structure

a copy of the original jet is kept
kept pieces are stored under the form of a "CompositeJet"
rejected pieces are also stored in the structure

Usage Examples

Filtering as proposed in arXiv:0802.2470 for boosted object reconstruction (and used also in arXiv:0810.1304 for dijet reconstructions) involves two parameters, the filtering radius, Rfilt, and the number of subjets you wish to keep, nfilt. To get a filter of this kind define

Filter filter(JetDefinition(cambridge_algorithm,Rfilt), SelectorNHardest(nfilt));

You apply it as follows

PseudoJet filtered_jet = filter(jet);

To get trimming defined with respect to a jet's pt, arXiv:0912.1342, you need an Rtrim to define subjets and a pt_fraction_min to decide which subjets to keep:

Filter trimmer(JetDefinition(cambridge_algorithm,Rfilt), SelectorPtFractionMin(pt_fraction_min));

You then apply it as before

PseudoJet trimmed_jet = trimmer(jet);

You can then find out which pieces were filtered or trimmed jet is made of by calling

trimmed_jet.pieces()

Trimming defined with respect to an event's effective mass can be carried out with a SelectorPtMin(...) selector.

More sophisticated filters/trimmers can easily be obtained by combining Selectors.

[MORE INFO, E.G. ON PIECES REJECTED, SHOULD FOLLOW]

Implementation

If the jet was defined with the cambridge/aachen algorithm (or is made of pieces each of which comes from the C/A alg) and the filtering definition is C/A, then the filter does not rerun the C/A algorithm on the constituents, but instead makes use of the existent C/A cluster sequence in the original jet.

See also 12 - use of filtering for a usage example.

Definition at line 135 of file Filter.hh.

Constructor & Destructor Documentation

fastjet::Filter::Filter	(	JetDefinition	subjet_def,
		Selector	selector,
		double	rho = `0.0`
	)		`[inline]`

define a filter that decomposes a jet into subjets using a generic JetDefinition and then keeps only a subset of these subjets according to a Selector.

Optionally, each subjet may be internally bakground-subtracted prior to selection.

Parameters:

subjet_def	the jet definition applied to obtain the subjets
selector	the Selector applied to compute the kept subjets
rho	if non-zero, backgruond-subtract each subjet befor selection

Note: internal subtraction only applies on jets that are obtained with a cluster sequence with area support and explicit ghosts

Definition at line 154 of file Filter.hh.

                                                                        : 
    _subjet_def(subjet_def), _Rfiltfunc(0), _selector(selector), _rho(rho) {}

fastjet::Filter::Filter	(	double	Rfilt,
		Selector	selector,
		double	rho = `0.0`
	)		`[inline]`

Same as the full constructor (see above) but just specifying the radius By default, Cambridge-Aachen is used.

Parameters:

Rfilt the filtering radius

Definition at line 160 of file Filter.hh.

References fastjet::cambridge_algorithm.

                                                            : 
    _subjet_def(JetDefinition(cambridge_algorithm, Rfilt)), 
    _Rfiltfunc(0), _selector(selector), _rho(rho) {}

fastjet::Filter::Filter	(	FunctionOfPseudoJet< double > *	Rfilt_func,
		Selector	selector,
		double	rho = `0.0`
	)		`[inline]`

Same as the full constructor (see above) but just specifying a filtering radius that will depend on the jet being filtered As for teh previous case, Cambridge-Aachen is used.

Parameters:

Rfilt_func the filtering radius function of a PseudoJet

Definition at line 168 of file Filter.hh.

                                                                                       : 
    _Rfiltfunc(Rfilt_func), _selector(selector), _rho(rho) {}

Member Function Documentation

PseudoJet fastjet::Filter::result ( const PseudoJet & jet ) const [virtual]

runs the filtering and sets kept and rejected to be the jets of interest (with non-zero rho, they will have been subtracted).

Parameters:

jet	the jet that gets filtered

Returns:: the filtered jet

Implements fastjet::Transformer.

Definition at line 62 of file Filter.cc.

                                                   {
  // start by getting the list of subjets (including a list of sanity
  // checks)
  // NB: subjets is empty to begin with (see the comment for
  //     _set_filtered_elements_cafilt)
  vector<PseudoJet> subjets; 
  _set_filtered_elements(jet, subjets);

  // now build the vector of kept and rejected subjets
  vector<PseudoJet> kept, rejected;
  // Note that the following line is the one requiring that _selector
  // be declared as mutable
  if (_selector.takes_reference()) _selector.set_reference(jet);
  _selector.sift(subjets, kept, rejected);

  // gather the info under the form of a PseudoJet
  return _finalise(jet, kept, rejected);
}

The documentation for this class was generated from the following files:

tools/fastjet/tools/Filter.hh
tools/Filter.cc

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Options

Input conditions

Output/structure

Usage Examples

Implementation

Constructor & Destructor Documentation

Member Function Documentation