Page MenuHomeHEPForge
Files F11221452

No OneTemporary
Actions

View Options

Index: contrib/contribs/RecursiveTools/trunk/example_advanced_usage.ref
===================================================================
--- contrib/contribs/RecursiveTools/trunk/example_advanced_usage.ref (revision 1051)
+++ contrib/contribs/RecursiveTools/trunk/example_advanced_usage.ref (revision 1052)
@@ -1,158 +1,144 @@
-# read an event with 354 particles
-#--------------------------------------------------------------------------
-# FastJet release 3.0.6
-# M. Cacciari, G.P. Salam and G. Soyez
-# A software package for jet finding and analysis at colliders
-# http://fastjet.fr
-#
-# Please cite EPJC72(2012)1896 [arXiv:1111.6097] if you use this package
-# for scientific work and optionally PLB641(2006)57 [hep-ph/0512210].
-#
-# FastJet is provided without warranty under the terms of the GNU GPLv2.
-# It uses T. Chan's closest pair algorithm, S. Fortune's Voronoi code
-# and 3rd party plugin jet algorithms. See COPYING file for details.
-#--------------------------------------------------------------------------
---------------------------------------------------------------------------------------------
Soft Drops to be tested:
---------------------------------------------------------------------------------------------
name beta z_cut sym R0 mu recurse reclust mode
beta=2.0 zcut=.1 2.000 0.100 scalar_z 1.000 inf larger_pt CA groom
beta=1.0 zcut=.1 1.000 0.100 scalar_z 1.000 inf larger_pt CA groom
beta=0.5 zcut=.1 0.500 0.100 scalar_z 1.000 inf larger_pt CA groom
beta=2.0 zcut=.2 2.000 0.200 scalar_z 1.000 inf larger_pt CA groom
beta=1.0 zcut=.2 1.000 0.200 scalar_z 1.000 inf larger_pt CA groom
beta=0.5 zcut=.2 0.500 0.200 scalar_z 1.000 inf larger_pt CA groom
MMDT-like zcut=.1 0.000 0.100 scalar_z 1.000 inf larger_pt CA tag
MMDT-like zcut=.2 0.000 0.200 scalar_z 1.000 inf larger_pt CA tag
MMDT-like zcut=.3 0.000 0.300 scalar_z 1.000 inf larger_pt CA tag
MMDT-like zcut=.4 0.000 0.400 scalar_z 1.000 inf larger_pt CA tag
beta=-2.0 zcut=.05 -2.000 0.050 scalar_z 1.000 inf larger_pt CA tag
beta=-1.0 zcut=.05 -1.000 0.050 scalar_z 1.000 inf larger_pt CA tag
beta=-0.5 zcut=.05 -0.500 0.050 scalar_z 1.000 inf larger_pt CA tag
b=.5 z=.3 R0=1.0 0.500 0.300 scalar_z 1.000 inf larger_pt CA groom
b=.5 z=.3 R0=0.5 0.500 0.300 scalar_z 0.500 inf larger_pt CA groom
b=.5 z=.3 R0=0.2 0.500 0.300 scalar_z 0.200 inf larger_pt CA groom
b=2 z=.4 scalar_z 2.000 0.400 scalar_z 1.000 inf larger_pt CA groom
b=2 z=.4 vector_z 2.000 0.400 vector_z 1.000 inf larger_pt CA groom
b=2 z=.4 y 2.000 0.400 y 1.000 inf larger_pt CA groom
b=3 z=.2 larger_pt 3.000 0.200 scalar_z 1.000 inf larger_pt CA groom
b=3 z=.2 larger_mt 3.000 0.200 scalar_z 1.000 inf larger_mt CA groom
b=3 z=.2 larger_m 3.000 0.200 scalar_z 1.000 inf larger_m CA groom
b=2 z=.1 mu=1.0 2.000 0.100 scalar_z 1.000 1.000 larger_pt CA groom
b=2 z=.1 mu=0.8 2.000 0.100 scalar_z 1.000 0.800 larger_pt CA groom
b=2 z=.1 mu=0.5 2.000 0.100 scalar_z 1.000 0.500 larger_pt CA groom
b=2.0 z=.2 kT 2.000 0.200 scalar_z 1.000 inf larger_pt KT groom
b=1.0 z=.2 kT 1.000 0.200 scalar_z 1.000 inf larger_pt KT groom
b=0.5 z=.2 kT 0.500 0.200 scalar_z 1.000 inf larger_pt KT groom
b=2.0 z=.4 kT 2.000 0.400 scalar_z 1.000 inf larger_pt KT groom
b=1.0 z=.4 kT 1.000 0.400 scalar_z 1.000 inf larger_pt KT groom
b=0.5 z=.4 kT 0.500 0.400 scalar_z 1.000 inf larger_pt KT groom
---------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------
Analyzing Jet 1:
---------------------------------------------------------------------------------------------
name pt m y phi constit delta_R sym mu mxdropz
Original Jet 983.3873 39.9912 -0.8673 2.9051 35
beta=2.0 zcut=.1 980.4398 27.1382 -0.8675 2.9053 25 0.2092 0.0047 0.8353 0.0014
beta=1.0 zcut=.1 971.5229 20.8426 -0.8686 2.9051 22 0.0954 0.0294 0.5476 0.0047
beta=0.5 zcut=.1 933.8859 9.9073 -0.8697 2.9075 13 0.0217 0.0174 0.8786 0.0294
beta=2.0 zcut=.2 975.8387 22.6675 -0.8684 2.9057 23 0.1316 0.0045 0.9195 0.0047
beta=1.0 zcut=.2 971.5229 20.8426 -0.8686 2.9051 22 0.0954 0.0294 0.5476 0.0047
beta=0.5 zcut=.2 917.6736 8.7048 -0.8696 2.9079 12 0.0200 0.1543 0.5576 0.0294
MMDT-like zcut=.1 917.6736 8.7048 -0.8696 2.9079 12 0.0200 0.1543 0.5576 0.0294
MMDT-like zcut=.2 669.6354 1.9839 -0.8677 2.9075 4 0.0044 0.2031 0.7051 0.1543
MMDT-like zcut=.3 446.5813 1.0182 -0.8678 2.9069 2 0.0030 0.4251 0.4848 0.2031
MMDT-like zcut=.4 446.5813 1.0182 -0.8678 2.9069 2 0.0030 0.4251 0.4848 0.2031
beta=-2.0 zcut=.05 ---- untagged jet ----
beta=-1.0 zcut=.05 ---- untagged jet ----
beta=-0.5 zcut=.05 ---- untagged jet ----
b=.5 z=.3 R0=1.0 917.6736 8.7048 -0.8696 2.9079 12 0.0200 0.1543 0.5576 0.0294
b=.5 z=.3 R0=0.5 917.6736 8.7048 -0.8696 2.9079 12 0.0200 0.1543 0.5576 0.0294
b=.5 z=.3 R0=0.2 917.6736 8.7048 -0.8696 2.9079 12 0.0200 0.1543 0.5576 0.0294
b=2 z=.4 scalar_z 971.5229 20.8426 -0.8686 2.9051 22 0.0954 0.0294 0.5476 0.0047
b=2 z=.4 vector_z 971.5229 20.8426 -0.8686 2.9051 22 0.0954 0.0294 0.5476 0.0047
b=2 z=.4 y 971.5229 20.8426 -0.8686 2.9051 22 0.0954 0.0171 0.5476 0.0013
b=3 z=.2 larger_pt 980.4398 27.1382 -0.8675 2.9053 25 0.2092 0.0047 0.8353 0.0014
b=3 z=.2 larger_mt 980.4398 27.1382 -0.8675 2.9053 25 0.2092 0.0047 0.8353 0.0014
b=3 z=.2 larger_m 980.4398 27.1382 -0.8675 2.9053 25 0.2092 0.0047 0.8353 0.0014
b=2 z=.1 mu=1.0 980.4398 27.1382 -0.8675 2.9053 25 0.2092 0.0047 0.8353 0.0014
b=2 z=.1 mu=0.8 971.5229 20.8426 -0.8686 2.9051 22 0.0954 0.0294 0.5476 0.0047
b=2 z=.1 mu=0.5 446.5813 1.0182 -0.8678 2.9069 2 0.0030 0.4251 0.4848 0.2031
b=2.0 z=.2 kT 983.3873 39.9912 -0.8673 2.9051 35 0.1119 0.0377 0.5030 0.0000
b=1.0 z=.2 kT 983.3873 39.9912 -0.8673 2.9051 35 0.1119 0.0377 0.5030 0.0000
b=0.5 z=.2 kT 946.4934 20.1170 -0.8699 2.9084 21 0.0233 0.1579 0.5951 0.0377
b=2.0 z=.4 kT 983.3873 39.9912 -0.8673 2.9051 35 0.1119 0.0377 0.5030 0.0000
b=1.0 z=.4 kT 946.4934 20.1170 -0.8699 2.9084 21 0.0233 0.1579 0.5951 0.0377
b=0.5 z=.4 kT 946.4934 20.1170 -0.8699 2.9084 21 0.0233 0.1579 0.5951 0.0377
---------------------------------------------------------------------------------------------
Analyzing Jet 2:
---------------------------------------------------------------------------------------------
name pt m y phi constit delta_R sym mu mxdropz
Original Jet 908.0979 87.7124 0.2195 6.0349 47
beta=2.0 zcut=.1 887.9353 11.3171 0.2232 6.0303 15 0.1116 0.0044 0.7910 0.0104
beta=1.0 zcut=.1 884.0262 8.9520 0.2228 6.0306 14 0.0570 0.0067 0.8862 0.0104
beta=0.5 zcut=.1 872.2856 7.0426 0.2230 6.0308 12 0.0346 0.0232 0.7445 0.0104
beta=2.0 zcut=.2 887.9353 11.3171 0.2232 6.0303 15 0.1116 0.0044 0.7910 0.0104
beta=1.0 zcut=.2 872.2856 7.0426 0.2230 6.0308 12 0.0346 0.0232 0.7445 0.0104
beta=0.5 zcut=.2 852.0552 5.2435 0.2230 6.0300 10 0.0154 0.0608 0.7701 0.0232
MMDT-like zcut=.1 800.2694 4.0381 0.2230 6.0310 9 0.0101 0.2350 0.2291 0.0608
MMDT-like zcut=.2 800.2694 4.0381 0.2230 6.0310 9 0.0101 0.2350 0.2291 0.0608
MMDT-like zcut=.3 ---- untagged jet ----
MMDT-like zcut=.4 ---- untagged jet ----
beta=-2.0 zcut=.05 ---- untagged jet ----
beta=-1.0 zcut=.05 ---- untagged jet ----
beta=-0.5 zcut=.05 ---- untagged jet ----
b=.5 z=.3 R0=1.0 852.0552 5.2435 0.2230 6.0300 10 0.0154 0.0608 0.7701 0.0232
b=.5 z=.3 R0=0.5 852.0552 5.2435 0.2230 6.0300 10 0.0154 0.0608 0.7701 0.0232
b=.5 z=.3 R0=0.2 800.2694 4.0381 0.2230 6.0310 9 0.0101 0.2350 0.2291 0.0608
b=2 z=.4 scalar_z 884.0262 8.9520 0.2228 6.0306 14 0.0570 0.0067 0.8862 0.0104
b=2 z=.4 vector_z 884.0262 8.9520 0.2228 6.0306 14 0.0570 0.0067 0.8862 0.0104
b=2 z=.4 y 884.0262 8.9520 0.2228 6.0306 14 0.0570 0.0014 0.8862 0.0050
b=3 z=.2 larger_pt 887.9353 11.3171 0.2232 6.0303 15 0.1116 0.0044 0.7910 0.0104
b=3 z=.2 larger_mt 887.9353 11.3171 0.2232 6.0303 15 0.1116 0.0044 0.7910 0.0104
b=3 z=.2 larger_m 887.9353 11.3171 0.2232 6.0303 15 0.1116 0.0044 0.7910 0.0104
b=2 z=.1 mu=1.0 887.9353 11.3171 0.2232 6.0303 15 0.1116 0.0044 0.7910 0.0104
b=2 z=.1 mu=0.8 887.9353 11.3171 0.2232 6.0303 15 0.1116 0.0044 0.7910 0.0104
b=2 z=.1 mu=0.5 800.2694 4.0381 0.2230 6.0310 9 0.0101 0.2350 0.2291 0.0608
b=2.0 z=.2 kT 900.1551 59.2173 0.2190 6.0292 31 0.0176 0.2314 0.8689 0.0104
b=1.0 z=.2 kT 900.1551 59.2173 0.2190 6.0292 31 0.0176 0.2314 0.8689 0.0104
b=0.5 z=.2 kT 900.1551 59.2173 0.2190 6.0292 31 0.0176 0.2314 0.8689 0.0104
b=2.0 z=.4 kT 900.1551 59.2173 0.2190 6.0292 31 0.0176 0.2314 0.8689 0.0104
b=1.0 z=.4 kT 900.1551 59.2173 0.2190 6.0292 31 0.0176 0.2314 0.8689 0.0104
b=0.5 z=.4 kT 900.1551 59.2173 0.2190 6.0292 31 0.0176 0.2314 0.8689 0.0104
---------------------------------------------------------------------------------------------
Analyzing Jet 3:
---------------------------------------------------------------------------------------------
name pt m y phi constit delta_R sym mu mxdropz
Original Jet 72.9429 23.4022 -1.1908 6.1199 43
beta=2.0 zcut=.1 71.5847 20.0943 -1.1761 6.1254 37 0.6803 0.0730 0.5627 0.0111
beta=1.0 zcut=.1 71.5847 20.0943 -1.1761 6.1254 37 0.6803 0.0730 0.5627 0.0111
beta=0.5 zcut=.1 67.3730 11.3061 -1.1810 6.0789 29 0.3790 0.0855 0.6966 0.0730
beta=2.0 zcut=.2 67.3730 11.3061 -1.1810 6.0789 29 0.3790 0.0855 0.6966 0.0730
beta=1.0 zcut=.2 67.3730 11.3061 -1.1810 6.0789 29 0.3790 0.0855 0.6966 0.0730
beta=0.5 zcut=.2 57.6019 5.9671 -1.1998 6.1138 16 0.1161 0.2463 0.7416 0.0855
MMDT-like zcut=.1 57.6019 5.9671 -1.1998 6.1138 16 0.1161 0.2463 0.7416 0.0855
MMDT-like zcut=.2 57.6019 5.9671 -1.1998 6.1138 16 0.1161 0.2463 0.7416 0.0855
MMDT-like zcut=.3 43.4356 4.4251 -1.2213 6.0950 13 0.1136 0.4598 0.5944 0.2463
MMDT-like zcut=.4 43.4356 4.4251 -1.2213 6.0950 13 0.1136 0.4598 0.5944 0.2463
beta=-2.0 zcut=.05 ---- untagged jet ----
beta=-1.0 zcut=.05 43.4356 4.4251 -1.2213 6.0950 13 0.1136 0.4598 0.5944 0.2463
beta=-0.5 zcut=.05 71.5847 20.0943 -1.1761 6.1254 37 0.6803 0.0730 0.5627 0.0111
b=.5 z=.3 R0=1.0 57.6019 5.9671 -1.1998 6.1138 16 0.1161 0.2463 0.7416 0.0855
b=.5 z=.3 R0=0.5 57.6019 5.9671 -1.1998 6.1138 16 0.1161 0.2463 0.7416 0.0855
b=.5 z=.3 R0=0.2 57.6019 5.9671 -1.1998 6.1138 16 0.1161 0.2463 0.7416 0.0855
b=2 z=.4 scalar_z 67.3730 11.3061 -1.1810 6.0789 29 0.3790 0.0855 0.6966 0.0730
b=2 z=.4 vector_z 67.3730 11.3061 -1.1810 6.0789 29 0.3790 0.0859 0.6966 0.0741
b=2 z=.4 y 57.6019 5.9671 -1.1998 6.1138 16 0.1161 0.0763 0.7416 0.0376
b=3 z=.2 larger_pt 71.5847 20.0943 -1.1761 6.1254 37 0.6803 0.0730 0.5627 0.0111
b=3 z=.2 larger_mt 71.5847 20.0943 -1.1761 6.1254 37 0.6803 0.0730 0.5627 0.0111
b=3 z=.2 larger_m 71.5847 20.0943 -1.1761 6.1254 37 0.6803 0.0730 0.5627 0.0111
b=2 z=.1 mu=1.0 71.5847 20.0943 -1.1761 6.1254 37 0.6803 0.0730 0.5627 0.0111
b=2 z=.1 mu=0.8 71.5847 20.0943 -1.1761 6.1254 37 0.6803 0.0730 0.5627 0.0111
- b=2 z=.1 mu=0.5 ---- untagged jet ----
+ b=2 z=.1 mu=0.5 10.2806 0.1396 -1.1761 6.0554 1 0.0000 0.0000 0.0000 0.4598
b=2.0 z=.2 kT 72.9429 23.4022 -1.1908 6.1199 43 0.2517 0.3453 0.4508 0.0000
b=1.0 z=.2 kT 72.9429 23.4022 -1.1908 6.1199 43 0.2517 0.3453 0.4508 0.0000
b=0.5 z=.2 kT 72.9429 23.4022 -1.1908 6.1199 43 0.2517 0.3453 0.4508 0.0000
b=2.0 z=.4 kT 72.9429 23.4022 -1.1908 6.1199 43 0.2517 0.3453 0.4508 0.0000
b=1.0 z=.4 kT 72.9429 23.4022 -1.1908 6.1199 43 0.2517 0.3453 0.4508 0.0000
b=0.5 z=.4 kT 72.9429 23.4022 -1.1908 6.1199 43 0.2517 0.3453 0.4508 0.0000
Index: contrib/contribs/RecursiveTools/trunk/ChangeLog
===================================================================
--- contrib/contribs/RecursiveTools/trunk/ChangeLog (revision 1051)
+++ contrib/contribs/RecursiveTools/trunk/ChangeLog (revision 1052)
@@ -1,427 +1,439 @@
+2017-09-06 Gregory Soyez <soyez@fastjet.fr>
+
+ * 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
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/RecursiveSymmetryCutBase.cc
===================================================================
--- contrib/contribs/RecursiveTools/trunk/RecursiveSymmetryCutBase.cc (revision 1051)
+++ contrib/contribs/RecursiveTools/trunk/RecursiveSymmetryCutBase.cc (revision 1052)
@@ -1,448 +1,431 @@
// $Id$
//
// Copyright (c) 2014-, Gavin P. Salam, Gregory Soyez, Jesse Thaler
//
//----------------------------------------------------------------------
// This file is part of FastJet contrib.
//
// It is free software; you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2 of the License, or (at
// your option) any later version.
//
// It is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
// or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
// License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this code. If not, see <http://www.gnu.org/licenses/>.
//----------------------------------------------------------------------
#include "RecursiveSymmetryCutBase.hh"
#include "fastjet/JetDefinition.hh"
#include "fastjet/ClusterSequenceAreaBase.hh"
#include <cassert>
#include <algorithm>
#include <cstdlib>
using namespace std;
FASTJET_BEGIN_NAMESPACE // defined in fastjet/internal/base.hh
namespace contrib{
LimitedWarning RecursiveSymmetryCutBase::_negative_mass_warning;
LimitedWarning RecursiveSymmetryCutBase::_mu2_gt1_warning;
//LimitedWarning RecursiveSymmetryCutBase::_nonca_warning;
LimitedWarning RecursiveSymmetryCutBase::_explicit_ghost_warning;
bool RecursiveSymmetryCutBase::_verbose = false;
//----------------------------------------------------------------------
PseudoJet RecursiveSymmetryCutBase::result(const PseudoJet & jet) const {
// construct the input jet (by default, recluster with C/A)
if (! jet.has_constituents()){
throw Error("RecursiveSymmetryCutBase can only be applied to jets with constituents");
}
PseudoJet j =
_do_reclustering
? _recluster ? (*_recluster)(jet)
: Recluster(cambridge_algorithm, JetDefinition::max_allowable_R)(jet)
: jet;
// sanity check: the jet must have a valid CS
if (! j.has_valid_cluster_sequence()){
throw Error("RecursiveSymmetryCutBase can only be applied to jets associated to a (valid) cluster sequence");
}
// check that area information is there in case we have a subtractor
// GS: do we really need this since subtraction may not require areas?
if (_subtractor) {
const ClusterSequenceAreaBase * csab =
dynamic_cast<const ClusterSequenceAreaBase *>(j.associated_cs());
if (csab == 0 || (!csab->has_explicit_ghosts()))
_explicit_ghost_warning.warn("RecursiveSymmetryCutBase: there is no clustering sequence, or it lacks explicit ghosts: subtraction is not guaranteed to function properly");
}
// establish the first subjet and optionally subtract it
PseudoJet subjet = j;
if (_subtractor && (!_input_jet_is_subtracted)) {
subjet = (*_subtractor)(subjet);
}
// variables for tracking what will happen
PseudoJet piece1, piece2;
// vectors for storing optional verbose structure
// these hold the deltaR, symmetry, and mu values of dropped branches
std::vector<double> dropped_delta_R;
std::vector<double> dropped_symmetry;
std::vector<double> dropped_mu;
double sym, mu2;
// now recurse into the jet's structure
RecursionStatus status;
while ((status=recurse_one_step(subjet, piece1, piece2, sym, mu2)) != recursion_success) {
// start with sanity checks:
- if (status == recursion_issue){
+ if ((status == recursion_issue) || (status == recursion_no_parents)) {
// we should return piece1 by our convention for recurse_one_step
- PseudoJet result = piece1;
+ PseudoJet result;
+ if (status == recursion_issue){
+ result = piece1;
+ if (_verbose) cout << "reached end; returning null jet " << endl;
+ } else {
+ result = _result_no_substructure(piece1);
+ if (_verbose) cout << "no parents found; returning last PJ or empty jet" << endl;
+ }
- if (_verbose) cout << "reached end; returning null jet " << endl;
-
if (result != 0) {
// if in grooming mode, add dummy structure information
StructureType * structure = new StructureType(result);
structure->_symmetry = 0.0;
structure->_mu = 0.0;
structure->_delta_R = 0.0;
if (_verbose_structure) { // still want to store verbose information about dropped branches
structure->_has_verbose = true;
structure->_dropped_symmetry = dropped_symmetry;
structure->_dropped_mu = dropped_mu;
structure->_dropped_delta_R = dropped_delta_R;
}
result.set_structure_shared_ptr(SharedPtr<PseudoJetStructureBase>(structure));
}
return result;
}
- if (status == recursion_no_parents){
- // end of the recursion
- PseudoJet result = _result_no_substructure(piece1);
-
- if (_verbose) cout << "no parents found; returning last PJ or empty jet" << endl;
-
- if (result !=0){
- StructureType * structure = new StructureType(result);
- structure->_symmetry = 0.0;
- structure->_mu = 0.0;
- structure->_delta_R = 0.0;
- if (_verbose_structure) { // still want to store verbose information about dropped branches
- structure->_has_verbose = true;
- structure->_dropped_symmetry = dropped_symmetry;
- structure->_dropped_mu = dropped_mu;
- structure->_dropped_delta_R = dropped_delta_R;
- }
- result.set_structure_shared_ptr(SharedPtr<PseudoJetStructureBase>(structure));
- }
- return result;
- }
-
assert(status == recursion_dropped);
// if desired, store information about dropped branches before recursing
if (_verbose_structure) {
dropped_delta_R.push_back(piece1.delta_R(piece2));
dropped_symmetry.push_back(sym);
dropped_mu.push_back((mu2 >= 0) ? sqrt(mu2) : -sqrt(-mu2));
}
subjet = piece1;
}
// we've tagged the splitting, return the jet with its substructure
StructureType * structure = new StructureType(subjet);
structure->_symmetry = sym;
structure->_mu = (mu2 >= 0) ? sqrt(mu2) : -sqrt(-mu2);
structure->_delta_R = piece1.delta_R(piece2);
if (_verbose_structure) {
structure->_has_verbose = true;
structure->_dropped_symmetry = dropped_symmetry;
structure->_dropped_mu = dropped_mu;
structure->_dropped_delta_R = dropped_delta_R;
}
subjet.set_structure_shared_ptr(SharedPtr<PseudoJetStructureBase>(structure));
return subjet;
}
//----------------------------------------------------------------------
// the method below is the one actually performing one step of the
// recursion.
//
// It returns a status code (defined above)
//
// In case of success, all the information is filled
// In case of "no parents", piee1 is the same subjet
// In case of trouble, piece2 will be a 0 PJ and piece1 is the PJ we
// should return (either 0 itself if the issue was critical, or
// non-wero in case of a minor issue just causing the recursion to
// stop)
RecursiveSymmetryCutBase::RecursionStatus
RecursiveSymmetryCutBase::recurse_one_step(const PseudoJet & subjet,
PseudoJet &piece1, PseudoJet &piece2,
double &sym, double &mu2,
void *extra_parameters) const {
bool use_mu_cut = (_mu_cut != numeric_limits<double>::infinity());
if (!subjet.has_parents(piece1, piece2)){
piece1 = subjet;
piece2 = PseudoJet();
return recursion_no_parents;
}
// first sanity check:
// - zero or negative pts are not allowed for the input subjet
// - zero or negative masses are not allowed for configurations
// in which the mass will effectively appear in a denominator
// (The masses will be checked later)
if (subjet.pt2() <= 0){ // this is a critical problem, return an empty PJ
piece1 = piece2 = PseudoJet();
return recursion_issue;
}
if (_subtractor) {
piece1 = (*_subtractor)(piece1);
piece2 = (*_subtractor)(piece2);
}
// determine the symmetry parameter
if (_symmetry_measure == y) {
// the original d_{ij}/m^2 choice from MDT
// first make sure the mass is sensible
if (subjet.m2() <= 0) {
_negative_mass_warning.warn("RecursiveSymmetryCutBase: cannot calculate y, because (sub)jet mass is negative; bailing out");
// since rounding errors can give -ve masses, be a it more
// tolerant and consider that no substructure has been found
piece1 = _result_no_substructure(subjet);
piece2 = PseudoJet();
return recursion_issue;
}
sym = piece1.kt_distance(piece2) / subjet.m2();
} else if (_symmetry_measure == vector_z) {
// min(pt1, pt2)/(pt), where the denominator is a vector sum
// of the two subjets
sym = min(piece1.pt(), piece2.pt()) / subjet.pt();
} else if (_symmetry_measure == scalar_z) {
// min(pt1, pt2)/(pt1+pt2), where the denominator is a scalar sum
// of the two subjets
double pt1 = piece1.pt();
double pt2 = piece2.pt();
// make sure denominator is non-zero
sym = pt1 + pt2;
if (sym == 0){ // this is a critical problem, return an empty PJ
piece1 = piece2 = PseudoJet();
return recursion_issue;
}
sym = min(pt1, pt2) / sym;
} else {
throw Error ("Unrecognized choice of symmetry_measure");
}
// determine the symmetry cut
// (This function is specified in the derived classes)
double this_symmetry_cut = symmetry_cut_fn(piece1, piece2, extra_parameters);
// and make a first tagging decision based on symmetry cut
bool tagged = (sym > this_symmetry_cut);
// if tagged based on symmetry cut, then check the mu cut (if relevant)
// and update the tagging decision. Calculate mu^2 regardless, for cases
// of users not cutting on mu2, but still interested in its value.
mu2 = max(piece1.m2(), piece2.m2())/subjet.m2();
if (tagged && use_mu_cut) {
// first a sanity check -- mu2 won't be sensible if the subjet mass
// is negative, so we can't then trust the mu cut - bail out
if (subjet.m2() <= 0) {
_negative_mass_warning.warn("RecursiveSymmetryCutBase: cannot trust mu, because (sub)jet mass is negative; bailing out");
piece1 = piece2 = PseudoJet();
return recursion_issue;
}
if (mu2 > 1) _mu2_gt1_warning.warn("RecursiveSymmetryCutBase encountered mu^2 value > 1");
if (mu2 > pow(_mu_cut,2)) tagged = false;
}
// we'll continue unclustering, allowing for the different
// ways of choosing which parent to look into
if (_recursion_choice == larger_pt) {
if (piece1.pt2() < piece2.pt2()) std::swap(piece1, piece2);
} else if (_recursion_choice == larger_mt) {
if (piece1.mt2() < piece2.mt2()) std::swap(piece1, piece2);
} else if (_recursion_choice == larger_m) {
if (piece1.m2() < piece2.m2()) std::swap(piece1, piece2);
} else {
throw Error ("Unrecognized value for recursion_choice");
}
return tagged ? recursion_success : recursion_dropped;
}
//----------------------------------------------------------------------
string RecursiveSymmetryCutBase::description() const {
ostringstream ostr;
ostr << "Recursive " << (_grooming_mode ? "Groomer" : "Tagger") << " with a symmetry cut ";
switch(_symmetry_measure) {
case y:
ostr << "y"; break;
case scalar_z:
ostr << "scalar_z"; break;
case vector_z:
ostr << "vector_z"; break;
default:
cerr << "failed to interpret symmetry_measure" << endl; exit(-1);
}
ostr << " > " << symmetry_cut_description();
if (_mu_cut != numeric_limits<double>::infinity()) {
ostr << ", mass-drop cut mu=max(m1,m2)/m < " << _mu_cut;
} else {
ostr << ", no mass-drop requirement";
}
ostr << ", recursion into the subjet with larger ";
switch(_recursion_choice) {
case larger_pt:
ostr << "pt"; break;
case larger_mt:
ostr << "mt(=sqrt(m^2+pt^2))"; break;
case larger_m:
ostr << "mass"; break;
default:
cerr << "failed to interpret recursion_choice" << endl; exit(-1);
}
if (_subtractor) {
ostr << " and subtractor: " << _subtractor->description();
if (_input_jet_is_subtracted) {ostr << " (input jet is assumed already subtracted)";}
}
return ostr.str();
}
// decide what to return when no substructure has been found
PseudoJet RecursiveSymmetryCutBase::_result_no_substructure(const PseudoJet &last_parent) const{
if (_grooming_mode){
// in grooming mode, return the last parent
return last_parent;
} else {
// in tagging mode, return an empty PseudoJet
return PseudoJet();
}
}
//========================================================================
// implementation of the details of the structure
// the number of dropped subjets
int RecursiveSymmetryCutBase::StructureType::dropped_count(bool global) const {
check_verbose("dropped_count()");
if (global && _is_composite){
vector<PseudoJet> all_pieces = pieces(PseudoJet()); // for composite jet, the argument is not used
assert(all_pieces.size() == 2);
return _dropped_delta_R.size()
+all_pieces[0].structure_of<RecursiveSymmetryCutBase>().dropped_count(true)
+all_pieces[1].structure_of<RecursiveSymmetryCutBase>().dropped_count(true);
}
return _dropped_delta_R.size();
}
// the delta_R of all the dropped subjets
vector<double> RecursiveSymmetryCutBase::StructureType::dropped_delta_R(bool global) const {
check_verbose("dropped_delta_R()");
if (global && _is_composite){
vector<PseudoJet> all_pieces = pieces(PseudoJet()); // for composite jet, the argument is not used
assert(all_pieces.size() == 2);
vector<double> all_dropped = all_pieces[0].structure_of<RecursiveSymmetryCutBase>().dropped_delta_R(true);
vector<double> all_dropped2 = all_pieces[1].structure_of<RecursiveSymmetryCutBase>().dropped_delta_R(true);
all_dropped.insert(all_dropped.end(), all_dropped2.begin(), all_dropped2.end());
all_dropped.insert(all_dropped.end(), _dropped_delta_R.begin(), _dropped_delta_R.end());
return all_dropped;
}
return _dropped_delta_R;
}
// the symmetry of all the dropped subjets
vector<double> RecursiveSymmetryCutBase::StructureType::dropped_symmetry(bool global) const {
check_verbose("dropped_symmetry()");
if (global && _is_composite){
vector<PseudoJet> all_pieces = pieces(PseudoJet()); // for composite jet, the argument is not used
assert(all_pieces.size() == 2);
vector<double> all_dropped = all_pieces[0].structure_of<RecursiveSymmetryCutBase>().dropped_symmetry(true);
vector<double> all_dropped2 = all_pieces[1].structure_of<RecursiveSymmetryCutBase>().dropped_symmetry(true);
all_dropped.insert(all_dropped.end(), all_dropped2.begin(), all_dropped2.end());
all_dropped.insert(all_dropped.end(), _dropped_symmetry.begin(), _dropped_symmetry.end());
return all_dropped;
}
return _dropped_symmetry;
}
// the mu of all the dropped subjets
vector<double> RecursiveSymmetryCutBase::StructureType::dropped_mu(bool global) const {
check_verbose("dropped_mu()");
if (global && _is_composite){
vector<PseudoJet> all_pieces = pieces(PseudoJet()); // for composite jet, the argument is not used
assert(all_pieces.size() == 2);
vector<double> all_dropped = all_pieces[0].structure_of<RecursiveSymmetryCutBase>().dropped_mu(true);
vector<double> all_dropped2 = all_pieces[1].structure_of<RecursiveSymmetryCutBase>().dropped_mu(true);
all_dropped.insert(all_dropped.end(), all_dropped2.begin(), all_dropped2.end());
all_dropped.insert(all_dropped.end(), _dropped_mu.begin(), _dropped_mu.end());
return all_dropped;
}
return _dropped_mu;
}
// the maximum of the symmetry over the dropped subjets
double RecursiveSymmetryCutBase::StructureType::max_dropped_symmetry(bool global) const {
check_verbose("max_dropped_symmetry()");
if (global && _is_composite){
vector<PseudoJet> all_pieces = pieces(PseudoJet()); // for composite jet, the argument is not used
assert(all_pieces.size() == 2);
double local_max = (_dropped_symmetry.size() == 0)
? 0.0 : *max_element(_dropped_symmetry.begin(),_dropped_symmetry.end());
return max(local_max, max(all_pieces[0].structure_of<RecursiveSymmetryCutBase>().max_dropped_symmetry(true),
all_pieces[1].structure_of<RecursiveSymmetryCutBase>().max_dropped_symmetry(true)));
}
if (_dropped_symmetry.size() == 0) return 0.0;
return *max_element(_dropped_symmetry.begin(),_dropped_symmetry.end());
}
//------------------------------------------------------------------------
// helper class to sort by decreasing thetag
class SortRecursiveSoftDropStructureZgThetagPair{
public:
bool operator()(const pair<double, double> &p1, const pair<double, double> &p2) const{
return p1.second > p2.second;
}
};
//------------------------------------------------------------------------
// the (zg,thetag) pairs of all the dropped subjets, ordered from largest to smallest thetag
vector<pair<double,double> > RecursiveSymmetryCutBase::StructureType::sorted_zg_and_thetag() const {
check_verbose("sorted_zg_and_thetag()");
vector<pair<double, double> > all;
if (_is_composite){
vector<double> all_thetag = dropped_delta_R();
vector<double> all_zg = dropped_symmetry();
unsigned int n = all_zg.size();
assert(all_thetag.size() == n);
all.reserve(n);
for (unsigned int i=0;i<n;++i)
all.push_back(pair<double,double>(all_zg[i], all_thetag[i]));
} else {
unsigned int n = _dropped_symmetry.size();
assert(_dropped_delta_R.size() == n);
all.reserve(n);
for (unsigned int i=0;i<n;++i)
all.push_back(pair<double,double>(_dropped_symmetry[i], _dropped_delta_R[i]));
}
sort(all.begin(), all.end(), SortRecursiveSoftDropStructureZgThetagPair());
return all;
}
} // namespace contrib
FASTJET_END_NAMESPACE

File Metadata

Mime Type
text/x-diff
Expires
Wed, May 14, 10:27 AM (1 d, 20 h)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
5111142
Default Alt Text
(44 KB)

Event Timeline