Changeset 35cdc46 in git for external/fastjet/tools/Pruner.cc

Timestamp:

Sep 3, 2014, 3:18:54 PM (10 years ago)

Author:

Pavel Demin <demin@…>

Branches:

ImprovedOutputFile, Timing, dual_readout, llp, master

Children:

be2222c

Parents:

5b5a56b

Message:

upgrade FastJet to version 3.1.0-beta.1, upgrade Nsubjettiness to version 2.1.0, add SoftKiller version 1.0.0

File:

• external/fastjet/tools/Pruner.cc (modified) (7 diffs)

external/fastjet/tools/Pruner.cc

@@ -1 @@
-//STARTHEADER
-// $Id$
-//
-// Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+//FJSTARTHEADER
+// $Id: Pruner.cc 3481 2014-07-29 17:24:12Z soyez $
+//
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
@@ -13 +13 @@
 //
 //  The algorithms that underlie FastJet have required considerable
-//  development and are described in hep-ph/0512210. If you use
+//  development. They are described in the original FastJet paper,
+//  hep-ph/0512210 and in the manual, arXiv:1111.6097. If you use
 //  FastJet as part of work towards a scientific publication, please
-//  include a citation to the FastJet paper.
+//  quote the version you use and include a citation to the manual and
+//  optionally also to hep-ph/0512210.
 //
 //  FastJet is distributed in the hope that it will be useful,
@@ -25 +27 @@
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
-//ENDHEADER
+//FJENDHEADER
 
 #include "fastjet/tools/Pruner.hh"
@@ -47 +49 @@
 //----------------------------------------------------------------------
 // alternative (dynamic) ctor
-//  \param jet_def the jet definition for the internal clustering
+//  \param jet_def     the jet definition for the internal clustering
 //  \param zcut_dyn    dynamic pt-fraction cut in the pruning
 //  \param Rcut_dyn    dynamic angular distance cut in the pruning
 Pruner::Pruner(const JetDefinition &jet_def, 
-         FunctionOfPseudoJet<double> *zcut_dyn,
-         FunctionOfPseudoJet<double> *Rcut_dyn)
+         const FunctionOfPseudoJet<double> *zcut_dyn,
+         const FunctionOfPseudoJet<double> *Rcut_dyn)
   : _jet_def(jet_def), _zcut(0), _Rcut_factor(0),
     _zcut_dyn(zcut_dyn), _Rcut_dyn(Rcut_dyn), _get_recombiner_from_jet(false)  {
@@ -74 +76 @@
   double zcut = (_zcut_dyn) ? (*_zcut_dyn)(jet) : _zcut;
   PruningPlugin * pruning_plugin;
+
   // for some constructors, we get the recombiner from the 
-  // input jet -- some acrobatics are needed (see plans for FJ3.1
-  // for a hopefully better solution).
+  // input jet -- some acrobatics are needed
   if (_get_recombiner_from_jet) {
-    const JetDefinition::Recombiner * common_recombiner = 
-                                              _get_common_recombiner(jet);
-    if (common_recombiner) {
-      JetDefinition jet_def = _jet_def;
-      if (typeid(*common_recombiner) == typeid(JetDefinition::DefaultRecombiner)) {
-        RecombinationScheme scheme = 
-          static_cast<const JetDefinition::DefaultRecombiner *>(common_recombiner)->scheme();
-        jet_def.set_recombination_scheme(scheme);
-      } else {
-        jet_def.set_recombiner(common_recombiner);
-      }
-      pruning_plugin = new PruningPlugin(jet_def, zcut, Rcut);
-    } else {
-      // if there wasn't a common recombiner, we just use the default
-      // recombiner that was in _jet_def
-      pruning_plugin = new PruningPlugin(_jet_def, zcut, Rcut);
-    }
+    JetDefinition jet_def = _jet_def;
+
+    // if all the pieces have a shared recombiner, we'll use that
+    // one. Otherwise, use the one from _jet_def as a fallback.
+    JetDefinition jet_def_for_recombiner;
+    if (_check_common_recombiner(jet, jet_def_for_recombiner)){
+      jet_def.set_recombiner(jet_def_for_recombiner);
+    }
+    pruning_plugin = new PruningPlugin(jet_def, zcut, Rcut);
   } else {
     pruning_plugin = new PruningPlugin(_jet_def, zcut, Rcut);
@@ -122 +116 @@
   PseudoJet result_local = SelectorNHardest(1)(cs->inclusive_jets())[0];
   PrunerStructure * s = new PrunerStructure(result_local);
+  s->_Rcut = Rcut;
+  s->_zcut = zcut;
   result_local.set_structure_shared_ptr(SharedPtr<PseudoJetStructureBase>(s));
   
@@ -155 +151 @@
 }
 
-// see if there is a common recombiner among the pieces; if there
-// is return a pointer to it; otherwise, return NULL.
-// 
-// NB: this way of doing things is not ideal, because quite some work
-//     is needed to get a correct handling of the final recombiner
-//     (e.g. default v. non-default). In future add
-//     set_recombiner(jet_def) to JetDefinition, maybe also add
-//     an invalid_scheme to the default recombiner and then 
-//     do all the work below directly with a JetDefinition directly
-//     together with JD::has_same_recombiner(...)
-const JetDefinition::Recombiner * Pruner::_get_common_recombiner(const PseudoJet &jet) const{
-  if (jet.has_associated_cluster_sequence())
-    return jet.validated_cs()->jet_def().recombiner();
+// 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 Pruner::_check_common_recombiner(const PseudoJet &jet, 
+                                      JetDefinition &jet_def_for_recombiner,
+                                      bool assigned) const{
+  if (jet.has_associated_cluster_sequence()){
+    // if the jet def for recombination has already been assigned, check if we have the same
+    if (assigned)
+      return jet.validated_cs()->jet_def().has_same_recombiner(jet_def_for_recombiner);
+
+    // otherwise, assign it.
+    jet_def_for_recombiner = jet.validated_cs()->jet_def();
+    assigned = true;
+    return true;
+  }
 
   // if the jet has pieces, recurse in the pieces
   if (jet.has_pieces()){
     vector<PseudoJet> pieces = jet.pieces();
-    if (pieces.size() == 0) return 0;
-    const JetDefinition::Recombiner * reco = _get_common_recombiner(pieces[0]);
-    for (unsigned int i=1;i<pieces.size(); i++)
-      if (_get_common_recombiner(pieces[i]) != reco) return 0;
+    if (pieces.size() == 0) return false;
+    for (unsigned int i=0;i<pieces.size(); i++)
+      if (!_check_common_recombiner(pieces[i], jet_def_for_recombiner, assigned)) return false;
     // never returned false, so we're OK.
-    return reco;
+    return true;
   }
 
   // return false for any other (unknown) structure
-  return 0;
+  return false;
 }