| 1 | #ifndef __FASTJET_CONTRIB_TOOLS_RECLUSTER_HH__
|
|---|
| 2 | #define __FASTJET_CONTRIB_TOOLS_RECLUSTER_HH__
|
|---|
| 3 |
|
|---|
| 4 | // $Id: Recluster.hh 723 2014-07-30 09:11:01Z gsoyez $
|
|---|
| 5 | //
|
|---|
| 6 | // Copyright (c) 2014-, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
|
|---|
| 7 | //
|
|---|
| 8 | //----------------------------------------------------------------------
|
|---|
| 9 | // This file is part of FastJet contrib.
|
|---|
| 10 | //
|
|---|
| 11 | // It is free software; you can redistribute it and/or modify it under
|
|---|
| 12 | // the terms of the GNU General Public License as published by the
|
|---|
| 13 | // Free Software Foundation; either version 2 of the License, or (at
|
|---|
| 14 | // your option) any later version.
|
|---|
| 15 | //
|
|---|
| 16 | // It is distributed in the hope that it will be useful, but WITHOUT
|
|---|
| 17 | // ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
|---|
| 18 | // or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
|
|---|
| 19 | // License for more details.
|
|---|
| 20 | //
|
|---|
| 21 | // You should have received a copy of the GNU General Public License
|
|---|
| 22 | // along with this code. If not, see <http://www.gnu.org/licenses/>.
|
|---|
| 23 | //----------------------------------------------------------------------
|
|---|
| 24 |
|
|---|
| 25 | #include <fastjet/JetDefinition.hh>
|
|---|
| 26 | #include <fastjet/CompositeJetStructure.hh> // to derive the ReclusterStructure from CompositeJetStructure
|
|---|
| 27 | #include <fastjet/tools/Transformer.hh> // to derive Recluster from Transformer
|
|---|
| 28 | #include <iostream>
|
|---|
| 29 | #include <string>
|
|---|
| 30 |
|
|---|
| 31 | FASTJET_BEGIN_NAMESPACE // defined in fastjet/internal/base.hh
|
|---|
| 32 |
|
|---|
| 33 | namespace contrib{
|
|---|
| 34 |
|
|---|
| 35 | //----------------------------------------------------------------------
|
|---|
| 36 | /// \class Recluster
|
|---|
| 37 | /// Class that helps reclustering a jet with a new jet definition
|
|---|
| 38 | ///
|
|---|
| 39 | /// The result of the reclustering is returned as a single PseudoJet
|
|---|
| 40 | /// with a CompositeJet structure. The pieces of that PseudoJet will
|
|---|
| 41 | /// be the individual subjets
|
|---|
| 42 | ///
|
|---|
| 43 | /// When constructed from a JetDefinition, that definition will be
|
|---|
| 44 | /// used to obtain the subjets. When constructed from a JetAlgorithm
|
|---|
| 45 | /// and parameters (0 parameters for e+e-, just R or R and an extra
|
|---|
| 46 | /// parameter for others) the recombination scheme will be taken as
|
|---|
| 47 | /// the same one used to initially cluster the original jet.
|
|---|
| 48 | ///
|
|---|
| 49 | /// The result of this transformer depends on its usage. There are two
|
|---|
| 50 | /// typical use-cases: either we recluster one fat jet into subjets,
|
|---|
| 51 | /// OR, we recluster the jet with a different jet alg. When Recluster
|
|---|
| 52 | /// is created from a full jet definition. The last parameter of the
|
|---|
| 53 | /// constructors below dicatate that behaviour: if "single" is true
|
|---|
| 54 | /// (the default), a single jet, issued from a regular clustering is
|
|---|
| 55 | /// returned (if there are more than one, the hardest is taken);
|
|---|
| 56 | /// otherwise (single==false), the result will be a composite jet with
|
|---|
| 57 | /// each subjet as pieces
|
|---|
| 58 | ///
|
|---|
| 59 | /// Open points for discussion:
|
|---|
| 60 | ///
|
|---|
| 61 | /// - do we add an option to force area support? [could be useful
|
|---|
| 62 | /// e.g. for the filter with a subtractor where area support is
|
|---|
| 63 | /// mandatory]
|
|---|
| 64 | ///
|
|---|
| 65 | class Recluster : public Transformer {
|
|---|
| 66 | public:
|
|---|
| 67 | /// define a recluster that decomposes a jet into subjets using a
|
|---|
| 68 | /// generic JetDefinition
|
|---|
| 69 | ///
|
|---|
| 70 | /// \param subjet_def the jet definition applied to obtain the subjets
|
|---|
| 71 | /// \param single when true, cluster the jet in a single jet (the
|
|---|
| 72 | /// hardest one) with an associated ClusterSequence,
|
|---|
| 73 | /// otherwise return a composite jet with subjets
|
|---|
| 74 | /// as pieces.
|
|---|
| 75 | Recluster(const JetDefinition & subjet_def, bool single=true)
|
|---|
| 76 | : _subjet_def(subjet_def), _use_full_def(true), _single(single) {}
|
|---|
| 77 |
|
|---|
| 78 | /// define a recluster that decomposes a jet into subjets using a
|
|---|
| 79 | /// JetAlgorithm and its parameters
|
|---|
| 80 | ///
|
|---|
| 81 | /// \param subjet_alg the jet algorithm applied to obtain the subjets
|
|---|
| 82 | /// \param subjet_radius the jet radius if required
|
|---|
| 83 | /// \param subjet_extra optional extra parameters for the jet algorithm (only when needed)
|
|---|
| 84 | /// \param single when true, cluster the jet in a single jet (the
|
|---|
| 85 | /// hardest one) with an associated ClusterSequence,
|
|---|
| 86 | /// otherwise return a composite jet with subjets
|
|---|
| 87 | /// as pieces.
|
|---|
| 88 | ///
|
|---|
| 89 | /// Typically, for e+e- algoriothm you should use the third version
|
|---|
| 90 | /// below with no parameters, for "standard" pp algorithms, just the
|
|---|
| 91 | /// clustering radius has to be specified and for genkt-type of
|
|---|
| 92 | /// algorithms, both the radius and the extra parameter have to be
|
|---|
| 93 | /// specified.
|
|---|
| 94 | Recluster(JetAlgorithm subjet_alg, double subjet_radius, double subjet_extra,
|
|---|
| 95 | bool single=true)
|
|---|
| 96 | : _subjet_alg(subjet_alg), _use_full_def(false),
|
|---|
| 97 | _subjet_radius(subjet_radius), _has_subjet_radius(true),
|
|---|
| 98 | _subjet_extra(subjet_extra), _has_subjet_extra(true), _single(single) {}
|
|---|
| 99 | Recluster(JetAlgorithm subjet_alg, double subjet_radius, bool single=true)
|
|---|
| 100 | : _subjet_alg(subjet_alg), _use_full_def(false),
|
|---|
| 101 | _subjet_radius(subjet_radius), _has_subjet_radius(true),
|
|---|
| 102 | _has_subjet_extra(false), _single(single) {}
|
|---|
| 103 | Recluster(JetAlgorithm subjet_alg, bool single=true)
|
|---|
| 104 | : _subjet_alg(subjet_alg), _use_full_def(false),
|
|---|
| 105 | _has_subjet_radius(false), _has_subjet_extra(false), _single(single) {}
|
|---|
| 106 |
|
|---|
| 107 | /// default dtor
|
|---|
| 108 | virtual ~Recluster(){};
|
|---|
| 109 |
|
|---|
| 110 | //----------------------------------------------------------------------
|
|---|
| 111 | // standard Transformer behaviour inherited from the base class
|
|---|
| 112 | // (i.e. result(), description() and structural info)
|
|---|
| 113 |
|
|---|
| 114 | /// runs the reclustering and sets kept and rejected to be the jets of interest
|
|---|
| 115 | /// (with non-zero rho, they will have been subtracted).
|
|---|
| 116 | ///
|
|---|
| 117 | /// \param jet the jet that gets reclustered
|
|---|
| 118 | /// \return the reclustered jet
|
|---|
| 119 | virtual PseudoJet result(const PseudoJet & jet) const;
|
|---|
| 120 |
|
|---|
| 121 | /// class description
|
|---|
| 122 | virtual std::string description() const;
|
|---|
| 123 |
|
|---|
| 124 | // the type of the associated structure
|
|---|
| 125 | typedef CompositeJetStructure StructureType;
|
|---|
| 126 |
|
|---|
| 127 | private:
|
|---|
| 128 | /// set the reclustered elements in the simple case of C/A+C/A
|
|---|
| 129 | void _recluster_cafilt(const std::vector<PseudoJet> & all_pieces,
|
|---|
| 130 | std::vector<PseudoJet> & subjets,
|
|---|
| 131 | double Rfilt) const;
|
|---|
| 132 |
|
|---|
| 133 | /// set the reclustered elements in the generic re-clustering case
|
|---|
| 134 | void _recluster_generic(const PseudoJet & jet,
|
|---|
| 135 | std::vector<PseudoJet> & subjets,
|
|---|
| 136 | const JetDefinition & subjet_def,
|
|---|
| 137 | bool do_areas) const;
|
|---|
| 138 |
|
|---|
| 139 | // a series of checks
|
|---|
| 140 | //--------------------------------------------------------------------
|
|---|
| 141 | /// get the pieces down to the fundamental pieces
|
|---|
| 142 | bool _get_all_pieces(const PseudoJet &jet, std::vector<PseudoJet> &all_pieces) const;
|
|---|
| 143 |
|
|---|
| 144 | /// get the common recombiner to all pieces (NULL if none)
|
|---|
| 145 | const JetDefinition::Recombiner* _get_common_recombiner(const std::vector<PseudoJet> &all_pieces) const;
|
|---|
| 146 |
|
|---|
| 147 | /// construct the proper jet definition ensuring that the recombiner
|
|---|
| 148 | /// is taken from the underlying pieces (an error is thrown if the
|
|---|
| 149 | /// pieces do no share a common recombiner)
|
|---|
| 150 | void _build_jet_def_with_recombiner(const std::vector<PseudoJet> &all_pieces,
|
|---|
| 151 | JetDefinition &subjet_def) const;
|
|---|
| 152 |
|
|---|
| 153 | /// check if one can apply the simplified trick for C/A subjets
|
|---|
| 154 | bool _check_ca(const std::vector<PseudoJet> &all_pieces,
|
|---|
| 155 | const JetDefinition &subjet_def) const;
|
|---|
| 156 |
|
|---|
| 157 | /// check if the jet (or all its pieces) have explicit ghosts
|
|---|
| 158 | /// (assuming the jet has area support
|
|---|
| 159 | ///
|
|---|
| 160 | /// Note that if the jet has an associated cluster sequence that is no
|
|---|
| 161 | /// longer valid, an error will be thrown
|
|---|
| 162 | bool _check_explicit_ghosts(const std::vector<PseudoJet> &all_pieces) const;
|
|---|
| 163 |
|
|---|
| 164 | JetDefinition _subjet_def; ///< the jet definition to use to extract the subjets
|
|---|
| 165 | JetAlgorithm _subjet_alg; ///< the jet algorithm to be used
|
|---|
| 166 | bool _use_full_def; ///< true when the full JetDefinition is supplied to the ctor
|
|---|
| 167 | double _subjet_radius; ///< the jet radius (only if needed for the jet alg)
|
|---|
| 168 | bool _has_subjet_radius; ///< the subjet radius has been specified
|
|---|
| 169 | double _subjet_extra; ///< the jet alg extra param (only if needed)
|
|---|
| 170 | bool _has_subjet_extra; ///< the extra param has been specified
|
|---|
| 171 |
|
|---|
| 172 | bool _single; ///< (true) return a single jet with a
|
|---|
| 173 | ///< regular clustering or (false) a
|
|---|
| 174 | ///< composite jet with subjets as pieces
|
|---|
| 175 |
|
|---|
| 176 | static LimitedWarning _explicit_ghost_warning;
|
|---|
| 177 | };
|
|---|
| 178 |
|
|---|
| 179 | } // namespace contrib
|
|---|
| 180 |
|
|---|
| 181 | FASTJET_END_NAMESPACE // defined in fastjet/internal/base.hh
|
|---|
| 182 |
|
|---|
| 183 | #endif // __FASTJET_CONTRIB_TOOLS_RECLUSTER_HH__
|
|---|
