EIC code displayed by LXR master/​include/​fastjet/​contrib/​BottomUpSoftDrop.hh	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-18 09:57:13

 // $Id: BottomUpSoftDrop.hh 1085 2017-10-11 02:16:59Z jthaler $
 //
 // Copyright (c) 2017-, Gavin P. Salam, Gregory Soyez, Jesse Thaler,
 // Kevin Zhou, Frederic Dreyer
 //
 //----------------------------------------------------------------------
 // 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/>.
 //----------------------------------------------------------------------
 
 #ifndef __BOTTOMUPSOFTDROP_HH__
 #define __BOTTOMUPSOFTDROP_HH__
 
 #include "fastjet/ClusterSequence.hh"
 #include "fastjet/WrappedStructure.hh"
 #include "fastjet/tools/Transformer.hh"
 
 #include <iostream>
 #include <string>
 
 // TODO
 //
 //  - missing class description
 //
 //  - check what to do when pta=ptb=0
 //    for the moment, we recombine both for multiple reasons
 //     . this avois breakingteh symemtry between pa and pb
 //     . it would be groomed in later steps anyway
 //    Note that this is slightly inconsistent with our use of
 //    > (instead of >=) in the cdt 
 
 FASTJET_BEGIN_NAMESPACE
 
 namespace contrib{
   
 // fwd declarations
 class BottomUpSoftDrop;
 class BottomUpSoftDropStructure;
 class BottomUpSoftDropRecombiner;
 class BottomUpSoftDropPlugin;
 
 //----------------------------------------------------------------------
 /// \class BottomUpSoftDrop
 /// Implementation of the BottomUpSoftDrop transformer
 ///
 /// Bottom-Up Soft drop grooms a jet by applying a modified
 /// recombination scheme, where particles are recombined only if they
 /// pass the Soft Drop condition
 ///
 /// \f[
 ///   z < z_{\rm cut} (\theta/R0)^\beta
 /// \f]
 ///
 /// the groomed jet contains the particles remaining after this
 /// pair-wise recombination
 ///
 /// Note:
 ///  - one can use BottomUpSoftDrop on a full event with the
 ///    global_grooming(event) method.
 ///  - if two recombined particles a and b have momentum pta=ptb=0,
 ///    we recombine both.
 /// 
 
   
 class BottomUpSoftDrop : public Transformer {
 public:
   /// minimal constructor, which the jet algorithm to CA, sets the radius
   /// to JetDefinition::max_allowable_R (practically equivalent to
   /// infinity) and also tries to use a recombiner based on the one in
   /// the jet definition of the particular jet being Soft Dropped.
   ///
   ///  \param beta           the value for beta
   ///  \param symmetry_cut   the value for symmetry_cut
   ///  \param R0             the value for R0
   BottomUpSoftDrop(double beta, double symmetry_cut, double R0 = 1.0) 
     : _jet_def(cambridge_algorithm, JetDefinition::max_allowable_R),
       _beta(beta),_symmetry_cut(symmetry_cut), _R0(R0),
       _get_recombiner_from_jet(true) {}
 
   /// alternative constructor which takes a specified jet algorithm
   ///
   ///  \param jet_alg        the jet algorithm for the internal clustering (uses R=infty)
   ///  \param symmetry_cut   the value of symmetry_cut
   ///  \param beta           the value for beta
   ///  \param R0             the value for R0
   BottomUpSoftDrop(const JetAlgorithm jet_alg, double beta, double symmetry_cut,
            double R0 = 1.0) 
     : _jet_def(jet_alg, JetDefinition::max_allowable_R),
       _beta(beta), _symmetry_cut(symmetry_cut), _R0(R0),
       _get_recombiner_from_jet(true) {}
 
 
   /// alternative ctor in which the full reclustering jet definition can
   /// be specified.
   ///
   ///  \param jet_def        the jet definition for the internal clustering
   ///  \param symmetry_cut   the value of symmetry_cut
   ///  \param beta           the value for beta
   ///  \param R0             the value for R0
   BottomUpSoftDrop(const JetDefinition &jet_def, double beta, double symmetry_cut,
            double R0 = 1.0)
     : _jet_def(jet_def), _beta(beta), _symmetry_cut(symmetry_cut), _R0(R0),
       _get_recombiner_from_jet(false) {}
 
   /// action on a single jet
   virtual PseudoJet result(const PseudoJet &jet) const;
 
   /// global grooming on a full event
   /// note: does not support jet areas
   virtual std::vector<PseudoJet> global_grooming(const std::vector<PseudoJet> & event) const;
   
   /// description
   virtual std::string description() const;
   
   // the type of the associated structure
   typedef BottomUpSoftDropStructure StructureType;
 
 private:
   /// check if the jet has explicit_ghosts (knowing that there is an
   /// area support)
   bool _check_explicit_ghosts(const PseudoJet &jet) const;
   
   /// see if there is a common recombiner among the pieces; if there
   /// is return true and set jet_def_for_recombiner so that the
   /// recombiner can be taken from that JetDefinition. Otherwise,
   /// return false. 'assigned' is initially false; when true, each
   /// time we meet a new jet definition, we'll check it shares the
   /// same recombiner as jet_def_for_recombiner.
   bool _check_common_recombiner(const PseudoJet &jet, 
                 JetDefinition &jet_def_for_recombiner,
                 bool assigned=false) const;
 
 
   JetDefinition _jet_def; ///< the internal jet definition
   double _beta;           ///< the value of beta
   double _symmetry_cut;   ///< the value of symmetry_cut
   double _R0;             ///< the value of R0
   bool   _get_recombiner_from_jet; ///< true for minimal constructor,
                                    ///< causes recombiner to be set equal 
                                    ///< to that already used in the jet 
                                    ///< (if it can be deduced)
 };
 
 //----------------------------------------------------------------------
 /// The structure associated with a PseudoJet thas has gone through a
 /// bottom/up SoftDrop transformer
 class BottomUpSoftDropStructure : public WrappedStructure{
 public:
   /// default ctor
   ///  \param result_jet  the jet for which we have to keep the structure
   BottomUpSoftDropStructure(const PseudoJet & result_jet)
     : WrappedStructure(result_jet.structure_shared_ptr()){}
 
   /// description
   virtual std::string description() const{
     return "Bottom/Up Soft Dropped PseudoJet";
   }
 
   /// return the constituents that have been rejected
   std::vector<PseudoJet> rejected() const{ 
     return validated_cs()->childless_pseudojets();
   }
 
   /// return the other jets that may have been found along with the
   /// result of the bottom/up Soft Drop
   /// The resulting vector is sorted in pt
   std::vector<PseudoJet> extra_jets() const {
     return sorted_by_pt((!SelectorNHardest(1))(validated_cs()->inclusive_jets()));
   }
 
   /// return the value of beta that was used for this specific Soft Drop.
   double beta() const {return _beta;}
 
   /// return the value of symmetry_cut that was used for this specific Soft Drop.
   double symmetry_cut() const {return _symmetry_cut;}
 
   /// return the value of R0 that was used for this specific Soft Drop.
   double R0() const {return _R0;}
 
 protected:
   friend class BottomUpSoftDrop; ///< to allow setting the internal information
 
 private:
   double _beta, _symmetry_cut, _R0;
 };
 
 //----------------------------------------------------------------------
 /// Class for Soft Drop recombination
 /// recombines the objects that are not vetoed by Bottom-Up SoftDrop
 ///
 /// This recombiner only recombines, using the provided 'recombiner',
 /// objects (i and j) that pass the following SoftDrop criterion:
 ///
 ///   min(pti, ptj) > zcut (pti+ptj) (theta_ij/R0)^beta
 ///
 /// If the criterion fail, the hardest of i and j is kept and the
 /// softest is rejected.
 ///
 /// Note that this in not meant for standalone use [in particular
 /// because it could lead to memory issues due to the rejected indices
 /// stored internally].
 ///
 /// This class is a direct adaptation of PruningRecombiner in Fastjet tools
 class BottomUpSoftDropRecombiner : public JetDefinition::Recombiner {
 public:
   /// ctor
   ///  \param symmetry_cut   value of cut on symmetry measure
   ///  \param beta   avalue of beta parameter
   ///  \param recomb pointer to a recombiner to use to cluster pairs
   BottomUpSoftDropRecombiner(double beta, double symmetry_cut, double R0,
                              const JetDefinition::Recombiner *recombiner)
     : _beta(beta), _symmetry_cut(symmetry_cut), _R0sqr(R0*R0),
       _recombiner(recombiner) {}
 
   /// perform a recombination taking into account the Soft Drop
   /// conditions
   virtual void recombine(const PseudoJet &pa, 
              const PseudoJet &pb,
              PseudoJet &pab) const;
 
   /// returns the description of the recombiner
   virtual std::string description() const {
     std::ostringstream oss;
     oss << "SoftDrop recombiner with symmetry_cut = " << _symmetry_cut
     << ", beta = " << _beta
     << ", and underlying recombiner = " << _recombiner->description();
     return oss.str();    
   }
 
   /// return the history indices that have been soft dropped away
   const std::vector<unsigned int> & rejected() const{ return _rejected;}
 
   /// clears the list of rejected indices
   ///
   /// If one decides to use this recombiner standalone, one has to
   /// call this after each clustering in order for the rejected() vector
   /// to remain sensible and not grow to infinite size.
   void clear_rejected(){ _rejected.clear();}
 
 private:
   double _beta;          ///< beta parameter
   double _symmetry_cut;  ///< value of symmetry_cut
   double _R0sqr;         ///< normalisation of the angular distance
   const JetDefinition::Recombiner *_recombiner; ///< the underlying recombiner to use
   mutable std::vector<unsigned int> _rejected;  ///< list of rejected history indices
 };
 
 //----------------------------------------------------------------------
 /// \class BottomUpSoftDropPlugin
 /// Class for a bottom/up Soft Drop algorithm, based on the Pruner plugin
 ///
 /// This is an internal plugin that clusters the particles using the
 /// BottomUpRecombiner. 
 ///
 /// See BottomUpRecombiner for a description of what bottom-up
 /// SoftDrop does.
 ///
 /// Note that this is an internal class used by the BottomUpSoftDrop
 /// transformer and it is not meant to be used as a standalone
 /// clustering tool.
 class BottomUpSoftDropPlugin : public JetDefinition::Plugin {
 public:
   /// ctor
   ///  \param jet_def the jet definition to be used for the 
   ///                 internal clustering
   ///  \param symmetry_cut    value of cut on symmetry measure
   ///  \param beta    value of beta parameter
   BottomUpSoftDropPlugin(const JetDefinition &jet_def, double beta, double symmetry_cut,
                          double R0 = 1.0)
     : _jet_def(jet_def), _beta(beta), _symmetry_cut(symmetry_cut), _R0(R0) {}
 
   /// the actual clustering work for the plugin
   virtual void run_clustering(ClusterSequence &input_cs) const;
 
   /// description of the plugin
   virtual std::string description() const;
 
   /// returns the radius
   virtual double R() const {return _jet_def.R();}
 
 private:
   JetDefinition _jet_def; ///< the internal jet definition
   double _beta;           ///< beta parameter
   double _symmetry_cut;   ///< value of symmetry_cut 
   double _R0;             ///< normalisation of the angular distance
 };
 
 }
 
 FASTJET_END_NAMESPACE      // defined in fastjet/internal/base.hh
 #endif // __BOTTOMUPSOFTDROP_HH__

This page was automatically generated by the 2.3.7 LXR engine. The LXR team