Page MenuHomeHEPForge
Files F9501246

No OneTemporary
Actions

View Options

Index: contrib/contribs/RecursiveTools/trunk/ChangeLog
===================================================================
--- contrib/contribs/RecursiveTools/trunk/ChangeLog (revision 1135)
+++ contrib/contribs/RecursiveTools/trunk/ChangeLog (revision 1136)
@@ -1,674 +1,679 @@
+2018-06-18 Jesse Thaler <jthaler@jthaler.net>
+
+ * README
+ Fixed incorrect order of zcut and beta in the README for SoftDrop example.
+
2018-05-29 Jesse Thaler <jthaler@jthaler.net>
* VERSION
* NEWS
Changed to 2.0.0-beta2, noted in news
2018-04-21 Jesse Thaler <jthaler@jthaler.net>
* AUTHORS: updated arxiv number for RecursiveSoftDrop
2018-04-21 Gavin Salam <gavin.salam@cern.ch>
* README: updated arxiv number for RecursiveSoftDrop & Bottom-up
Soft Drop.
2018-04-04 Gregory Soyez <soyez@fastjet.fr>
* RecursiveSoftDrop.cc (contrib):
fixed syntax of calls to structure_of<...>
(thanks to Attila Krasznahorkay)
2018-01-24 Gregory Soyez <soyez@fastjet.fr>
* RecursiveSoftDrop.cc:
for the (dafault) dynamical R0 implementation, the dynamical R0 is
evolved independently in each branch.
2017-10-10 Jesse Thaler <jthaler@jthaler.net>
* AUTHORS
Added mention of BUSD
* README
Some tweaks to the wording
2017-10-11 Gregory Soyez <soyez@fastjet.fr>
* IteratedSoftDrop.hh:
IteratedSoftDropInfo::size() and multiplicity() now return an
unsigned int instead of a double
2017-10-10 Jesse Thaler <jthaler@jthaler.net>
* AUTHORS
Updated journal reference for ISD
* example_isd.{cc,ref}:
Included soft drop multiplicity in example
* README
Added warning at top that documentation has not been updated
* VERSION
Changed to 2.0.0-beta1
2017-10-10 Gregory Soyez <soyez@fastjet.fr>
* example_isd.ref:
updated to reflect the bugfix below
* IteratedSoftDrop.cc:
fixed issue in description (was taking sqrt of -ve number when
there were no angular cut)
* NEWS:
drafted for RecursiveTools-2.0.0-beta1
* TODO:
updated list in view of a beta release
* example_isd.cc:
pointed to the right header for IteratedSoftDrop
* RecursiveSoftDrop.{hh,cc}:
* IteratedSoftDrop.{hh,cc}:
moved IteratedSoftDrop to its own file (replacing the old
implementation)
* example_advanced_usage.ref:
updated reference file following the fix below.
2017-09-28 Gregory Soyez <soyez@fastjet.fr>
* RecursiveSymmetryCutBase.cc:
when no substructure is found, keep the _symmetry, _delta_R and
_mu structure variables at -1. This for example allows one to
trigger on substructure by checking if delta_R>=0.
Note: we could set it to 0 (as it was before) and trigger using
_delta_R>0 but there might be some genuine substructure exactly
collinear.
2017-09-19 Gregory Soyez <soyez@fastjet.fr>
* example_isd.ref:
updated to the latest version of the example
2017-09-18 Gregory Soyez <soyez@fastjet.fr>
* Makefile:
updating make check to use all the examples (failing on ISD as
expected, see below)
* example_bottomup_softdrop.cc:
fixed typo
* example_bottomup_softdrop.ref:
* example_recursive_softdrop.ref:
added reference output for this example
* RecursiveSoftDrop.{hh,cc}:
* RecursiveSymmetryCutBase.{cc,hh}:
moved the "all_prongs" method from the base structure t oa
standalone function in RecursiveSoftDrop.hh
In practice, this is irrelevant for mMDT and SD (since pieces()
gets the job done, and the substructure class does not have (as
is) reliable info to get the full structure)
* RecursiveSymmetryCutBase.cc:
revamped a series of requests for substructure info to better
handle possible recursion into deeper jet substructure.
* RecursiveSoftDrop.{hh,cc}:
updated "description" to reuse the info from the base class
* example_isd.cc:
updated to use the newer implementation of ISD. Checked that it
gives the same results as the former implementation.
Note: make check still needs fixing because the example now
computes a different set of angularities
* RecursiveSoftDrop.hh:
added a few helpers to IteratedSoftDropInfo ([] operator and size,
meaning it can be used as a vector<pair<double,double> >)
* RecursiveSymmetryCutBase.cc:
. fixed bugs in the calculation of the geometric distances for ee
coordinates
. fixed bug in the computation of the (zg,thetag) pairs [it was
returning the groomed ones instead of the ones passing the
condition]
* example_recursive_softdrop.cc:
set the R0 parameter to the original jet radius
2017-09-13 Gregory Soyez <soyez@fastjet.fr>
* example_recursive_softdrop.cc:
tied up a few comments and the code output
* RecursiveSymmetryCutBase.{hh,cc}:
removed the unneeded _is_composite
* RecursiveSoftDrop.cc:
fixed issue with "verbose" dropped info on branches with no
further substructure
2017-09-11 Gregory Soyez <soyez@fastjet.fr>
* RecursiveSoftDrop.{hh,cc}:
have IteratedSoftDDrop returning by default an object of type
IteratedSoftDropInfo; added several helpers
2017-09-08 Gregory Soyez <soyez@fastjet.fr>
* RecursiveSoftDrop.{hh,cc}:
updated IteratedSoftDrop to give it the flexibility of
RecursiveSoftDrop
* RecursiveSymmetryCutBase.hh:
fixed typo in comment
* example_mmdt_ee.cc: *** ADDED ***
added an example to illustrat usage in ee collisions
* example_isd.cc:
* BottomUpSoftDrop.cc:
* IteratedSoftDrop.cc:
* RecursiveSoftDrop.cc:
Fixed compilation issues with FJ 3.0 (mostly the usage of features
introduced only in FJ3.1)
* RecursiveSymmetryCutBase.{hh,cc}:
used the internal Recluster class for FJ<3.1.0 and the FJ antive
one for FJ>=3.1.0
* BottomUpSoftDrop.{hh,cc}:
moved the implementation of global_grooming to the source file and
fixed a few trivial compilation errors
2017-09-08 Frédéric Dreyer <frederic.dreyer@gmail.com>
* BottomUpSoftDrop.hh:
added the global_grooming method to process full event
2017-09-07 Gregory Soyez <soyez@fastjet.fr>
* RecursiveSoftDrop.cc:
cleaned (mostly by removing older commented-out code)
* RecursiveSoftDrop.{hh,cc}:
* RecursiveSymmetryCutBase.{hh,cc}:
* SoftDrop.cc:
added support for ee coordinates. For that, the symmetry measure
has to be set to either theta_E (which uses the 3-vector angle
theta) or to cos_theta_E which uses sqrt(2*[1-cos(theta)])
Accordingly, the recursion_choice can be set to larger_E to
recurse into the branch with the largest energy. The larger_m
mode, recorsing into the larger-mass branch is also possible but
not advised (for the same reason as the pp version).
* RecursiveSymmetryCutBase.{hh,cc}:
switched to the Recluster class provided with FastJet. ASlso
included the recluster description to RecursiveSymmetryCutBase
when it is user-defined.
2017-09-06 Gregory Soyez <soyez@fastjet.fr>
* BottomUpSoftDrop.{hh,cc}:
. renamed SoftDropStructure -> BottomUpSoftDropStructure
SoftDropRecombiner -> BottomUpSoftDropRecombiner
SoftDropPlugin -> BottomUpSoftDropPlugin
. moved 'description' to source file (instead of header)
. kept the "area" information when available (jets will just
appear as having a 0 area)
. added most class description (main class still missing)
* RecursiveSoftDrop.cc:
. put internal classes to handle CS history in an internal namespace
. replaced the "switch" in the mail loop by a series of if (allows
us a few simplificatins/cleaning)
. more uniform treatment of issues in the presence of an angular cut
(as part of the above reorganisation)
* example_advanced_usage.ref:
updated reference output file following the bugfix (missing
"grooming mode" initialisation in one of the SoftDrop ctors) on
2017-08-01
* RecursiveSymmetryCutBase.cc:
removed redundent code
2017-08-10 Gregory Soyez <soyez@fastjet.fr>
* RecursiveSoftDrop.cc:
fixed trivial typo in variable name
>>>>>>> .r1071
2017-08-04 Gregory Soyez <soyez@fastjet.fr>
* RecursiveSoftDrop.cc:
do not impose an angular cut in IterativeSD if it is -ve.
2017-08-01 Gregory Soyez <soyez@fastjet.fr>
* example_recursive_softdrop.cc:
added a series of optional flags
* RecursiveSoftDrop.cc:
fixed a few issues with the fixed depth version
* RecursiveSymmetryCutBase.hh:
a jet is now considered as havig substructure if deltaR>0
(coherent with released version)
* SoftDrop.hh:
bugfix: set the "grooming mode" by default in all ctors
EDIT: caused issue with make check, fixed on 2017-09-069 (see
above)
* RecursiveSoftDrop.{hh,cc}:
added support for the "same depth" variant
* RecursiveSymmetryCutBase.cc:
also associate a RecursiveSymmetryCutBase::StructureType structure
to the result jet in case it is just a single particle (in
grooming mode)
2017-07-31 Gregory Soyez <soyez@fastjet.fr>
* RecursiveSymmetryCutBase.{hh,cc}:
added the option to pass an extra parameter to the symmetry cut
function
* RecursiveSymmetryCutBase.{hh,cc}:
* ModifiedMassDropTagger.hh
* SoftDrop.hh:
minor adaptions due to the above change + added a few methods to
query the class information (symmetry cut, beta, ...)
* RecursiveSoftDrop.{hh,cc}:
Added support for
- a dynamical R0
- recursing only in the hardest branch
- imposing a min deltaR cut
Added a tentative IterativeSoftDrop class
2017-07-28 Gregory Soyez <soyez@fastjet.fr>
* RecursiveSoftDrop.cc:
adapted to the latest changes in RecursiveSymmetryCutBase
* RecursiveSymmetryCutBase.{hh,cc}:
reorganised the output of the recursion step (recurse_one_step)
using an enum to make iot more readable (and to fix issues where
the dropped prong is actually 0, e.g. after subtraction)
2017-07-26 Gregory Soyez <soyez@fastjet.fr>
* example_recursive_softdrop.cc: *** ADDED ***
added a draft example for the use of RecursiveSoftDrop
* RecursiveSoftDrop.{hh,cc}: *** ADDED ***
added a first pass at an implementation of RecursiveSoftDrop.
This is based on Frederic's initial version but keeps the
branching structure of the jet. Some of the features, like
dynamical R0, direct access to the substructure or the same depth
variant, are still unsupported.
* SoftDrop.hh:
declared _beta, _symmetry_cut and _R0sqr as protected (was
private) so they ca n be used by RecursiveSoftDrop
* RecursiveSymmetryCutBase.{hh,cc}:
extracted from result() the part that performs one step of the
resursion (implemented as recurse_one_step()). This is repeatedly
called by result(). It has specific conventions to indicate
whether or not some substructure has been found or if one ran into
some issue.
2017-04-25 Kevin Zhou <knzhou@mit.edu>
* IteratedSoftDrop.hh
. Added Doxygen documentation
* RecursiveSymmetryCutBase.hh
. Added references to ISD
2017-04-25 Jesse Thaler <jthaler@jthaler.net>
* AUTHORS, COPYING:
. Added ISD arXiv number
* example_isd.{cc,ref}
. Added ISD arXiv number
. Changing z_cut to be optimal value (with Lambda = 1 GeV)
. Tweaked formatting
* IteratedSoftDrop.{hh,cc}
. Added ISD arXiv number
. Assert added if recluster does not return one jet.
* README
. Added ISD arXiv number and tweaked wording
2017-04-20 Kevin Zhou <knzhou@mit.edu>
* example_isd.{cc,ref} ** ADDED **
* IteratedSoftDrop.{cc,hh} ** ADDED **
* Makefile
. Added IteratedSoftDrop (ISD) as appropriate
* AUTHORS
. Added myself to author list
. Added placeholder for ISD paper
* COPYING
. Added placeholder for ISD paper
* README
. Added description of ISD
* TODO
. Added tasks to integrate ISD with other classes, e.g. SD,
Recluster, and the future RecursiveSoftDrop (RSD)
* NEWS
. Added dummy for release of 1.1.0
* VERSION:
. Switched version number to 1.1.0-dev
* example_advanced_usage.cc:
. Added $Id$ tag, didn't change anything else
2014-07-30 Gregory Soyez <soyez@fastjet.fr>
* Recluster.hh: fixed the name of the #define for the header
2014-07-09 Gregory Soyez <soyez@fastjet.fr> + Jesse
* NEWS:
release of RecursiveTools v1.0.0
* VERSION:
switched version number to 1.0.0
2014-07-08 Gavin Salam <gavin.salam@cern.ch>
* README (RecursionChoice):
added ref to .hh for constness specs of virtual functions (to
reduce risk of failed overloading due to wrong constness).
2014-07-08 Gregory Soyez <soyez@fastjet.fr> + Jesse
* README:
partially rewrote the description of set_subtractor
2014-07-07 Gregory Soyez <soyez@fastjet.fr> + Jesse
* example_advanced_usage.cc:
* example_softdrop.cc:
a few small fixed in the header of the files
* VERSION:
switched over to 1.0.0-alpha2-devel
* README:
Reordered a few things and added a few details.
* Makefile (check):
Be quiter during "make check"
* Recluster.cc (contrib):
Documented the "single" ctor argument
* RecursiveSymmetryCutBase.cc (contrib):
If the user sets himself the reclustering, disable the "non-CA"
warning (we assume that he knows what he is doing). Mentioned in
the comments that non-CA reclustering has to be used at the user's
risk. Also throw when th input jet has no constituents or when
there is no cluster sequence after reclustering.
* Recluster.cc (contrib):
replaced a remaining mention to "filtering" by reclustering
2014-07-04 Jesse Thaler <jthaler@jthaler.net>
* VERSION
. Ready for alpha release
2014-06-17 Jesse Thaler <jthaler@jthaler.net>
* example_advanced_usage.{cc,ref} ** ADDED **
* Makefile
. New example file to test a bunch of soft drop options
. Put in makefile as well
. Fixed nasty memory bug with pointers to Recluster
* RecursiveSymmetryCutBase.cc
* example_softdrop.ref
. description() now says Groomer vs. Tagger
* RecursiveSymmetryCutBase.{cc,hh}
. Added optional verbose logging information about
kinematics of dropped branches
* example_softdrop.cc
* example_advanced_usage.cc
. Fixed
2014-06-16 Gregory Soyez <soyez@fastjet.fr>
* Makefile:
also install the RecursiveSymmetryuCutBase.hh header
2014-06-13 Jesse Thaler <jthaler@jthaler.net>
* AUTHORS
. Added myself to author list
. Put complete bibliographic details on papers
* COPYING
. Added boilerplate MC/GPLv2 statement
* example.cc: ** REMOVED ** renamed to...
* example_mmdt.cc ** ADDED **
* Makefile
. Made name change for consistency
. Made corresponding changes in Makefile
* example_mmdt_sub.cc:
* example_mmdt.cc:
* example_recluster.cc:
. light editing of comments
* example_softdrop.cc:
. light editing of comments
. added assert for sdjet != 0, since SoftDrop is a groomer
* ModifiedMassDropTagger.hh
* Recluster.{cc,hh}
* RecursiveSymmetryCutBase.{cc,hh}
* SoftDrop.hh
. Updated some comments
* README
. Updated to include basic usage description and some
technical details
* TODO:
. Added some discussion points.
2014-06-13 Gregory Soyez <soyez@fastjet.fr>
* example_softdrop.{cc,ref}:
added an example for SoftDrop
* SoftDrop.{hh,cc}:
* ModifiedMassDropTagger.{hh,cc}:
* RecursiveSymmetryCutBase.{hh,cc}: *** ADDED ***
. added a base class for both the mMDT and SoftDrop
. made mMDT and SoftDrop inherit from RecursiveSymmetryCutBase
. moved the reclustering to the base class. By default, both
mMDT and SoftDrop now recluster the jet with C/A
. added set_grooming_mode and set_tagging_mode methods to the
base class
* Merging the development branch 1.0-beta1-softdrop-addition back
into the trunk (will correspond to revision 682)
* VERSION:
switched back to 1.0.0-devel
* SoftDrop.{hh,cc}:
added support for re-clustering through set_reclustering(bool,
Recluster*). By default, reclustering is done with
Cambridge/Aachen.
* example_recluster.{cc,ref}: *** ADDED ***
added an example of reclustering
* Recluster.{hh,cc}:
added a 'single' ctor argument [true by default]. When true, the
hardest jet after reclustering is returned, otherwise, the result
is a composite jet with all the subjets as its pieces.
2014-05-15 Gregory Soyez <soyez@fastjet.fr>
* VERSION:
set version number to 1.0-alpha-PUWS14.1 in preparation for a
fastjet-contrib release for the pileup-workshop at CERN on May
2014.
2014-04-25 Gregory Soyez <soyez@fastjet.fr>
* ModifiedMassDropTagger.hh:
* ModifiedMassDropTagger.cc:
Added comments at various places
* AUTHORS:
* README:
Updated info about what is now included in this contrib
* SoftDrop.hh: *** ADDED ***
* SoftDrop.cc: *** ADDED ***
* Recluster.hh: *** ADDED ***
* Recluster.cc; *** ADDED ***
Added tools for reclustering and softDrop
2014-04-25 Gregory Soyez <soyez@fastjet.fr>
branch started at revision 611 to start including SoftDrop in the
Recursivetols contrib
2014-04-24 Gregory Soyez <soyez@fastjet.fr>
* ModifiedMassDropTagger.hh:
added a mention of the fact that when result is called in the
presence of a subtractor, then the output is a subtracted
PseudoJet.
* ModifiedMassDropTagger.hh:
declared _symmetry_cut as protected (rather than provate) so it
can be accessed if symmetry_cut_description() is overloaded.
* example.cc:
trivial typo fixed in a comment
2014-02-04 Gavin Salam <gavin.salam@cern.ch>
* VERSION:
upped it to 1.0-beta1
* example_mmdt_sub.cc (main):
added an #if to make sure FJ3.1 features are only used if FJ3.1
is available. (Currently FJ3.1 is only available to FJ developers).
2014-01-26 Gavin Salam <gavin.salam@cern.ch>
* VERSION:
renamed to 1.0-beta0
* ModifiedMassDropTagger.hh:
* README:
added info on author names
* example_mmdt_sub.ref: *** ADDED ***
added reference output for the pileup test.
2014-01-25 Gavin Salam <gavin.salam@cern.ch>
* example_mmdt_sub.cc:
* Makefile:
added an extra example illustrating functionality with pileup
subtraction.
2014-01-24 Gavin Salam <gavin.salam@cern.ch>
* ModifiedMassDropTagger.cc:
Reorganised code so that (sub)jet.m2()>0 check is only used when
absolutely necessary: so if using a scalar_z symmetry measure,
whenever scalar_z < zcut, then there is no point checking the mu
condition. This means that there's no issue if the (sub)jet mass
is negative, and one simply recurses down into the jet. (Whereas
before it would bail out, reducing the tagging efficiency).
Also removed the verbose code.
2014-01-23 Gavin Salam <gavin.salam@cern.ch>
* ModifiedMassDropTagger.cc|hh:
* example.cc
replaced "asymmetry" with "symmetry" in a number of places;
implemented the structural information and added it to the example;
added a new simplified constructor;
improved doxygen documentation;
started renaming -> RecursiveTools
* README
some tidying
* VERSION
1.0-b0
2014-01-22 Gavin Salam <gavin.salam@cern.ch>
* ModifiedMassDropTagger.cc (contrib):
-ve mass now bails out also when using the "y" asymmetry measure.
Also, default my is now infinite.
2014-01-20 Gavin Salam <gavin.salam@cern.ch> + Gregory
* ModifiedMassDropTagger.cc|hh:
introduced a virtual asymmetry_cut_fn (essentially a
dummy function returning a constant), to allow for derived classes
to do fancier things.
added warning about non-C/A clustering.
explicitly labelled some (inherited) virtual functions as
virtual.
2014-01-20 Gavin Salam <gavin.salam@cern.ch>
* example.ref:
* example.cc (main):
got a first working example and make check setup.
* ModifiedMassDropTagger.cc|hh:
improved doxygen comments;
added option whereby input jet is assumed already subtracted
2014-01-19 Gavin Salam <gavin.salam@cern.ch>
* ModifiedMassDropTagger.cc|hh:
* many other files
Initial creation, with basic code for MMDT
Index: contrib/contribs/RecursiveTools/trunk/README
===================================================================
--- contrib/contribs/RecursiveTools/trunk/README (revision 1135)
+++ contrib/contribs/RecursiveTools/trunk/README (revision 1136)
@@ -1,346 +1,346 @@
------------------------------------------------------------------------
RecursiveTools FastJet contrib
------------------------------------------------------------------------
The RecursiveTools FastJet contrib aims to provide a common contrib
for a number of tools that involve recursive reclustering/declustering
of a jet for tagging or grooming purposes.
Currently it contains:
- ModifiedMassDropTagger
This corresponds to arXiv:1307.0007 by Mrinal Dasgupta, Alessandro
Fregoso, Simone Marzani and Gavin P. Salam
- SoftDrop
This corresponds to arXiv:1402.2657 by Andrew J. Larkoski, Simone
Marzani, Gregory Soyez, Jesse Thaler
- RecursiveSoftDrop
- BottomUpSoftDrop
This corresponds to arXiv:1804.03657 by Frederic Dreyer, Lina
Necib, Gregory Soyez and Jesse Thaler
- IteratedSoftDrop
This corresponds to arXiv:1704.06266 by Christopher Frye, Andrew J.
Larkoski, Jesse Thaler, Kevin Zhou
- Recluster
A generic tool to recluster a given jet into subjets
Note: a Recluster class is available natively in FastJet since v3.1.
Users are therefore encouraged to use the FastJet version
rather than this one which is mostly provided for
compatibility of this contrib with older versions of FastJet.
The interface for these tools is described in more detail below, with
all of the available options documented in the header files.
One note about nomenclature. A groomer is a procedure that takes a
PseudoJet and always returns another (non-zero) PseudoJet. A tagger is
a procedure that takes a PseudoJet, and either returns another PseudoJet
(i.e. tags it) or returns an empty PseudoJet (i.e. doesn't tag it).
------------------------------------------------------------------------
ModifiedMassDropTagger
------------------------------------------------------------------------
The Modified Mass Drop Tagger (mMDT) recursively declusters a jet,
following the largest pT subjet until a pair of subjets is found that
satisfy the symmetry condition on the energy sharing
z > z_cut
where z_cut is a predetermined value. By default, z is calculated as
the scalar pT fraction of the softest subjet. Note that larger values
of z_cut correspond to a more restrictive tagging criteria.
By default, mMDT will first recluster the jet using the CA clustering
algorithm, which means that mMDT can be called on any jet, regardless
of the original jet finding measure.
A default mMDT can be created via
double z_cut = 0.10;
ModifiedMassDropTagger mMDT(z_cut);
More options are available in the full constructor. To apply mMDT,
one simply calls it on the jet of interest.
PseudoJet tagged_jet = mMDT(original_jet);
Note that mMDT is a tagger, such that tagged_jet will only be non-zero
if the symmetry cut z > z_cut is satisfied by some branching of the
clustering tree.
To gain additional information about the mMDT procedure, one can use
tagged_jet.structure_of<ModifiedMassDropTagger>()
which gives access to information about the delta_R between the tagged
subjets, their z value, etc.
------------------------------------------------------------------------
SoftDrop
------------------------------------------------------------------------
The SoftDrop procedure is very similar to mMDT, albeit with a
generalised symmetry condition:
z > z_cut * (R / R0)^beta
Note that larger z_cut and smaller beta correspond to more aggressive
grooming of the jet.
SoftDrop is intended to be used as a groomer (instead of as a tagger),
such that if the symmetry condition fails throughout the whole
clustering tree, SoftDrop will still return a single particle in the
end. Apart from the tagger/groomer distinction, SoftDrop with beta=0 is
the same as mMDT.
A default SoftDrop groomer can be created via:
double z_cut = 0.10;
double beta = 2.0;
double R0 = 1.0; // this is the default value
- SoftDrop sd(z_cut,beta,R0);
+ SoftDrop sd(beta,z_cut,R0);
and acts on a desired jet as
PseudoJet groomed_jet = sd(original_jet);
and additional information can be obtained via
groomed_jet.structure_of<SoftDrop>()
SoftDrop is typically called with beta > 0, though beta < 0 is still a
viable option. Because beta < 0 is infrared-collinear unsafe in
grooming mode, one probably wants to switch to tagging mode for negative
beta, via set_tagging_mode().
------------------------------------------------------------------------
RecursiveSoftDrop
------------------------------------------------------------------------
The RecursiveSoftDrop procedure applies the Soft Drop procedure N times
in a jet in order to find up to N+1 prongs. N=0 makes no modification
to the jet, and N=1 is equivalent to the original SoftDrop.
Once one has more than one prong, one has to decide which will be
declustered next. At each step of the declustering procedure, one
undoes the clustering which has the largest declustering angle
(amongst all the branches that are searched for substructure). [see
"set_fixed_depth" below for an alternative]
Compared to SoftDrop, RecursiveSoftDrop takes an extra argument N
specifying the number of times the SoftDrop procedure is recursively
applied. Negative N means that the procedure is applied until no
further substructure is found (i.e. corresponds to taking N=infinity).
double z_cut = 0.10;
double beta = 2.0;
double R0 = 1.0; // this is the default value
int N = -1;
- RecursiveSoftDrop rsd(z_cut, beta, N, R0);
+ RecursiveSoftDrop rsd(beta, z_cut, N, R0);
One then acts on a jet as
PseudoJet groomed_jet = rsd(jet)
and get additional information via
groomed_jet.structure_of<RecursiveSoftDrop>()
------------------------------------------------------------------------
IteratedSoftDrop
------------------------------------------------------------------------
Iterated Soft Drop (ISD) is a repeated variant of SoftDrop. After
performing the Soft Drop procedure once, it logs the groomed symmetry
factor, then recursively performs Soft Drop again on the harder
branch. This procedure is repeated down to an (optional) angular cut
theta_cut, yielding a set of symmetry factors from which observables
can be built.
An IteratedSoftDrop tool can be created as follows:
double beta = -1.0;
double z_cut = 0.005;
double theta_cut = 0.0;
double R0 = 0.5; // characteristic radius of jet algorithm
IteratedSoftDrop isd(beta, z_cut, double theta_cut, R0);
By default, ISD applied on a jet gives a result of type
IteratedSoftDropInfo that can then be probed to obtain physical
observables
IteratedSoftDropInfo isd_info = isd(jet);
unsigned int multiplicity = isd_info.multiplicity();
double kappa = 1.0; // changes angular scale of ISD angularity
double isd_width = isd_info.angularity(kappa);
vector<pair<double,double> > zg_thetags = isd_info.all_zg_thetag();
vector<pair<double,double> > zg_thetags = isd_info();
for (unsigned int i=0; i< isd_info.size(); ++i){
cout << "(zg, theta_g)_" << i << " = "
<< isd_info[i].first << " " << isd_info[i].second << endl;
}
Alternatively, one can directly get the multiplicity, angularity, and
(zg,thetag) pairs from the IteratedSoftDrop class, at the expense of
re-running the declustering procedure:
unsigned int multiplicity = isd.multiplicity(jet);
double isd_width = isd.angularity(jet, 1.0);
vector<pair<double,double> > zg_thetags = isd.all_zg_thetag(jet);
Note: the iterative declustering procedure is the same as what one
would obtain with RecursiveSoftDrop with an (optional) angular cut
and recursing only in the hardest branch [see the "Changing
behaviour" section below for details], except that it returns some
information about the jet instead of a modified jet as RSD does.
------------------------------------------------------------------------
BottomUpSoftDrop
------------------------------------------------------------------------
This is a bottom-up version of the RecursiveSoftDrop procedure, in a
similar way as Pruning can be seen as a bottom-up version of Trimming.
In practice, the jet is reclustered and at each step of the clustering
one checks the SoftDrop condition
z > z_cut * (R / R0)^beta
If the condition is met, the pair is recombined. If the condition is
not met, only the hardest of the two objects is kept for further
clustering and the softest is rejected.
------------------------------------------------------------------------
Recluster
------------------------------------------------------------------------
*** NOTE: this is provided only for backwards compatibility ***
*** with FastJet <3.1. For FastJet >=3.1, the native ***
*** fastjet::Recluster is used instead ***
The Recluster class allows the constituents of a jet to be reclustered
with a different recursive clustering algorithm. This is used
internally in the mMDT/SoftDrop/RecursiveSoftDrop/IteratedSoftDrop
code in order to recluster the jet using the CA algorithm. This is
achieved via
Recluster ca_reclusterer(cambridge_algorithm,
JetDefinition::max_allowable_R);
PseudoJet reclustered_jet = ca_reclusterer(original_jet);
Note that reclustered_jet creates a new ClusterSequence that knows to
delete_self_when_unused.
------------------------------------------------------------------------
Changing behaviour
------------------------------------------------------------------------
The behaviour of the all the tools provided here
(ModifiedMassDropTagger, SoftDrop, RecursiveSoftDrop and
IteratedSoftDrop) can be tweaked using the following options:
SymmetryMeasure = {scalar_z, vector_z, y, theta_E, cos_theta_E}
[constructor argument]
: The definition of the energy sharing between subjets, with 0
corresponding to the most asymmetric.
. scalar_z = min(pt1,pt2)/(pt1+pt2) [default]
. vector_z = min(pt1,pt2)/pt_{1+2}
. y = min(pt1^2,pt2^2)/m_{12}^2 (original y from MDT)
. theta_E = min(E1,E2)/(E1+E2),
with angular measure theta_{12}^2
. cos_theta_E = min(E1,E2)/(E1+E2),
with angular measure 2[1-cos(theta_{12})]
The last two variants are meant for use in e+e- collisions,
together with the "larger_E" recursion choice (see below)
RecursionChoice = {larger_pt, larger_mt, larger_m, larger_E}
[constructor argument]
: The path to recurse through the tree after the symmetry condition
fails. Options refer to transverse momentum (pt), transverse mass
(mt=sqrt(pt^2+m^2), mass (m) or energy (E). the latter is meant
for use in e+e- collisions
mu_cut [constructor argument]
: An optional mass drop condition
set_subtractor(subtractor*) [or subtractor as a constructor argument]
: provide a subtractor. When a subtractor is supplied, the
kinematic constraints are applied on subtracted 4-vectors. In
this case, the result of the ModifiedMassDropTagger/SoftDrop is a
subtracted PseudoJet, and it is assumed that
ModifiedMassDropTagger/SoftDrop is applied to an unsubtracted jet.
The latter default can be changed by calling
set_input_jet_is_subtracted().
set_reclustering(bool, Recluster*)
: An optional setting to recluster a jet with a different jet
recursive jet algorithm. The code is only designed to give sensible
results with the CA algorithm, but other reclustering algorithm
(especially kT) may be appropriate in certain contexts.
Use at your own risk.
set_grooming_mode()/set_tagging_mode()
: In grooming mode, the algorithm will return a single particle if the
symmetry condition fails for the whole tree. In tagging mode, the
algorithm will return an zero PseudoJet if no symmetry conditions
passes. Note that ModifiedMassDropTagger defaults to tagging mode
and SoftDrop defaults to grooming mode.
set_verbose_structure(bool)
: when set to true, additional information will be stored in the jet
structure. This includes in particular values of symmetry,
delta_R, and mu of dropped branches
For the specific case of RecursiveSoftDrop, additional tweaking is
possible via the following methods
set_fixed_depth_mode(bool)
: when this is true, RSD will recurse (N times) into all the
branches found during the previous iteration [instead of recursing
through the largest declustering angle until N prongs have been
found]. This yields at most 2^N prong. For infinite N, the two
options are equivalent.
set_dynamical_R0(bool)
: By default the angles in the SD condition are normalised to the
parameter R0. With "dynamical R0", RSD will dynamically adjust R0
to be the angle between the two prongs found during the previous
iteration.
set_hardest_branch_only(bool)
: When substructure is found, only recurse into the hardest of the
two branches for further substructure search. This uses the class
RecursionChoice.
set_min_deltaR_squared(double):
: set a minimal angle (squared) at which we stop the declustering
procedure. This cut is ineffective for negative values of the
argument.
------------------------------------------------------------------------
Technical Details
------------------------------------------------------------------------
Both ModifiedMassDropTagger and SoftDrop inherit from
RecursiveSymmetryCutBase, which provides a common codebase for recursive
declustering of a jet with a symmetry cut condition. A generic
RecursiveSymmetryCutBase depends on the following (virtual) functions
(see header file for exact full specs, including constness):
double symmetry_cut_fn(PseudoJet &, PseudoJet &)
: The function that defines the symmetry cut. This is what actually
defines different recursive declustering schemes, and all classes
that inherit from RecursiveSymmetryCutBase must define this
function.
string symmetry_cut_description()
: the string description of the symmetry cut.
------------------------------------------------------------------------

File Metadata

Mime Type
text/x-diff
Expires
Sun, Feb 23, 2:08 PM (7 h, 59 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
4486469
Default Alt Text
(34 KB)

Event Timeline