Changeset 49234af for external – Delphes

external/fastjet/AUTHORS

-              rf6b6ee7
+              r49234af
 ----------------------------------------------------------------------
 Many people have provided bug reports, suggestions for development and
 in some cases explicit code for plugin algorithms. We would in
 particular like to thank
+Many people have provided bug reports, suggestions for development,
+documentation and in some cases explicit code for plugin
+algorithms. We would in particular like to thank
 Vanya Belyaev
 …
 Hartmut Stadie
 Mark Sutton
+Jesse Thaler
 Chris Vermilion
 Markus Wobisch
+Christopher Young
 ----------------------------------------------------------------------

external/fastjet/ActiveAreaSpec.hh

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id: ActiveAreaSpec.hh 2577 2011-09-13 15:11:38Z salam $
+//FJSTARTHEADER
+// $Id: ActiveAreaSpec.hh 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER

external/fastjet/AreaDefinition.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
+//FJSTARTHEADER
+// $Id: AreaDefinition.cc 3619 2014-08-13 14:17:19Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include "fastjet/AreaDefinition.hh"
 …
     break;
   default:
     cerr << "Error: unrecognized area_type in AreaDefinition::description():"
+    ostr << "Error: unrecognized area_type in AreaDefinition::description():"
          << area_type() << endl;
     exit(-1);
+    throw Error(ostr.str());
+  }
   return ostr.str();

external/fastjet/AreaDefinition.hh

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id: AreaDefinition.hh 2687 2011-11-14 11:17:51Z soyez $
+//FJSTARTHEADER
+// $Id: AreaDefinition.hh 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2006-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2006-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER

external/fastjet/BasicRandom.cc

-              rf6b6ee7
+              r49234af
+//STARTHEADER
+// simple random number generator class taken from nlojet++.
+// $Id$
+//FJSTARTHEADER
+// $Id: BasicRandom.cc 3433 2014-07-23 08:17:03Z salam $
 //
 //  Copyright (C) 2002 Zoltan Nagy
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
+//  This program is free software; you can redistribute it and/or modify
+//----------------------------------------------------------------------
+// This file is part of FastJet.
+//
+//  FastJet 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.
 //
+//  This program is distributed in the hope that it will be useful,
+//  The algorithms that underlie FastJet have required considerable
+//  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
+//  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,
 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 …
 //
 //  You should have received a copy of the GNU General Public License
 //  along with this program; if not, write to the Free Software
 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 //ENDHEADER
+//  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
+//----------------------------------------------------------------------
+//FJENDHEADER
 //   nlo includes

external/fastjet/CMakeLists.txt

rf6b6ee7	r49234af
1	1	include_directories(${CMAKE_SOURCE_DIR}/external)
2	2
3		file(GLOB sources .cc plugins//.cc contribs/Nsubjettiness/.cc tools/*cc)
	3	file(GLOB sources .cc plugins//.cc contribs//.cc tools/.cc)
4	4
5	5	add_library(fastjet OBJECT ${sources})

external/fastjet/CircularRange.hh

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id: CircularRange.hh 2577 2011-09-13 15:11:38Z salam $
+//FJSTARTHEADER
+// $Id: CircularRange.hh 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER

external/fastjet/ClosestPair2D.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+//FJSTARTHEADER
+// $Id: ClosestPair2D.cc 3433 2014-07-23 08:17:03Z salam $
+//
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include "fastjet/internal/ClosestPair2D.hh"
 …
 FASTJET_BEGIN_NAMESPACE      // defined in fastjet/internal/base.hh
-const unsigned int huge_unsigned = 4294967295U;
 const unsigned int twopow31      = 2147483648U;
 …
   ID2 = _ID(_points[ID1].neighbour);
   distance2 = _points[ID1].neighbour_dist2;
+  // we make the swap explicitly in the std namespace to avoid
+  // potential conflict with the fastjet::swap introduced by
+  // SharedPtr.
+  // This is only an issue because we are in the fastjet namespace
   if (ID1 > ID2) std::swap(ID1,ID2);
+}

external/fastjet/ClusterSequence.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
+//FJSTARTHEADER
+// $Id: ClusterSequence.cc 3685 2014-09-11 20:15:00Z salam $
 //
 // Copyright (c) 2005-2013, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include "fastjet/Error.hh"
 …
 #include "fastjet/ClusterSequenceStructure.hh"
 #include "fastjet/version.hh" // stores the current version number
+#include "fastjet/internal/LazyTiling9Alt.hh"
+#include "fastjet/internal/LazyTiling9.hh"
+#include "fastjet/internal/LazyTiling25.hh"
+#ifndef __FJCORE__
+#include "fastjet/internal/LazyTiling9SeparateGhosts.hh"
+#endif  // __FJCORE__
 #include<iostream>
 #include<sstream>
 …
 //DEP //----------------------------------------------------------------------
 //DEP void ClusterSequence::_initialise_and_run (
 //DEP                             const double & R,
+//DEP                             const double R,
 //DEP                             const Strategy & strategy,
 //DEP                             const bool & writeout_combinations) {
 …
   //             ./fastjet_timing_plugins -kt -nhardest 30 -repeat 50000 -strategy -3 -R 0.5 -nev 1  <  ../../data/Pythia-PtMin1000-LHC-1000ev.dat
   if (_strategy == Best) {
+    _strategy = _best_strategy();
+#ifdef DROP_CGAL
+    // fall back strategy for large N when CGAL is missing
+    if (_strategy == NlnN) _strategy = N2MHTLazy25;
+#endif  // DROP_CGAL
+  } else if (_strategy == BestFJ30) {
     int N = _jets.size();
     //if (N <= 55*max(0.5,min(1.0,_Rparam))) {// old empirical scaling with R
 …
   // run the code containing the selected strategy
   //
   // We order the strategies stqrting from the ones used by the Best
+  // We order the strategies starting from the ones used by the Best
   // strategy in the order of increasing N, then the remaining ones
   // again in the order of increasing N.
 …
   } else if (_strategy == N2MinHeapTiled) {
     this->_minheap_faster_tiled_N2_cluster();
+  } else if (_strategy == N2MHTLazy9Alt) {
+    // attempt to use an external tiling routine -- it manipulates
+    // the CS history via the plugin mechanism
+    _plugin_activated = true;
+    LazyTiling9Alt tiling(*this);
+    tiling.run();
+    _plugin_activated = false;
+  } else if (_strategy == N2MHTLazy25) {
+    // attempt to use an external tiling routine -- it manipulates
+    // the CS history via the plugin mechanism
+    _plugin_activated = true;
+    LazyTiling25 tiling(*this);
+    tiling.run();
+    _plugin_activated = false;
+  } else if (_strategy == N2MHTLazy9) {
+    // attempt to use an external tiling routine -- it manipulates
+    // the CS history via the plugin mechanism
+    _plugin_activated = true;
+    LazyTiling9 tiling(*this);
+    tiling.run();
+    _plugin_activated = false;
+#ifndef __FJCORE__
+  } else if (_strategy == N2MHTLazy9AntiKtSeparateGhosts) {
+    // attempt to use an external tiling routine -- it manipulates
+    // the CS history via the plugin mechanism
+    _plugin_activated = true;
+    LazyTiling9SeparateGhosts tiling(*this);
+    tiling.run();
+    _plugin_activated = false;
+#else
+    throw Error("N2MHTLazy9AntiKtSeparateGhosts strategy not supported with FJCORE");
+#endif  // __FJCORE__
   } else if (_strategy == NlnN) {
     this->_delaunay_cluster();
 …
 // these needs to be defined outside the class definition.
 bool ClusterSequence::_first_time = true;
 int ClusterSequence::_n_exclusive_warnings = 0;
+LimitedWarning ClusterSequence::_exclusive_warnings;
 …
 //----------------------------------------------------------------------
-// Return the component corresponding to the specified index.
-// taken from CLHEP
 string ClusterSequence::strategy_string (Strategy strategy_in)  const {
   string strategy;
 …
   case N2PoorTiled:
     strategy = "N2PoorTiled"; break;
+  case N2MHTLazy9:
+    strategy = "N2MHTLazy9"; break;
+  case N2MHTLazy9Alt:
+    strategy = "N2MHTLazy9Alt"; break;
+  case N2MHTLazy25:
+    strategy = "N2MHTLazy25"; break;
+  case N2MHTLazy9AntiKtSeparateGhosts:
+    strategy = "N2MHTLazy9AntiKtSeparateGhosts"; break;
   case N3Dumb:
     strategy = "N3Dumb"; break;
 …
     } else {return 1.0;}
   } else {throw Error("Unrecognised jet algorithm");}
+}
+//----------------------------------------------------------------------
+// returns a suggestion for the best strategy to use on event
+// multiplicity, algorithm, R, etc.
+//
+// Some of the work to establish the best strategy is collected in
+// issue-tracker/2014-07-auto-strategy-selection;
+// transition_fit_v2.fit indicates the results of the fits that we're
+// using here. (Automatically generated by transition_fit_v2.gp).
+//
+// The transition to NlnN is always present, and it is the the
+// caller's responsibility to drop back down to N2MHTLazy25 if NlnN
+// isn't available.
+//
+// This routine should be called only if the jet alg is one of kt,
+// antikt, cam or genkt.
+Strategy ClusterSequence::_best_strategy() const {
+  int N = _jets.size();
+  // define bounded R, always above 0.1, because we don't trust any
+  // of our parametrizations below R = 0.1
+  double bounded_R = max(_Rparam, 0.1);
+  // the very first test thing is a quick hard-coded test to decide
+  // if we immediately opt for N2Plain
+  if (N <= 30 || N <= 39.0/(bounded_R + 0.6)) {
+    return N2Plain;
+  }
+  // Define objects that describe our various boundaries. A prefix N_
+  // indicates that boundary is for N, while L_ means it's for log(N).
+  //
+  // Hopefully having them static will ensure minimal overhead
+  // in creating them; collecting them in one place should
+  // help with updates?
+  //
+  const static _Parabola N_Tiled_to_MHT_lowR             (-45.4947,54.3528,44.6283);
+  const static _Parabola L_MHT_to_MHTLazy9_lowR          (0.677807,-1.05006,10.6994);
+  const static _Parabola L_MHTLazy9_to_MHTLazy25_akt_lowR(0.169967,-0.512589,12.1572);
+  const static _Parabola L_MHTLazy9_to_MHTLazy25_kt_lowR (0.16237,-0.484612,12.3373);
+  const static _Parabola L_MHTLazy9_to_MHTLazy25_cam_lowR = L_MHTLazy9_to_MHTLazy25_kt_lowR;
+  const static _Parabola L_MHTLazy25_to_NlnN_akt_lowR    (0.0472051,-0.22043,15.9196);
+  const static _Parabola L_MHTLazy25_to_NlnN_kt_lowR     (0.118609,-0.326811,14.8287);
+  const static _Parabola L_MHTLazy25_to_NlnN_cam_lowR    (0.10119,-0.295748,14.3924);
+  const static _Line     L_Tiled_to_MHTLazy9_medR         (-1.31304,7.29621);
+  const static _Parabola L_MHTLazy9_to_MHTLazy25_akt_medR = L_MHTLazy9_to_MHTLazy25_akt_lowR;
+  const static _Parabola L_MHTLazy9_to_MHTLazy25_kt_medR  = L_MHTLazy9_to_MHTLazy25_kt_lowR;
+  const static _Parabola L_MHTLazy9_to_MHTLazy25_cam_medR = L_MHTLazy9_to_MHTLazy25_cam_lowR;
+  const static _Parabola L_MHTLazy25_to_NlnN_akt_medR     = L_MHTLazy25_to_NlnN_akt_lowR;
+  const static _Parabola L_MHTLazy25_to_NlnN_kt_medR      = L_MHTLazy25_to_NlnN_kt_lowR;
+  const static _Parabola L_MHTLazy25_to_NlnN_cam_medR     = L_MHTLazy25_to_NlnN_cam_lowR;
+  const static double    N_Plain_to_MHTLazy9_largeR         = 75;
+  const static double    N_MHTLazy9_to_MHTLazy25_akt_largeR = 700;
+  const static double    N_MHTLazy9_to_MHTLazy25_kt_largeR  = 1000;
+  const static double    N_MHTLazy9_to_MHTLazy25_cam_largeR = 1000;
+  const static double    N_MHTLazy25_to_NlnN_akt_largeR     = 100000;
+  const static double    N_MHTLazy25_to_NlnN_kt_largeR      = 40000;
+  const static double    N_MHTLazy25_to_NlnN_cam_largeR     = 15000;
+  // We have timing studies only for kt, cam and antikt; for other
+  // algorithms we set the local jet_algorithm variable to the one of
+  // kt,cam,antikt that we think will be closest in behaviour to the
+  // other alg.
+  JetAlgorithm jet_algorithm;
+  if (_jet_algorithm == genkt_algorithm) {
+    // for genkt, then we set the local jet_algorithm variable (used
+    // only for strategy choice) to be either kt or antikt, depending on
+    // the p value.
+    double p   = jet_def().extra_param();
+    if (p < 0.0) jet_algorithm = antikt_algorithm;
+    else         jet_algorithm =     kt_algorithm;
+  } else if (_jet_algorithm == cambridge_for_passive_algorithm) {
+    // we assume (but haven't tested) that using the kt-alg timing
+    // transitions should be adequate for cambridge_for_passive_algorithm
+    jet_algorithm = kt_algorithm;
+  } else {
+    jet_algorithm = _jet_algorithm;
+  }
+  if (bounded_R < 0.65) {
+    // low R case
+    if          (N    < N_Tiled_to_MHT_lowR(bounded_R))              return N2Tiled;
+    double logN = log(double(N));
+    if          (logN < L_MHT_to_MHTLazy9_lowR(bounded_R))           return N2MinHeapTiled;
+    else {
+      if (jet_algorithm == antikt_algorithm){
+        if      (logN < L_MHTLazy9_to_MHTLazy25_akt_lowR(bounded_R)) return N2MHTLazy9;
+        else if (logN < L_MHTLazy25_to_NlnN_akt_lowR(bounded_R))     return N2MHTLazy25;
+        else                                                         return NlnN;
+      } else if (jet_algorithm == kt_algorithm){
+        if      (logN < L_MHTLazy9_to_MHTLazy25_kt_lowR(bounded_R))  return N2MHTLazy9;
+        else if (logN < L_MHTLazy25_to_NlnN_kt_lowR(bounded_R))      return N2MHTLazy25;
+        else                                                         return NlnN;
+      } else if (jet_algorithm == cambridge_algorithm)  {
+        if      (logN < L_MHTLazy9_to_MHTLazy25_cam_lowR(bounded_R)) return N2MHTLazy9;
+        else if (logN < L_MHTLazy25_to_NlnN_cam_lowR(bounded_R))     return N2MHTLazy25;
+        else                                                         return NlnNCam;
+      }
+    }
+  } else if (bounded_R < 0.5*pi) {
+    // medium R case
+    double logN = log(double(N));
+    if      (logN < L_Tiled_to_MHTLazy9_medR(bounded_R))             return N2Tiled;
+    else {
+      if (jet_algorithm == antikt_algorithm){
+        if      (logN < L_MHTLazy9_to_MHTLazy25_akt_medR(bounded_R)) return N2MHTLazy9;
+        else if (logN < L_MHTLazy25_to_NlnN_akt_medR(bounded_R))     return N2MHTLazy25;
+        else                                                         return NlnN;
+      } else if (jet_algorithm == kt_algorithm){
+        if      (logN < L_MHTLazy9_to_MHTLazy25_kt_medR(bounded_R))  return N2MHTLazy9;
+        else if (logN < L_MHTLazy25_to_NlnN_kt_medR(bounded_R))      return N2MHTLazy25;
+        else                                                         return NlnN;
+      } else if (jet_algorithm == cambridge_algorithm)  {
+        if      (logN < L_MHTLazy9_to_MHTLazy25_cam_medR(bounded_R)) return N2MHTLazy9;
+        else if (logN < L_MHTLazy25_to_NlnN_cam_medR(bounded_R))     return N2MHTLazy25;
+        else                                                         return NlnNCam;
+      }
+    }
+  } else {
+    // large R case (R > pi/2)
+    if      (N    < N_Plain_to_MHTLazy9_largeR)                      return N2Plain;
+    else {
+      if (jet_algorithm == antikt_algorithm){
+        if      (N < N_MHTLazy9_to_MHTLazy25_akt_largeR)             return N2MHTLazy9;
+        else if (N < N_MHTLazy25_to_NlnN_akt_largeR)                 return N2MHTLazy25;
+        else                                                         return NlnN;
+      } else if (jet_algorithm == kt_algorithm){
+        if      (N < N_MHTLazy9_to_MHTLazy25_kt_largeR)              return N2MHTLazy9;
+        else if (N < N_MHTLazy25_to_NlnN_kt_largeR)                  return N2MHTLazy25;
+        else                                                         return NlnN;
+      } else if (jet_algorithm == cambridge_algorithm)  {
+        if      (N < N_MHTLazy9_to_MHTLazy25_cam_largeR)             return N2MHTLazy9;
+        else if (N < N_MHTLazy25_to_NlnN_cam_largeR)                 return N2MHTLazy25;
+        else                                                         return NlnNCam;
+      }
+    }
+  }
+  bool code_should_never_reach_here = false;
+  assert(code_should_never_reach_here);
+  return N2MHTLazy9;
+}
 …
 //----------------------------------------------------------------------
 // return all inclusive jets with pt > ptmin
 vector<PseudoJet> ClusterSequence::inclusive_jets (const double & ptmin) const{
+vector<PseudoJet> ClusterSequence::inclusive_jets (const double ptmin) const{
   double dcut = ptmin*ptmin;
   int i = _history.size() - 1; // last jet
 …
 // return the number of exclusive jets that would have been obtained
 // running the algorithm in exclusive mode with the given dcut
 int ClusterSequence::n_exclusive_jets (const double & dcut) const {
+int ClusterSequence::n_exclusive_jets (const double dcut) const {
   // first locate the point where clustering would have stopped (i.e. the
 …
 // return all exclusive jets that would have been obtained running
 // the algorithm in exclusive mode with the given dcut
 vector<PseudoJet> ClusterSequence::exclusive_jets (const double & dcut) const {
+vector<PseudoJet> ClusterSequence::exclusive_jets (const double dcut) const {
   int njets = n_exclusive_jets(dcut);
   return exclusive_jets(njets);
 …
 // return the jets obtained by clustering the event to n jets.
 // Throw an error if there are fewer than n particles.
 vector<PseudoJet> ClusterSequence::exclusive_jets (const int & njets) const {
+vector<PseudoJet> ClusterSequence::exclusive_jets (const int njets) const {
   // make sure the user does not ask for more than jets than there
 …
 // return the jets obtained by clustering the event to n jets.
 // If there are fewer than n particles, simply return all particles
 vector<PseudoJet> ClusterSequence::exclusive_jets_up_to (const int & njets) const {
+vector<PseudoJet> ClusterSequence::exclusive_jets_up_to (const int njets) const {
   // provide a warning when extracting exclusive jets for algorithms
   // that does not support it explicitly.
   // Native algorithm that support it are: kt, ee_kt, cambridge,
+  // Native algorithm that support it are: kt, ee_kt, Cambridge/Aachen,
   //   genkt and ee_genkt (both with p>=0)
   // For plugins, we check Plugin::exclusive_sequence_meaningful()
 …
        (_jet_def.extra_param() <0)) &&
       ((_jet_def.jet_algorithm() != plugin_algorithm) ||
+       (!_jet_def.plugin()->exclusive_sequence_meaningful())) &&
+      (_n_exclusive_warnings < 5)) {
+    _n_exclusive_warnings++;
+    cerr << "FastJet WARNING: dcut and exclusive jets for jet-finders other than kt should be interpreted with care." << endl;
+       (!_jet_def.plugin()->exclusive_sequence_meaningful()))) {
+    _exclusive_warnings.warn("dcut and exclusive jets for jet-finders other than kt, C/A or genkt with p>=0 should be interpreted with care.");
+  }
 …
 /// return the dmin corresponding to the recombination that went from
 /// n+1 to n jets
 double ClusterSequence::exclusive_dmerge (const int & njets) const {
+double ClusterSequence::exclusive_dmerge (const int njets) const {
   assert(njets >= 0);
   if (njets >= _initial_n) {return 0.0;}
 …
 /// exclusive_dmerge, except in cases where the dmin do not increase
 /// monotonically.
 double ClusterSequence::exclusive_dmerge_max (const int & njets) const {
+double ClusterSequence::exclusive_dmerge_max (const int njets) const {
   assert(njets >= 0);
   if (njets >= _initial_n) {return 0.0;}
 …
 /// the algorithm with the given dcut.
 std::vector<PseudoJet> ClusterSequence::exclusive_subjets
    (const PseudoJet & jet, const double & dcut) const {
+   (const PseudoJet & jet, const double dcut) const {
   set<const history_element*> subhist;
 …
 /// exclusive_subjets.size()
 int ClusterSequence::n_exclusive_subjets(const PseudoJet & jet,
                         const double & dcut) const {
+                        const double dcut) const {
   set<const history_element*> subhist;
   // get the set of history elements that correspond to subjets at
 …
 // //----------------------------------------------------------------------
 // // print out all inclusive jets with pt > ptmin
 // void ClusterSequence::print_jets (const double & ptmin) const{
+// void ClusterSequence::print_jets (const double ptmin) const{
 //     vector<PseudoJet> jets = sorted_by_pt(inclusive_jets(ptmin));
 //
 …
 // initialise the history in a standard way
 void ClusterSequence::_add_step_to_history (
                const int & step_number, const int & parent1,
                const int & parent2, const int & jetp_index,
                const double & dij) {
+               const int step_number, const int parent1,
+               const int parent2, const int jetp_index,
+               const double dij) {
   history_element element;
 …
 /// of the recombined jet, newjet_k.
 void ClusterSequence::_do_ij_recombination_step(
                                const int & jet_i, const int & jet_j,
                                const double & dij,
+                               const int jet_i, const int jet_j,
+                               const double dij,
                                int & newjet_k) {
 …
 /// jet_i with the beam
 void ClusterSequence::_do_iB_recombination_step(
                                   const int & jet_i, const double & diB) {
+                                  const int jet_i, const double diB) {
   // get history index
   int newstep_k = _history.size();

external/fastjet/ClusterSequence.hh

-              rf6b6ee7
+              r49234af
+//STARTHEADER
+// $Id: ClusterSequence.hh 3114 2013-05-04 08:46:00Z salam $
+#ifndef __FASTJET_CLUSTERSEQUENCE_HH__
+#define __FASTJET_CLUSTERSEQUENCE_HH__
+//FJSTARTHEADER
+// $Id: ClusterSequence.hh 3709 2014-09-29 13:19:11Z soyez $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
+//ENDHEADER
+#ifndef __FASTJET_CLUSTERSEQUENCE_HH__
+#define __FASTJET_CLUSTERSEQUENCE_HH__
+//FJENDHEADER
 #include<vector>
 …
   ClusterSequence () : _deletes_self_when_unused(false) {}
+//   /// create a clustersequence starting from the supplied set
+//   /// of pseudojets and clustering them with the long-invariant
+//   /// kt algorithm (E-scheme recombination) with the supplied
+//   /// value for R.
+//   ///
+//   /// If strategy=DumbN3 a very stupid N^3 algorithm is used for the
+//   /// clustering; otherwise strategy = NlnN* uses cylinders algorithms
+//   /// with some number of pi coverage. If writeout_combinations=true a
+//   /// summary of the recombination sequence is written out
+//   template<class L> ClusterSequence (const std::vector<L> & pseudojets,
+//                 const double & R = 1.0,
+//                 const Strategy & strategy = Best,
+//                 const bool & writeout_combinations = false);
+  /// create a clustersequence starting from the supplied set
+  /// of pseudojets and clustering them with jet definition specified
+  /// create a ClusterSequence, starting from the supplied set
+  /// of PseudoJets and clustering them with jet definition specified
   /// by jet_def (which also specifies the clustering strategy)
   template<class L> ClusterSequence (
 …
   /// algorithm) with pt >= ptmin. Time taken should be of the order
   /// of the number of jets returned.
   std::vector<PseudoJet> inclusive_jets (const double & ptmin = 0.0) const;
+  std::vector<PseudoJet> inclusive_jets (const double ptmin = 0.0) const;
   /// return the number of jets (in the sense of the exclusive
   /// algorithm) that would be obtained when running the algorithm
   /// with the given dcut.
   int n_exclusive_jets (const double & dcut) const;
+  int n_exclusive_jets (const double dcut) const;
   /// return a vector of all jets (in the sense of the exclusive
   /// algorithm) that would be obtained when running the algorithm
   /// with the given dcut.
   std::vector<PseudoJet> exclusive_jets (const double & dcut) const;
+  std::vector<PseudoJet> exclusive_jets (const double dcut) const;
   /// return a vector of all jets when the event is clustered (in the
 …
   /// If there are fewer than njets particles in the ClusterSequence
   /// an error is thrown
   std::vector<PseudoJet> exclusive_jets (const int & njets) const;
+  std::vector<PseudoJet> exclusive_jets (const int njets) const;
   /// return a vector of all jets when the event is clustered (in the
 …
   /// If there are fewer than njets particles in the ClusterSequence
   /// the function just returns however many particles there were.
   std::vector<PseudoJet> exclusive_jets_up_to (const int & njets) const;
+  std::vector<PseudoJet> exclusive_jets_up_to (const int njets) const;
   /// return the dmin corresponding to the recombination that went
   /// from n+1 to n jets (sometimes known as d_{n n+1}). If the number
   /// of particles in the event is <= njets, the function returns 0.
   double exclusive_dmerge (const int & njets) const;
+  double exclusive_dmerge (const int njets) const;
   /// return the maximum of the dmin encountered during all recombinations
 …
   /// exclusive_dmerge, except in cases where the dmin do not increase
   /// monotonically.
   double exclusive_dmerge_max (const int & njets) const;
+  double exclusive_dmerge_max (const int njets) const;
   /// return the ymin corresponding to the recombination that went from
 …
   //int n_exclusive_jets (const PseudoJet & jet, const double & dcut) const;
+  //int n_exclusive_jets (const PseudoJet & jet, const double dcut) const;
   /// return a vector of all subjets of the current jet (in the sense
 …
   /// just getting that list of constituents.
   std::vector<PseudoJet> exclusive_subjets (const PseudoJet & jet,
                                             const double & dcut) const;
+                                            const double dcut) const;
   /// return the size of exclusive_subjets(...); still n ln n with same
 …
   /// exclusive_subjets.size()
   int n_exclusive_subjets(const PseudoJet & jet,
                           const double & dcut) const;
+                          const double dcut) const;
   /// return the list of subjets obtained by unclustering the supplied
 …
                                                   int nsub) const;
   /// return the dij that was present in the merging nsub+1 -> nsub
+  /// returns the dij that was present in the merging nsub+1 -> nsub
   /// subjets inside this jet.
   ///
 …
   double exclusive_subdmerge(const PseudoJet & jet, int nsub) const;
   /// return the maximum dij that occurred in the whole event at the
+  /// returns the maximum dij that occurred in the whole event at the
   /// stage that the nsub+1 -> nsub merge of subjets occurred inside
   /// this jet.
 …
   //std::vector<PseudoJet> exclusive_jets (const PseudoJet & jet,
   //                                       const int & njets) const;
   //double exclusive_dmerge (const PseudoJet & jet, const int & njets) const;
+  //                                       const int njets) const;
+  //double exclusive_dmerge (const PseudoJet & jet, const int njets) const;
   /// returns the sum of all energies in the event (relevant mainly for e+e-)
 …
 // Not yet. Perhaps in a future release.
 //   /// print out all inclusive jets with pt > ptmin
 //   virtual void print_jets (const double & ptmin=0.0) const;
+//   virtual void print_jets (const double ptmin=0.0) const;
   /// add on to subjet_vector the constituents of jet (for internal use mainly)
 …
   ///
   /// NB: after having made this call, the user is still allowed to
+  /// delete the CS or let it go out of scope. Jets associated with it
+  /// will then simply not be able to access their substructure after
+  /// that point.
+  /// delete the CS. Jets associated with it will then simply not be
+  /// able to access their substructure after that point.
   void delete_self_when_unused();
 …
   /// returns the scale associated with a jet as required for this
+  /// clustering algorithm (kt^2 for the kt-algorithm, 1 for the
+  /// Cambridge algorithm). [May become virtual at some point]
+  /// clustering algorithm (kt^2 for the kt-algorithm, 1 for the
+  /// Cambridge algorithm). Intended mainly for internal use and not
+  /// valid for plugin algorithms.
   double jet_scale_for_algorithm(const PseudoJet & jet) const;
 …
   /// the plugin can associate some extra information with the
+  /// ClusterSequence object by calling this function. The
+  /// ClusterSequence takes ownership of the pointer (and
+  /// responsibility for deleting it when the CS gets deleted).
+  inline void plugin_associate_extras(Extras * extras_in) {
+    _extras.reset(extras_in);
+  }
+  /// the plugin can associate some extra information with the
   /// ClusterSequence object by calling this function
+  ///
+  /// As of FJ v3.1, this is deprecated, in line with the deprecation
+  /// of auto_ptr in C++11
   inline void plugin_associate_extras(std::auto_ptr<Extras> extras_in) {
-    //_extras = extras_in;
     _extras.reset(extras_in.release());
+  }
 …
 //DEP   /// clustering, provided for legacy purposes. The jet finder is that
 //DEP   /// specified in the static member _default_jet_algorithm.
 //DEP   void _initialise_and_run (const double & R,
+//DEP   void _initialise_and_run (const double R,
 //DEP                       const Strategy & strategy,
 //DEP                       const bool & writeout_combinations);
 …
   /// jet_j, at distance scale dij; return the index newjet_k of the
   /// result of the recombination of i and j.
   void _do_ij_recombination_step(const int & jet_i, const int & jet_j,
                                  const double & dij, int & newjet_k);
+  void _do_ij_recombination_step(const int jet_i, const int jet_j,
+                                 const double dij, int & newjet_k);
   /// carry out an recombination step in which _jets[jet_i] merges with
   /// the beam,
   void _do_iB_recombination_step(const int & jet_i, const double & diB);
+  void _do_iB_recombination_step(const int jet_i, const double diB);
   /// every time a jet is added internally during clustering, this
 …
   void _update_structure_use_count();
+  /// returns a suggestion for the best strategy to use on event
+  /// multiplicity, algorithm, R, etc.
+  Strategy _best_strategy() const;
+  /// \if internal_doc
+  /// \class _Parabola
+  /// returns c*(a*R**2 + b*R + 1);
+  /// Written as a class in case we want to give names to different
+  /// parabolas
+  /// \endif
+  class _Parabola {
+  public:
+    _Parabola(double a, double b, double c) : _a(a), _b(b), _c(c) {}
+    inline double operator()(const double R) const {return _c*(_a*R*R + _b*R + 1);}
+  private:
+    double _a, _b, _c;
+  };
+  /// \if internal_doc
+  /// \class _Line
+  /// operator()(R) returns a*R+b;
+  /// \endif
+  class _Line {
+  public:
+    _Line(double a, double b) : _a(a), _b(b) {}
+    inline double operator()(const double R) const {return _a*R + _b;}
+  private:
+    double _a, _b;
+  };
   /// This contains the physical PseudoJets; for each PseudoJet one
 …
   bool _plugin_activated;
-  //std::auto_ptr<Extras> _extras; // things the plugin might want to add
   SharedPtr<Extras> _extras; // things the plugin might want to add
 …
   void _fast_NsqrtN_cluster();
   void _add_step_to_history(const int & step_number, const int & parent1,
                                const int & parent2, const int & jetp_index,
                                const double & dij);
+  void _add_step_to_history(const int step_number, const int parent1,
+                               const int parent2, const int jetp_index,
+                               const double dij);
   /// internal routine associated with the construction of the unique
 …
   /// currently used only in the Voronoi based code
   void _add_ktdistance_to_map(const int & ii,
+  void _add_ktdistance_to_map(const int ii,
                               DistMap & DijMap,
                               const DynamicNearestNeighbours * DNN);
 …
   static bool _first_time;
+  /// record the number of warnings provided about the exclusive
+  /// algorithm -- so that we don't print it out more than a few
+  /// times.
+  static int _n_exclusive_warnings;
+  /// manage warnings related to exclusive jets access
+  static LimitedWarning _exclusive_warnings;
   /// the limited warning member for notification of user that
 …
     int        _jets_index;
   };
   /// structure analogous to BriefJet, but with the extra information
 …
   // routines for tiled case, including some overloads of the plain
   // BriefJet cases
   int  _tile_index(const double & eta, const double & phi) const;
+  int  _tile_index(const double eta, const double phi) const;
   void _tj_set_jetinfo ( TiledJet * const jet, const int _jets_index);
   void  _bj_remove_from_tiles(TiledJet * const jet);
 …
   void _add_untagged_neighbours_to_tile_union(const int tile_index,
                  std::vector<int> & tile_union, int & n_near_tiles);
   //----------------------------------------------------------------------
 …
 // template<class L> ClusterSequence::ClusterSequence (
 //                                const std::vector<L> & pseudojets,
 //                                const double & R,
+//                                const double R,
 //                                const Strategy & strategy,
 //                                const bool & writeout_combinations) {
 …
 inline unsigned int ClusterSequence::n_particles() const {return _initial_n;}
+//----------------------------------------------------------------------
+// implementation of JetDefinition::operator() is here to avoid nasty
+// issues of order of implementations and includes
+template<class L>
+std::vector<PseudoJet> JetDefinition::operator()(const std::vector<L> & particles) const {
+  // create a new cluster sequence
+  ClusterSequence * cs = new ClusterSequence(particles, *this);
+  // get the jets, and sort them according to whether the algorithm
+  // is spherical or not
+  std::vector<PseudoJet> jets;
+  if (is_spherical()) {
+    jets = sorted_by_E(cs->inclusive_jets());
+  } else {
+    jets = sorted_by_pt(cs->inclusive_jets());
+  }
+  // make sure the ClusterSequence gets deleted once it's no longer
+  // needed
+  if (jets.size() != 0) {
+    cs->delete_self_when_unused();
+  } else {
+    delete cs;
+  }
+  return jets;
+}

external/fastjet/ClusterSequence1GhostPassiveArea.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
+//FJSTARTHEADER
+// $Id: ClusterSequence1GhostPassiveArea.cc 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include "fastjet/ClusterSequence1GhostPassiveArea.hh"

external/fastjet/ClusterSequence1GhostPassiveArea.hh

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id: ClusterSequence1GhostPassiveArea.hh 2687 2011-11-14 11:17:51Z soyez $
+//FJSTARTHEADER
+// $Id: ClusterSequence1GhostPassiveArea.hh 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #ifndef __FASTJET_CLUSTERSEQUENCE1GHOSTPASSIVEAREA_HH__

external/fastjet/ClusterSequenceActiveArea.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
+//FJSTARTHEADER
+// $Id: ClusterSequenceActiveArea.cc 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include "fastjet/PseudoJet.hh"

external/fastjet/ClusterSequenceActiveArea.hh

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id: ClusterSequenceActiveArea.hh 2687 2011-11-14 11:17:51Z soyez $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+//FJSTARTHEADER
+// $Id: ClusterSequenceActiveArea.hh 3619 2014-08-13 14:17:19Z salam $
+//
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #ifndef __FASTJET_CLUSTERSEQUENCEACTIVEAREA_HH__
 …
   /// the background (e.g. non-jet) activity in a highly populated event; the
   /// one that has been most extensively tested is median.
+  ///
+  /// These strategies are OBSOLETE and deprecated (see comment
+  /// for pt_per_unit_area).
   enum mean_pt_strategies{median=0, non_ghost_median, pttot_over_areatot,
                           pttot_over_areatot_cut, mean_ratio_cut, play,
 …
   /// have pt/area > median(pt/area)*range.
   ///
+  /// NB: This call is OBSOLETE; use media_pt_per_unit_area from the
+  //      ClusterSequenceAreaBase class instead
+  /// NB: This call is OBSOLETE and deprecated; use a
+  /// JetMedianBackgroundEstimator or GridMedianBackgroundEstimator
+  /// instead.
   double pt_per_unit_area(mean_pt_strategies strat=median,
                           double range=2.0 ) const;
-  // following code removed -- now dealt with by AreaBase class (and
-  // this definition here conflicts with it).
-//   /// fits a form pt_per_unit_area(y) = a + b*y^2 in the range
-//   /// abs(y)<raprange (for negative raprange, it defaults to
-//   /// _safe_rap_for_area).
-//   void parabolic_pt_per_unit_area(double & a,double & b, double raprange=-1.0,
-//                                double exclude_above=-1.0,
-//                                bool use_area_4vector=false ) const;
-//
   /// rewrite the empty area from the parent class, so as to use
   /// all info at our disposal

external/fastjet/ClusterSequenceActiveAreaExplicitGhosts.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+//FJSTARTHEADER
+// $Id: ClusterSequenceActiveAreaExplicitGhosts.cc 3433 2014-07-23 08:17:03Z salam $
+//
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include "fastjet/ClusterSequenceActiveAreaExplicitGhosts.hh"

external/fastjet/ClusterSequenceActiveAreaExplicitGhosts.hh

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id: ClusterSequenceActiveAreaExplicitGhosts.hh 2687 2011-11-14 11:17:51Z soyez $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+//FJSTARTHEADER
+// $Id: ClusterSequenceActiveAreaExplicitGhosts.hh 3433 2014-07-23 08:17:03Z salam $
+//
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #ifndef __FASTJET_CLUSTERSEQUENCEACTIVEAREAEXPLICITGHOSTS_HH_

external/fastjet/ClusterSequenceArea.cc

-              rf6b6ee7
+              r49234af
+//FJSTARTHEADER
+// $Id: ClusterSequenceArea.cc 3433 2014-07-23 08:17:03Z salam $
+//
+// Copyright (c) 2006-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+//
+//----------------------------------------------------------------------
+// This file is part of FastJet.
+//
+//  FastJet 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.
+//
+//  The algorithms that underlie FastJet have required considerable
+//  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
+//  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,
+//  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 FastJet. If not, see <http://www.gnu.org/licenses/>.
+//----------------------------------------------------------------------
+//FJENDHEADER
 #include "fastjet/ClusterSequenceArea.hh"

external/fastjet/ClusterSequenceArea.hh

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id: ClusterSequenceArea.hh 2690 2011-11-14 14:57:54Z soyez $
 //
 // Copyright (c) 2006-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+//FJSTARTHEADER
+// $Id: ClusterSequenceArea.hh 3484 2014-07-29 21:39:39Z soyez $
+//
+// Copyright (c) 2006-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #ifndef __FASTJET_CLUSTERSEQUENCEAREA_HH__
 …
     break;
   default:
+    std::cerr << "Error: unrecognized area_type in ClusterSequenceArea:"
+              << _area_def.area_type() << std::endl;
+    exit(-1);
+    std::ostringstream err;
+    err << "Error: unrecognized area_type in ClusterSequenceArea:"
+        << _area_def.area_type();
+    throw Error(err.str());
+    //exit(-1);
+  }
   // now copy across the information from the area base class

external/fastjet/ClusterSequenceAreaBase.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+//FJSTARTHEADER
+// $Id: ClusterSequenceAreaBase.cc 3433 2014-07-23 08:17:03Z salam $
+//
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER

external/fastjet/ClusterSequenceAreaBase.hh

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id: ClusterSequenceAreaBase.hh 2687 2011-11-14 11:17:51Z soyez $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+//FJSTARTHEADER
+// $Id: ClusterSequenceAreaBase.hh 3433 2014-07-23 08:17:03Z salam $
+//
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #ifndef __FASTJET_CLUSTERSEQUENCEAREABASE_HH__

external/fastjet/ClusterSequencePassiveArea.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
+//FJSTARTHEADER
+// $Id: ClusterSequencePassiveArea.cc 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include "fastjet/ClusterSequencePassiveArea.hh"

external/fastjet/ClusterSequencePassiveArea.hh

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id: ClusterSequencePassiveArea.hh 2687 2011-11-14 11:17:51Z soyez $
+//FJSTARTHEADER
+// $Id: ClusterSequencePassiveArea.hh 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #ifndef __FASTJET_CLUSTERSEQUENCEPASSIVEAREA_HH__

external/fastjet/ClusterSequenceStructure.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+//FJSTARTHEADER
+// $Id: ClusterSequenceStructure.cc 3433 2014-07-23 08:17:03Z salam $
+//
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include "fastjet/ClusterSequenceStructure.hh"

external/fastjet/ClusterSequenceStructure.hh

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id: ClusterSequenceStructure.hh 3071 2013-04-01 12:52:46Z cacciari $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+//FJSTARTHEADER
+// $Id: ClusterSequenceStructure.hh 3433 2014-07-23 08:17:03Z salam $
+//
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER

external/fastjet/ClusterSequenceVoronoiArea.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
 //
 // Copyright (c) 2006-2007 Matteo Cacciari, Gavin Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 // This file is part of a simple command-line handling environment
+//FJSTARTHEADER
+// $Id: ClusterSequenceVoronoiArea.cc 3433 2014-07-23 08:17:03Z salam $
+//
+// Copyright (c) 2006-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+//
+//----------------------------------------------------------------------
+// This file is part of FastJet.
 //
 //  FastJet is free software; you can redistribute it and/or modify
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include "fastjet/ClusterSequenceVoronoiArea.hh"
 …
   //  -- first the initial ones
   _voronoi_area.reserve(2*n_particles());
+  _voronoi_area_4vector.reserve(2*n_particles());
   for (unsigned int i=0; i<n_particles(); i++) {
     _voronoi_area.push_back(_pa_calc->area(i));

external/fastjet/ClusterSequenceVoronoiArea.hh

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id: ClusterSequenceVoronoiArea.hh 2687 2011-11-14 11:17:51Z soyez $
+//FJSTARTHEADER
+// $Id: ClusterSequenceVoronoiArea.hh 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #ifndef __FASTJET_CLUSTERSEQUENCEVORONOIAREA_HH__
 …
     return _voronoi_area[jet.cluster_hist_index()];}
   /// return a 4-vector area associated with the given jet -- stricly
+  /// return a 4-vector area associated with the given jet -- strictly
   /// this is not the exact 4-vector area, but rather an approximation
   /// made of sums of centres of all Voronoi cells in jet, each

external/fastjet/ClusterSequenceWithArea.hh

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id: ClusterSequenceWithArea.hh 2577 2011-09-13 15:11:38Z salam $
+//FJSTARTHEADER
+// $Id: ClusterSequenceWithArea.hh 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2006-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2006-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #ifndef __FASTJET_CLUSTERSEQUENCEWITHAREA_HH__

external/fastjet/ClusterSequence_CP2DChan.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+//FJSTARTHEADER
+// $Id: ClusterSequence_CP2DChan.cc 3433 2014-07-23 08:17:03Z salam $
+//
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include "fastjet/ClusterSequence.hh"

external/fastjet/ClusterSequence_Delaunay.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+//FJSTARTHEADER
+// $Id: ClusterSequence_Delaunay.cc 3475 2014-07-29 11:57:23Z salam $
+//
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 …
     throw Error(err.str());
     //assert(false);
+  }
+  } else
 #endif // DROP_CGAL
+  {
+    ostringstream err;
+    err << "ERROR: Unrecognized value for strategy: "<<_strategy<<endl;
+    //ostringstream err;
+    //err << "ERROR: Unrecognized value for strategy: "<<_strategy<<endl;
+    //throw Error(err.str());
+    //-----------------------------------------------------------------
+    // The code should never reach this point, because the checks above
+    // should always handle all _strategy values for which
+    // _delaunay_cluster() is called
     assert(false);
-    throw Error(err.str());
+  }
 …
 ///
 void ClusterSequence::_add_ktdistance_to_map(
                           const int & ii,
+                          const int ii,
                           DistMap & DijMap,
                           const DynamicNearestNeighbours * DNN) {

external/fastjet/ClusterSequence_DumbN3.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
+//FJSTARTHEADER
+// $Id: ClusterSequence_DumbN3.cc 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER

external/fastjet/ClusterSequence_N2.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
+//FJSTARTHEADER
+// $Id: ClusterSequence_N2.cc 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER

external/fastjet/ClusterSequence_TiledN2.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
+//FJSTARTHEADER
+// $Id: ClusterSequence_TiledN2.cc 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
 // The plain N^2 part of the ClusterSequence class -- separated out
+//FJENDHEADER
+// The tiled N^2 part of the ClusterSequence class -- separated out
 // from the rest of the class implementation so as to speed up
 // compilation of this particular part while it is under test.
 …
 #include "fastjet/ClusterSequence.hh"
 #include "fastjet/internal/MinHeap.hh"
+#include "fastjet/internal/TilingExtent.hh"
 FASTJET_BEGIN_NAMESPACE      // defined in fastjet/internal/base.hh
 …
   _tile_size_phi = twopi / _n_tiles_phi; // >= _Rparam and fits in 2pi
+  // always include zero rapidity in the tiling region
+  _tiles_eta_min = 0.0;
+  _tiles_eta_max = 0.0;
+  // but go no further than following
+  const double maxrap = 7.0;
+  // and find out how much further one should go
+  for(unsigned int i = 0; i < _jets.size(); i++) {
+    double eta = _jets[i].rap();
+    // first check if eta is in range -- to avoid taking into account
+    // very spurious rapidities due to particles with near-zero kt.
+    if (abs(eta) < maxrap) {
+      if (eta < _tiles_eta_min) {_tiles_eta_min = eta;}
+      if (eta > _tiles_eta_max) {_tiles_eta_max = eta;}
+    }
+  }
+  TilingExtent tiling_analysis(*this);
+  _tiles_eta_min = tiling_analysis.minrap();
+  _tiles_eta_max = tiling_analysis.maxrap();
+  // // always include zero rapidity in the tiling region
+  // _tiles_eta_min = 0.0;
+  // _tiles_eta_max = 0.0;
+  // // but go no further than following
+  // const double maxrap = 7.0;
+  //
+  // // and find out how much further one should go
+  // for(unsigned int i = 0; i < _jets.size(); i++) {
+  //   double eta = _jets[i].rap();
+  //   // first check if eta is in range -- to avoid taking into account
+  //   // very spurious rapidities due to particles with near-zero kt.
+  //   if (abs(eta) < maxrap) {
+  //     if (eta < _tiles_eta_min) {_tiles_eta_min = eta;}
+  //     if (eta > _tiles_eta_max) {_tiles_eta_max = eta;}
+  //   }
+  // }
   // now adjust the values
 …
 //----------------------------------------------------------------------
 /// return the tile index corresponding to the given eta,phi point
 int ClusterSequence::_tile_index(const double & eta, const double & phi) const {
+int ClusterSequence::_tile_index(const double eta, const double phi) const {
   int ieta, iphi;
   if      (eta <= _tiles_eta_min) {ieta = 0;}
 …
 /// their "tagged" status is false; when a neighbour is added its
 /// tagged status is set to true.
+///
+/// Note that with a high level of warnings (-pedantic -Wextra -ansi,
+/// gcc complains about tile_index maybe being used uninitialised for
+/// oldB in ClusterSequence::_minheap_faster_tiled_N2_cluster(). We
+/// have explicitly checked that it was harmless so we could disable
+/// the gcc warning by hand using the construct below
+///
+///  #pragma GCC diagnostic push
+///  #pragma GCC diagnostic ignored "-Wpragmas"
+///  #pragma GCC diagnostic ignored "-Wuninitialized"
+///  #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+///    ...
+///  #pragma GCC diagnostic pop
+///
+/// the @GCC diagnostic push/pop directive was only introduced in
+/// gcc-4.6, so for broader usage, we'd need to insert #pragma GCC
+/// diagnostic ignored "-Wpragmas" at the top of this file
 inline void ClusterSequence::_add_untagged_neighbours_to_tile_union(
                const int tile_index,
 …
   TiledJet * jetA = briefjets, * jetB;
   TiledJet oldB;
   oldB.tile_index=0; // prevents a gcc warning
+  oldB.tile_index=0; // prevents a gcc warning
   // will be used quite deep inside loops, but declare it here so that
 …
   TiledJet * jetA = briefjets, * jetB;
   TiledJet oldB;
   oldB.tile_index=0; // prevents a gcc warning
+  oldB.tile_index=0; // prevents a gcc warning
   // will be used quite deep inside loops, but declare it here so that
 …
     // when we set NN for both jetA and jetB on the RH tiles.
+  }
   // now create the diJ (where J is i's NN) table -- remember that
 …
+}
 //----------------------------------------------------------------------
 /// run a tiled clustering, with our minheap for keeping track of the
 …
   TiledJet oldB;
   oldB.tile_index=0; // prevents a gcc warning
   // will be used quite deep inside loops, but declare it here so that

external/fastjet/CompositeJetStructure.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
+//FJSTARTHEADER
+// $Id: CompositeJetStructure.cc 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include <fastjet/CompositeJetStructure.hh>
 …
   double a_err=0;
   for (unsigned i = 0; i < _pieces.size(); i++)
     a_err += _pieces[i].area();
+    a_err += _pieces[i].area_error();
   return a_err;

external/fastjet/CompositeJetStructure.hh

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id: CompositeJetStructure.hh 3071 2013-04-01 12:52:46Z cacciari $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+//FJSTARTHEADER
+// $Id: CompositeJetStructure.hh 3652 2014-09-03 13:31:13Z salam $
+//
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 …
   virtual bool is_pure_ghost(const PseudoJet &reference) const;
+  // allow to modify the area information
+  // (for use in join())
+  //------------------------------------------------------------------------------
+  void set_area_information(PseudoJet *area_4vector_ptr){
+    _area_4vector_ptr = area_4vector_ptr;
+  //unused: // allows one to modify the area information
+  //unused: // (for use in join())
+  //unused: //
+  //unused: // This member cannot be used by users who need to create a jet with
+  //unused: // user-supplied area information, because it sets only the 4-vector
+  //unused: // part of the area, but not all the other area information
+  //unused: // (e.g. scalar area) -- that other information is always deduced
+  //unused: // dynamically from the individual constituents.
+  //unused: // ------------------------------------------------------------------------------
+  //unused: void set_area_information(PseudoJet *area_4vector_ptr){
+  //unused:   _area_4vector_ptr = area_4vector_ptr;
+  //unused: }
+  /// disable the area of the composite jet
+  ///
+  /// this can be used e.g. to discard the area of a composite jet
+  /// made of pieces with non-explicit-ghost area since the area may
+  /// by erroneous in that case
+  void discard_area(){
+    if (_area_4vector_ptr) delete _area_4vector_ptr;
+    _area_4vector_ptr = 0;
+  }
 …
                                     const JetDefinition::Recombiner & recombiner){
   std::vector<PseudoJet> pieces;
+  pieces.reserve(2);
   pieces.push_back(j1);
   pieces.push_back(j2);
 …
                                     const JetDefinition::Recombiner & recombiner){
   std::vector<PseudoJet> pieces;
+  pieces.reserve(3);
   pieces.push_back(j1);
   pieces.push_back(j2);
 …
                                     const JetDefinition::Recombiner & recombiner){
   std::vector<PseudoJet> pieces;
+  pieces.reserve(4);
   pieces.push_back(j1);
   pieces.push_back(j2);

external/fastjet/Dnn2piCylinder.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+//FJSTARTHEADER
+// $Id: Dnn2piCylinder.cc 3433 2014-07-23 08:17:03Z salam $
+//
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER

external/fastjet/Dnn3piCylinder.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
+//FJSTARTHEADER
+// $Id: Dnn3piCylinder.cc 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER

external/fastjet/Dnn4piCylinder.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
+//FJSTARTHEADER
+// $Id: Dnn4piCylinder.cc 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER

external/fastjet/DnnPlane.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
+//FJSTARTHEADER
+// $Id: DnnPlane.cc 3442 2014-07-24 07:20:49Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 …
 #include<list>
 #include "fastjet/internal/DnnPlane.hh"
 using namespace std;
 FASTJET_BEGIN_NAMESPACE      // defined in fastjet/internal/base.hh
+const double DnnPlane::DISTANCE_FOR_CGAL_CHECKS=1.0e-12;
 …
        _TR.insert(Point(input_points[i].first, input_points[i].second));
+    // we are not up to dealing with coincident vertices, so make
+    // sure the user knows!
+    _CrashIfVertexPresent(sv.vertex, i);
+    // we need to assicate an index to each vertex -- thus when we get
+    // a vertex (e.g. as a nearest neighbour) from CGAL, we will be
+    // able to figure out which particle it corresponded to.
+    sv.vertex->info() = i;
+    // check if we are dealing with coincident vertices
+    int coinciding_index = _CheckIfVertexPresent(sv.vertex, i);
+    if (coinciding_index == i){
+      // we need to associate an index to each vertex -- thus when we get
+      // a vertex (e.g. as a nearest neighbour) from CGAL, we will be
+      // able to figure out which particle it corresponded to.
+      sv.vertex->info() = sv.coincidence = i;
+    } else {
+      //cout << "  coincident with " << coinciding_index << endl;
+      // the new vertex points to the already existing one and we
+      // record the coincidence
+      //
+      // Note that we must not only set the coincidence of the
+      // currently-added particle, the one it coincides with also
+      // needs be updated (taking into account that it might already
+      // coincide with another one)
+      //
+      // An example may help. Say coinciding_index = i1 and we're adding i2==i.
+      // Then _sv[i2].coincidence = i1; _sv[i1].coincidence = i2. In both
+      // cases sv.vertex->info() == i1;
+      //
+      // Later on we add i3; we find out that its coinciding index is i1;
+      // so we set _sv[i3].coincidence = i2 and sv[i1].coincidence = i3.
+      //
+      // This gives us the structure
+      //  _supervertex[i1].coincidence == in
+      //  _supervertex[i2].coincidence == i1
+      //  ...
+      //  _supervertex[in].coincidence == in-1
+      //
+      sv.coincidence = _supervertex[coinciding_index].coincidence; // handles cases with previous coincidences
+      _supervertex[coinciding_index].coincidence = i;
+    }
     _supervertex.push_back(sv);
+  }
 …
 /// Crashes if the given vertex handle already exists. Otherwise
 /// it does the bookkeeping for future such tests
+void DnnPlane::_CrashIfVertexPresent(
+        const Vertex_handle & vertex, const int & its_index) {
+  if (!_crash_on_coincidence) return;
+int DnnPlane::_CheckIfVertexPresent(
+        const Vertex_handle & vertex, const int its_index) {
   // vertices that do not have the same geometric position as any
   // other vertex so far added have info().val() == NEW_VERTEX -- this
 …
   // DNN:DNN) to be equal to a vertex "index".
   if (vertex->info().val() != NEW_VERTEX) {
+    ostringstream err;
+    err << "ERROR in DnnPlane::_CrashIfVertexPresent"
+         <<endl << "Point "<<its_index<<" coincides with point "
+         <<vertex->info().val() << endl;
+    throw DnnError(err.str());
+  }
+    if (_crash_on_coincidence){
+      ostringstream err;
+      err << "Error: DnnPlane::_CheckIfVertexPresent"
+          << "Point "<<its_index<<" coincides with point "
+          <<vertex->info().val() << endl;
+      throw DnnError(err.str());
+    }
+    return vertex->info().val();
+  }
+  return its_index;
+}
 …
                           vector<int> & indices_of_updated_neighbours) {
+  if (_verbose) cout << "Starting  DnnPlane::RemoveAndAddPoints" << endl;
   // build set of UNION of Voronoi neighbours of a pair of nearest
 …
   set<int> indices_removed;
+  // for each of the indices to be removed add the voronoi neighbourhood to
+  // the NeighbourUnion set.
+  // for each of the indices to be removed add the voronoi
+  // neighbourhood to the NeighbourUnion set as well as the coinciding
+  // points that had the current point as coincidence before.
   for (size_t ir = 0; ir < indices_to_remove.size(); ir++) {
     int index = indices_to_remove[ir];
     indices_removed.insert(index);
+    if (_verbose) cout << " Starting  RemoveAndAddPoints" << endl;
+    if (_verbose) cout << " point " << index << endl;
+    if (_verbose) cout << "  scheduling point " << index << " for removal" << endl;
+    if (_supervertex[index].coincidence != index){
+      // we have a coincidence
+      //
+      // The only one of the coincident points that has to be
+      // inserted in the neighbourhood list (and thus updated) is the
+      // one that has 'index' as coincidence.
+      int new_index = _supervertex[index].coincidence;
+      while (_supervertex[new_index].coincidence != index)
+        new_index = _supervertex[new_index].coincidence;
+      if (_verbose) cout << "  inserted coinciding " << new_index << " to neighbours union" << endl;
+      NeighbourUnion.insert(new_index);
+      // if this is the point among the coiciding ones that holds the
+      // CGAL vertex, then also insert the CGAL neighbours, otherwise
+      // just skip that step.
+      if (index != _supervertex[index].vertex->info().val()) continue;
+    }
     // have a circulators that will go round the Voronoi neighbours of
     // _supervertex[index1].vertex
     Vertex_circulator vc = _TR.incident_vertices(_supervertex[index].vertex);
     Vertex_circulator done = vc;
+    do  {
+      // if a neighbouring vertex not the infinite vertex, then add it
+      // to our union of neighbouring vertices.
+      if (_verbose) cout << "examining " << vc->info().val() << endl;
+      if (vc->info().val() != INFINITE_VERTEX) {
+        // NB: from it=1 onwards occasionally it might already have
+        // been inserted -- but double insertion still leaves only one
+        // copy in the set, so there's no problem
+        NeighbourUnion.insert(vc->info().val());
+        if (_verbose) cout << "inserted " << vc->info().val() << endl;
+      }
+    } while (++vc != done);
+    if (vc != NULL){ // a safety check in case there is no Voronoi
+                     // neighbour (which may happen e.g. if we just
+                     // have a bunch of coincident points)
+      do  {
+        // if a neighbouring vertex is not the infinite vertex, then add it
+        // to our union of neighbouring vertices.
+        if (_verbose) cout << "examining " << vc->info().val() << endl;
+        if (vc->info().val() != INFINITE_VERTEX) {
+          // NB: from it=1 onwards occasionally it might already have
+          // been inserted -- but double insertion still leaves only one
+          // copy in the set, so there's no problem
+          NeighbourUnion.insert(vc->info().val());
+          if (_verbose) cout << "  inserted " << vc->info().val() << " to neighbours union" << endl;
+        }
+      } while (++vc != done);
+    }
+  }
 …
   for (size_t ir = 0; ir < indices_to_remove.size(); ir++) {
     int index = indices_to_remove[ir];
+    if (_verbose) cout << "  removing " << index << endl;
     // NeighbourUnion should not contain the points to be removed
     // (because later we will assume they still exist).
     NeighbourUnion.erase(indices_to_remove[ir]);
+    // first deal with  coincidences
+    if (_supervertex[index].coincidence != index){
+      int new_index = _supervertex[index].coincidence;
+      // if this is the point among the coiciding ones that "owns" the
+      // CGAL vertex we need to re-label the CGAL vertex so that it
+      // points to the coincident particle and set the current one to
+      // NULL
+      //
+      // This can be done only on the first point as they all share
+      // the same value
+      //
+      // Note that this has to be done before the following step since
+      // it will alter the coincidence information
+      if (index == _supervertex[index].vertex->info().val())
+        _supervertex[new_index].vertex->info() = new_index;
+      // we need to browse the coincidences until we end the loop, at
+      // which point we reset the coincidence of the point that has
+      // the current one as a coincidence
+      while (_supervertex[new_index].coincidence != index)
+        new_index = _supervertex[new_index].coincidence;
+      _supervertex[new_index].coincidence = _supervertex[index].coincidence;
+      // remove the coincidence on the point being removed and mark it
+      // as removed
+      _supervertex[index].coincidence = index;
+      _supervertex[index].vertex = NULL;
+      continue;
+    }
     // points to be removed should also be eliminated from the
     // triangulation and the supervertex structure should be updated
 …
   // of the neighbour union happens to be on the wrong side.
   Face_handle face;
+  if (indices_to_remove.size() > 0) {
+  //if (indices_to_remove.size() > 0) { // GS: use NeighbourUnion instead
+                                        //     (safe also in case of coincidences)
+  if (NeighbourUnion.size() > 0) {
     // face can only be found if there were points to remove in first place
     face = _TR.incident_faces(
 …
     int index = _supervertex.size()-1;
     indices_added.push_back(index);
+    if (indices_to_remove.size() > 0) {
+    if (_verbose) cout << "  adding " << index << endl;
+    //if (indices_to_remove.size() > 0) {
+    if (NeighbourUnion.size() > 0) {
       // be careful of using face (for location hinting) only when it exists
       _supervertex[index].vertex = _TR.insert(Point(points_to_add[ia].first,
 …
                                                     points_to_add[ia].second));
+    }
+    // we are not up to dealing with coincident vertices, so make
+    // sure the user knows!
+    _CrashIfVertexPresent(_supervertex[index].vertex, index);
+    _supervertex[index].vertex->info() = index;
+    // check if this leads to a coincidence
+    int coinciding_index = _CheckIfVertexPresent(_supervertex[index].vertex, index);
+    if (coinciding_index == index){
+      // we need to associate an index to each vertex -- thus when we get
+      // a vertex (e.g. as a nearest neighbour) from CGAL, we will be
+      // able to figure out which particle it corresponded to.
+      _supervertex[index].vertex->info() = _supervertex[index].coincidence = index;
+    } else {
+      if (_verbose) cout << "  coinciding with vertex " << coinciding_index << endl;
+      // the new vertex points to an already existing one and we
+      // record the coincidence
+      //
+      // we also update the NN of the coinciding particle (to avoid
+      // having to loop over the list of coinciding neighbours later)
+      // This is done first as it allows us to check if this is a new
+      // coincidence or a coincidence added to a particle that was
+      // previously "alone"
+      _supervertex[coinciding_index].NNindex = index;
+      _supervertex[coinciding_index].NNdistance = 0.0;
+      indices_of_updated_neighbours.push_back(coinciding_index);
+      // Note that we must not only set the coincidence of the
+      // currently-added particle, the one it coincides with also
+      // needs be updated (taking into account that it might already
+      // coincide with another one)
+      _supervertex[index].coincidence = _supervertex[coinciding_index].coincidence; // handles cases with previous coincidences
+      _supervertex[coinciding_index].coincidence = index;
+    }
     // first find nearest neighbour of "newpoint" (shorthand for
 …
     indices_of_updated_neighbours.push_back(index);
     _SetAndUpdateNearest(index, indices_of_updated_neighbours);
+    //cout << "Added: " << setprecision(20) << " ("
+    //     << points_to_add[ia].first << "," << points_to_add[ia].second
+    //     << ") with index " << index << endl;
+  }
 …
+  }
+  if (_verbose) cout << "Leaving  DnnPlane::RemoveAndAddPoints" << endl;
+}
 //----------------------------------------------------------------------
 /// Determines the index and distance of the nearest neighbour to
 /// point j and puts the information into the _supervertex entry for j.
+void DnnPlane::_SetNearest (const int & j) {
+void DnnPlane::_SetNearest (const int j) {
+  // first deal with the cases where we have a coincidence
+  if (_supervertex[j].coincidence != j){
+    _supervertex[j].NNindex = _supervertex[j].coincidence;
+    _supervertex[j].NNdistance = 0.0;
+    return;
+  }
+  // The code below entirely uses CGAL distance comparisons to compute
+  // the nearest neighbour. It has the mais drawback to induice a
+  // 10-20% time penalty so we switched to our own comparison (which
+  // only turns to CGAL for dangerous situations)
+  //
+  //  Vertex_handle current = _supervertex[j].vertex;
+  //  Vertex_circulator vc = _TR.incident_vertices(current);
+  //  Vertex_circulator done = vc;
+  //  Vertex_handle nearest = _TR.infinite_vertex();
+  //  double mindist = HUGE_DOUBLE;
+  //
+  //   // when there is only one finite point left in the triangulation,
+  //   // there are no triangles. Presumably this is why voronoi returns
+  //   // NULL for the incident vertex circulator. Check if this is
+  //   // happening before circulating over it... (Otherwise it crashes
+  //   // when looking for neighbours of last point)
+  //   if (vc != NULL){
+  //     // initialise the nearest vertex handle to the first incident
+  //     // vertex that is not INFINITE_VERTEX
+  //     while (vc->info().val() == INFINITE_VERTEX){
+  //       vc++;
+  //       if (vc==done) break; // if vc==done, then INFINITE_VERTEX is the
+  //                       // only element in the neighbourhood
+  //     }
+  //
+  //     // if there is just the infinite vertex, we have vc->info().val()
+  //     // == INFINITE_VERTEX and nothing has to be done
+  //     // otherwise, use the current vc as an initialisation
+  //     if (vc->info().val() != INFINITE_VERTEX){
+  //       nearest = vc; // initialisation to the first non-infinite vertex
+  //
+  //       // and loop over the following ones
+  //       while (++vc != done){
+  //    // we should not compare with the infinite vertex
+  //    if (vc->info().val() == INFINITE_VERTEX) continue;
+  //
+  //    if (_verbose) cout << current->info().val() << " " << vc->info().val() << endl;
+  //    // use CGAL's distance comparison to check if 'vc' is closer to
+  //    // 'current' than the nearest so far (we include the == case for
+  //    // safety though it should not matter in this precise case)
+  //    if (CGAL::compare_distance_to_point(current->point(), vc->point(), nearest->point())!=CGAL::LARGER){
+  //      nearest = vc;
+  //      if (_verbose) cout << "nearer";
+  //    }
+  //       }
+  //
+  //       // now compute the distance
+  //       //
+  //       // Note that since we're always using CGAL to compare distances
+  //       // (and never the distance computed using _euclid_distance) we
+  //       // should not worry about rounding errors in mindist
+  //       mindist = _euclid_distance(current->point(), nearest->point());
+  //     }
+  //   }
+  //
+  //  // set j's supervertex info about nearest neighbour
+  //  _supervertex[j].NNindex = nearest->info().val();
+  //  _supervertex[j].NNdistance = mindist;
   Vertex_handle current = _supervertex[j].vertex;
   Vertex_circulator vc = _TR.incident_vertices(current);
 …
   double mindist = HUGE_DOUBLE; // change this to "HUGE" or max_double?
   Vertex_handle nearest = _TR.infinite_vertex();
   // when there is only one finite point left in the triangulation,
   // there are no triangles. Presumably this is why voronoi returns
 …
       // find distance between j and its Voronoi neighbour (vc)
       if (_verbose) cout << current->info().val() << " " << vc->info().val() << endl;
+      dist = _euclid_distance(current->point(), vc->point());
       // check if j is closer to vc than vc's currently registered
       // nearest neighbour (and update things if it is)
       if (dist < mindist) {
         mindist = dist; nearest = vc;
         if (_verbose) cout << "nearer ";
+      if (_is_closer_to(current->point(), vc->point(), nearest, dist, mindist)){
+        nearest = vc;
+        if (_verbose) cout << "nearer ";
+      }
       if (_verbose) cout << vc->point() << "; "<< dist << endl;
+    }
   } while (++vc != done); // move on to next Voronoi neighbour
   // set j's supervertex info about nearest neighbour
   _supervertex[j].NNindex = nearest->info().val();
 …
 //----------------------------------------------------------------------
 /// Determines and stores the nearest neighbour of j, and where
 /// necessary update the nearest-neighbour info of Voronoi neighbours
+/// necessary updates the nearest-neighbour info of Voronoi neighbours
 /// of j;
 ///
 …
 /// NB: note that we have _SetAndUpdateNearest as a completely
 ///     separate routine from _SetNearest because we want to
 ///     use one single ciruclation over voronoi neighbours to find the
+///     use one single circulation over voronoi neighbours to find the
 ///     nearest neighbour and to update the voronoi neighbours if need
 ///     be.
 void DnnPlane::_SetAndUpdateNearest(
                           const int & j,
+                          const int j,
                           vector<int> & indices_of_updated_neighbours) {
+  //cout << "SetAndUpdateNearest for point " << j << endl;
+  // first deal with coincidences
+  if (_supervertex[j].coincidence != j){
+    _supervertex[j].NNindex = _supervertex[j].coincidence;
+    _supervertex[j].NNdistance = 0.0;
+    //cout << "  set to coinciding point " << _supervertex[j].coincidence << endl;
+    return;
+  }
   Vertex_handle current = _supervertex[j].vertex;
 …
     if (vc->info().val() != INFINITE_VERTEX) {
       if (_verbose) cout << current->info().val() << " " << vc->info().val() << endl;
+      // find distance between j and its Voronoi neighbour (vc)
+      dist = _euclid_distance(current->point(), vc->point());
       // update the mindist if we are closer than anything found so far
       if (dist < mindist) {
         mindist = dist; nearest = vc;
         if (_verbose) cout << "nearer ";
+      if (_is_closer_to(current->point(), vc->point(), nearest, dist, mindist)){
+        nearest = vc;
+        if (_verbose) cout << "nearer ";
+      }
       // find index corresponding to vc for easy manipulation
       int vcindx = vc->info().val();
       if (_verbose) cout << vc->point() << "; "<< dist << endl;
+      // check if j is closer to vc than vc's currently registered
+      // nearest neighbour (and update things if it is)
+      if (dist < _supervertex[vcindx].NNdistance) {
+      if (_is_closer_to_with_hint(vc->point(), current->point(),
+                                  _supervertex[_supervertex[vcindx].NNindex].vertex,
+                                  dist, _supervertex[vcindx].NNdistance)){
         if (_verbose) cout << vcindx << "'s NN becomes " << current->info().val() << endl;
-        _supervertex[vcindx].NNdistance = dist;
         _supervertex[vcindx].NNindex = j;
         indices_of_updated_neighbours.push_back(vcindx);
+      }
+      // original code without the use of CGAL distance in potentially
+      // dangerous cases
+      //
+      // // check if j is closer to vc than vc's currently registered
+      // // nearest neighbour (and update things if it is)
+      // //
+      // // GS: originally, the distance test below was a strict <. It
+      // //     has to be <= because if the two distances are ==, it is
+      // //     possible that the old NN is no longer connected to vc in
+      // //     the triangulation, and we are sure that the newly
+      // //     inserted point (j) is (since we loop over j's
+      // //     neighbouring points in the triangulation).
+      // if (dist <= _supervertex[vcindx].NNdistance) {
+      //        if (_verbose) cout << vcindx << "'s NN becomes " << current->info().val() << endl;
+      //        _supervertex[vcindx].NNdistance = dist;
+      //        _supervertex[vcindx].NNindex = j;
+      //        indices_of_updated_neighbours.push_back(vcindx);
+      // }
+    }
   } while (++vc != done); // move on to next Voronoi neighbour
   // set j's supervertex info about nearest neighbour
+  //cout << "  set to point " << nearest->info().val() << endl;
   _supervertex[j].NNindex = nearest->info().val();
   _supervertex[j].NNdistance = mindist;

external/fastjet/Error.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
+//FJSTARTHEADER
+// $Id: Error.cc 3695 2014-09-18 13:57:56Z cacciari $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include "fastjet/Error.hh"
 …
 #include <sstream>
+#ifndef __FJCORE__
 // printing the stack would need execinfo
 #ifdef FASTJET_HAVE_EXECINFO_H
 #include <execinfo.h>
 #include <cstdlib>
+#endif
+#ifdef FASTJET_HAVE_DEMANGLING_SUPPORT
+#include <cstdio>
+#include <cxxabi.h>
+#endif // FASTJET_HAVE_DEMANGLING_SUPPORT
+#endif // FASTJET_HAVE_EXECINFO_H
+#endif  // __FJCORE__
 FASTJET_BEGIN_NAMESPACE      // defined in fastjet/internal/base.hh
 …
 bool Error::_print_backtrace = false;
 ostream * Error::_default_ostr = & cerr;
+#if (!defined(FASTJET_HAVE_EXECINFO_H)) || defined(__FJCORE__)
+  LimitedWarning Error::_execinfo_undefined;
+#endif
+//----------------------------------------------------------------------
+#ifndef __FJCORE__
+// demangling only is included, i.e. --enable-demangling is specified
+// at configure time, execinfo.h is present and the GNU C++ ABI is
+// supported
+#if defined(FASTJET_HAVE_EXECINFO_H) && defined(FASTJET_HAVE_DEMANGLING_SUPPORT)
+// demangle a given backtrace symbol
+//
+// Notes:
+//  - at the moment, only the symbol is parsed.
+//  - one can get the offset by using
+//      "%*[^(]%*[^_]%127[^+)]%64[+x0123456789abcdef]", symbol, offset
+//    and checking if sscanf returns 0, 1 or 2
+//    (offset includes the leading +)
+//  - Similarly one could exctract the address and try to convert it
+//    into a filename+line number like addr2line does but this seems
+//    to require exteral dependencies. If we want to go down that
+//    route, one could look into the inplementation o faddr2line(.c)
+//    and/or dladdr.
+string Error::_demangle(const char* symbol) {
+  size_t size;
+  int status;
+  char temp[128];
+  char* demangled;
+  // first, try to demangle a c++ name
+  // decryption:
+  //   %*[^(]  matches any number of characters different from "("
+  //           the * tells not to store in input var
+  //   %*[^_]  matches any number of characters different from "_"
+  //           the * tells not to store in input var
+  //   %127[^)+]  matches at most 127 characters different from "+"
+  //              match is stored
+  if (1 == sscanf(symbol, "%*[^(]%*[^_]%127[^)+]", temp)) {
+    //cout << symbol << " -> " << temp << endl;
+    if (NULL != (demangled = abi::__cxa_demangle(temp, NULL, &size, &status))) {
+      string result(demangled);
+      free(demangled);
+      return result;
+    }
+  }
+  //if that didn't work, try to get a regular c symbol
+  if (1 == sscanf(symbol, "%127s", temp)) {
+    return temp;
+  }
+  //if all else fails, just return the symbol
+  return symbol;
+}
+#endif  // FASTJET_HAVE_DEMANGLING_SUPPORT && FASTJET_HAVE_EXECINFO_H
+#endif  // __FJCORE__
+//----------------------------------------------------------------------
 Error::Error(const std::string & message_in) {
   _message = message_in;
   if (_print_errors && _default_ostr){
     ostringstream oss;
     oss << "fastjet::Error:  "<< message_in << endl;
+#ifndef __FJCORE__
     // only print the stack if execinfo is available and stack enabled
 #ifdef FASTJET_HAVE_EXECINFO_H
 …
       oss << "stack:" << endl;
       for (int i = 1; i < size && messages != NULL; ++i){
+#ifdef FASTJET_HAVE_DEMANGLING_SUPPORT
+        oss << "  #" << i << ": " << _demangle(messages[i])
+            << " [" << messages[i]  << "]" << endl;
+#else
         oss << "  #" << i << ": " << messages[i] << endl;
+#endif
+      }
       free(messages);
+    }
+#endif
+#endif  // FASTJET_HAVE_EXECINFO_H
+#endif  // __FJCORE__
     *_default_ostr << oss.str();
 …
+}
+//----------------------------------------------------------------------
+void Error::set_print_backtrace(bool enabled) {
+#if (!defined(FASTJET_HAVE_EXECINFO_H)) || defined(__FJCORE__)
+  if (enabled) {
+    _execinfo_undefined.warn("Error::set_print_backtrace(true) will not work with this build of FastJet");
+  }
+#endif
+  _print_backtrace = enabled;
+}
 FASTJET_END_NAMESPACE

external/fastjet/Error.hh

-              rf6b6ee7
+              r49234af
 #define __FASTJET_ERROR_HH__
 //STARTHEADER
 // $Id: Error.hh 2577 2011-09-13 15:11:38Z salam $
+//FJSTARTHEADER
+// $Id: Error.hh 3694 2014-09-18 13:21:54Z soyez $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include<iostream>
 #include<string>
 #include "fastjet/internal/base.hh"
+#include "fastjet/config.h"
+#if (!defined(FASTJET_HAVE_EXECINFO_H)) || defined(__FJCORE__)
+#include "fastjet/LimitedWarning.hh"
+#endif
 FASTJET_BEGIN_NAMESPACE      // defined in fastjet/internal/base.hh
 …
   /// controls whether the backtrace is printed out with the error message or not.
   /// The default is "false".
   static void set_print_backtrace(bool enabled) {_print_backtrace = enabled;}
+  static void set_print_backtrace(bool enabled);
   /// sets the default output stream for all errors; by default
 …
 private:
+#ifndef __FJCORE__
+#if defined(FASTJET_HAVE_EXECINFO_H) && defined(FASTJET_HAVE_DEMANGLING_SUPPORT)
+  /// demangle a given backtrace symbol
+  std::string _demangle(const char* symbol);
+#endif
+#endif
   std::string _message;                ///< error message
   static bool _print_errors;           ///< do we print anything?
   static bool _print_backtrace;        ///< do we print the backtrace?
   static std::ostream * _default_ostr; ///< the output stream (cerr if not set)
+#if (!defined(FASTJET_HAVE_EXECINFO_H)) || defined(__FJCORE__)
+  static LimitedWarning _execinfo_undefined;
+#endif
 };

external/fastjet/FunctionOfPseudoJet.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
+//FJSTARTHEADER
+// $Id: FunctionOfPseudoJet.cc 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include <fastjet/FunctionOfPseudoJet.hh>

external/fastjet/FunctionOfPseudoJet.hh

-              rf6b6ee7
+              r49234af
 #define __FASTJET_FUNCTION_OF_PSEUDOJET_HH__
 //STARTHEADER
 // $Id: FunctionOfPseudoJet.hh 2577 2011-09-13 15:11:38Z salam $
+//FJSTARTHEADER
+// $Id: FunctionOfPseudoJet.hh 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include <fastjet/PseudoJet.hh>
 …
   FunctionOfPseudoJet(){}
+  /// ctor that creates a constant function
+  FunctionOfPseudoJet(const TOut &constant_value);
+  // ctor that creates a constant function
+  //----------
+  // this declaration was present in versions of FJ from 3.0.0 to 3.0.6,
+  // but never implemented. It is being removed from 3.0.7 upwards
+  // to avoid misleading users
+  //FunctionOfPseudoJet(const TOut &constant_value);
   /// default dtor (virtual to allow safe polymorphism)

external/fastjet/GhostedAreaSpec.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
+//FJSTARTHEADER
+// $Id: GhostedAreaSpec.cc 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include "fastjet/GhostedAreaSpec.hh"

external/fastjet/GhostedAreaSpec.hh

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id: GhostedAreaSpec.hh 2728 2011-11-20 14:18:59Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+//FJSTARTHEADER
+// $Id: GhostedAreaSpec.hh 3433 2014-07-23 08:17:03Z salam $
+//
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 …
   // for accessing values set by the user
+  inline double ghost_rapmax () const {return _ghost_maxrap;}
+  inline double ghost_maxrap () const {return _ghost_maxrap;}
   inline double ghost_etamax () const {return _ghost_maxrap;}
   inline double ghost_maxrap () const {return _ghost_maxrap;}
+  inline double ghost_maxeta () const {return _ghost_maxrap;}
   inline double ghost_area   () const {return _ghost_area   ;}
   inline double grid_scatter () const {return _grid_scatter;}
 …
   // when explicitly modifying values, sometimes call the initializer
   inline void set_ghost_area   (double val) {_ghost_area    = val; _initialize();}
+  inline void set_ghost_rapmax (double val) {_ghost_maxrap = val; _initialize();}
+  inline void set_ghost_maxrap (double val) {_ghost_maxrap = val; _initialize();}
   inline void set_ghost_etamax (double val) {_ghost_maxrap = val; _initialize();}
   inline void set_ghost_maxrap (double val) {_ghost_maxrap = val; _initialize();}
+  inline void set_ghost_maxeta (double val) {_ghost_maxrap = val; _initialize();}
   inline void set_grid_scatter (double val) {_grid_scatter   = val; }
   inline void set_pt_scatter   (double val) {_pt_scatter     = val; }

external/fastjet/JetDefinition.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+//FJSTARTHEADER
+// $Id: JetDefinition.cc 3677 2014-09-09 22:45:25Z soyez $
+//
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include "fastjet/JetDefinition.hh"
 …
   // cross-check the number of parameters that were declared in setting up the
   // algorithm (passed internally from the public constructors)
+  switch (jet_algorithm_in) {
+  case ee_kt_algorithm:
+    if (nparameters != 0) {
+      ostringstream oss;
+      oss << "ee_kt_algorithm should be constructed with 0 parameters but was called with "
+          << nparameters << " parameter(s)\n";
+      throw Error(oss.str());
+    }
+    break;
+  case genkt_algorithm:
+  case ee_genkt_algorithm:
+    if (nparameters != 2) {
+      ostringstream oss;
+      oss << "(ee_)genkt_algorithm should be constructed with 2 parameters but was called with "
+          << nparameters << " parameter(s)\n";
+      throw Error(oss.str());
+    }
+    break;
+  default:
+    if (nparameters != 1) {
+      ostringstream oss;
+      oss << "The jet algorithm you requested ("
+          << jet_algorithm_in << ") should be constructed with 1 parameter but was called with "
+          << nparameters << " parameter(s)\n";
+      throw Error(oss.str());
+    }
+  unsigned int nparameters_expected = n_parameters_for_algorithm(jet_algorithm_in);
+  if (nparameters != (int) nparameters_expected){
+    ostringstream oss;
+    oss << "The jet algorithm you requested ("
+        << jet_algorithm_in << ") should be constructed with " << nparameters_expected
+        << " parameter(s) but was called with " << nparameters << " parameter(s)\n";
+    throw Error(oss.str());
+  }
 …
 //----------------------------------------------------------------------
+// returns true if the jet definition involves an algorithm
+// intended for use on a spherical geometry (e.g. e+e- algorithms,
+// as opposed to most pp algorithms, which use a cylindrical,
+// rapidity-phi geometry).
+bool JetDefinition::is_spherical() const {
+  if (jet_algorithm() == plugin_algorithm) {
+    return plugin()->is_spherical();
+  } else {
+    return (jet_algorithm() == ee_kt_algorithm ||  // as of 2013-02-14, the two
+            jet_algorithm() == ee_genkt_algorithm  // native spherical algorithms
+            );
+  }
+}
+//----------------------------------------------------------------------
 string JetDefinition::description() const {
+  ostringstream name;
+  name << description_no_recombiner();
+  if ((jet_algorithm() == plugin_algorithm) || (jet_algorithm() == undefined_jet_algorithm)){
+    return name.str();
+  }
+  if (n_parameters_for_algorithm(jet_algorithm()) == 0)
+    name << " with ";
+  else
+    name << " and ";
+  name << recombiner()->description();
+  return name.str();
+}
+//----------------------------------------------------------------------
+string JetDefinition::description_no_recombiner() const {
   ostringstream name;
   if (jet_algorithm() == plugin_algorithm) {
     return plugin()->description();
-  } else if (jet_algorithm() == kt_algorithm) {
-    name << "Longitudinally invariant kt algorithm with R = " << R();
-    name << " and " << recombiner()->description();
-  } else if (jet_algorithm() == cambridge_algorithm) {
-    name << "Longitudinally invariant Cambridge/Aachen algorithm with R = "
-         << R() ;
-    name << " and " << recombiner()->description();
-  } else if (jet_algorithm() == antikt_algorithm) {
-    name << "Longitudinally invariant anti-kt algorithm with R = "
-         << R() ;
-    name << " and " << recombiner()->description();
-  } else if (jet_algorithm() == genkt_algorithm) {
-    name << "Longitudinally invariant generalised kt algorithm with R = "
-         << R() << ", p = " << extra_param();
-    name << " and " << recombiner()->description();
-  } else if (jet_algorithm() == cambridge_for_passive_algorithm) {
-    name << "Longitudinally invariant Cambridge/Aachen algorithm with R = "
-         << R() << "and a special hack whereby particles with kt < "
-         << extra_param() << "are treated as passive ghosts";
-  } else if (jet_algorithm() == ee_kt_algorithm) {
-    name << "e+e- kt (Durham) algorithm (NB: no R)";
-    name << " with " << recombiner()->description();
-  } else if (jet_algorithm() == ee_genkt_algorithm) {
-    name << "e+e- generalised kt algorithm with R = "
-         << R() << ", p = " << extra_param();
-    name << " and " << recombiner()->description();
   } else if (jet_algorithm() == undefined_jet_algorithm) {
+    name << "uninitialised JetDefinition (jet_algorithm=undefined_jet_algorithm)" ;
+  } else {
+    throw Error("JetDefinition::description(): unrecognized jet_algorithm");
+  }
+    return "uninitialised JetDefinition (jet_algorithm=undefined_jet_algorithm)" ;
+  }
+  name << algorithm_description(jet_algorithm());
+  switch (n_parameters_for_algorithm(jet_algorithm())){
+  case 0: name << " (NB: no R)"; break;
+  case 1: name << " with R = " << R(); break; // the parameter is always R
+  case 2:
+    // the 1st parameter is always R
+    name << " with R = " << R();
+    // the 2nd depends on the algorithm
+    if (jet_algorithm() == cambridge_for_passive_algorithm){
+      name << "and a special hack whereby particles with kt < "
+           << extra_param() << "are treated as passive ghosts";
+    } else {
+      name << ", p = " << extra_param();
+    }
+  };
   return name.str();
+}
+//----------------------------------------------------------------------
+string JetDefinition::algorithm_description(const JetAlgorithm jet_alg){
+  ostringstream name;
+  switch (jet_alg){
+  case plugin_algorithm:                return "plugin algorithm";
+  case kt_algorithm:                    return "Longitudinally invariant kt algorithm";
+  case cambridge_algorithm:             return "Longitudinally invariant Cambridge/Aachen algorithm";
+  case antikt_algorithm:                return "Longitudinally invariant anti-kt algorithm";
+  case genkt_algorithm:                 return "Longitudinally invariant generalised kt algorithm";
+  case cambridge_for_passive_algorithm: return "Longitudinally invariant Cambridge/Aachen algorithm";
+  case ee_kt_algorithm:                 return "e+e- kt (Durham) algorithm (NB: no R)";
+  case ee_genkt_algorithm:              return "e+e- generalised kt algorithm";
+  case undefined_jet_algorithm:         return "undefined jet algorithm";
+  default:
+    throw Error("JetDefinition::algorithm_description(): unrecognized jet_algorithm");
+  };
+}
+//----------------------------------------------------------------------
+unsigned int JetDefinition::n_parameters_for_algorithm(const JetAlgorithm jet_alg){
+  switch (jet_alg) {
+  case ee_kt_algorithm:    return 0;
+  case genkt_algorithm:
+  case ee_genkt_algorithm: return 2;
+  default:                 return 1;
+  };
+}
+//----------------------------------------------------------------------
 void JetDefinition::set_recombination_scheme(
                                RecombinationScheme recomb_scheme) {
 …
   // do not forget to delete the existing recombiner if needed
   if (_recombiner_shared()) _recombiner_shared.reset();
+  if (_shared_recombiner()) _shared_recombiner.reset();
   _recombiner = 0;
+}
+void JetDefinition::set_recombiner(const JetDefinition &other_jet_def){
+  // make sure the "invariants" of the other jet def are sensible
+  assert(other_jet_def._recombiner ||
+         other_jet_def.recombination_scheme() != external_scheme);
+  // first treat the situation where we're using the default recombiner
+  if (other_jet_def._recombiner == 0){
+    set_recombination_scheme(other_jet_def.recombination_scheme());
+    return;
+  }
+  // in other cases, copy the pointer to the recombiner
+  _recombiner = other_jet_def._recombiner;
+  // set the default recombiner appropriately
+  _default_recombiner = DefaultRecombiner(external_scheme);
+  // and set the _shared_recombiner to the same state
+  // as in the other_jet_def, whatever that was
+  _shared_recombiner.reset(other_jet_def._shared_recombiner);
+  // NB: it is tempting to go via set_recombiner and then to sort
+  // out the shared part, but this would be dangerous in the
+  // specific (rare?) case where other_jet_def is the same as this
+  // it deletes_recombiner_when_unused. In that case the shared
+  // pointer reset would delete the recombiner.
+}
 …
   if (other_jd.recombination_scheme() != scheme) return false;
   // if the scheme is "external", also check that they ahve the same
+  // if the scheme is "external", also check that they have the same
   // recombiner
   return (scheme != external_scheme)
 …
+}
 /// allows to let the JetDefinition handle the deletion of the
+/// causes the JetDefinition to handle the deletion of the
 /// recombiner when it is no longer used
 void JetDefinition::delete_recombiner_when_unused(){
   if (_recombiner == 0){
     throw Error("tried to call JetDefinition::delete_recombiner_when_unused() for a JetDefinition without a user-defined recombination scheme");
+  }
+  _recombiner_shared.reset(_recombiner);
+  } else if (_shared_recombiner.get()) {
+    throw Error("Error in JetDefinition::delete_recombiner_when_unused: the recombiner is already scheduled for deletion when unused (or was already set as shared)");
+  }
+  _shared_recombiner.reset(_recombiner);
+}
 …
   case BIpt2_scheme:
     return "boost-invariant pt2 scheme recombination";
+  case WTA_pt_scheme:
+    return "pt-ordered Winner-Takes-All recombination";
+  // Energy-ordering can lead to dangerous situations with particles at
+  // rest. We instead implement the WTA_modp_scheme
+  //
+  //   case WTA_E_scheme:
+  //     return "energy-ordered Winner-Takes-All recombination";
+  case WTA_modp_scheme:
+    return "|3-momentum|-ordered Winner-Takes-All recombination";
   default:
     ostringstream err;
 …
     weightb = pb.perp2();
     break;
+  case WTA_pt_scheme:{
+    const PseudoJet & phard = (pa.pt2() >= pb.pt2()) ? pa : pb;
+    /// keep y,phi and m from the hardest, sum pt
+    pab.reset_PtYPhiM(pa.pt()+pb.pt(),
+                      phard.rap(), phard.phi(), phard.m());
+    return;}
+  // Energy-ordering can lead to dangerous situations with particles at
+  // rest. We instead implement the WTA_modp_scheme
+  //
+  //   case WTA_E_scheme:{
+  //     const PseudoJet & phard = (pa.E() >= pb.E()) ? pa : pb;
+  //     /// keep 3-momentum direction and mass from the hardest, sum energies
+  //     ///
+  //     /// If the particle with the largest energy is at rest, the sum
+  //     /// remains at rest, implying that the mass of the sum is larger
+  //     /// than the mass of pa.
+  //     double Eab = pa.E() + pb.E();
+  //     double scale = (phard.modp2()==0.0)
+  //       ? 0.0
+  //       : sqrt((Eab*Eab - phard.m2())/phard.modp2());
+  //     pab.reset(phard.px()*scale, phard.py()*scale, phard.pz()*scale, Eab);
+  //     return;}
+  case WTA_modp_scheme:{
+    // Note: we need to compute both a and b modp. And we need pthard
+    // and its modp. If we want to avoid repeating the test and do
+    // only 2 modp calculations, we'd have to duplicate the code (or
+    // use a pair<const PJ&>). An alternative is to write modp_soft as
+    // modp_ab-modp_hard but this could suffer from larger rounding
+    // errors
+    bool a_hardest = (pa.modp2() >= pb.modp2());
+    const PseudoJet & phard = a_hardest ? pa : pb;
+    const PseudoJet & psoft = a_hardest ? pb : pa;
+    /// keep 3-momentum direction and mass from the hardest, sum modp
+    ///
+    /// If the hardest particle is at rest, the sum remains at rest
+    /// (the energy of the sum is therefore the mass of pa)
+    double modp_hard = phard.modp();
+    double modp_ab = modp_hard + psoft.modp();
+    if (phard.modp2()==0.0){
+      pab.reset(0.0, 0.0, 0.0, phard.m());
+    } else {
+      double scale = modp_ab/modp_hard;
+      pab.reset(phard.px()*scale, phard.py()*scale, phard.pz()*scale,
+                sqrt(modp_ab*modp_ab + phard.m2()));
+    }
+    return;}
   default:
     ostringstream err;
 …
   case BIpt_scheme:
   case BIpt2_scheme:
+  case WTA_pt_scheme:
+  //case WTA_E_scheme:
+  case WTA_modp_scheme:
     break;
   case pt_scheme:

external/fastjet/JetDefinition.hh

-              rf6b6ee7
+              r49234af
+//STARTHEADER
+// $Id: JetDefinition.hh 2687 2011-11-14 11:17:51Z soyez $
+//
+// Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+#ifndef __FASTJET_JETDEFINITION_HH__
+#define __FASTJET_JETDEFINITION_HH__
+//FJSTARTHEADER
+// $Id: JetDefinition.hh 3677 2014-09-09 22:45:25Z soyez $
+//
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
+//ENDHEADER
+#ifndef __FASTJET_JETDEFINITION_HH__
+#define __FASTJET_JETDEFINITION_HH__
+//FJENDHEADER
 #include<cassert>
 …
 /// clustering events with kt and cambridge style algorithms.
 enum Strategy {
+  /// fastest form about 500..10^4
+  /// Like N2MHTLazy9 in a number of respects, but does not calculate
+  /// ghost-ghost distances and so does not carry out ghost-ghost
+  /// recombination.
+  ///
+  /// If you want active ghosted areas, then this is only suitable for
+  /// use with the anti-kt algorithm (or genkt with negative p), and
+  /// does not produce any pure ghost jets. If used with active areas
+  /// with Kt or Cam algorithms it will actually produce a passive
+  /// area.
+  ///
+  /// Particles are deemed to be ghosts if their pt is below a
+  /// threshold (currently 1e-50, hard coded as ghost_limit in
+  /// LazyTiling9SeparateGhosts).
+  ///
+  /// Currently for events with a couple of thousand normal particles
+  /// and O(10k) ghosts, this can be quicker than N2MHTLazy9, which
+  /// would otherwise be the best strategy.
+  ///
+  /// New in FJ3.1
+  N2MHTLazy9AntiKtSeparateGhosts   = -10,
+  /// only looks into a neighbouring tile for a particle's nearest
+  /// neighbour (NN) if that particle's in-tile NN is further than the
+  /// distance to the edge of the neighbouring tile. Uses tiles of
+  /// size R and a 3x3 tile grid around the particle.
+  /// New in FJ3.1
+  N2MHTLazy9   = -7,
+  /// Similar to N2MHTLazy9, but uses tiles of size R/2 and a 5x5 tile
+  /// grid around the particle.
+  /// New in FJ3.1
+  N2MHTLazy25   = -6,
+  /// Like to N2MHTLazy9 but uses slightly different optimizations,
+  /// e.g. for calculations of distance to nearest tile; as of
+  /// 2014-07-18 it is slightly slower and not recommended for
+  /// production use. To considered deprecated.
+  /// New in FJ3.1
+  N2MHTLazy9Alt   = -5,
+  /// faster that N2Tiled above about 500 particles; differs from it
+  /// by retainig the di(closest j) distances in a MinHeap (sort of
+  /// priority queue) rather than a simple vector.
   N2MinHeapTiled   = -4,
   /// fastest from about 50..500
 …
   /// worse even than the usual N^3 algorithms
   N3Dumb      =  0,
+  /// automatic selection of the best (based on N)
+  /// automatic selection of the best (based on N), including
+  /// the LazyTiled strategies that are new to FJ3.1
   Best        =  1,
   /// best of the NlnN variants -- best overall for N>10^4.
 …
   /// (Does not work for R>=2pi)
   NlnNCam      = 12, // 2piMultD
+  /// the automatic strategy choice that was being made in FJ 3.0
+  /// (restricted to strategies that were present in FJ 3.0)
+  BestFJ30     =  21,
   /// the plugin has been used...
   plugin_strategy = 999
 …
 /// \enum JetAlgorithm
 /// the various families of jet-clustering algorithm
+//
+// [Remember to update the "is_spherical()" routine if any further
+// spherical algorithms are added to the list below]
 enum JetAlgorithm {
   /// the longitudinally invariant kt algorithm
 …
   /// where p = extra_param()
   genkt_algorithm=3,
+  /// a version of cambridge with a special distance measure for particles
+  /// whose pt is < extra_param()
+  /// a version of cambridge with a special distance measure for
+  /// particles whose pt is < extra_param(); this is not usually
+  /// intended for end users, but is instead automatically selected
+  /// when requesting a passive Cambridge area.
   cambridge_for_passive_algorithm=11,
   /// a version of genkt with a special distance measure for particles
   /// whose pt is < extra_param() [relevant for passive areas when p<=0]
+  /// ***** NB: THERE IS CURRENTLY NO IMPLEMENTATION FOR THIS ALG *******
   genkt_for_passive_algorithm=13,
   //.................................................................
 …
 //======================================================================
+/// the various recombination schemes
+/// The various recombination schemes
+///
+/// Note that the schemes that recombine with non-linear weighting of
+/// the directions (e.g. pt2, winner-takes-all) are collinear safe
+/// only for algorithms with a suitable ordering of the
+/// recombinations: orderings in which, for particles of comparable
+/// energies, small-angle clusterings take place before large-angle
+/// clusterings. This property is satisfied by all gen-kt algorithms.
+///
 enum RecombinationScheme {
   /// summing the 4-momenta
 …
   /// no preprocessing
   BIpt2_scheme=6,
+  /// pt-based Winner-Takes-All (WTA) recombination: the
+  /// result of the recombination has the rapidity, azimuth and mass
+  /// of the the PseudoJet with the larger pt, and a pt equal to the
+  /// sum of the two pt's
+  WTA_pt_scheme=7,
+  /// mod-p-based Winner-Takes-All (WTA) recombination: the result of
+  /// the recombination gets the 3-vector direction and mass of the
+  /// PseudoJet with the larger |3-momentum| (modp), and a
+  /// |3-momentum| equal to the scalar sum of the two |3-momenta|.
+  WTA_modp_scheme=8,
+  // Energy-ordering can lead to dangerous situations with particles at
+  // rest. We instead implement the WTA_modp_scheme
+  //
+  // // energy-based Winner-Takes-All (WTA) recombination: the result of
+  // // the recombination gets the 3-vector direction and mass of the
+  // // PseudoJet with the larger energy, and an energy equal to the
+  // // to the sum of the two energies
+  // WTA_E_scheme=8,
   /// for the user's external scheme
   external_scheme = 99
 …
                 const Recombiner * recombiner_in,
                 Strategy strategy_in = Best) {
     *this = JetDefinition(jet_algorithm_in, R_in, external_scheme, strategy_in);
+    *this = JetDefinition(jet_algorithm_in, R_in, xtra_param_in, external_scheme, strategy_in);
     _recombiner = recombiner_in;
-    set_extra_param(xtra_param_in);
+  }
 …
                 RecombinationScheme recomb_scheme_in = E_scheme,
                 int nparameters_in = 1);
+  /// cluster the supplied particles and returns a vector of resulting
+  /// jets, sorted by pt (or energy in the case of spherical,
+  /// i.e. e+e-, algorithms). This routine currently only makes
+  /// sense for "inclusive" type algorithms.
+  template <class L>
+  std::vector<PseudoJet> operator()(const std::vector<L> & particles) const;
   /// R values larger than max_allowable_R are not allowed.
 …
   /// set the recombiner class to the one provided
+  ///
+  /// Note that in order to associate to a jet definition a recombiner
+  /// from another jet definition, it is strongly recommended to use
+  /// the set_recombiner(const JetDefinition &) method below. The
+  /// latter correctly handles the situations where the jet definition
+  /// owns the recombiner (i.e. where delete_recombiner_when_unused
+  /// has been called). In such cases, using set_recombiner(const
+  /// Recombiner *) may lead to memory corruption.
   void set_recombiner(const Recombiner * recomb) {
     if (_recombiner_shared()) _recombiner_shared.reset(recomb);
+    if (_shared_recombiner()) _shared_recombiner.reset(recomb);
     _recombiner = recomb;
     _default_recombiner = DefaultRecombiner(external_scheme);
+  }
+  /// set the recombiner to be the same as the one of 'other_jet_def'
+  ///
+  /// Note that this is the recommended method to associate to a jet
+  /// definition the recombiner from another jet definition. Compared
+  /// to the set_recombiner(const Recombiner *) above, it correctly
+  /// handles the case where the jet definition owns the recombiner
+  /// (i.e. where delete_recombiner_when_unused has been called)
+  void set_recombiner(const JetDefinition &other_jet_def);
   /// calling this tells the JetDefinition to handle the deletion of
+  /// the recombiner when it is no longer used
+  /// the recombiner when it is no longer used. (Should not be called
+  /// if the recombiner was initialised from a JetDef whose recombiner
+  /// was already scheduled to delete itself - memory handling will
+  /// already be automatic across both JetDef's in that case).
   void delete_recombiner_when_unused();
 …
   const Plugin * plugin() const {return _plugin;};
   /// allows to let the JetDefinition handle the deletion of the
+  /// calling this causes the JetDefinition to handle the deletion of the
   /// plugin when it is no longer used
   void delete_plugin_when_unused();
 …
   void set_extra_param(double xtra_param) {_extra_param = xtra_param;}
   /// return a pointer to the currently defined recombiner.
+  /// returns a pointer to the currently defined recombiner.
   ///
   /// Warning: the pointer may be to an internal recombiner (for
 …
   /// returns true if the current jet definitions shares the same
   /// recombiner as teh one passed as an argument
+  /// recombiner as the one passed as an argument
   bool has_same_recombiner(const JetDefinition &other_jd) const;
+  /// returns true if the jet definition involves an algorithm
+  /// intended for use on a spherical geometry (e.g. e+e- algorithms,
+  /// as opposed to most pp algorithms, which use a cylindrical,
+  /// rapidity-phi geometry).
+  bool is_spherical() const;
   /// return a textual description of the current jet definition
   std::string description() const;
+  /// returns a description not including the recombiner information
+  std::string description_no_recombiner() const;
+  /// a short textual description of the algorithm jet_alg
+  static std::string algorithm_description(const JetAlgorithm jet_alg);
+  /// the number of parameters associated to a given jet algorithm
+  static unsigned int n_parameters_for_algorithm(const JetAlgorithm jet_alg);
 public:
 …
     virtual bool exclusive_sequence_meaningful() const {return false;}
+    /// returns true if the plugin implements an algorithm intended
+    /// for use on a spherical geometry (e.g. e+e- algorithms, as
+    /// opposed to most pp algorithms, which use a cylindrical,
+    /// rapidity-phi geometry).
+    virtual bool is_spherical() const {return false;}
     /// a destructor to be replaced if necessary in derived classes...
     virtual ~Plugin() {};
 …
   DefaultRecombiner _default_recombiner;
   const Recombiner * _recombiner;
   SharedPtr<const Recombiner> _recombiner_shared;
+  SharedPtr<const Recombiner> _shared_recombiner;
 };
 …
 FASTJET_END_NAMESPACE
+// include ClusterSequence which includes the implementation of the
+// templated JetDefinition::operator()(...) member
+#include "fastjet/ClusterSequence.hh"
 #endif // __FASTJET_JETDEFINITION_HH__

external/fastjet/LimitedWarning.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
+//FJSTARTHEADER
+// $Id: LimitedWarning.cc 3619 2014-08-13 14:17:19Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include "fastjet/LimitedWarning.hh"
 …
 /// output a warning to ostr
 void LimitedWarning::warn(const std::string & warning) {
   warn(warning, _default_ostr);
+}
+// /// output a warning to ostr
+// void LimitedWarning::warn(const std::string & warning) {
+//   warn(warning, _default_ostr);
+// }
 void LimitedWarning::warn(const std::string & warning, std::ostream * ostr) {
+void LimitedWarning::warn(const char * warning, std::ostream * ostr) {
   if (_this_warning_summary == 0) {
     // prepare the information for the summary
 …
     // prepare the warning within a string stream
     ostringstream warnstr;
     warnstr << "WARNING: ";
+    warnstr << "WARNING from FastJet: ";
     warnstr << warning;
     _n_warn_so_far++;

external/fastjet/LimitedWarning.hh

-              rf6b6ee7
+              r49234af
 #define __FASTJET_LIMITEDWARNING_HH__
 //STARTHEADER
 // $Id: LimitedWarning.hh 2577 2011-09-13 15:11:38Z salam $
+//FJSTARTHEADER
+// $Id: LimitedWarning.hh 3622 2014-08-13 14:45:45Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 …
   /// constructor that provides a user-set max number of warnings
   LimitedWarning(int max_warn) : _max_warn(max_warn), _n_warn_so_far(0), _this_warning_summary(0) {}
+  LimitedWarning(int max_warn_in) : _max_warn(max_warn_in), _n_warn_so_far(0), _this_warning_summary(0) {}
   /// outputs a warning to standard error (or the user's default
   /// warning stream if set)
+  void warn(const std::string & warning);
+  void warn(const char * warning) {warn(warning, _default_ostr);}
+  /// outputs a warning to standard error (or the user's default
+  /// warning stream if set)
+  void warn(const std::string & warning) {warn(warning.c_str(), _default_ostr);}
   /// outputs a warning to the specified stream
+  void warn(const std::string & warning, std::ostream * ostr);
+  void warn(const char * warning, std::ostream * ostr);
+  /// outputs a warning to the specified stream
+  void warn(const std::string & warning, std::ostream * ostr) {warn(warning.c_str(), ostr);}
   /// sets the default output stream for all warnings (by default
 …
     _max_warn_default = max_warn;
+  }
+  /// the maximum number of warning messages that will be printed
+  /// by this instance of the class
+  int max_warn() const {return _max_warn;}
+  /// the number of times so far that a warning has been registered
+  /// with this instance of the class.
+  int n_warn_so_far() const {return _n_warn_so_far;}
   /// returns a summary of all the warnings that came through the

external/fastjet/MinHeap.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
+//FJSTARTHEADER
+// $Id: MinHeap.cc 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include "fastjet/internal/MinHeap.hh"
 …
 ///
 ///   . for _heap[i], the "parent" is to be found at (i-1)/2
 void MinHeap::_initialise(const std::vector<double> & values){
+void MinHeap::initialise(const std::vector<double> & values){
   // fill the high-range of the heap with the largest possible value

external/fastjet/NNH.hh

-              rf6b6ee7
+              r49234af
 #define __FASTJET_NNH_HH__
 //STARTHEADER
 // $Id: NNH.hh 3203 2013-09-15 07:49:50Z salam $
 //
 // Copyright (c) 2009, Matteo Cacciari, Gavin Salam and Gregory Soyez
+//FJSTARTHEADER
+// $Id: NNH.hh 3433 2014-07-23 08:17:03Z salam $
+//
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include<fastjet/ClusterSequence.hh>
 …
   class NNBJ; // forward declaration
   /// establish the nearest neighbour for jet, and cross check constistency
+  /// establish the nearest neighbour for jet, and cross check consistency
   /// of distances for the other jets that are encountered. Assumes
   /// jet not contained within begin...end

external/fastjet/PseudoJet.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+//FJSTARTHEADER
+// $Id: PseudoJet.cc 3652 2014-09-03 13:31:13Z salam $
+//
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 …
 // return the product, coeff * jet
 PseudoJet operator* (double coeff, const PseudoJet & jet) {
+  // see the comment in operator*= about ensuring valid rap phi
+  // before a multiplication to handle case of multiplication by
+  // zero, while maintaining rapidity and phi
+  jet._ensure_valid_rap_phi();
   //return PseudoJet(coeff*jet.four_mom());
   // the following code is hopefully more efficient
 …
 /// multiply the jet's momentum by the coefficient
 void PseudoJet::operator*=(double coeff) {
+  // operator*= aims to maintain the rapidity and azimuth
+  // for the PseudoJet; if they have already been evaluated
+  // this is fine, but if they haven't and coeff is sufficiently
+  // small as to cause a zero or underflow result, then a subsequent
+  // invocation of rap or phi will lead to a non-sensical result.
+  // So, here, we preemptively ensure that rapidity and phi
+  // are correctly cached
+  _ensure_valid_rap_phi();
   _px *= coeff;
   _py *= coeff;
 …
 //----------------------------------------------------------------------
 /// transform this jet (given in lab) into a jet in the rest
 /// frame of prest
+/// transform this jet (given in the rest frame of prest) into a jet
+/// in the lab frame
 //
 // NB: code adapted from that in herwig f77 (checked how it worked
 …
 //----------------------------------------------------------------------
 /// transform this jet (given in the rest frame of prest) into a jet
 /// in the lab frame;
+/// transform this jet (given in lab) into a jet in the rest
+/// frame of prest
 //
 // NB: code adapted from that in herwig f77 (checked how it worked
 …
 // an Error is thrown if this PseudoJet has no currently valid
 // associated ClusterSequence
 std::vector<PseudoJet> PseudoJet::exclusive_subjets (const double & dcut) const {
+std::vector<PseudoJet> PseudoJet::exclusive_subjets (const double dcut) const {
   return validated_structure_ptr()->exclusive_subjets(*this, dcut);
+}
 …
 // an Error is thrown if this PseudoJet has no currently valid
 // associated ClusterSequence
 int PseudoJet::n_exclusive_subjets(const double & dcut) const {
+int PseudoJet::n_exclusive_subjets(const double dcut) const {
   return validated_structure_ptr()->n_exclusive_subjets(*this, dcut);
+}
 …
 PseudoJet join(const PseudoJet & j1, const PseudoJet & j2){
   vector<PseudoJet> pieces;
+  pieces.reserve(2);
   pieces.push_back(j1);
   pieces.push_back(j2);
 …
 PseudoJet join(const PseudoJet & j1, const PseudoJet & j2, const PseudoJet & j3){
   vector<PseudoJet> pieces;
+  pieces.reserve(3);
   pieces.push_back(j1);
   pieces.push_back(j2);
 …
 PseudoJet join(const PseudoJet & j1, const PseudoJet & j2, const PseudoJet & j3, const PseudoJet & j4){
   vector<PseudoJet> pieces;
+  pieces.reserve(4);
   pieces.push_back(j1);
   pieces.push_back(j2);

external/fastjet/PseudoJet.hh

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id: PseudoJet.hh 3111 2013-05-04 08:17:27Z salam $
+//FJSTARTHEADER
+// $Id: PseudoJet.hh 3566 2014-08-11 15:36:34Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 …
   /// structure type
   ///
   /// If there is no sructure associated, an Error is thrown.
+  /// If there is no structure associated, an Error is thrown.
   /// If the type is not met, a std::bad_cast error is thrown.
   template<typename StructureType>
 …
   /// an Error is thrown if this PseudoJet has no currently valid
   /// associated ClusterSequence
   std::vector<PseudoJet> exclusive_subjets (const double & dcut) const;
+  std::vector<PseudoJet> exclusive_subjets (const double dcut) const;
   /// return the size of exclusive_subjets(...); still n ln n with same
 …
   /// an Error is thrown if this PseudoJet has no currently valid
   /// associated ClusterSequence
   int n_exclusive_subjets(const double & dcut) const;
+  int n_exclusive_subjets(const double dcut) const;
   /// return the list of subjets obtained by unclustering the supplied
 …
   std::vector<PseudoJet> exclusive_subjets_up_to (int nsub) const;
   /// return the dij that was present in the merging nsub+1 -> nsub
+  /// Returns the dij that was present in the merging nsub+1 -> nsub
   /// subjets inside this jet.
+  ///
+  /// Returns 0 if there were nsub or fewer constituents in the jet.
   ///
   /// an Error is thrown if this PseudoJet has no currently valid
 …
   double exclusive_subdmerge(int nsub) const;
   /// return the maximum dij that occurred in the whole event at the
+  /// Returns the maximum dij that occurred in the whole event at the
   /// stage that the nsub+1 -> nsub merge of subjets occurred inside
   /// this jet.
+  ///
+  /// Returns 0 if there were nsub or fewer constituents in the jet.
   ///
   /// an Error is thrown if this PseudoJet has no currently valid
 …
   /// set cached rapidity and phi values
   void _set_rap_phi() const;
+  // needed for operator* to have access to _ensure_valid_rap_phi()
+  friend PseudoJet operator*(double, const PseudoJet &);
 };
 …
 /// momentum components are equal to val (=0.0)
 bool operator==(const PseudoJet & jet, const double val);
+inline bool operator==(const double val, const PseudoJet & jet) {return jet == val;}
 /// Can only be used with val=0 and tests whether at least one of the
 /// four momentum components is different from val (=0.0)
+inline bool operator!=(const PseudoJet & a, const double & val) {return !(a==val);}
+inline bool operator!=(const PseudoJet & a, const double val)  {return !(a==val);}
+inline bool operator!=( const double val, const PseudoJet & a) {return !(a==val);}
 inline double dot_product(const PseudoJet & a, const PseudoJet & b) {
 …
     _ref_values = reference_values;
   };
   inline int operator() (const int & i1, const int & i2) const {
+  inline int operator() (const int i1, const int i2) const {
     return  (*_ref_values)[i1] < (*_ref_values)[i2];
   };

external/fastjet/PseudoJetStructureBase.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+//FJSTARTHEADER
+// $Id: PseudoJetStructureBase.cc 3433 2014-07-23 08:17:03Z salam $
+//
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER

external/fastjet/PseudoJetStructureBase.hh

-              rf6b6ee7
+              r49234af
 #define __FASTJET_PSEUDOJET_STRUCTURE_BASE_HH__
 //STARTHEADER
 // $Id: PseudoJetStructureBase.hh 3071 2013-04-01 12:52:46Z cacciari $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+//FJSTARTHEADER
+// $Id: PseudoJetStructureBase.hh 3433 2014-07-23 08:17:03Z salam $
+//
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 …
   ///
   /// By default, throws an Error
+  ///
+  /// Note: in a future major release of FastJet (4 or higher),
+  /// "const double & dcut" may be replaced with "const double dcut",
+  /// requiring a modification of derived classes that overload
+  /// this function.
   virtual std::vector<PseudoJet> exclusive_subjets(const PseudoJet &reference, const double & dcut) const;
 …
   ///
   /// By default, throws an Error
+  ///
+  /// Note: in a future major release of FastJet (4 or higher),
+  /// "const double & dcut" may be replaced with "const double dcut",
+  /// requiring a modification of derived classes that overload
+  /// this function.
   virtual int n_exclusive_subjets(const PseudoJet &reference, const double & dcut) const;

external/fastjet/RangeDefinition.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
+//FJSTARTHEADER
+// $Id: RangeDefinition.cc 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include "fastjet/RangeDefinition.hh"

external/fastjet/RangeDefinition.hh

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id: RangeDefinition.hh 2577 2011-09-13 15:11:38Z salam $
+//FJSTARTHEADER
+// $Id: RangeDefinition.hh 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #ifndef __FASTJET_RANGEDEFINITION_HH__

external/fastjet/Selector.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
+//FJSTARTHEADER
+// $Id: Selector.cc 3504 2014-08-01 06:07:54Z soyez $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 …
+}
+//----------------------------------------------------------------------
+// sum the momenta of the jets that pass the cuts
+PseudoJet Selector::sum(const std::vector<PseudoJet> & jets) const {
+  PseudoJet this_sum(0,0,0,0);
+  const SelectorWorker * worker_local = validated_worker();
+  // separate strategies according to whether the worker applies jet by jet
+  if (worker_local->applies_jet_by_jet()) {
+    for (unsigned i = 0; i < jets.size(); i++) {
+      if (worker_local->pass(jets[i])) this_sum += jets[i];
+    }
+  } else {
+    std::vector<const PseudoJet *> jetptrs(jets.size());
+    for (unsigned i = 0; i < jets.size(); i++) {
+      jetptrs[i] = & jets[i];
+    }
+    worker_local->terminator(jetptrs);
+    for (unsigned i = 0; i < jetptrs.size(); i++) {
+      if (jetptrs[i]) this_sum += jets[i];
+    }
+  }
+  return this_sum;
+}
+//----------------------------------------------------------------------
+// sum the (scalar) pt of the jets that pass the cuts
+double Selector::scalar_pt_sum(const std::vector<PseudoJet> & jets) const {
+  double this_sum = 0.0;
+  const SelectorWorker * worker_local = validated_worker();
+  // separate strategies according to whether the worker applies jet by jet
+  if (worker_local->applies_jet_by_jet()) {
+    for (unsigned i = 0; i < jets.size(); i++) {
+      if (worker_local->pass(jets[i])) this_sum += jets[i].pt();
+    }
+  } else {
+    std::vector<const PseudoJet *> jetptrs(jets.size());
+    for (unsigned i = 0; i < jets.size(); i++) {
+      jetptrs[i] = & jets[i];
+    }
+    worker_local->terminator(jetptrs);
+    for (unsigned i = 0; i < jetptrs.size(); i++) {
+      if (jetptrs[i]) this_sum += jets[i].pt();
+    }
+  }
+  return this_sum;
+}
 //----------------------------------------------------------------------
 …
 class SW_Circle : public SW_WithReference {
 public:
   SW_Circle(const double &radius) : _radius2(radius*radius) {}
+  SW_Circle(const double radius) : _radius2(radius*radius) {}
   /// return a copy of the current object
 …
 // select on objets within a distance 'radius' of a variable location
 Selector SelectorCircle(const double & radius) {
+Selector SelectorCircle(const double radius) {
   return Selector(new SW_Circle(radius));
+}
 …
 class SW_Doughnut : public SW_WithReference {
 public:
   SW_Doughnut(const double &radius_in, const double &radius_out)
+  SW_Doughnut(const double radius_in, const double radius_out)
     : _radius_in2(radius_in*radius_in), _radius_out2(radius_out*radius_out) {}
 …
 // select on objets with distance from the centre is between 'radius_in' and 'radius_out'
 Selector SelectorDoughnut(const double & radius_in, const double & radius_out) {
+Selector SelectorDoughnut(const double radius_in, const double radius_out) {
   return Selector(new SW_Doughnut(radius_in, radius_out));
+}
 …
 class SW_Strip : public SW_WithReference {
 public:
   SW_Strip(const double &delta) : _delta(delta) {}
+  SW_Strip(const double delta) : _delta(delta) {}
   /// return a copy of the current object
 …
 // select on objets within a distance 'radius' of a variable location
 Selector SelectorStrip(const double & half_width) {
+Selector SelectorStrip(const double half_width) {
   return Selector(new SW_Strip(half_width));
+}
 …
 class SW_Rectangle : public SW_WithReference {
 public:
   SW_Rectangle(const double &delta_rap, const double &delta_phi)
+  SW_Rectangle(const double delta_rap, const double delta_phi)
     : _delta_rap(delta_rap),  _delta_phi(delta_phi) {}
 …
 // select on objets within a distance 'radius' of a variable location
 Selector SelectorRectangle(const double & half_rap_width, const double & half_phi_width) {
+Selector SelectorRectangle(const double half_rap_width, const double half_phi_width) {
   return Selector(new SW_Rectangle(half_rap_width, half_phi_width));
+}

external/fastjet/Selector.hh

-              rf6b6ee7
+              r49234af
 #define __FASTJET_SELECTOR_HH__
 //STARTHEADER
 // $Id: Selector.hh 3203 2013-09-15 07:49:50Z salam $
 //
 // Copyright (c) 2009-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+//FJSTARTHEADER
+// $Id: Selector.hh 3711 2014-09-29 13:54:51Z salam $
+//
+// Copyright (c) 2009-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include "fastjet/PseudoJet.hh"
 …
   //----------------------------------------------------------
+  /// returns true if a given object passes the selection criterion.
+  /// This has to be overloaded by derived workers
+  /// returns true if a given object passes the selection criterion,
+  /// and is the main function that needs to be overloaded by derived
+  /// workers.
+  ///
+  /// NB: this function is used only if applies_jet_by_jet() returns
+  /// true. If it does not, then derived classes are expected to
+  /// (re)implement the terminator function()
   virtual bool pass(const PseudoJet & jet) const = 0;
   /// For each jet that does not pass the cuts, this routine sets the
   /// pointer to 0.
   ///
   /// It does not assume that the PseudoJet* passed as argumetn are not NULL
+  /// pointer to 0.
+  ///
+  /// It does not assume that the PseudoJet* passed as argument are not NULL
   virtual void terminator(std::vector<const PseudoJet *> & jets) const {
     for (unsigned i = 0; i < jets.size(); i++) {
 …
     throw Error("this selector has no computable area");
+  }
 };
 …
   Selector(SelectorWorker * worker_in) {_worker.reset(worker_in);}
 #ifndef __FJCORE__
   /// ctor from a RangeDefinition
 …
   /// passes and then evaluating the size of the vector
   unsigned int count(const std::vector<PseudoJet> & jets) const;
+  /// Return the 4-vector sum of the objects that pass the selection.
+  ///
+  /// This will often be more efficient that getting the vector of objects that
+  /// passes and then evaluating the size of the vector
+  PseudoJet sum(const std::vector<PseudoJet> & jets) const;
+  /// Return the scalar pt sum of the objects that pass the selection.
+  ///
+  /// This will often be more efficient that getting the vector of objects that
+  /// passes and then evaluating the size of the vector
+  double scalar_pt_sum(const std::vector<PseudoJet> & jets) const;
   /// sift the input jets into two vectors -- those that pass the selector
 …
+  }
   /// class that gets throw when a Selector is applied despite it not
+  /// class that gets thrown when a Selector is applied despite it not
   /// having a valid underlying worker.
   class InvalidWorker : public Error {
 …
   };
   /// class that gets throw when a Selector is applied despite it not
   /// having a valid underlying worker.
+  /// class that gets thrown when the area is requested from a Selector for which
+  /// the area is not meaningful
   class InvalidArea : public Error {
   public:
 …
 /// select objets within a distance 'radius' from the location of the
 /// reference jet, set by Selector::set_reference(...)
 Selector SelectorCircle(const double & radius);
+Selector SelectorCircle(const double radius);
 /// select objets with distance from the reference jet is between 'radius_in'
 /// and 'radius_out'; the reference jet is set by Selector::set_reference(...)
 Selector SelectorDoughnut(const double & radius_in, const double & radius_out);
+Selector SelectorDoughnut(const double radius_in, const double radius_out);
 /// select objets within a rapidity distance 'half_width' from the
 /// location of the reference jet, set by Selector::set_reference(...)
 Selector SelectorStrip(const double & half_width);
+Selector SelectorStrip(const double half_width);
 /// select objets within rapidity distance 'half_rap_width' from the
 /// reference jet and azimuthal-angle distance within 'half_phi_width'; the
 /// reference jet is set by Selector::set_reference(...)
 Selector SelectorRectangle(const double & half_rap_width, const double & half_phi_width);
+Selector SelectorRectangle(const double half_rap_width, const double half_phi_width);

external/fastjet/SharedPtr.hh

-              rf6b6ee7
+              r49234af
 #define __FASTJET_SHARED_PTR_HH__
 //STARTHEADER
 // $Id: SharedPtr.hh 3129 2013-06-05 08:48:36Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+//FJSTARTHEADER
+// $Id: SharedPtr.hh 3433 2014-07-23 08:17:03Z salam $
+//
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include "fastjet/internal/base.hh"

external/fastjet/VERSION

rf6b6ee7	r49234af
1		3.~~0.6~~
	1	3.1.0

external/fastjet/Voronoi.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
+//FJSTARTHEADER
+// $Id: Voronoi.cc 3433 2014-07-23 08:17:03Z salam $
 //
+// Copyright (c) 1994 by AT&T Bell Laboratories (see below)
+//
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
+// This file is included as part of FastJet but was mostly written by
+// S. Fortune in C, put into C++ with memory management by S
+// O'Sullivan, and with further interface and memory management
+// modifications by Gregory Soyez.
+// This file is part of FastJet.
 //
+// Permission to use, copy, modify, and distribute this software for
+// any purpose without fee is hereby granted, provided that this
+// entire notice is included in all copies of any software which is or
+// includes a copy or modification of this software and in all copies
+// of the supporting documentation for such software. THIS SOFTWARE IS
+// BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED WARRANTY.
+// IN PARTICULAR, NEITHER THE AUTHORS NOR AT&T MAKE ANY REPRESENTATION
+// OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY OF THIS
+// SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+//  FastJet 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.
 //
+//  The algorithms that underlie FastJet have required considerable
+//  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
+//  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,
+//  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 FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER

external/fastjet/WrappedStructure.hh

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id: WrappedStructure.hh 2577 2011-09-13 15:11:38Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+//FJSTARTHEADER
+// $Id: WrappedStructure.hh 3433 2014-07-23 08:17:03Z salam $
+//
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER

external/fastjet/config_auto.h

-              rf6b6ee7
+              r49234af
 #endif
+/* defined if demangling is enabled at configure time and is supported through
+   the GNU C++ ABI */
+/* #undef HAVE_DEMANGLING_SUPPORT */
 /* Define to 1 if you have the <dlfcn.h> header file. */
 #ifndef FASTJET_HAVE_DLFCN_H
 …
 /* Define to the full name and version of this package. */
 #ifndef FASTJET_PACKAGE_STRING
 #define FASTJET_PACKAGE_STRING  "FastJet 3.0.6"
+#define FASTJET_PACKAGE_STRING  "FastJet 3.1.0"
 #endif
 …
 /* Define to the version of this package. */
 #ifndef FASTJET_PACKAGE_VERSION
 #define FASTJET_PACKAGE_VERSION  "3.0.6"
+#define FASTJET_PACKAGE_VERSION  "3.1.0"
 #endif
 …
 /* Version number of package */
 #ifndef FASTJET_VERSION
+#define FASTJET_VERSION  "3.0.6"
+#endif
+#define FASTJET_VERSION  "3.1.0"
+#endif
+/* Major version of this package */
+#ifndef FASTJET_VERSION_MAJOR
+#define FASTJET_VERSION_MAJOR  3
+#endif
+/* Minor version of this package */
+#ifndef FASTJET_VERSION_MINOR
+#define FASTJET_VERSION_MINOR  1
+#endif
+/* Version of the package under the form XYYZZ (instead of X.Y.Z) */
+#ifndef FASTJET_VERSION_NUMBER
+#define FASTJET_VERSION_NUMBER  30100
+#endif
+/* Patch version of this package */
+#ifndef FASTJET_VERSION_PATCHLEVEL
+#define FASTJET_VERSION_PATCHLEVEL  0
+#endif
+/* Pre-release version of this package */
+/* #undef VERSION_PRERELEASE */
 /* once: _INCLUDE_FASTJET_CONFIG_AUTO_H */

external/fastjet/config_raw.h

-              rf6b6ee7
+              r49234af
 /* The TrackJet plugin is enabled */
 #define ENABLE_PLUGIN_TRACKJET /**/
+/* defined if demangling is enabled at configure time and is supported through
+   the GNU C++ ABI */
+/* #undef HAVE_DEMANGLING_SUPPORT */
 /* Define to 1 if you have the <dlfcn.h> header file. */
 …
 /* Define to the full name and version of this package. */
 #define PACKAGE_STRING "FastJet 3.0.6"
+#define PACKAGE_STRING "FastJet 3.1.0"
 /* Define to the one symbol short name of this package. */
 …
 /* Define to the version of this package. */
 #define PACKAGE_VERSION "3.0.6"
+#define PACKAGE_VERSION "3.1.0"
 /* Define to 1 if you have the ANSI C header files. */
 …
 /* Version number of package */
+#define VERSION "3.0.6"
+#define VERSION "3.1.0"
+/* Major version of this package */
+#define VERSION_MAJOR 3
+/* Minor version of this package */
+#define VERSION_MINOR 1
+/* Version of the package under the form XYYZZ (instead of X.Y.Z) */
+#define VERSION_NUMBER 30100
+/* Patch version of this package */
+#define VERSION_PATCHLEVEL 0
+/* Pre-release version of this package */
+/* #undef VERSION_PRERELEASE */

external/fastjet/config_win.h

-              rf6b6ee7
+              r49234af
+#define FASTJET_PACKAGE_STRING  "FastJet 3.0.6"
+#define FASTJET_PACKAGE_VERSION  "3.0.6"
+#define FASTJET_PACKAGE_STRING  "FastJet 3.1.0"
+#define FASTJET_PACKAGE_VERSION  "3.1.0"
+#define FASTJET_VERSION  "3.1.0"
+#define FASTJET_VERSION_MAJOR       3
+#define FASTJET_VERSION_MINOR       1
+#define FASTJET_VERSION_PATCHLEVEL  0
+#define FASTJET_VERSION_NUMBER      30100
 /* The ATLASCone plugin is disabled by default*/

external/fastjet/contribs/Nsubjettiness/AUTHORS

-              rf6b6ee7
+              r49234af
    JHEP 1202:093 (2012), arXiv:1108.2701.
+New in v2.0 is the winner-take-all axis, described in:
+   Jet Shapes with the Broadening Axis.
+   Andrew J. Larkoski, Duff Neill, and Jesse Thaler.
+   JHEP 1404:017 (2014), arXiv:1401.2158.
+as well as in unpublished work by Gavin Salam.
 ----------------------------------------------------------------------

external/fastjet/contribs/Nsubjettiness/AxesFinder.cc

-              rf6b6ee7
+              r49234af
 //  Jesse Thaler, Ken Van Tilburg, Christopher K. Vermilion, and TJ Wilkason
 //
+//  $Id: AxesFinder.cc 670 2014-06-06 01:24:42Z jthaler $
 //----------------------------------------------------------------------
 // This file is part of FastJet contrib.
 …
 template <int N>
 std::vector<LightLikeAxis> AxesFinderFromOnePassMinimization::UpdateAxesFast(const std::vector <LightLikeAxis> & old_axes,
                                   const std::vector <fastjet::PseudoJet> & inputJets) {
+                                  const std::vector <fastjet::PseudoJet> & inputJets) const {
    assert(old_axes.size() == N);
 …
    for (int n = 0; n < N; ++n) {
       new_axes[n].reset(0.0,0.0,0.0,0.0);
-#ifdef FASTJET2
-      new_jets[n].reset(0.0,0.0,0.0,0.0);
-#else
-      // use cheaper reset if available
       new_jets[n].reset_momentum(0.0,0.0,0.0,0.0);
-#endif
+   }
 …
 // (This is just a wrapper for the templated version above.)
 std::vector<LightLikeAxis> AxesFinderFromOnePassMinimization::UpdateAxes(const std::vector <LightLikeAxis> & old_axes,
                                       const std::vector <fastjet::PseudoJet> & inputJets) {
+                                      const std::vector <fastjet::PseudoJet> & inputJets) const {
    int N = old_axes.size();
    switch (N) {
 …
 // uses minimization of N-jettiness to continually update axes until convergence.
 // The function returns the axes found at the (local) minimum
 std::vector<fastjet::PseudoJet> AxesFinderFromOnePassMinimization::getBetterAxes(int n_jets, const std::vector <fastjet::PseudoJet> & inputJets, const std::vector<fastjet::PseudoJet>& seedAxes) {
+std::vector<fastjet::PseudoJet> AxesFinderFromOnePassMinimization::getAxes(int n_jets, const std::vector <fastjet::PseudoJet> & inputJets, const std::vector<fastjet::PseudoJet>& seedAxes) const {
    // convert from PseudoJets to LightLikeAxes
 …
+}
 PseudoJet AxesFinderFromKmeansMinimization::jiggle(const PseudoJet& axis) {
+PseudoJet AxesFinderFromKmeansMinimization::jiggle(const PseudoJet& axis) const {
    double phi_noise = ((double)rand()/(double)RAND_MAX) * _noise_range * 2.0 - _noise_range;
    double rap_noise = ((double)rand()/(double)RAND_MAX) * _noise_range * 2.0 - _noise_range;
 …
 // Repeatedly calls the one pass finder to try to find global minimum
 std::vector<fastjet::PseudoJet> AxesFinderFromKmeansMinimization::getBetterAxes(int n_jets, const std::vector <fastjet::PseudoJet> & inputJets, const std::vector<fastjet::PseudoJet>& seedAxes) {
+std::vector<fastjet::PseudoJet> AxesFinderFromKmeansMinimization::getAxes(int n_jets, const std::vector <fastjet::PseudoJet> & inputJets, const std::vector<fastjet::PseudoJet>& seedAxes) const {
    // first iteration
 …
 // It continually updates until it reaches convergence or it reaches the maximum number of attempts.
 // This is essentially the same as a stable cone finder.
 std::vector<fastjet::PseudoJet> AxesFinderFromGeometricMinimization::getBetterAxes(int n_jets, const std::vector <fastjet::PseudoJet> & particles, const std::vector<fastjet::PseudoJet>& currentAxes) {
+std::vector<fastjet::PseudoJet> AxesFinderFromGeometricMinimization::getAxes(int /*n_jets*/, const std::vector <fastjet::PseudoJet> & particles, const std::vector<fastjet::PseudoJet>& currentAxes) const {
    std::vector<fastjet::PseudoJet> seedAxes = currentAxes;
    double seedTau = _function->tau(particles, seedAxes);
+   double seedTau = _function.tau(particles, seedAxes);
    for (int i = 0; i < _nAttempts; i++) {
 …
          // start from unclustered beam measure
          int minJ = -1;
          double minDist = _function->beam_distance_squared(particles[i]);
+         double minDist = _function.beam_distance_squared(particles[i]);
          // which axis am I closest to?
          for (unsigned int j = 0; j < seedAxes.size(); j++) {
             double tempDist = _function->jet_distance_squared(particles[i],seedAxes[j]);
+            double tempDist = _function.jet_distance_squared(particles[i],seedAxes[j]);
             if (tempDist < minDist) {
                minDist = tempDist;
 …
       // calculate tau on new axes
       seedAxes = newAxes;
       double tempTau = _function->tau(particles, newAxes);
+      double tempTau = _function.tau(particles, newAxes);
       // close enough to stop?

external/fastjet/contribs/Nsubjettiness/AxesFinder.hh

-              rf6b6ee7
+              r49234af
 //  Jesse Thaler, Ken Van Tilburg, Christopher K. Vermilion, and TJ Wilkason
 //
+//  $Id: AxesFinder.hh 678 2014-06-12 20:43:03Z jthaler $
 //----------------------------------------------------------------------
 // This file is part of FastJet contrib.
 …
 class AxesFinder {
+protected:
+   AxesFinder* _startingFinder; // storing a possible starting finder if needed
+   std::vector<fastjet::PseudoJet> _seedAxes;
+   AxesFinder(AxesFinder* startingFinder = NULL) : _startingFinder(startingFinder) {}
+public:
+   virtual ~AxesFinder(){
+      if (_startingFinder) delete _startingFinder;  //TODO: Convert to smart pointers to avoid this.
+   }
+   // Allow setting of seedAxes from a starting finder
+   std::vector<fastjet::PseudoJet> getAxes(int n_jets, const std::vector<fastjet::PseudoJet> & inputs, const std::vector<fastjet::PseudoJet>& currentAxes) {
+      if (_startingFinder) {
+         _seedAxes = _startingFinder->getAxes(n_jets,inputs,currentAxes);
+         return getBetterAxes(n_jets,inputs,_seedAxes);
+      } else {
+         _seedAxes = getBetterAxes(n_jets,inputs,currentAxes);
+         return _seedAxes;
+      }
+   }
+   // say what the current seed axes are
+   std::vector<fastjet::PseudoJet> seedAxes() const {
+      return _seedAxes;
+   }
+   // This function should be overloaded, and updates the seedAxes
+   virtual std::vector<fastjet::PseudoJet> getBetterAxes(int n_jets, const std::vector<fastjet::PseudoJet> & inputs, const std::vector<fastjet::PseudoJet>& seedAxes) = 0;
+};
+public:
+   // This function should be overloaded, and updates the seedAxes to return new axes
+   virtual std::vector<fastjet::PseudoJet> getAxes(int n_jets,
+                                                   const std::vector<fastjet::PseudoJet>& inputs,
+                                                   const std::vector<fastjet::PseudoJet>& seedAxes) const = 0;
+   // convenient shorthand for squaring
+   static inline double sq(double x) {return x*x;}
+   //virtual destructor
+   virtual ~AxesFinder(){}
+};
 //------------------------------------------------------------------------
 /// \class AxesFinderFromExclusiveJetDefinition
 …
 // with different jet algorithms.
 class AxesFinderFromExclusiveJetDefinition : public AxesFinder {
+   private:
+      fastjet::JetDefinition _def;
+   public:
+      AxesFinderFromExclusiveJetDefinition(fastjet::JetDefinition def) : _def(def) {}
+      virtual std::vector<fastjet::PseudoJet> getBetterAxes(int n_jets, const std::vector <fastjet::PseudoJet> & inputs, const std::vector<fastjet::PseudoJet>& currentAxes) {
+         fastjet::ClusterSequence jet_clust_seq(inputs, _def);
+         return jet_clust_seq.exclusive_jets(n_jets);
+      }
+public:
+   AxesFinderFromExclusiveJetDefinition(fastjet::JetDefinition def)
+   : _def(def) {}
+   virtual std::vector<fastjet::PseudoJet> getAxes(int n_jets,
+                                                   const std::vector <fastjet::PseudoJet> & inputs,
+                                                   const std::vector<fastjet::PseudoJet>& /*seedAxes*/) const {
+      fastjet::ClusterSequence jet_clust_seq(inputs, _def);
+      return jet_clust_seq.exclusive_jets(n_jets);
+   }
+private:
+   fastjet::JetDefinition _def;
 };
 …
 // winner take all recombination scheme.
 class AxesFinderFromWTA_KT : public AxesFinderFromExclusiveJetDefinition {
+   private:
+      const WinnerTakeAllRecombiner *recomb;
+   public:
+      AxesFinderFromWTA_KT() : AxesFinderFromExclusiveJetDefinition(
+         fastjet::JetDefinition(fastjet::kt_algorithm,
+         fastjet::JetDefinition::max_allowable_R, //maximum jet radius constant
+         recomb = new WinnerTakeAllRecombiner(),
+         fastjet::Best)) {}
+      ~AxesFinderFromWTA_KT() {delete recomb;}
+   };
+public:
+   AxesFinderFromWTA_KT()
+   : AxesFinderFromExclusiveJetDefinition(
+      fastjet::JetDefinition(fastjet::kt_algorithm,
+      fastjet::JetDefinition::max_allowable_R, //maximum jet radius constant
+      &_recomb,
+      fastjet::Best)) {}
+private:
+   const WinnerTakeAllRecombiner _recomb;
+};
 //------------------------------------------------------------------------
 …
 // winner take all recombination scheme.
 class AxesFinderFromWTA_CA : public AxesFinderFromExclusiveJetDefinition {
+   private:
+      const WinnerTakeAllRecombiner *recomb;
+   public:
+      AxesFinderFromWTA_CA() : AxesFinderFromExclusiveJetDefinition(
+         fastjet::JetDefinition(fastjet::cambridge_algorithm,
+         fastjet::JetDefinition::max_allowable_R, //maximum jet radius constant
+         recomb = new WinnerTakeAllRecombiner(),
+         fastjet::Best)) {}
+      ~AxesFinderFromWTA_CA() {delete recomb;}
+};
+//  The following classes are for testing, and are commented out for initial release
+//
+////------------------------------------------------------------------------
+///// \class AxesFinderFromWTA2_KT
+//// This class finds axes by finding the exlusive jets after clustering according to a kT algorithm and a
+//// winner take all recombination scheme with alpha = 2.
+//class AxesFinderFromWTA2_KT : public AxesFinderFromExclusiveJetDefinition {
+//   private:
+//      const WinnerTakeAllRecombiner *recomb;
+//   public:
+//      AxesFinderFromWTA2_KT() : AxesFinderFromExclusiveJetDefinition(
+//         fastjet::JetDefinition(fastjet::kt_algorithm,
+//         fastjet::JetDefinition::max_allowable_R, //maximum jet radius constant
+//         recomb = new WinnerTakeAllRecombiner(2), // uses alpha = 2 here
+//         fastjet::Best)) {}
+//      ~AxesFinderFromWTA2_KT() {delete recomb;}
+//   };
+//
+////------------------------------------------------------------------------
+///// \class AxesFinderFromWTA2_CA
+//// This class finds axes by finding the exlusive jets after clustering according to a CA algorithm and a
+//// winner take all recombination scheme with alpha = 2.
+//class AxesFinderFromWTA2_CA : public AxesFinderFromExclusiveJetDefinition {
+//   private:
+//      const WinnerTakeAllRecombiner *recomb;
+//   public:
+//      AxesFinderFromWTA2_CA() : AxesFinderFromExclusiveJetDefinition(
+//         fastjet::JetDefinition(fastjet::cambridge_algorithm,
+//         fastjet::JetDefinition::max_allowable_R, //maximum jet radius constant
+//         recomb = new WinnerTakeAllRecombiner(2), //uses alpha = 2 here
+//         fastjet::Best)) {}
+//      ~AxesFinderFromWTA2_CA() {delete recomb;}
+//};
+public:
+   AxesFinderFromWTA_CA()
+   : AxesFinderFromExclusiveJetDefinition(
+      fastjet::JetDefinition(fastjet::cambridge_algorithm,
+      fastjet::JetDefinition::max_allowable_R, //maximum jet radius constant
+      &_recomb,
+      fastjet::Best)) {}
+private:
+   const WinnerTakeAllRecombiner _recomb;
+};
 //------------------------------------------------------------------------
 …
 // E_scheme recombination.
 class AxesFinderFromKT : public AxesFinderFromExclusiveJetDefinition {
+   public:
+      AxesFinderFromKT() : AxesFinderFromExclusiveJetDefinition(
+         fastjet::JetDefinition(fastjet::kt_algorithm,
+         fastjet::JetDefinition::max_allowable_R, //maximum jet radius constant
+         fastjet::E_scheme,
+         fastjet::Best)) {}
+public:
+   AxesFinderFromKT()
+   : AxesFinderFromExclusiveJetDefinition(
+      fastjet::JetDefinition(fastjet::kt_algorithm,
+      fastjet::JetDefinition::max_allowable_R, //maximum jet radius constant
+      fastjet::E_scheme,
+      fastjet::Best)) {}
 };
 …
 // E_scheme recombination.
 class AxesFinderFromCA : public AxesFinderFromExclusiveJetDefinition {
+   public:
+      AxesFinderFromCA() : AxesFinderFromExclusiveJetDefinition(
+         fastjet::JetDefinition(fastjet::cambridge_algorithm,
+                                fastjet::JetDefinition::max_allowable_R,  //maximum jet radius constant
+         fastjet::E_scheme,
+         fastjet::Best)) {}
+public:
+   AxesFinderFromCA()
+   : AxesFinderFromExclusiveJetDefinition(
+      fastjet::JetDefinition(fastjet::cambridge_algorithm,
+                             fastjet::JetDefinition::max_allowable_R,  //maximum jet radius constant
+      fastjet::E_scheme,
+      fastjet::Best)) {}
 };
 …
 // This can be implemented with different jet algorithms.
 class AxesFinderFromHardestJetDefinition : public AxesFinder {
+   private:
+      fastjet::JetDefinition _def;
+   public:
+      AxesFinderFromHardestJetDefinition(fastjet::JetDefinition def) : _def(def) {}
+      virtual std::vector<fastjet::PseudoJet> getBetterAxes(int n_jets, const std::vector <fastjet::PseudoJet> & inputs, const std::vector<fastjet::PseudoJet>& currentAxes) {
+         fastjet::ClusterSequence jet_clust_seq(inputs, _def);
+         std::vector<fastjet::PseudoJet> myJets = sorted_by_pt(jet_clust_seq.inclusive_jets());
+         myJets.resize(n_jets);  // only keep n hardest
+         return myJets;
+      }
+public:
+   AxesFinderFromHardestJetDefinition(fastjet::JetDefinition def)
+   : _def(def) {}
+   virtual std::vector<fastjet::PseudoJet> getAxes(int n_jets,
+                                                   const std::vector <fastjet::PseudoJet> & inputs,
+                                                   const std::vector<fastjet::PseudoJet>& /*seedAxes*/) const {
+      fastjet::ClusterSequence jet_clust_seq(inputs, _def);
+      std::vector<fastjet::PseudoJet> myJets = sorted_by_pt(jet_clust_seq.inclusive_jets());
+      myJets.resize(n_jets);  // only keep n hardest
+      return myJets;
+   }
+private:
+   fastjet::JetDefinition _def;
 };
 …
 // to an anti kT algorithm and E_scheme.
 class AxesFinderFromAntiKT : public AxesFinderFromHardestJetDefinition {
+   public:
+      AxesFinderFromAntiKT(double R0) : AxesFinderFromHardestJetDefinition(fastjet::JetDefinition(fastjet::antikt_algorithm,R0,fastjet::E_scheme,fastjet::Best)) {}
+public:
+   AxesFinderFromAntiKT(double R0)
+   : AxesFinderFromHardestJetDefinition(
+      fastjet::JetDefinition(fastjet::antikt_algorithm,
+                             R0,fastjet::E_scheme,fastjet::Best)) {}
 };
 …
 class AxesFinderFromUserInput : public AxesFinder {
+   public:
+      AxesFinderFromUserInput() {}
+      virtual std::vector<fastjet::PseudoJet> getBetterAxes(int n_jets, const std::vector <fastjet::PseudoJet> & inputs, const std::vector<fastjet::PseudoJet>& currentAxes) {
+         assert(currentAxes.size() == (unsigned int) n_jets);
+         return currentAxes;
+      }
+public:
+   AxesFinderFromUserInput() {}
+   virtual std::vector<fastjet::PseudoJet> getAxes(int n_jets, const std::vector <fastjet::PseudoJet> & /*inputs*/, const std::vector<fastjet::PseudoJet>& currentAxes) const {
+      assert(currentAxes.size() == (unsigned int) n_jets);
+      (void)(n_jets);  // adding this line to fix unused-parameter warning
+      return currentAxes;
+   }
 };
 …
 class AxesFinderFromOnePassMinimization : public AxesFinder {
+   private:
+      double _precision;  // Desired precision in axes alignment
+      int _halt;  // maximum number of steps per iteration
+      double _beta;
+      double _Rcutoff;
+      DefaultUnnormalizedMeasure _measureFunction;
+   public:
+      // From a startingFinder, try to minimize the unnormalized_measure
+      AxesFinderFromOnePassMinimization(AxesFinder* startingFinder, double beta, double Rcutoff)
+         : AxesFinder(startingFinder),
+           _precision(0.0001), //hard coded for now
+           _halt(1000), //hard coded for now
+           _beta(beta),
+           _Rcutoff(Rcutoff),
+           _measureFunction(beta, Rcutoff)
+           {}
+      virtual std::vector<fastjet::PseudoJet> getBetterAxes(int n_jets, const std::vector <fastjet::PseudoJet> & inputJets, const std::vector<fastjet::PseudoJet>& currentAxes);
+      template <int N> std::vector<LightLikeAxis> UpdateAxesFast(const std::vector <LightLikeAxis> & old_axes,
+                                  const std::vector <fastjet::PseudoJet> & inputJets);
+      std::vector<LightLikeAxis> UpdateAxes(const std::vector <LightLikeAxis> & old_axes,
+                                      const std::vector <fastjet::PseudoJet> & inputJets);
+public:
+   // From a startingFinder, try to minimize the unnormalized_measure
+   AxesFinderFromOnePassMinimization(double beta, double Rcutoff)
+      : _precision(0.0001), //hard coded for now
+        _halt(1000), //hard coded for now
+        _beta(beta),
+        _Rcutoff(Rcutoff),
+        _measureFunction(beta, Rcutoff)
+        {}
+   virtual std::vector<fastjet::PseudoJet> getAxes(int n_jets,
+                                                   const std::vector <fastjet::PseudoJet> & inputJets,
+                                                   const std::vector<fastjet::PseudoJet>& currentAxes) const;
+private:
+   double _precision;  // Desired precision in axes alignment
+   int _halt;  // maximum number of steps per iteration
+   double _beta;
+   double _Rcutoff;
+   DefaultUnnormalizedMeasureFunction _measureFunction;
+   template <int N> std::vector<LightLikeAxis> UpdateAxesFast(const std::vector <LightLikeAxis> & old_axes,
+                                                              const std::vector <fastjet::PseudoJet> & inputJets) const;
+   std::vector<LightLikeAxis> UpdateAxes(const std::vector <LightLikeAxis> & old_axes,
+                                         const std::vector <fastjet::PseudoJet> & inputJets) const;
 };
 …
 class AxesFinderFromKmeansMinimization : public AxesFinder{
+   private:
+      int _n_iterations;   // Number of iterations to run  (0 for no minimization, 1 for one-pass, >>1 for global minimum)
+      double _noise_range; // noise range for random initialization
+      DefaultUnnormalizedMeasure _measureFunction; //function to test whether minimum is reached
+      AxesFinderFromOnePassMinimization _onePassFinder;  //one pass finder for minimization
+      PseudoJet jiggle(const PseudoJet& axis);
+   public:
+      AxesFinderFromKmeansMinimization(AxesFinder *startingFinder, double beta, double Rcutoff, int n_iterations) :
+         AxesFinder(startingFinder),
+         _n_iterations(n_iterations),
+         _noise_range(1.0), // hard coded for the time being
+         _measureFunction(beta, Rcutoff),
+         _onePassFinder(NULL, beta, Rcutoff)
+         {}
+      virtual std::vector<fastjet::PseudoJet> getBetterAxes(int n_jets, const std::vector <fastjet::PseudoJet> & inputJets, const std::vector<fastjet::PseudoJet>& currentAxes);
+public:
+   AxesFinderFromKmeansMinimization(double beta, double Rcutoff, int n_iterations)
+   :  _n_iterations(n_iterations),
+      _noise_range(1.0), // hard coded for the time being
+      _measureFunction(beta, Rcutoff),
+      _onePassFinder(beta, Rcutoff)
+      {}
+   virtual std::vector<fastjet::PseudoJet> getAxes(int n_jets, const std::vector <fastjet::PseudoJet> & inputJets, const std::vector<fastjet::PseudoJet>& currentAxes) const;
+private:
+   int _n_iterations;   // Number of iterations to run  (0 for no minimization, 1 for one-pass, >>1 for global minimum)
+   double _noise_range; // noise range for random initialization
+   DefaultUnnormalizedMeasureFunction _measureFunction; //function to test whether minimum is reached
+   AxesFinderFromOnePassMinimization _onePassFinder;  //one pass finder that is repeatedly called
+   PseudoJet jiggle(const PseudoJet& axis) const;
 };
 …
 class AxesFinderFromGeometricMinimization : public AxesFinder {
+   private:
+      MeasureFunction* _function;
+      double _Rcutoff;
+      double _nAttempts;
+      double _accuracy;
+   public:
+      AxesFinderFromGeometricMinimization(AxesFinder* startingFinder, double beta, double Rcutoff) : AxesFinder(startingFinder), _Rcutoff(Rcutoff) {
+         if (beta != 2.0) {
+            std::cerr << "Geometric minimization is currently only defined for beta = 2.0." << std::endl;
+            exit(1);
+         }
+         _nAttempts = 100;
+         _accuracy = 0.000000001;
+         _function = new GeometricMeasure(beta,_Rcutoff);
+public:
+   AxesFinderFromGeometricMinimization(double beta, double Rcutoff)
+   :  _nAttempts(100),
+      _accuracy(0.000000001),
+      _function(beta,Rcutoff)
+   {
+      if (beta != 2.0) {
+         throw Error("Geometric minimization is currently only defined for beta = 2.0.");
+      }
+      ~AxesFinderFromGeometricMinimization() {
+         delete _function;
+      }
+      virtual std::vector<fastjet::PseudoJet> getBetterAxes(int n_jets, const std::vector <fastjet::PseudoJet> & particles, const std::vector<fastjet::PseudoJet>& currentAxes);
+   }
+   virtual std::vector<fastjet::PseudoJet> getAxes(int n_jets, const std::vector <fastjet::PseudoJet> & particles, const std::vector<fastjet::PseudoJet>& currentAxes) const;
+private:
+   double _nAttempts;
+   double _accuracy;
+   GeometricMeasureFunction _function;
 };
 …
 // in order to better facilitate calculations.
 class LightLikeAxis {
+private:
+   double _rap, _phi, _weight, _mom;
+   double DistanceSq(double rap2, double phi2) const {
+      double rap1 = _rap;
+      double phi1 = _phi;
+      double distRap = rap1-rap2;
+      double distPhi = std::fabs(phi1-phi2);
+      if (distPhi > M_PI) {distPhi = 2.0*M_PI - distPhi;}
+      return sq(distRap) + sq(distPhi);
+   }
+   double Distance(double rap2, double phi2) const {
+      return std::sqrt(DistanceSq(rap2,phi2));
+   }
 public:
    LightLikeAxis() : _rap(0.0), _phi(0.0), _weight(0.0), _mom(0.0) {}
 …
+   }
+private:
+   double _rap, _phi, _weight, _mom;
+   double DistanceSq(double rap2, double phi2) const {
+      double rap1 = _rap;
+      double phi1 = _phi;
+      double distRap = rap1-rap2;
+      double distPhi = std::fabs(phi1-phi2);
+      if (distPhi > M_PI) {distPhi = 2.0*M_PI - distPhi;}
+      return distRap*distRap + distPhi*distPhi;
+   }
+   double Distance(double rap2, double phi2) const {
+      return std::sqrt(DistanceSq(rap2,phi2));
+   }
 };

external/fastjet/contribs/Nsubjettiness/MeasureFunction.cc

-              rf6b6ee7
+              r49234af
 //  Jesse Thaler, Ken Van Tilburg, Christopher K. Vermilion, and TJ Wilkason
 //
+//  $Id: MeasureFunction.cc 670 2014-06-06 01:24:42Z jthaler $
 //----------------------------------------------------------------------
 // This file is part of FastJet contrib.
 …
 // Return all of the necessary TauComponents for specific input particles and axes
+TauComponents MeasureFunction::result(const std::vector<fastjet::PseudoJet>& particles, const std::vector<fastjet::PseudoJet>& axes) {
+TauComponents MeasureFunction::result(const std::vector<fastjet::PseudoJet>& particles, const std::vector<fastjet::PseudoJet>& axes) const {
+   // first find partition
+   // this sets jetPartitionStorage and beamPartitionStorage
+   PseudoJet beamPartitionStorage;
+   std::vector<fastjet::PseudoJet> jetPartitionStorage = get_partition(particles,axes,&beamPartitionStorage);
+   // then return result calculated from partition
+   return result_from_partition(jetPartitionStorage,axes,&beamPartitionStorage);
+}
+   std::vector<double> jetPieces(axes.size(), 0.0);
+   double beamPiece = 0.0;
+std::vector<fastjet::PseudoJet> MeasureFunction::get_partition(const std::vector<fastjet::PseudoJet>& particles,
+                                                               const std::vector<fastjet::PseudoJet>& axes,
+                                                               PseudoJet * beamPartitionStorage) const {
+   // Calculates the unnormalized sub-tau values, i.e. a std::vector of the contributions to tau_N of each Voronoi region (or region within R_0)
+   std::vector<std::vector<PseudoJet> > jetPartition(axes.size());
+   std::vector<PseudoJet> beamPartition;
+   // Figures out the partiting of the input particles into the various jet pieces
+   // Based on which axis the parition is closest to
    for (unsigned i = 0; i < particles.size(); i++) {
 …
       if (j_min == -1) {
          if (_has_beam) beamPiece += beam_numerator(particles[i]);
+         if (_has_beam) beamPartition.push_back(particles[i]);
          else assert(_has_beam);  // this should never happen.
       } else {
          jetPieces[j_min] += jet_numerator(particles[i],axes[j_min]);
+         jetPartition[j_min].push_back(particles[i]);
+      }
+   }
+   // Calculates normalization for tau and subTau if _has_denominator is true, otherwise returns 1.0 (i.e. no normalization)
+   double tauDen = 0.0;
+   if (_has_denominator) {
+      for (unsigned i = 0; i < particles.size(); i++) {
+         tauDen += denominator(particles[i]);
+      }
+   } else {
+      tauDen = 1.0; // if no denominator, then 1.0 for no normalization factor
+   // Store beam partition
+   if (beamPartitionStorage) {
+      *beamPartitionStorage = join(beamPartition);
+   }
+   // Store jet partitions
+   std::vector<PseudoJet> jetPartitionStorage(axes.size(),PseudoJet(0,0,0,0));
+   for (unsigned j = 0; j < axes.size(); j++) {
+      jetPartitionStorage[j] = join(jetPartition[j]);
+   }
+   return jetPartitionStorage;
+}
+// does partition, but only stores index of PseudoJets
+std::vector<std::list<int> > MeasureFunction::get_partition_list(const std::vector<fastjet::PseudoJet>& particles,
+                                                                 const std::vector<fastjet::PseudoJet>& axes) const {
+   std::vector<std::list<int> > jetPartition(axes.size());
+   // Figures out the partiting of the input particles into the various jet pieces
+   // Based on which axis the parition is closest to
+   for (unsigned i = 0; i < particles.size(); i++) {
+      // find minimum distance; start with beam (-1) for reference
+      int j_min = -1;
+      double minRsq;
+      if (_has_beam) minRsq = beam_distance_squared(particles[i]);
+      else minRsq = std::numeric_limits<double>::max(); // make it large value
+      // check to see which axis the particle is closest to
+      for (unsigned j = 0; j < axes.size(); j++) {
+         double tempRsq = jet_distance_squared(particles[i],axes[j]); // delta R distance
+         if (tempRsq < minRsq) {
+            minRsq = tempRsq;
+            j_min = j;
+         }
+      }
+      if (j_min == -1) {
+         assert(_has_beam); // consistency check
+      } else {
+         jetPartition[j_min].push_back(i);
+      }
+   }
+   return jetPartition;
+}
+// Uses existing partition and calculates result
+// TODO:  Can we cache this for speed up when doing area subtraction?
+TauComponents MeasureFunction::result_from_partition(const std::vector<fastjet::PseudoJet>& jet_partition,
+                                                     const std::vector<fastjet::PseudoJet>& axes,
+                                                     PseudoJet * beamPartitionStorage) const {
+   std::vector<double> jetPieces(axes.size(), 0.0);
+   double beamPiece = 0.0;
+   double tauDen = 0.0;
+   if (!_has_denominator) tauDen = 1.0;  // if no denominator, then 1.0 for no normalization factor
+   // first find jet pieces
+   for (unsigned j = 0; j < axes.size(); j++) {
+      std::vector<PseudoJet> thisPartition = jet_partition[j].constituents();
+      for (unsigned i = 0; i < thisPartition.size(); i++) {
+         jetPieces[j] += jet_numerator(thisPartition[i],axes[j]); //numerator jet piece
+         if (_has_denominator) tauDen += denominator(thisPartition[i]); // denominator
+      }
+   }
+   // then find beam piece
+   if (_has_beam) {
+      assert(beamPartitionStorage); // make sure I have beam information
+      std::vector<PseudoJet> beamPartition = beamPartitionStorage->constituents();
+      for (unsigned i = 0; i < beamPartition.size(); i++) {
+         beamPiece += beam_numerator(beamPartition[i]); //numerator beam piece
+         if (_has_denominator) tauDen += denominator(beamPartition[i]); // denominator
+      }
+   }
    return TauComponents(jetPieces, beamPiece, tauDen, _has_denominator, _has_beam);
+}
 } //namespace contrib

external/fastjet/contribs/Nsubjettiness/MeasureFunction.hh

-              rf6b6ee7
+              r49234af
 //  Jesse Thaler, Ken Van Tilburg, Christopher K. Vermilion, and TJ Wilkason
 //
+//  $Id: MeasureFunction.hh 678 2014-06-12 20:43:03Z jthaler $
 //----------------------------------------------------------------------
 // This file is part of FastJet contrib.
 …
 #include <limits>
 FASTJET_BEGIN_NAMESPACE      // defined in fastjet/internal/base.hh
 namespace contrib{
+inline double sq(double x) {return x*x;}
+///////
+//
+// Measure Function
+//
+///////
+///////
+//
+// TauComponents
+// (eventually we might want to put this in a separate header file)
+//
+///////
 /// \class TauComponents
 // This class creates a wrapper for the various tau/subtau values calculated in Njettiness. This class allows Njettiness access to these variables
 // without ever having to do the calculation itself. It takes in subtau numerators and tau denominator from MeasureFunction
 // and outputs tau numerator, and normalized tau and subtau.
-// TODO:  Consider merging with NjettinessExtras.  Add axes information?
 class TauComponents {
-private:
-   // these values are input in the constructor
-   std::vector<double> _jet_pieces_numerator;
-   double _beam_piece_numerator;
-   double _denominator;
-   bool _has_denominator; //added so that TauComponents knows if denominator is used or not
-   bool _has_beam; //added so that TauComponents knows if beam regions is used or not
-   // these values are derived from above values
-   std::vector<double> _jet_pieces;
-   double _beam_piece;
-   double _numerator;
-   double _tau;
 public:
 …
    double beam_piece() const { return _beam_piece; }
    double tau() const { return _tau; }
+};
+private:
+   // these values are input in the constructor
+   std::vector<double> _jet_pieces_numerator;
+   double _beam_piece_numerator;
+   double _denominator;
+   bool _has_denominator; //added so that TauComponents knows if denominator is used or not
+   bool _has_beam; //added so that TauComponents knows if beam regions is used or not
+   // these values are derived from above values
+   std::vector<double> _jet_pieces;
+   double _beam_piece;
+   double _numerator;
+   double _tau;
+};
+///////
+//
+// Measure Function
+//
+///////
 //------------------------------------------------------------------------
 …
 class MeasureFunction {
+public:
+   //These functions define the measure by which tau_N is calculated,
+   //and are overloaded by the various measures below
+   // Distanes to axes.  These are called many times, so need to be as fast as possible
+   virtual double jet_distance_squared(const fastjet::PseudoJet& particle, const fastjet::PseudoJet& axis) const = 0;
+   virtual double beam_distance_squared(const fastjet::PseudoJet& particle) const = 0;
+   // The actual measures used in N-(sub)jettiness
+   virtual double jet_numerator(const fastjet::PseudoJet& particle, const fastjet::PseudoJet& axis) const  = 0;
+   virtual double beam_numerator(const fastjet::PseudoJet& particle) const = 0;
+   // a possible normalization factor
+   virtual double denominator(const fastjet::PseudoJet& particle) const = 0;
+   //------
+   // The functions below call the above functions and are not virtual
+   //------
+   // Return all of the necessary TauComponents for specific input particles and axes
+   // Also have optional pointers to get out information about partitioning
+   TauComponents result(const std::vector<fastjet::PseudoJet>& particles, const std::vector<fastjet::PseudoJet>& axes) const;
+   // Just getting tau value if that is all that is needed
+   double tau(const std::vector<fastjet::PseudoJet>& particles, const std::vector<fastjet::PseudoJet>& axes) const {
+      return result(particles,axes).tau();
+   }
+   // Create the partitioning and stores internally
+   std::vector<fastjet::PseudoJet> get_partition(const std::vector<fastjet::PseudoJet>& particles, const std::vector<fastjet::PseudoJet>& axes, PseudoJet * beamPartitionStorage = NULL) const;
+   // Essentially same as get_partition, but in the form needed for the jet algorithm
+   std::vector<std::list<int> > get_partition_list(const std::vector<fastjet::PseudoJet>& particles, const std::vector<fastjet::PseudoJet>& axes) const;
+   // calculates the tau result using an existing partition
+   TauComponents result_from_partition(const std::vector<fastjet::PseudoJet>& jet_partitioning, const std::vector<fastjet::PseudoJet>& axes, PseudoJet * beamPartitionStorage = NULL) const;
+   // shorthand for squaring
+   static inline double sq(double x) {return x*x;}
+   //virtual destructor
+   virtual ~MeasureFunction(){}
 protected:
    //bool set by derived classes to choose whether or not to use the denominator
 …
    MeasureFunction(bool has_denominator = true, bool has_beam = true) : _has_denominator(has_denominator), _has_beam(has_beam) {}
+public:
+   virtual ~MeasureFunction(){}
+   //These functions define the measure by which tau_N is calculated,
+   //and are overloaded by the various measures below
+   // Distanes to axes.  These are called many times, so need to be as fast as possible
+   virtual double jet_distance_squared(const fastjet::PseudoJet& particle, const fastjet::PseudoJet& axis) = 0;
+   virtual double beam_distance_squared(const fastjet::PseudoJet& particle) = 0;
+   // The actual measures used in N-(sub)jettiness
+   virtual double jet_numerator(const fastjet::PseudoJet& particle, const fastjet::PseudoJet& axis) = 0;
+   virtual double beam_numerator(const fastjet::PseudoJet& particle) = 0;
+   // a possible normalization factor
+   virtual double denominator(const fastjet::PseudoJet& particle) = 0;
+   // These functions call the above functions and are not virtual
+   // Do I cluster a particle into a jet?
+   bool do_cluster(const fastjet::PseudoJet& particle, const fastjet::PseudoJet& axis) {
+      return (jet_distance_squared(particle,axis) <= beam_distance_squared(particle));
+   }
+   // Return all of the necessary TauComponents for specific input particles and axes
+   TauComponents result(const std::vector<fastjet::PseudoJet>& particles, const std::vector<fastjet::PseudoJet>& axes);
+   double tau(const std::vector<fastjet::PseudoJet>& particles, const std::vector<fastjet::PseudoJet>& axes) {
+      return result(particles,axes).tau();
+   }
+};
+/// \class DefaultNormalizedMeasure
+};
+/// \class DefaultNormalizedMeasureFunction
 // This class is the default measure, inheriting from the class above. This class will calculate tau_N
 // of a jet according to this measure. This measure is defined as the pT of the particle multiplied by deltaR
 // to the power of beta. This class includes the normalization factor determined by R0
+class DefaultNormalizedMeasure : public MeasureFunction {
+   private:
+      double _beta;
+      double _R0;
+      double _Rcutoff;
+   public:
+      DefaultNormalizedMeasure(double beta, double R0, double Rcutoff, bool normalized = true)
+      : MeasureFunction(normalized), _beta(beta), _R0(R0), _Rcutoff(Rcutoff) {}
+      virtual double jet_distance_squared(const fastjet::PseudoJet& particle, const fastjet::PseudoJet& axis) {
+         return particle.squared_distance(axis);
+      }
+      virtual double beam_distance_squared(const fastjet::PseudoJet& particle) {
+         return sq(_Rcutoff);
+      }
+      virtual double jet_numerator(const fastjet::PseudoJet& particle, const fastjet::PseudoJet& axis) {
+         return particle.perp() * std::pow(jet_distance_squared(particle,axis),_beta/2.0);
+      }
+      virtual double beam_numerator(const fastjet::PseudoJet& particle) {
+         return particle.perp() * std::pow(_Rcutoff,_beta);
+      }
+      virtual double denominator(const fastjet::PseudoJet& particle) {
+         return particle.perp() * std::pow(_R0,_beta);
+      }
+class DefaultNormalizedMeasureFunction : public MeasureFunction {
+public:
+   DefaultNormalizedMeasureFunction(double beta, double R0, double Rcutoff, bool normalized = true)
+   : MeasureFunction(normalized), _beta(beta), _R0(R0), _Rcutoff(Rcutoff) {}
+   virtual double jet_distance_squared(const fastjet::PseudoJet& particle, const fastjet::PseudoJet& axis) const {
+      return particle.squared_distance(axis);
+   }
+   virtual double beam_distance_squared(const fastjet::PseudoJet& /*particle*/) const {
+      return sq(_Rcutoff);
+   }
+   virtual double jet_numerator(const fastjet::PseudoJet& particle, const fastjet::PseudoJet& axis) const{
+      return particle.perp() * std::pow(jet_distance_squared(particle,axis),_beta/2.0);
+   }
+   virtual double beam_numerator(const fastjet::PseudoJet& particle) const {
+      return particle.perp() * std::pow(_Rcutoff,_beta);
+   }
+   virtual double denominator(const fastjet::PseudoJet& particle) const {
+      return particle.perp() * std::pow(_R0,_beta);
+   }
+private:
+   double _beta;
+   double _R0;
+   double _Rcutoff;
 };
 //------------------------------------------------------------------------
 /// \class DefaultUnnormalizedMeasure
+/// \class DefaultUnnormalizedMeasureFunction
 // This class is the unnormalized default measure, inheriting from the class above. The only difference from above
 // is that the denominator is defined to be 1.0 by setting _has_denominator to false.
 class DefaultUnnormalizedMeasure : public DefaultNormalizedMeasure {
    public:
       // Since all methods are identical, UnnormalizedMeasure inherits directly from NormalizedMeasure. R0 is defaulted to NAN since the value of R0 is unecessary for this class.
       // the "false" flag sets _has_denominator in MeasureFunction to false so no denominator is used.
       DefaultUnnormalizedMeasure(double beta, double Rcutoff) : DefaultNormalizedMeasure(beta, NAN, Rcutoff, false) {}
+class DefaultUnnormalizedMeasureFunction : public DefaultNormalizedMeasureFunction {
+public:
+   // Since all methods are identical, UnnormalizedMeasure inherits directly
+   // from NormalizedMeasure. R0 is a dummy value since the value of R0 is unecessary for this class,
+   // and the "false" flag sets _has_denominator in MeasureFunction to false so no denominator is used.
+   DefaultUnnormalizedMeasureFunction(double beta, double Rcutoff)
+   : DefaultNormalizedMeasureFunction(beta, std::numeric_limits<double>::quiet_NaN(), Rcutoff, false) {}
 };
 //------------------------------------------------------------------------
 /// \class GeometricMeasure
+/// \class GeometricMeasureFunction
 // This class is the geometic measure, inheriting from the class above. This class will calculate tau_N
 // of a jet according to this measure. This measure is defined by the Lorentz dot product between
 // the particle and the axis. This class includes normalization of tau_N.
+class GeometricMeasure : public MeasureFunction {
+   private:
+      double _jet_beta;
+      double _beam_beta;
+      double _Rcutoff;
+      // create light-like axis
+      fastjet::PseudoJet lightFrom(const fastjet::PseudoJet& input) const {
+         double length = sqrt(pow(input.px(),2) + pow(input.py(),2) + pow(input.pz(),2));
+         return fastjet::PseudoJet(input.px()/length,input.py()/length,input.pz()/length,1.0);
+      }
+   public:
+      // Right now, we are hard coded for beam_beta = 1.0, but that will need to change
+      GeometricMeasure(double jet_beta, double Rcutoff) : _jet_beta(jet_beta), _beam_beta(1.0), _Rcutoff(Rcutoff) {}
+      virtual double jet_distance_squared(const fastjet::PseudoJet& particle, const fastjet::PseudoJet& axis) {
+         fastjet::PseudoJet lightAxis = lightFrom(axis);
+         double pseudoRsquared = 2.0*dot_product(lightFrom(axis),particle)/(lightAxis.pt()*particle.pt());
+         return pseudoRsquared;
+      }
+      virtual double beam_distance_squared(const fastjet::PseudoJet& particle) {
+         return sq(_Rcutoff);
+      }
+      virtual double jet_numerator(const fastjet::PseudoJet& particle, const fastjet::PseudoJet& axis) {
+         fastjet::PseudoJet lightAxis = lightFrom(axis);
+         double weight = (_beam_beta == 1.0) ? 1.0 : std::pow(lightAxis.pt(),_beam_beta - 1.0);
+         return particle.pt() * weight * std::pow(jet_distance_squared(particle,axis),_jet_beta/2.0);
+      }
+      virtual double beam_numerator(const fastjet::PseudoJet& particle) {
+         double weight = (_beam_beta == 1.0) ? 1.0 : std::pow(particle.pt()/particle.e(),_beam_beta - 1.0);
+         return particle.pt() * weight * std::pow(_Rcutoff,_jet_beta);
+      }
+      virtual double denominator(const fastjet::PseudoJet& particle) {
+         return 1.0;
+      }
+};
+class GeometricMeasureFunction : public MeasureFunction {
+public:
+   // Right now, we are hard coded for beam_beta = 1.0, but that will need to change
+   GeometricMeasureFunction(double jet_beta, double Rcutoff) :
+     MeasureFunction(false), // doesn't have denominator
+     _jet_beta(jet_beta), _beam_beta(1.0), _Rcutoff(Rcutoff) {}
+   virtual double jet_distance_squared(const fastjet::PseudoJet& particle, const fastjet::PseudoJet& axis) const {
+      fastjet::PseudoJet lightAxis = lightFrom(axis);
+      double pseudoRsquared = 2.0*dot_product(lightFrom(axis),particle)/(lightAxis.pt()*particle.pt());
+      return pseudoRsquared;
+   }
+   virtual double beam_distance_squared(const fastjet::PseudoJet&  /*particle*/) const {
+      return sq(_Rcutoff);
+   }
+   virtual double jet_numerator(const fastjet::PseudoJet& particle, const fastjet::PseudoJet& axis) const {
+      fastjet::PseudoJet lightAxis = lightFrom(axis);
+      double weight = (_beam_beta == 1.0) ? 1.0 : std::pow(lightAxis.pt(),_beam_beta - 1.0);
+      return particle.pt() * weight * std::pow(jet_distance_squared(particle,axis),_jet_beta/2.0);
+   }
+   virtual double beam_numerator(const fastjet::PseudoJet& particle) const {
+      double weight = (_beam_beta == 1.0) ? 1.0 : std::pow(particle.pt()/particle.e(),_beam_beta - 1.0);
+      return particle.pt() * weight * std::pow(_Rcutoff,_jet_beta);
+   }
+   virtual double denominator(const fastjet::PseudoJet&  /*particle*/) const {
+      return std::numeric_limits<double>::quiet_NaN();
+   }
+private:
+   double _jet_beta;
+   double _beam_beta;
+   double _Rcutoff;
+   // create light-like axis
+   fastjet::PseudoJet lightFrom(const fastjet::PseudoJet& input) const {
+      double length = sqrt(pow(input.px(),2) + pow(input.py(),2) + pow(input.pz(),2));
+      return fastjet::PseudoJet(input.px()/length,input.py()/length,input.pz()/length,1.0);
+   }
+};
 } //namespace contrib

external/fastjet/contribs/Nsubjettiness/Njettiness.cc

-              rf6b6ee7
+              r49234af
 //  Jesse Thaler, Ken Van Tilburg, Christopher K. Vermilion, and TJ Wilkason
 //
+//  $Id: Njettiness.cc 677 2014-06-12 18:56:46Z jthaler $
 //----------------------------------------------------------------------
 // This file is part of FastJet contrib.
 …
 ///////
+// Helper function to correlate one pass minimization with appropriate measure
+void Njettiness::setOnePassAxesFinder(MeasureMode measure_mode, AxesFinder* startingFinder, double beta, double Rcutoff) {
+   if (measure_mode == normalized_measure || measure_mode == unnormalized_measure || measure_mode == normalized_cutoff_measure || measure_mode == unnormalized_cutoff_measure) {
+      _axesFinder = new AxesFinderFromOnePassMinimization(startingFinder, beta, Rcutoff);
+   }
+   else if (measure_mode == geometric_measure || measure_mode == geometric_cutoff_measure) {
+      _axesFinder = new AxesFinderFromGeometricMinimization(startingFinder, beta, Rcutoff);
+   }
+   else {
+      std::cerr << "Minimization only set up for normalized_measure, unnormalized_measure, normalized_cutoff_measure, unnormalized_cutoff_measure, geometric_measure, geometric_cutoff_measure" << std::endl;
+      exit(1); }
+}
+// Parsing needed for constructor to set AxesFinder and MeasureFunction
+// All of the parameter handling is here, and checking that number of parameters is correct.
+void Njettiness::setMeasureFunctionandAxesFinder(AxesMode axes_mode, MeasureMode measure_mode, double para1, double para2, double para3, double para4) {
+Njettiness::Njettiness(const AxesDefinition & axes_def, const MeasureDefinition & measure_def)
+: _axes_def(axes_def.create()), _measure_def(measure_def.create()) {
+   setMeasureFunctionAndAxesFinder();  // call helper function to do the hard work
+}
+Njettiness::Njettiness(AxesMode axes_mode, const MeasureDefinition & measure_def)
+: _axes_def(createAxesDef(axes_mode)), _measure_def(measure_def.create()) {
+   setMeasureFunctionAndAxesFinder();  // call helper function to do the hard work
+}
+// Convert from MeasureMode enum to MeasureDefinition
+// This returns a pointer that will be claimed by a SharedPtr
+MeasureDefinition* Njettiness::createMeasureDef(MeasureMode measure_mode, int num_para, double para1, double para2, double para3) const {
    // definition of maximum Rcutoff for non-cutoff measures, changed later by other measures
    double Rcutoff = std::numeric_limits<double>::max();  //large number
    // Most (but all measures have some kind of beta value)
    double beta = NAN;
+   // Most (but not all) measures have some kind of beta value
+   double beta = std::numeric_limits<double>::quiet_NaN();
    // The normalized measures have an R0 value.
    double R0 = NAN;
+   double R0 = std::numeric_limits<double>::quiet_NaN();
    // Find the MeasureFunction and set the parameters.
    switch (measure_mode) {
 …
          beta = para1;
          R0 = para2;
          if(correctParameterCount(2, para1, para2, para3, para4))
             _measureFunction = new DefaultNormalizedMeasure(beta, R0, Rcutoff); //normalized_measure requires 2 parameters, beta and R0
          else {
             std::cerr << "normalized_measure needs 2 parameters (beta and R0)" << std::endl;
             exit(1); }
+         if(num_para == 2) {
+            return new NormalizedMeasure(beta,R0);
+         } else {
+            throw Error("normalized_measure needs 2 parameters (beta and R0)");
+         }
          break;
       case unnormalized_measure:
          beta = para1;
          if(correctParameterCount(1, para1, para2, para3, para4))
             _measureFunction = new DefaultUnnormalizedMeasure(beta, Rcutoff); //unnormalized_measure requires 1 parameter, beta
          else {
             std::cerr << "unnormalized_measure needs 1 parameter (beta)" << std::endl;
             exit(1); }
+         if(num_para == 1) {
+            return new UnnormalizedMeasure(beta);
+         } else {
+            throw Error("unnormalized_measure needs 1 parameter (beta)");
+         }
          break;
       case geometric_measure:
          beta = para1;
          if(correctParameterCount(1, para1, para2, para3, para4))
             _measureFunction = new GeometricMeasure(beta,Rcutoff); //geometric_measure requires 1 parameter, beta
          else {
             std::cerr << "geometric_measure needs 1 parameter (beta)" << std::endl;
             exit(1); }
+         if (num_para == 1) {
+            return new GeometricMeasure(beta);
+         } else {
+            throw Error("geometric_measure needs 1 parameter (beta)");
+         }
          break;
       case normalized_cutoff_measure:
 …
          R0 = para2;
          Rcutoff = para3; //Rcutoff parameter is 3rd parameter in normalized_cutoff_measure
          if(correctParameterCount(3, para1, para2, para3, para4))
             _measureFunction = new DefaultNormalizedMeasure(beta, R0, Rcutoff); //normalized_cutoff_measure requires 3 parameters, beta, R0, and Rcutoff
          else {
             std::cerr << "normalized_cutoff_measure has 3 parameters (beta, R0, Rcutoff)" << std::endl;
             exit(1); }
+         if (num_para == 3) {
+            return new NormalizedCutoffMeasure(beta,R0,Rcutoff);
+         } else {
+            throw Error("normalized_cutoff_measure has 3 parameters (beta, R0, Rcutoff)");
+         }
          break;
       case unnormalized_cutoff_measure:
          beta = para1;
          Rcutoff = para2; //Rcutoff parameter is 2nd parameter in normalized_cutoff_measure
          if (correctParameterCount(2, para1, para2, para3, para4))
             _measureFunction = new DefaultUnnormalizedMeasure(beta, Rcutoff); //unnormalized_cutoff_measure requires 2 parameters, beta and Rcutoff
          else {
             std::cerr << "unnormalized_cutoff_measure has 2 parameters (beta, Rcutoff)" << std::endl;
             exit(1); }
+         if (num_para == 2) {
+            return new UnnormalizedCutoffMeasure(beta,Rcutoff);
+         } else {
+            throw Error("unnormalized_cutoff_measure has 2 parameters (beta, Rcutoff)");
+         }
          break;
       case geometric_cutoff_measure:
          beta = para1;
          Rcutoff = para2; //Rcutoff parameter is 2nd parameter in geometric_cutoff_measure
          if(correctParameterCount(2, para1, para2, para3, para4))
             _measureFunction = new GeometricMeasure(beta,Rcutoff); //geometric_cutoff_measure requires 2 parameters, beta and Rcutoff
          else {
             std::cerr << "geometric_cutoff_measure has 2 parameters (beta,Rcutoff)" << std::endl;
             exit(1); }
+         if(num_para == 2) {
+           return new GeometricCutoffMeasure(beta,Rcutoff);
+         } else {
+            throw Error("geometric_cutoff_measure has 2 parameters (beta, Rcutoff)");
+         }
          break;
       default:
          assert(false);
          break;
+   }
+   // Choose which AxesFinder from user input.
+   // Uses setOnePassAxesFinder helpful function to use beta and Rcutoff values about (if needed)
+   }
+   return NULL;
+}
+// Convert from AxesMode enum to AxesDefinition
+// This returns a pointer that will be claimed by a SharedPtr
+AxesDefinition* Njettiness::createAxesDef(Njettiness::AxesMode axes_mode) const {
    switch (axes_mode) {
       case wta_kt_axes:
+         _axesFinder = new AxesFinderFromWTA_KT();
+         break;
+         return new WTA_KT_Axes();
       case wta_ca_axes:
+         _axesFinder = new AxesFinderFromWTA_CA();
+         break;
+         return new WTA_CA_Axes();
       case kt_axes:
+         _axesFinder = new AxesFinderFromKT();
+         break;
+         return new KT_Axes();
       case ca_axes:
+         _axesFinder = new AxesFinderFromCA();
+         break;
+         return new CA_Axes();
       case antikt_0p2_axes:
+         _axesFinder = new AxesFinderFromAntiKT(0.2);
+         break;
+         return new AntiKT_Axes(0.2);
       case onepass_wta_kt_axes:
+         setOnePassAxesFinder(measure_mode, new AxesFinderFromWTA_KT(), beta, Rcutoff);
+         break;
+         return new OnePass_WTA_KT_Axes();
       case onepass_wta_ca_axes:
+         setOnePassAxesFinder(measure_mode, new AxesFinderFromWTA_CA(), beta, Rcutoff);
+         break;
+         return new OnePass_WTA_CA_Axes();
       case onepass_kt_axes:
+         setOnePassAxesFinder(measure_mode, new AxesFinderFromKT(), beta, Rcutoff);
+         break;
+         return new OnePass_KT_Axes();
       case onepass_ca_axes:
+         setOnePassAxesFinder(measure_mode, new AxesFinderFromCA(), beta, Rcutoff);
+         break;
+         return new OnePass_CA_Axes();
       case onepass_antikt_0p2_axes:
+         setOnePassAxesFinder(measure_mode, new AxesFinderFromAntiKT(0.2), beta, Rcutoff);
+         break;
+         return new OnePass_AntiKT_Axes(0.2);
       case onepass_manual_axes:
+         setOnePassAxesFinder(measure_mode, new AxesFinderFromUserInput(), beta, Rcutoff);
+         break;
+      case min_axes: //full minimization is not defined for geometric_measure.
+         if (measure_mode == normalized_measure || measure_mode == unnormalized_measure || measure_mode == normalized_cutoff_measure || measure_mode == unnormalized_cutoff_measure)
+            //Defaults to 100 iteration to find minimum
+            _axesFinder = new AxesFinderFromKmeansMinimization(new AxesFinderFromKT(), beta, Rcutoff, 100);
+         else {
+            std::cerr << "Multi-pass minimization only set up for normalized_measure, unnormalized_measure, normalized_cutoff_measure, unnormalized_cutoff_measure." << std::endl;
+            exit(1);
+         }
+         break;
+         return new OnePass_Manual_Axes();
+      case min_axes:
+         return new MultiPass_Axes(100);
       case manual_axes:
+         _axesFinder = new AxesFinderFromUserInput();
+         break;
+// These options have been commented out because they have not been fully tested
+//      case wta2_kt_axes: // option for alpha = 2 added
+//         _axesFinder = new AxesFinderFromWTA2_KT();
+//         break;
+//      case wta2_ca_axes: // option for alpha = 2 added
+//         _axesFinder = new AxesFinderFromWTA2_CA();
+//         break;
+//      case onepass_wta2_kt_axes: // option for alpha = 2 added
+//         setOnePassAxesFinder(measure_mode, new AxesFinderFromWTA2_KT(), beta, Rcutoff);
+//         break;
+//      case onepass_wta2_ca_axes: // option for alpha = 2 added
+//         setOnePassAxesFinder(measure_mode, new AxesFinderFromWTA2_CA(), beta, Rcutoff);
+//         break;
+         return new Manual_Axes();
       default:
          assert(false);
+         break;
+      }
+         return NULL;
+   }
+}
+// Parsing needed for constructor to set AxesFinder and MeasureFunction
+// All of the parameter handling is here, and checking that number of parameters is correct.
+void Njettiness::setMeasureFunctionAndAxesFinder() {
+   // Get the correct MeasureFunction and AxesFinders
+   _measureFunction.reset(_measure_def->createMeasureFunction());
+   _startingAxesFinder.reset(_axes_def->createStartingAxesFinder(*_measure_def));
+   _finishingAxesFinder.reset(_axes_def->createFinishingAxesFinder(*_measure_def));
+}
 // setAxes for Manual mode
 void Njettiness::setAxes(std::vector<fastjet::PseudoJet> myAxes) {
    if (_current_axes_mode == manual_axes || _current_axes_mode == onepass_manual_axes) {
+void Njettiness::setAxes(const std::vector<fastjet::PseudoJet> & myAxes) {
+   if (_axes_def->supportsManualAxes()) {
       _currentAxes = myAxes;
+   }
+   else {
+      std::cerr << "You can only use setAxes if using manual_axes or onepass_manual_axes measure mode" << std::endl;
+      exit(1);
+   } else {
+      throw Error("You can only use setAxes for manual AxesDefinitions");
+   }
+}
 …
 // Calculates and returns all TauComponents that user would want.
 // This information is stored in _current_tau_components for later access as well.
 TauComponents Njettiness::getTauComponents(unsigned n_jets, const std::vector<fastjet::PseudoJet> & inputJets) {
+TauComponents Njettiness::getTauComponents(unsigned n_jets, const std::vector<fastjet::PseudoJet> & inputJets) const {
    if (inputJets.size() <= n_jets) {  //if not enough particles, return zero
       _currentAxes = inputJets;
 …
       _current_tau_components = TauComponents();
       _seedAxes = _currentAxes;
+      _currentJets = _currentAxes;
+      _currentBeam = PseudoJet(0.0,0.0,0.0,0.0);
    } else {
+      _currentAxes = _axesFinder->getAxes(n_jets,inputJets,_currentAxes); // sets current Axes
+      _seedAxes = _axesFinder->seedAxes(); // sets seed Axes (if one pass minimization was used)
+      _current_tau_components = _measureFunction->result(inputJets, _currentAxes);  // sets current Tau Values
+      _seedAxes = _startingAxesFinder->getAxes(n_jets,inputJets,_currentAxes); //sets starting point for minimization
+      if (_finishingAxesFinder) {
+         _currentAxes = _finishingAxesFinder->getAxes(n_jets,inputJets,_seedAxes);
+      } else {
+         _currentAxes = _seedAxes;
+      }
+      // Find partition and store information
+      // (jet information in _currentJets, beam in _currentBeam)
+      _currentJets = _measureFunction->get_partition(inputJets,_currentAxes,&_currentBeam);
+      // Find tau value and store information
+      _current_tau_components = _measureFunction->result_from_partition(_currentJets, _currentAxes,&_currentBeam);  // sets current Tau Values
+   }
    return _current_tau_components;
 …
 // Each vector element is a list of ints corresponding to the indices in
 // particles of the particles belonging to that jet.
+// TODO:  Consider moving to MeasureFunction
+std::vector<std::list<int> > Njettiness::getPartition(const std::vector<fastjet::PseudoJet> & particles) {
+   std::vector<std::list<int> > partitions(_currentAxes.size());
+   for (unsigned i = 0; i < particles.size(); i++) {
+      int j_min = -1;
+      // find minimum distance
+      double minR = std::numeric_limits<double>::max();  //large number
+      for (unsigned j = 0; j < _currentAxes.size(); j++) {
+         double tempR = _measureFunction->jet_distance_squared(particles[i],_currentAxes[j]); // delta R distance
+         if (tempR < minR) {
+            minR = tempR;
+            j_min = j;
+         }
+      }
+      if (_measureFunction->do_cluster(particles[i],_currentAxes[j_min])) partitions[j_min].push_back(i);
+   }
+   return partitions;
+}
+// Having found axes, assign each particle in particles to an axis, and return a set of jets.
+// Each jet is the sum of particles closest to an axis (Njet = Naxes).
+// TODO:  Consider moving to MeasureFunction
+std::vector<fastjet::PseudoJet> Njettiness::getJets(const std::vector<fastjet::PseudoJet> & particles) {
+   std::vector<fastjet::PseudoJet> jets(_currentAxes.size());
+   std::vector<std::list<int> > partition = getPartition(particles);
+   for (unsigned j = 0; j < partition.size(); ++j) {
+      std::list<int>::const_iterator it, itE;
+      for (it = partition[j].begin(), itE = partition[j].end(); it != itE; ++it) {
+         jets[j] += particles[*it];
+      }
+   }
+   return jets;
+}
+std::vector<std::list<int> > Njettiness::getPartitionList(const std::vector<fastjet::PseudoJet> & particles) const {
+   // core code is in MeasureFunction
+   return _measureFunction->get_partition_list(particles,_currentAxes);
+}
 } // namespace contrib

external/fastjet/contribs/Nsubjettiness/Njettiness.hh

-              rf6b6ee7
+              r49234af
 //  Jesse Thaler, Ken Van Tilburg, Christopher K. Vermilion, and TJ Wilkason
 //
+//  $Id: Njettiness.hh 670 2014-06-06 01:24:42Z jthaler $
 //----------------------------------------------------------------------
 // This file is part of FastJet contrib.
 …
 #define __FASTJET_CONTRIB_NJETTINESS_HH__
 #include "MeasureFunction.hh"
 #include "AxesFinder.hh"
+#include "NjettinessDefinition.hh"
 #include "fastjet/PseudoJet.hh"
+#include "fastjet/SharedPtr.hh"
+#include <fastjet/LimitedWarning.hh>
 #include <cmath>
 #include <vector>
 #include <list>
 FASTJET_BEGIN_NAMESPACE      // defined in fastjet/internal/base.hh
 namespace contrib {
 ///////
 //
 …
    // The various axes choices available to the user
+   // It is recommended to use AxesDefinition instead of these.
    enum AxesMode {
       kt_axes,             // exclusive kt axes
 …
    // "normalized_cutoff_measure" was the default in v1.0 of Nsubjettiness
    // "unnormalized_measure" is now the recommended default usage
+   // But it is recommended to use MeasureDefinition instead of these.
    enum MeasureMode {
       normalized_measure,           //default normalized measure
 …
    };
+private:
+   // The chosen axes/measure modes
+   AxesFinder* _axesFinder;  // The chosen axes
+   MeasureFunction* _measureFunction; // The chosen measure
+   // Main constructor that uses AxesMode and MeasureDefinition to specify measure
+   // Unlike Nsubjettiness or NjettinessPlugin, the value N is not chosen
+   Njettiness(const AxesDefinition & axes_def, const MeasureDefinition & measure_def);
+   // Enum information so functions can specify output based on specific options, primarily for setAxes
+   AxesMode _current_axes_mode;
+   MeasureMode _current_measure_mode;
+   // Information about the current information
+   TauComponents _current_tau_components; //automatically set to have components of 0; these values will be set by the getTau function call
+   std::vector<fastjet::PseudoJet> _currentAxes;
+   std::vector<fastjet::PseudoJet> _seedAxes; // axes used prior to minimization (if applicable)
+   // Needed for compilation of non C++11 users
+   bool isnan(double para) { return para != para; }
+   // Intermediate constructor (needed to enable v1.0.3 backwards compatibility?)
+   Njettiness(AxesMode axes_mode, const MeasureDefinition & measure_def);
+   // Helpful function to check to make sure input has correct number of parameters
+   bool correctParameterCount(int n, double para1, double para2, double para3, double para4){
+      int numpara;
+      if (!isnan(para1) && !isnan(para2) && !isnan(para3) && !isnan(para4)) numpara = 4;
+      else if (!isnan(para1) && !isnan(para2) && !isnan(para3) && isnan(para4)) numpara = 3;
+      else if (!isnan(para1) && !isnan(para2) && isnan(para3) && isnan(para4)) numpara = 2;
+      else if (!isnan(para1) && isnan(para2) && isnan(para3) && isnan(para4)) numpara = 1;
+      else numpara = 0;
+      return n == numpara;
+   // Alternative constructor which takes axes/measure information as enums with measure parameters
+   // This version is not recommended
+   Njettiness(AxesMode axes_mode,
+              MeasureMode measure_mode,
+              int num_para,
+              double para1 = std::numeric_limits<double>::quiet_NaN(),
+              double para2 = std::numeric_limits<double>::quiet_NaN(),
+              double para3 = std::numeric_limits<double>::quiet_NaN())
+   : _axes_def(createAxesDef(axes_mode)), _measure_def(createMeasureDef(measure_mode, num_para, para1, para2, para3)) {
+      setMeasureFunctionAndAxesFinder();  // call helper function to do the hard work
+   }
+   // Helper function to set onepass_axes depending on input measure_mode and startingFinder
+   void setOnePassAxesFinder(MeasureMode measure_mode, AxesFinder* startingFinder, double para1, double Rcutoff);
+   // created separate function to set MeasureFunction and AxesFinder in order to keep constructor cleaner.
+   void setMeasureFunctionandAxesFinder(AxesMode axes_mode, MeasureMode measure_mode, double para1, double para2, double para3, double para4);
+public:
+   // Main constructor which takes axes/measure information, and possible parameters.
+   // Unlike Nsubjettiness or NjettinessPlugin, the value N is not chosen
+   Njettiness(AxesMode axes_mode,
+              MeasureMode measure_mode,
+              double para1 = NAN,
+              double para2 = NAN,
+              double para3 = NAN,
+              double para4 = NAN)
+   : _current_axes_mode(axes_mode),
+   _current_measure_mode(measure_mode) {
+      setMeasureFunctionandAxesFinder(axes_mode, measure_mode, para1, para2, para3, para4);  // call helper function to do the hard work
+   }
+   ~Njettiness() {
+      // clean house
+      delete _measureFunction;
+      delete _axesFinder;
+   }
+   // destructor
+   ~Njettiness() {};
    // setAxes for Manual mode
    void setAxes(std::vector<fastjet::PseudoJet> myAxes);
+   void setAxes(const std::vector<fastjet::PseudoJet> & myAxes);
    // Calculates and returns all TauComponents that user would want.
    // This information is stored in _current_tau_components for later access as well.
    TauComponents getTauComponents(unsigned n_jets, const std::vector<fastjet::PseudoJet> & inputJets);
+   TauComponents getTauComponents(unsigned n_jets, const std::vector<fastjet::PseudoJet> & inputJets) const;
    // Calculates the value of N-subjettiness,
    // but only returns the tau value from _current_tau_components
    double getTau(unsigned n_jets, const std::vector<fastjet::PseudoJet> & inputJets) {
+   double getTau(unsigned n_jets, const std::vector<fastjet::PseudoJet> & inputJets) const {
       return getTauComponents(n_jets, inputJets).tau();
+   }
-   // returns enum information
-   MeasureMode currentMeasureMode() { return _current_measure_mode;}
-   AxesMode currentAxesMode() { return _current_axes_mode;}
    // Return all relevant information about tau components
+   TauComponents currentTauComponents() {return _current_tau_components;}
+   TauComponents currentTauComponents() const {return _current_tau_components;}
    // Return axes found by getTauComponents.
    std::vector<fastjet::PseudoJet> currentAxes() { return _currentAxes;}
+   std::vector<fastjet::PseudoJet> currentAxes() const { return _currentAxes;}
    // Return seedAxes used if onepass minimization (otherwise, same as currentAxes)
+   std::vector<fastjet::PseudoJet> seedAxes() { return _seedAxes;}
+   std::vector<fastjet::PseudoJet> seedAxes() const { return _seedAxes;}
+   // Return jet partition found by getTauComponents.
+   std::vector<fastjet::PseudoJet> currentJets() const {return _currentJets;}
+   // Return beam partition found by getTauComponents.
+   fastjet::PseudoJet currentBeam() const {return _currentBeam;}
    // partition inputs by Voronoi (each vector stores indices corresponding to inputJets)
    std::vector<std::list<int> > getPartition(const std::vector<fastjet::PseudoJet> & inputJets);
+   std::vector<std::list<int> > getPartitionList(const std::vector<fastjet::PseudoJet> & inputJets) const;
+   // partition inputs by Voronoi
+   std::vector<fastjet::PseudoJet> getJets(const std::vector<fastjet::PseudoJet> & inputJets);
+private:
+   // Information about Axes and Measures to be Used
+   // Implemented as SharedPtrs to avoid memory management headaches
+   SharedPtr<const AxesDefinition> _axes_def;
+   SharedPtr<const MeasureDefinition> _measure_def;
+   // The chosen axes/measure mode workers
+   // Implemented as SharedPtrs to avoid memory management headaches
+   // TODO: make into a SharedPtr<const AxesFinder>?
+   SharedPtr<MeasureFunction> _measureFunction;  // The chosen measure
+   SharedPtr<AxesFinder> _startingAxesFinder;    // The initial axes finder
+   SharedPtr<AxesFinder> _finishingAxesFinder;   // A possible minimization step
+   // Information about the current information
+   // Defined as mutables, so user should be aware that these change when getTau is called.
+   mutable TauComponents _current_tau_components; //automatically set to have components of 0; these values will be set by the getTau function call
+   mutable std::vector<fastjet::PseudoJet> _currentAxes; //axes found after minimization
+   mutable std::vector<fastjet::PseudoJet> _seedAxes; // axes used prior to minimization (if applicable)
+   mutable std::vector<fastjet::PseudoJet> _currentJets; //partitioning information
+   mutable fastjet::PseudoJet _currentBeam; //return beam, if requested
+   // created separate function to set MeasureFunction and AxesFinder in order to keep constructor cleaner.
+   void setMeasureFunctionAndAxesFinder();
+   // Convert old style enums into new style MeasureDefinition
+   AxesDefinition* createAxesDef(AxesMode axes_mode) const;
+   // Convert old style enums into new style MeasureDefinition
+   MeasureDefinition* createMeasureDef(MeasureMode measure_mode, int num_para, double para1, double para2, double para3) const;
 };
 } // namespace contrib

external/fastjet/contribs/Nsubjettiness/NjettinessPlugin.cc

-              rf6b6ee7
+              r49234af
 //  Jesse Thaler, Ken Van Tilburg, Christopher K. Vermilion, and TJ Wilkason
 //
+//  $Id: NjettinessPlugin.cc 663 2014-06-03 21:26:41Z jthaler $
 //----------------------------------------------------------------------
 // This file is part of FastJet contrib.
 …
-// Constructor with same arguments as Nsubjettiness.
-NjettinessPlugin::NjettinessPlugin(int N, Njettiness::AxesMode axes_mode, Njettiness::MeasureMode measure_mode, double para1, double para2, double para3, double para4)
-  : _N(N), _njettinessFinder(axes_mode, measure_mode, para1, para2, para3, para4) {}
-// Old constructor for compatibility
-NjettinessPlugin::NjettinessPlugin(int N, Njettiness::AxesMode mode, double beta, double R0, double Rcutoff)
-   : _N(N), _njettinessFinder(mode, Njettiness::normalized_cutoff_measure, beta, R0, Rcutoff) {}
 std::string NjettinessPlugin::description() const {return "N-jettiness jet finder";}
 // Clusters the particles according to the Njettiness jet algorithm
+// TODO: this code should be revisited to see if if can be made more clear.
+// Apologies for the complication with this code, but we need to make
+// a fake jet clustering tree.  The partitioning is done by getPartitionList
 void NjettinessPlugin::run_clustering(ClusterSequence& cs) const
+{
    std::vector<fastjet::PseudoJet> particles = cs.jets();
+   // HACK: remove area information from particles (in case this is called by
+   // a ClusterSequenceArea.  Will be fixed in a future FastJet release)
+   for (unsigned i = 0; i < particles.size(); i++) {
+      particles[i].set_structure_shared_ptr(SharedPtr<PseudoJetStructureBase>());
+   }
    _njettinessFinder.getTau(_N, particles);
+   std::vector<std::list<int> > partition = _njettinessFinder.getPartition(particles);
+   std::vector<std::list<int> > partition = _njettinessFinder.getPartitionList(particles);
    std::vector<fastjet::PseudoJet> jet_indices_for_extras;
    // output clusterings for each jet
+   for (size_t i = 0; i < partition.size(); ++i) {
+   for (size_t i0 = 0; i0 < partition.size(); ++i0) {
+      size_t i = partition.size() - 1 - i0; // reversed order of reading to match axes order
       std::list<int>& indices = partition[i];
       if (indices.size() == 0) continue;
 …
+   }
+   //HACK:  Re-reverse order of reading to match CS order
+   reverse(jet_indices_for_extras.begin(),jet_indices_for_extras.end());
    NjettinessExtras * extras = new NjettinessExtras(_njettinessFinder.currentTauComponents(),jet_indices_for_extras,_njettinessFinder.currentAxes());
    cs.plugin_associate_extras(std::auto_ptr<ClusterSequence::Extras>(extras));

external/fastjet/contribs/Nsubjettiness/NjettinessPlugin.hh

-              rf6b6ee7
+              r49234af
-// $Id$
-//
 //  Nsubjettiness Package
 //  Questions/Comments?  jthaler@jthaler.net
 …
 //  Jesse Thaler, Ken Van Tilburg, Christopher K. Vermilion, and TJ Wilkason
 //
+//  $Id: NjettinessPlugin.hh 671 2014-06-10 17:47:52Z jthaler $
 //----------------------------------------------------------------------
 // This file is part of FastJet contrib.
 …
 // to similar information
 class NjettinessExtras : public ClusterSequence::Extras {
+   private:
+      TauComponents _tau_components;
+      std::vector<fastjet::PseudoJet> _jets;
+      std::vector<fastjet::PseudoJet> _axes;
+      int labelOf(const fastjet::PseudoJet& jet) const {
+         int thisJet = -1;
+         for (unsigned int i = 0; i < _jets.size(); i++) {
+            if (_jets[i].cluster_hist_index() == jet.cluster_hist_index()) {
+               thisJet = i;
+               break;
+            }
+         }
+         return thisJet;
+      }
    public:
       NjettinessExtras(TauComponents tau_components, std::vector<fastjet::PseudoJet> jets, std::vector<fastjet::PseudoJet> axes) : _tau_components(tau_components), _jets(jets), _axes(axes) {}
 …
       std::vector<fastjet::PseudoJet> axes() const {return _axes;}
       double totalTau(const fastjet::PseudoJet& jet) const {
+      double totalTau(const fastjet::PseudoJet& /*jet*/) const {
          return _tau_components.tau();
+      }
       double subTau(const fastjet::PseudoJet& jet) const {
          if (labelOf(jet) == -1) return NAN;
+         if (labelOf(jet) == -1) return std::numeric_limits<double>::quiet_NaN(); // nonsense
          return _tau_components.jet_pieces()[labelOf(jet)];
+      }
 …
          return (labelOf(jet) >= 0);
+      }
+private:
+   TauComponents _tau_components;
+   std::vector<fastjet::PseudoJet> _jets;
+   std::vector<fastjet::PseudoJet> _axes;
+   int labelOf(const fastjet::PseudoJet& jet) const {
+      int thisJet = -1;
+      for (unsigned int i = 0; i < _jets.size(); i++) {
+         if (_jets[i].cluster_hist_index() == jet.cluster_hist_index()) {
+            thisJet = i;
+            break;
+         }
+      }
+      return thisJet;
+   }
 };
 …
  * onepass_wta_kt_axes  : one-pass minimization seeded by wta_kt
+ *
  * For the unnormalized_measure, N-jettiness is defined as:
+ * For the UnnormalizedMeasure(beta), N-jettiness is defined as:
+ *
  * tau_N = Sum_{all particles i} p_T^i min((DR_i1)^beta, (DR_i2)^beta, ...)
 …
  *   and jet j.
+ *
  * The normalized_meausure include an extra parameter R0, and the various cutoff
+ * The NormalizedMeausure include an extra parameter R0, and the various cutoff
  * measures include an Rcutoff, which effectively defines an angular cutoff
  * similar in effect to a cone-jet radius.
 …
 public:
+   NjettinessPlugin(int N,
+                    Njettiness::AxesMode axes_mode,
+                    Njettiness::MeasureMode measure_mode,
+                    double para1 = NAN,
+                    double para2 = NAN,
+                    double para3 = NAN,
+                    double para4 = NAN);
+   // Constructor with same arguments as Nsubjettiness.
+   NjettinessPlugin(int N,
+                    const AxesDefinition & axes_def,
+                    const MeasureDefinition & measure_def)
+   : _njettinessFinder(axes_def, measure_def), _N(N) {}
+   // Alternative constructors that define the measure via enums and parameters
+   // These constructors are likely be removed
+   NjettinessPlugin(int N,
+                 Njettiness::AxesMode axes_mode,
+                 Njettiness::MeasureMode measure_mode)
+   : _njettinessFinder(axes_mode, measure_mode, 0), _N(N) {}
+   NjettinessPlugin(int N,
+                 Njettiness::AxesMode axes_mode,
+                 Njettiness::MeasureMode measure_mode,
+                 double para1)
+   : _njettinessFinder(axes_mode, measure_mode, 1, para1), _N(N) {}
+   NjettinessPlugin(int N,
+                 Njettiness::AxesMode axes_mode,
+                 Njettiness::MeasureMode measure_mode,
+                 double para1,
+                 double para2)
+   : _njettinessFinder(axes_mode, measure_mode, 2, para1, para2), _N(N) {}
+   NjettinessPlugin(int N,
+                 Njettiness::AxesMode axes_mode,
+                 Njettiness::MeasureMode measure_mode,
+                 double para1,
+                 double para2,
+                 double para3)
+   : _njettinessFinder(axes_mode, measure_mode, 3, para1, para2, para3), _N(N) {}
    // Old constructor for backwards compatibility with v1.0,
    // where normalized_cutoff_measure was the only option
+   // where NormalizedCutoffMeasure was the only option
    NjettinessPlugin(int N,
                     Njettiness::AxesMode mode,
                     double beta,
                     double R0,
+                    double Rcutoff=std::numeric_limits<double>::max());
+                    double Rcutoff=std::numeric_limits<double>::max())
+   : _njettinessFinder(mode, NormalizedCutoffMeasure(beta, R0, Rcutoff)), _N(N) {}
 …
 private:
+   Njettiness _njettinessFinder;
    int _N;
-   mutable Njettiness _njettinessFinder; // TODO:  should muck with this so run_clustering can be const without this mutable
 };

external/fastjet/contribs/Nsubjettiness/Nsubjettiness.cc

rf6b6ee7	r49234af
5	5	// Jesse Thaler, Ken Van Tilburg, Christopher K. Vermilion, and TJ Wilkason
6	6	//
	7	// $Id: Nsubjettiness.cc 597 2014-04-16 23:07:55Z jthaler $
7	8	//----------------------------------------------------------------------
8	9	// This file is part of FastJet contrib.

external/fastjet/contribs/Nsubjettiness/Nsubjettiness.hh

-              rf6b6ee7
+              r49234af
 //  Jesse Thaler, Ken Van Tilburg, Christopher K. Vermilion, and TJ Wilkason
 //
+//  $Id: Nsubjettiness.hh 670 2014-06-06 01:24:42Z jthaler $
 //----------------------------------------------------------------------
 // This file is part of FastJet contrib.
 …
 #include <string>
 #include <climits>
 FASTJET_BEGIN_NAMESPACE      // defined in fastjet/internal/base.hh
 …
 public:
+   // Main constructor, which takes N, axes/measure modes,
+   // and up to four parameters for parameters (i.e. beta, Rcutoff, etc depending on measure)
+   // Main constructor, which takes N, the AxesDefiniation, and the MeasureDefinition.
+   // The Definitions are given in NjettinessDefinition.hh
+   //
+   // The recommended AxesDefinitions are (more are available as listed in the README
+   // and defined in NjettinessDefinition.hh):
+   //   KT_Axes             : exclusive kt axes
+   //   WTA_KT_Axes         : exclusive kt with winner-take-all recombination
+   //   OnePass_KT_Axes     : one-pass minimization from kt starting point
+   //   OnePass_WTA_KT_Axes : one-pass min. from wta_kt starting point
+   //
+   // The recommended measure definitions are (with the corresponding parameters)
+   //   NormalizedMeasure(beta,R0)
+   //      :  This was the original N-subjettiness measure (dimensionless)
+   //   UnnormalizedMeasure(beta)
+   //      :  This is the new recommended default, same as above but without
+   //      :  the normalization factor, and hence has units of GeV
+   //   NormalizedCutoffMeasure(beta,R0,Rcutoff)
+   //      :  Same as normalized_measure, but cuts off at Rcutoff
+   //   UnnormalizedCutoffMeasure(beta,Rcutoff)
+   //      :  Same as unnormalized_measure, but cuts off at Rcutoff
+   Nsubjettiness(int N,
+                 const AxesDefinition& axes_def,
+                 const MeasureDefinition& measure_def)
+   : _njettinessFinder(axes_def,measure_def), _N(N) {}
+   // Alternative constructors that define the measure via enums and parameters
+   // These constructors are likely be removed
+   // Zero parameter arguments
+   // (Currently, no measure uses this)
+   Nsubjettiness(int N,
+                 Njettiness::AxesMode axes_mode,
+                 Njettiness::MeasureMode measure_mode)
+   : _njettinessFinder(axes_mode, measure_mode, 0), _N(N) {}
+   // One parameter argument
+   // (for unnormalized_measure, para1=beta)
    Nsubjettiness(int N,
                  Njettiness::AxesMode axes_mode,
                  Njettiness::MeasureMode measure_mode,
+                 double para1 = NAN,
+                 double para2 = NAN,
+                 double para3 = NAN,
+                 double para4 = NAN)
+   : _njettinessFinder(axes_mode, measure_mode, para1, para2, para3, para4), _N(N) {}
+                 double para1)
+   : _njettinessFinder(axes_mode, measure_mode, 1, para1), _N(N) {}
+   // Two parameter arguments
+   // (for normalized_measure, para1=beta, para2=R0)
+   // (for unnormalized_cutoff_measure, para1=beta, para2=Rcutoff)
+   Nsubjettiness(int N,
+                 Njettiness::AxesMode axes_mode,
+                 Njettiness::MeasureMode measure_mode,
+                 double para1,
+                 double para2)
+   : _njettinessFinder(axes_mode, measure_mode, 2, para1, para2), _N(N) {}
+   // Three parameter arguments
+   // (for unnormalized_cutoff_measure, para1=beta, para2=R0, para3=Rcutoff)
+   Nsubjettiness(int N,
+                 Njettiness::AxesMode axes_mode,
+                 Njettiness::MeasureMode measure_mode,
+                 double para1,
+                 double para2,
+                 double para3)
+   : _njettinessFinder(axes_mode, measure_mode, 3, para1, para2, para3), _N(N) {}
    // Old constructor for backwards compatibility with v1.0,
 …
                  double R0,
                  double Rcutoff=std::numeric_limits<double>::max())
+   : _njettinessFinder(axes_mode, Njettiness::normalized_cutoff_measure, beta, R0, Rcutoff), _N(N) {}
+   : _njettinessFinder(axes_mode, NormalizedCutoffMeasure(beta,R0,Rcutoff)), _N(N) {}
    /// returns tau_N, measured on the constituents of this jet
    double result(const PseudoJet& jet) const;
 …
+   }
+   /// returns subjet regions found by result() calculation (these have valid constituents)
+   /// Note that the axes and the subjets are not the same
+   std::vector<fastjet::PseudoJet> currentSubjets() const {
+      return _njettinessFinder.currentJets();
+   }
+   /// returns components of tau_N without recalculating anything
+   TauComponents currentTauComponents() const {
+      return _njettinessFinder.currentTauComponents();
+   }
    // To set axes for manual use
    void setAxes(std::vector<fastjet::PseudoJet> myAxes) {
+   void setAxes(const std::vector<fastjet::PseudoJet> & myAxes) {
       // Cross check that manual axes are being used is in Njettiness
         _njettinessFinder.setAxes(myAxes);
 …
 private:
    mutable Njettiness _njettinessFinder; // TODO:  should muck with this so result can be const without this mutable
+   Njettiness _njettinessFinder; // TODO:  should muck with this so result can be const without this mutable
    int _N;
 …
    NsubjettinessRatio(int N,
                       int M,
+                      const AxesDefinition & axes_def,
+                      const MeasureDefinition & measure_def)
+   : _nsub_numerator(N,axes_def,measure_def),
+   _nsub_denominator(M,axes_def,measure_def) {}
+   // Alternative constructor with enums and parameters
+   // Again, likely to be removed
+   NsubjettinessRatio(int N,
+                      int M,
+                      Njettiness::AxesMode axes_mode,
+                      Njettiness::MeasureMode measure_mode)
+   : _nsub_numerator(N, axes_mode, measure_mode),
+   _nsub_denominator(M, axes_mode, measure_mode) {}
+   NsubjettinessRatio(int N,
+                      int M,
                       Njettiness::AxesMode axes_mode,
                       Njettiness::MeasureMode measure_mode,
+                      double para1 = NAN,
+                      double para2 = NAN,
+                      double para3 = NAN,
+                      double para4 = NAN)
+   : _nsub_numerator(N, axes_mode, measure_mode, para1, para2, para3, para4),
+   _nsub_denominator(M, axes_mode, measure_mode, para1, para2, para3, para4) {}
+   //returns tau_N/tau_M based off the input jet using result function from Nsubjettiness
+                      double para1)
+   : _nsub_numerator(N, axes_mode, measure_mode, para1),
+   _nsub_denominator(M, axes_mode, measure_mode, para1) {}
+   NsubjettinessRatio(int N,
+                      int M,
+                      Njettiness::AxesMode axes_mode,
+                      Njettiness::MeasureMode measure_mode,
+                      double para1,
+                      double para2)
+   : _nsub_numerator(N, axes_mode, measure_mode, para1, para2),
+   _nsub_denominator(M, axes_mode, measure_mode, para1, para2) {}
+   NsubjettinessRatio(int N,
+                      int M,
+                      Njettiness::AxesMode axes_mode,
+                      Njettiness::MeasureMode measure_mode,
+                      double para1,
+                      double para2,
+                      double para3)
+   : _nsub_numerator(N, axes_mode, measure_mode, para1, para2, para3),
+   _nsub_denominator(M, axes_mode, measure_mode, para1, para2, para3) {}
+   //returns tau_N/tau_M based off the input jet using result function from Nsubjettiness
    double result(const PseudoJet& jet) const;

external/fastjet/contribs/Nsubjettiness/VERSION

rf6b6ee7	r49234af
1		1.1.0-beta4
	1	2.1.0

external/fastjet/contribs/Nsubjettiness/WinnerTakeAllRecombiner.cc

-              rf6b6ee7
+              r49234af
 //  Jesse Thaler, Ken Van Tilburg, Christopher K. Vermilion, and TJ Wilkason
 //
+//  $Id: WinnerTakeAllRecombiner.cc 597 2014-04-16 23:07:55Z jthaler $
 //----------------------------------------------------------------------
 // This file is part of FastJet contrib.
 …
 // recombine pa and pb by creating pab with energy of the sum of particle energies in the direction of the harder particle
 // updated recombiner to use more general form of a metric equal to E*(pT/E)^(alpha), which reduces to pT*cosh(rap)^(1-alpha)
 // alpha is specified by the user. The default is alpha = 1, which is the typical behavior. alpha = 2 provides a metric which more

external/fastjet/contribs/Nsubjettiness/WinnerTakeAllRecombiner.hh

-              rf6b6ee7
+              r49234af
 //  Jesse Thaler, Ken Van Tilburg, Christopher K. Vermilion, and TJ Wilkason
 //
+//  $Id: WinnerTakeAllRecombiner.hh 670 2014-06-06 01:24:42Z jthaler $
 //----------------------------------------------------------------------
 // This file is part of FastJet contrib.
 …
    /// recombine pa and pb and put result into pab
+   virtual void recombine(const fastjet::PseudoJet & pa, const fastjet::PseudoJet & pb, fastjet::PseudoJet & pab) const;
+   virtual void recombine(const fastjet::PseudoJet & pa,
+                          const fastjet::PseudoJet & pb,
+                          fastjet::PseudoJet & pab) const;
 private:

external/fastjet/internal/ClosestPair2D.hh

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id: ClosestPair2D.hh 2577 2011-09-13 15:11:38Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+//FJSTARTHEADER
+// $Id: ClosestPair2D.hh 3433 2014-07-23 08:17:03Z salam $
+//
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #ifndef __FASTJET_CLOSESTPAIR2D__HH__

external/fastjet/internal/ClosestPair2DBase.hh

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id: ClosestPair2DBase.hh 2577 2011-09-13 15:11:38Z salam $
+//FJSTARTHEADER
+// $Id: ClosestPair2DBase.hh 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #ifndef __FASTJET_CLOSESTPAIR2DBASE__HH__

external/fastjet/internal/ClusterSequence_N2.icc

-              rf6b6ee7
+              r49234af
 #include "fastjet/ClusterSequence.hh"
 //STARTHEADER
+//FJSTARTHEADER
 // $Id: ClusterSequence_N2.cc 1351 2009-01-09 18:03:03Z salam $
 //
 // Copyright (c) 2005-2009, Matteo Cacciari, Gavin Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //
 //  You should have received a copy of the GNU General Public License
+//  along with FastJet; if not, write to the Free Software
+//  Foundation, Inc.:
+//      59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 //----------------------------------------------------------------------

external/fastjet/internal/Dnn2piCylinder.hh

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id: Dnn2piCylinder.hh 2577 2011-09-13 15:11:38Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+//FJSTARTHEADER
+// $Id: Dnn2piCylinder.hh 3442 2014-07-24 07:20:49Z salam $
+//
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 …
   /// Returns the index of  the nearest neighbour of point labelled
   /// by ii (assumes ii is valid)
   int NearestNeighbourIndex(const int & ii) const ;
+  int NearestNeighbourIndex(const int ii) const ;
   /// Returns the distance to the nearest neighbour of point labelled
   /// by index ii (assumes ii is valid)
   double NearestNeighbourDistance(const int & ii) const ;
+  double NearestNeighbourDistance(const int ii) const ;
   /// Returns true iff the given index corresponds to a point that
   /// exists in the DNN structure (meaning that it has been added, and
   /// not removed in the meantime)
   bool Valid(const int & index) const;
+  bool Valid(const int index) const;
   void RemoveAndAddPoints(const std::vector<int> & indices_to_remove,
 …
 /// initialised the class with instructions to ignore this problem the
 /// program will detect and ignore it, or crash.
 inline int Dnn2piCylinder::NearestNeighbourIndex(const int & current) const {
+inline int Dnn2piCylinder::NearestNeighbourIndex(const int current) const {
   int main_index = _mirror_info[current].main_index;
   int mirror_index = _mirror_info[current].mirror_index;
 …
+}
 inline double Dnn2piCylinder::NearestNeighbourDistance(const int & current) const {
+inline double Dnn2piCylinder::NearestNeighbourDistance(const int current) const {
   int main_index = _mirror_info[current].main_index;
   int mirror_index = _mirror_info[current].mirror_index;
 …
+}
 inline bool Dnn2piCylinder::Valid(const int & index) const {
+inline bool Dnn2piCylinder::Valid(const int index) const {
   return (_DNN->Valid(_mirror_info[index].main_index));
+}

external/fastjet/internal/Dnn3piCylinder.hh

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id: Dnn3piCylinder.hh 2577 2011-09-13 15:11:38Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+//FJSTARTHEADER
+// $Id: Dnn3piCylinder.hh 3442 2014-07-24 07:20:49Z salam $
+//
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 …
   /// Returns the index of  the nearest neighbour of point labelled
   /// by ii (assumes ii is valid)
   int NearestNeighbourIndex(const int & ii) const ;
+  int NearestNeighbourIndex(const int ii) const ;
   /// Returns the distance to the nearest neighbour of point labelled
   /// by index ii (assumes ii is valid)
   double NearestNeighbourDistance(const int & ii) const ;
+  double NearestNeighbourDistance(const int ii) const ;
   /// Returns true iff the given index corresponds to a point that
   /// exists in the DNN structure (meaning that it has been added, and
   /// not removed in the meantime)
   bool Valid(const int & index) const;
+  bool Valid(const int index) const;
   void RemoveAndAddPoints(const std::vector<int> & indices_to_remove,
 …
 /// initialised the class with instructions to ignore this problem the
 /// program will detect and ignore it, or crash.
 inline int Dnn3piCylinder::NearestNeighbourIndex(const int & current) const {
+inline int Dnn3piCylinder::NearestNeighbourIndex(const int current) const {
   int main_index = _mirror_info[current].main_index;
   int mirror_index = _mirror_info[current].mirror_index;
 …
+}
 inline double Dnn3piCylinder::NearestNeighbourDistance(const int & current) const {
+inline double Dnn3piCylinder::NearestNeighbourDistance(const int current) const {
   int main_index = _mirror_info[current].main_index;
   int mirror_index = _mirror_info[current].mirror_index;
 …
+}
 inline bool Dnn3piCylinder::Valid(const int & index) const {
+inline bool Dnn3piCylinder::Valid(const int index) const {
   return (_DNN->Valid(_mirror_info[index].main_index));
+}

external/fastjet/internal/Dnn4piCylinder.hh

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id: Dnn4piCylinder.hh 2577 2011-09-13 15:11:38Z salam $
+//FJSTARTHEADER
+// $Id: Dnn4piCylinder.hh 3442 2014-07-24 07:20:49Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 …
   /// Returns the index of  the nearest neighbour of point labelled
   /// by ii (assumes ii is valid)
   int NearestNeighbourIndex(const int & ii) const ;
+  int NearestNeighbourIndex(const int ii) const ;
   /// Returns the distance to the nearest neighbour of point labelled
   /// by index ii (assumes ii is valid)
   double NearestNeighbourDistance(const int & ii) const ;
+  double NearestNeighbourDistance(const int ii) const ;
   /// Returns true iff the given index corresponds to a point that
   /// exists in the DNN structure (meaning that it has been added, and
   /// not removed in the meantime)
   bool Valid(const int & index) const;
+  bool Valid(const int index) const;
   void RemoveAndAddPoints(const std::vector<int> & indices_to_remove,
 …
 // functions defined above
 inline int Dnn4piCylinder::NearestNeighbourIndex(const int & current) const {
+inline int Dnn4piCylinder::NearestNeighbourIndex(const int current) const {
   return (_DNN1->NearestNeighbourDistance(current) <
           _DNN2->NearestNeighbourDistance(current)) ?
 …
+}
 inline double Dnn4piCylinder::NearestNeighbourDistance(const int & current) const {
+inline double Dnn4piCylinder::NearestNeighbourDistance(const int current) const {
   return (_DNN1->NearestNeighbourDistance(current) <
           _DNN2->NearestNeighbourDistance(current)) ?
 …
+}
 inline bool Dnn4piCylinder::Valid(const int & index) const {
+inline bool Dnn4piCylinder::Valid(const int index) const {
   return (_DNN1->Valid(index) && _DNN2->Valid(index));
+}

external/fastjet/internal/DnnPlane.hh

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id: DnnPlane.hh 2577 2011-09-13 15:11:38Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+//FJSTARTHEADER
+// $Id: DnnPlane.hh 3442 2014-07-24 07:20:49Z salam $
+//
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 …
 /// class derived from DynamicNearestNeighbours that provides an
 /// implementation for the Euclidean plane
+///
+/// This class that uses CGAL Delaunay triangulation for most of the
+/// work (it allows for easy and efficient removal and addition of
+/// points and circulation over a point's neighbours). The treatment
+/// of coincident points is not supported by CGAL and is implemented
+/// according to the method specified in
+/// issue-tracker/2012-02-CGAL-coincident/METHOD
 /// \endif
 class DnnPlane : public DynamicNearestNeighbours {
 …
   /// Returns the index of  the nearest neighbour of point labelled
   /// by ii (assumes ii is valid)
   int NearestNeighbourIndex(const int & ii) const ;
+  int NearestNeighbourIndex(const int ii) const ;
   /// Returns the distance to the nearest neighbour of point labelled
   /// by index ii (assumes ii is valid)
   double NearestNeighbourDistance(const int & ii) const ;
+  double NearestNeighbourDistance(const int ii) const ;
   /// Returns true iff the given index corresponds to a point that
   /// exists in the DNN structure (meaning that it has been added, and
   /// not removed in the meantime)
   bool Valid(const int & index) const;
+  bool Valid(const int index) const;
   void RemoveAndAddPoints(const std::vector<int> & indices_to_remove,
 …
   double phi(const int i) const;
  private:
+private:
   /// Structure containing a vertex_handle and cached information on
 …
     double NNdistance;
     int NNindex;
+    int coincidence;  // ==vertex->info.val() if no coincidence
+                      // points to the coinciding SV in case of coincidence
     // later on for cylinder put a second vertex?
   };
 …
   bool _verbose;
   static const bool _crash_on_coincidence = true;
   //static const bool _crash_on_coincidence = false;
+  //static const bool _crash_on_coincidence = true;
+  static const bool _crash_on_coincidence = false;
   Triangulation _TR; /// CGAL object for dealing with triangulations
 …
   /// Determines the index and distance of the nearest neighbour to
   /// point j and puts the information into the _supervertex entry for j
   void _SetNearest(const int & j);
+  void _SetNearest(const int j);
   //----------------------------------------------------------------------
 …
   /// Note that j is NOT pushed onto indices_of_updated_neighbours --
   /// if you want it there, put it there yourself.
   void _SetAndUpdateNearest(const int & j,
+  void _SetAndUpdateNearest(const int j,
                             std::vector<int> & indices_of_updated_neighbours);
   /// given a vertex_handle returned by CGAL on insertion of a new
+  /// points, crash if it turns out that it corresponds to a vertex
+  /// that we already knew about (usually because two points coincide)
+  void _CrashIfVertexPresent(const Vertex_handle & vertex,
+                             const int & its_index);
+  /// points, returns the coinciding vertex's value if it turns out
+  /// that it corresponds to a vertex that we already knew about
+  /// (usually because two points coincide)
+  int _CheckIfVertexPresent(const Vertex_handle & vertex,
+                            const int its_index);
+  //----------------------------------------------------------------------
+  /// if the distance between 'pref' and 'candidate' is smaller (or
+  /// equal) than the one between 'pref' and 'near', return true and
+  /// set 'mindist' to that distance. Note that it is assumed that
+  /// 'mindist' is the euclidian distance between 'pref' and 'near'
+  ///
+  /// Note that the 'near' point is passed through its vertex rather
+  /// than as a point. This allows us to handle cases where we have no min
+  /// yet (near is the infinite vertex)
+  inline bool _is_closer_to(const Point &pref,
+                            const Point &candidate,
+                            const Vertex_handle &near,
+                            double & dist,
+                            double & mindist){
+    dist = _euclid_distance(pref, candidate);
+    return _is_closer_to_with_hint(pref, candidate, near, dist, mindist);
+  }
+  /// same as '_is_closer_to' except that 'dist' already contains the
+  /// distance between 'pref' and 'candidate'
+  inline bool _is_closer_to_with_hint(const Point &pref,
+                                      const Point &candidate,
+                                      const Vertex_handle &near,
+                                      const double & dist,
+                                      double & mindist){
+    // check if 'dist', the pre-computed distance between 'candidate'
+    // and 'pref' is smaller than the distance between 'pref' and its
+    // currently registered nearest neighbour 'near' (and update
+    // things if it is)
+    //
+    // Interestingly enough, it has to be pointed out that the use of
+    // 'abs' instead of 'std::abs' returns wrong results (apparently
+    // ints without any compiler warning)
+    //
+    // The (near != NULL) test is there for one single reason: when
+    // checking that a newly inserted point is not closer than a
+    // previous NN, if that distance comparison involves a "nearly
+    // degenerate" distance we need to access near->point. But
+    // sometimes, in the course of RemoveAndAddPoints, its previous NN
+    // has been deleted and its vertex (corresponding to 'near') set
+    // to NULL. This is not a problem as all points having a deleted
+    // point as NN will have their NN explicitly recomputed at the end
+    // of RemoveAndAddPoints so here we should just make sure there is
+    // no crash... that's done by checking (near != NULL)
+    if ((std::abs(dist-mindist)<DISTANCE_FOR_CGAL_CHECKS) &&
+        (near != NULL) &&
+        (_euclid_distance(candidate, near->point())<DISTANCE_FOR_CGAL_CHECKS)){
+      // we're in a situation where there might be a rounding issue,
+      // use CGAL's distance computation to get it right
+      //
+      // Note that in the test right above,
+      // (abs(dist-mindist)<1e-12) guarantees that the current
+      // nearest point is not the infinite vertex and thus
+      // nearest->point() is not ill-defined
+      if (_verbose) std::cout << "using CGAL's distance ordering" << std::endl;
+      if (CGAL::compare_distance_to_point(pref, candidate, near->point())!=CGAL::LARGER){
+        mindist = dist;
+        return true;
+      }
+    } else if (dist <= mindist) {
+      // Note that the use of a <= in the above expression (instead of
+      // a strict ordering <) is important in one case: when checking
+      // if a new point is the new NN of one of the points in its
+      // neighbourhood, in case of distances being ==, we are sure
+      // that 'candidate' is in a cell adjacent to 'pref' while it may
+      // no longer be the case for 'near'
+      mindist = dist;
+      return true;
+    }
+    return false;
+  }
+  /// if a distance between a point and 2 others is smaller than this
+  /// and the distance between the two points is also smaller than this
+  /// then use CGAL to compare the distances.
+  static const double DISTANCE_FOR_CGAL_CHECKS;
 };
 …
 // functions defined above
 inline int DnnPlane::NearestNeighbourIndex(const int & ii) const {
+inline int DnnPlane::NearestNeighbourIndex(const int ii) const {
   return _supervertex[ii].NNindex;}
 inline double DnnPlane::NearestNeighbourDistance(const int & ii) const {
+inline double DnnPlane::NearestNeighbourDistance(const int ii) const {
   return _supervertex[ii].NNdistance;}
 inline bool DnnPlane::Valid(const int & index) const {
+inline bool DnnPlane::Valid(const int index) const {
   if (index >= 0 && index < static_cast<int>(_supervertex.size())) {
     return (_supervertex[index].vertex != NULL);} else {return false;} }

external/fastjet/internal/DynamicNearestNeighbours.hh

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id: DynamicNearestNeighbours.hh 2687 2011-11-14 11:17:51Z soyez $
+//FJSTARTHEADER
+// $Id: DynamicNearestNeighbours.hh 3619 2014-08-13 14:17:19Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 …
 #include<cassert>
 #include "fastjet/internal/numconsts.hh"
+#include "fastjet/Error.hh"
 FASTJET_BEGIN_NAMESPACE      // defined in fastjet/internal/base.hh
 …
 /// Nearest Neighbours code
 /// \endif
 class DnnError {
+class DnnError : public Error {
 public:
   // constructors
+  DnnError() {;};
+  DnnError(const std::string & message_in) {
+    _message = message_in; std::cerr << message_in << std::endl;};
+  std::string message() const {return _message;};
+private:
+  std::string _message;
+  //DnnError() {}
+  DnnError(const std::string & message_in) : Error(message_in) {}
 };
 …
   /// Returns the index of the nearest neighbour of point labelled
   /// by ii (assumes ii is valid)
   virtual int NearestNeighbourIndex(const int & ii) const = 0;
+  virtual int NearestNeighbourIndex(const int ii) const = 0;
   /// Returns the distance to the nearest neighbour of point labelled
   /// by index ii (assumes ii is valid)
   virtual double NearestNeighbourDistance(const int & ii) const = 0;
+  virtual double NearestNeighbourDistance(const int ii) const = 0;
   /// Returns true iff the given index corresponds to a point that
   /// exists in the DNN structure (meaning that it has been added, and
   /// not removed in the meantime)
   virtual bool Valid(const int & index) const = 0;
+  virtual bool Valid(const int index) const = 0;
   /// remove the points labelled by the std::vector indices_to_remove, and
 …
   /// Remove the point labelled by index and return the list of
   /// points whose nearest neighbours have changed in the process
   inline void RemovePoint (const int & index,
+  inline void RemovePoint (const int index,
                            std::vector<int> & indices_of_updated_neighbours) {
     std::vector<int> indices_added;
 …
   /// point).
   inline void RemoveCombinedAddCombination(
                         const int & index1, const int & index2,
+                        const int index1, const int index2,
                         const EtaPhi & newpoint,
                         int & index3,

external/fastjet/internal/IsBase.hh

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id: IsBase.hh 3071 2013-04-01 12:52:46Z cacciari $
+//FJSTARTHEADER
+// $Id: IsBase.hh 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #ifndef __FASTJET_INTERNAL_IS_BASE_HH__

external/fastjet/internal/LimitedWarning.hh

-              rf6b6ee7
+              r49234af
 #define __FASTJET_INTERNALLIMITEDWARNING_HH__
 //STARTHEADER
 // $Id: LimitedWarning.hh 2577 2011-09-13 15:11:38Z salam $
+//FJSTARTHEADER
+// $Id: LimitedWarning.hh 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER

external/fastjet/internal/MinHeap.hh

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id: MinHeap.hh 2577 2011-09-13 15:11:38Z salam $
+//FJSTARTHEADER
+// $Id: MinHeap.hh 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #ifndef __FASTJET_MINHEAP__HH__
 …
   /// expansion to a maximum size max_size;
   MinHeap (const std::vector<double> & values, unsigned int max_size) :
+    _heap(max_size) {_initialise(values);};
+    _heap(max_size) {initialise(values);}
+  /// do the minimal setup for a MinHeap that can reach max_size;
+  /// initialisation must be performed later with the actual values.
+  MinHeap (unsigned int max_size) : _heap(max_size) {}
   /// constructor in which the the maximum size is the size of the values array
   MinHeap (const std::vector<double> & values) :
+    _heap(values.size()) {_initialise(values);};
+    _heap(values.size()) {initialise(values);}
+  /// initialise the heap with the supplied values. Should only be called if
+  /// the constructor did not supply values.
+  void initialise(const std::vector<double> & values);
   /// return the location of the minimal value on the heap
   inline unsigned int minloc() const {
     return (_heap[0].minloc) - &(_heap[0]);};
+    return (_heap[0].minloc) - &(_heap[0]);}
   /// return the minimal value on the heap
   inline double       minval() const {return _heap[0].minloc->value;};
+  inline double       minval() const {return _heap[0].minloc->value;}
   inline double operator[](int i) const {return _heap[i].value;};
+  inline double operator[](int i) const {return _heap[i].value;}
   /// remove the value at the specified location (i.e. replace it with
 …
   std::vector<ValueLoc> _heap;
-  void _initialise(const std::vector<double> & values);

external/fastjet/internal/SearchTree.hh

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id: SearchTree.hh 3107 2013-05-03 15:47:47Z salam $
+//FJSTARTHEADER
+// $Id: SearchTree.hh 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 …
 public:
   // so that it can access out _node object;
+  // so that it can access our _node object;
   // note: "class U" needed for clang (v1.1 branches/release_27) compilation
+  template<class U> friend class SearchTree<U>::const_circulator;
+  // 2014-07-22: as reported by Torbjorn Sjostrand,
+  // the next line was giving a warning with Apple LLVM version 5.1 (clang-503.0.40) (based on LLVM 3.4svn)
+  // (dependent nested name specifier 'SearchTree<U>::' for friend class declaration is not supported)
+  // Just commenting it out, things still seem to work; same with a template of type T
+  //template<class U> friend class SearchTree<U>::const_circulator;
+  friend class SearchTree<T>::const_circulator;
   friend class SearchTree<T>;

external/fastjet/internal/Triangulation.hh

-              rf6b6ee7
+              r49234af
 #define __FASTJET_TRIANGULATION__
 //STARTHEADER
 // $Id: Triangulation.hh 2595 2011-09-23 09:05:04Z salam $
+//FJSTARTHEADER
+// $Id: Triangulation.hh 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER

external/fastjet/internal/Voronoi.hh

-              rf6b6ee7
+              r49234af
 #define __FASTJET__VORONOI_H__
+//STARTHEADER
+// $Id: Voronoi.hh 2686 2011-11-14 09:28:22Z soyez $
+//
+// Copyright (c) 1994 by AT&T Bell Laboratories (see below)
+//
+//FJSTARTHEADER
+// $Id: Voronoi.hh 3433 2014-07-23 08:17:03Z salam $
+//
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
+// This file is included as part of FastJet but was mostly written by
+// S. Fortune in C, put into C++ with memory management by S
+// O'Sullivan, and with further interface and memeory management
+// modifications by Gregory Soyez.
+//
+// Permission to use, copy, modify, and distribute this software for
+// any purpose without fee is hereby granted, provided that this
+// entire notice is included in all copies of any software which is or
+// includes a copy or modification of this software and in all copies
+// of the supporting documentation for such software. THIS SOFTWARE IS
+// BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED WARRANTY.
+// IN PARTICULAR, NEITHER THE AUTHORS NOR AT&T MAKE ANY REPRESENTATION
+// OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY OF THIS
+// SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+//
+// This file is part of FastJet.
+//
+//  FastJet 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.
+//
+//  The algorithms that underlie FastJet have required considerable
+//  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
+//  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,
+//  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 FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER

external/fastjet/internal/base.hh

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id: base.hh 2717 2011-11-17 14:15:46Z salam $
+//FJSTARTHEADER
+// $Id: base.hh 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #ifndef __FASTJET_FASTJET_BASE_HH__

external/fastjet/internal/numconsts.hh

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id: numconsts.hh 2577 2011-09-13 15:11:38Z salam $
+//FJSTARTHEADER
+// $Id: numconsts.hh 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER

external/fastjet/plugins/ATLASCone/ATLASConePlugin.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
+//FJSTARTHEADER
+// $Id: ATLASConePlugin.cc 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2007-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2007-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 // fastjet stuff

external/fastjet/plugins/ATLASCone/fastjet/ATLASConePlugin.hh

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id: ATLASConePlugin.hh 2758 2011-11-24 08:31:58Z soyez $
+//FJSTARTHEADER
+// $Id: ATLASConePlugin.hh 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2007-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2007-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 // Note on the implementation:

external/fastjet/plugins/CDFCones/CDFJetCluPlugin.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
+//FJSTARTHEADER
+// $Id: CDFJetCluPlugin.cc 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include "fastjet/CDFJetCluPlugin.hh"

external/fastjet/plugins/CDFCones/CDFMidPointPlugin.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
+//FJSTARTHEADER
+// $Id: CDFMidPointPlugin.cc 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include "fastjet/CDFMidPointPlugin.hh"

external/fastjet/plugins/CDFCones/JetCluAlgorithm.cc

-              rf6b6ee7
+              r49234af
 // History of changes compared to the original JetCluAlgorithm.cc file
 //
+// 2014-08-13 Matteo Cacciari and Gavin Salam
+//        * commented out towers variable in JetCluAlgorithm::buildPreClusters
+//          interface to avoid compiler warning
+//
 // 2011-11-14  Gregory Soyez  <soyez@fastjet.fr>
 //
 …
+}
+void JetCluAlgorithm::buildPreClusters(std::vector<Cluster>& seedTowers, std::vector<PhysicsTower>& towers,
+// MC+GPS 2014-08-13, commented out the towers variable to avoid an
+// unused variable warning
+void JetCluAlgorithm::buildPreClusters(std::vector<Cluster>& seedTowers, std::vector<PhysicsTower>& /*towers*/,
                                        std::vector<Cluster>& preClusters)
+{

external/fastjet/plugins/CDFCones/MidPointAlgorithm.cc

-              rf6b6ee7
+              r49234af
 // History of changes compared to the original MidPointAlgorithm.cc file
 //
+// 2014-08-13 Matteo Cacciari and Gavin Salam
+//        * changed a number of int -> unsigned (and in one case
+//          added explicit conversion to int) to eliminate
+//          long-standing compiler warnings
+//
 // 2009-01-17  Gregory Soyez  <soyez@fastjet.fr>
 //
 …
   std::vector< std::vector<bool> > distanceOK;
   distanceOK.resize(stableCones.size() - 1);
+  for(int nCluster1 = 1; nCluster1 < stableCones.size(); nCluster1++){
+  // MC+GPS 2014-08-13, replaced int with unsigned
+  for(unsigned nCluster1 = 1; nCluster1 < stableCones.size(); nCluster1++){
     distanceOK[nCluster1 - 1].resize(nCluster1);
     double cluster1Rapidity = stableCones[nCluster1].fourVector.y();
     double cluster1Phi      = stableCones[nCluster1].fourVector.phi();
+    for(int nCluster2 = 0; nCluster2 < nCluster1; nCluster2++){
+    // MC+GPS 2014-08-13, replaced int with unsigned
+    for(unsigned nCluster2 = 0; nCluster2 < nCluster1; nCluster2++){
       double cluster2Rapidity = stableCones[nCluster2].fourVector.y();
       double cluster2Phi      = stableCones[nCluster2].fourVector.phi();
 …
   // Loop over all combinations. Calculate MidPoint. Make midPointClusters.
   bool reduceConeSize = false;
+  for(int iPair = 0; iPair < pairs.size(); iPair++){
+  // MC+GPS 2014-08-13, replaced int with unsigned
+  for(unsigned iPair = 0; iPair < pairs.size(); iPair++){
     // Calculate rapidity, phi and pT of MidPoint.
     LorentzVector midPoint(0,0,0,0);
+    for(int iPairMember = 0; iPairMember < pairs[iPair].size(); iPairMember++)
+    // MC+GPS 2014-08-13, replaced int with unsigned
+    for(unsigned iPairMember = 0; iPairMember < pairs[iPair].size(); iPairMember++)
       midPoint.add(stableCones[pairs[iPair][iPairMember]].fourVector);
     iterateCone(midPoint.y(),midPoint.phi(),midPoint.pt(),towers,stableCones,reduceConeSize);
 …
   if(testPair.size())
     nextClusterStart = testPair.back() + 1;
+  for(int nextCluster = nextClusterStart; nextCluster <= distanceOK.size(); nextCluster++){
+  // MC+GPS 2014-08-13, replaced int nextCluster with unsigned
+  for(unsigned nextCluster = nextClusterStart; nextCluster <= distanceOK.size(); nextCluster++){
     // Is new SeedCone less than 2*_coneRadius apart from all clusters in testPair?
     bool addCluster = true;
+    for(int iCluster = 0; iCluster < testPair.size() && addCluster; iCluster++)
+    // MC+GPS 2014-08-13, replaced int iCluster with unsigned
+    for(unsigned iCluster = 0; iCluster < testPair.size() && addCluster; iCluster++)
       if(!distanceOK[nextCluster - 1][testPair[iCluster]])
         addCluster = false;
 …
         pairs.push_back(testPair);
       // If not bigger than allowed, find more clusters within 2*_coneRadius.
+      if(testPair.size() < maxClustersInPair)
+      // GPS+MC 2014-08-13, replaced testPair.size() with int(testPair.size())
+      if(int(testPair.size()) < maxClustersInPair)
         addClustersToPairs(testPair,pairs,distanceOK,maxClustersInPair);
       // All combinations containing testPair found. Remove last element.

external/fastjet/plugins/CDFCones/fastjet/CDFJetCluPlugin.hh

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id: CDFJetCluPlugin.hh 2758 2011-11-24 08:31:58Z soyez $
+//FJSTARTHEADER
+// $Id: CDFJetCluPlugin.hh 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #ifndef __CDFJETCLUPLUGIN_HH__

external/fastjet/plugins/CDFCones/fastjet/CDFMidPointPlugin.hh

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id: CDFMidPointPlugin.hh 2758 2011-11-24 08:31:58Z soyez $
+//FJSTARTHEADER
+// $Id: CDFMidPointPlugin.hh 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #ifndef __CDFMIDPOINTPLUGIN_HH__

external/fastjet/plugins/CMSIterativeCone/CMSIterativeConePlugin.cc

-              rf6b6ee7
+              r49234af
+//STARTHEADER
+// $Id$
+//
+// Copyright (c) 2007-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) ????-????, CMS [for the iterative-cone code itself]
+//FJSTARTHEADER
+// $Id: CMSIterativeConePlugin.cc 1504 2009-04-10 13:39:48Z salam $
+//
+// Copyright (c) 2007-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
+// This file is part of FastJet. It contains code that has been
+// obtained from the CMS collaboration, revision 1.14 of the
+// CMSIterativeConeAlgorithm.cc file in CMSSW, see
+//   http://cmssw.cvs.cern.ch/cgi-bin/cmssw.cgi/CMSSW/RecoJets/JetAlgorithms/src/CMSIterativeConeAlgorithm.cc?hideattic=0&revision=1.14&view=markup
+//
+// Permission has been granted by the CMS collaboration to release it
+// in FastJet under the terms of the GNU Public License(v2) (see the
+// COPYING file in the main FastJet directory for details).
+// Changes from the original file are listed below.
+//
+// FastJet 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.
+//
+// The algorithms that underlie FastJet have required considerable
+// development and are described in hep-ph/0512210. If you use
+// FastJet as part of work towards a scientific publication, please
+// include a citation to the FastJet paper.
+//
+// FastJet 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 FastJet. If not, see <http://www.gnu.org/licenses/>.
+// This file is part of FastJet.
+//
+//  FastJet 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.
+//
+//  The algorithms that underlie FastJet have required considerable
+//  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
+//  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,
+//  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 FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 // List of changes compared to the original CMS code (revision 1.14 of

external/fastjet/plugins/CMSIterativeCone/fastjet/CMSIterativeConePlugin.hh

-              rf6b6ee7
+              r49234af
 //STARTHEADER
+//FJSTARTHEADER
 // $Id: CMSIterativeConePlugin.hh 1508 2009-04-10 22:46:49Z soyez $
 //
 // Copyright (c) 2007-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2007-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #ifndef __CMSITERATIVECONEPLUGIN_HH__

external/fastjet/plugins/D0RunICone/D0RunIBaseConePlugin.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
 //
 // Copyright (c) 2009-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+//FJSTARTHEADER
+// $Id: D0RunIBaseConePlugin.cc 1779 2010-10-25 10:32:59Z soyez $
+//
+// Copyright (c) 2009-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 // D0 stuff

external/fastjet/plugins/D0RunICone/fastjet/D0RunIBaseConePlugin.hh

-              rf6b6ee7
+              r49234af
 #define __D0RUNIBASECONEPLUGIN_HH__
 //STARTHEADER
+//FJSTARTHEADER
 // $Id: D0RunIBaseConePlugin.hh 1778 2010-10-25 10:02:58Z soyez $
 //
 // Copyright (c) 2009-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2009-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include "fastjet/JetDefinition.hh"

external/fastjet/plugins/D0RunICone/fastjet/D0RunIConePlugin.hh

-              rf6b6ee7
+              r49234af
 #define __D0RUNICONEPLUGIN_HH__
 //STARTHEADER
+//FJSTARTHEADER
 // $Id: D0RunIConePlugin.hh 1778 2010-10-25 10:02:58Z soyez $
 //
 // Copyright (c) 2009-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2009-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
+#include "fastjet/internal/base.hh" // namespace macros (include explicitly to help Doxygen)
 #include "D0RunIBaseConePlugin.hh"

external/fastjet/plugins/D0RunICone/fastjet/D0RunIpre96ConePlugin.hh

-              rf6b6ee7
+              r49234af
 #define __D0RUNIPRE96CONEPLUGIN_HH__
 //STARTHEADER
+//FJSTARTHEADER
 // $Id: D0RunIpre96ConePlugin.hh 1778 2010-10-25 10:02:58Z soyez $
 //
 // Copyright (c) 2009-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2009-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
+#include "fastjet/internal/base.hh" // namespace macros (include explicitly to help Doxygen)
 #include "D0RunIBaseConePlugin.hh"

external/fastjet/plugins/D0RunIICone/D0RunIIConePlugin.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
+//FJSTARTHEADER
+// $Id: D0RunIIConePlugin.cc 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include "fastjet/D0RunIIConePlugin.hh"

external/fastjet/plugins/D0RunIICone/ILConeAlgorithm.hpp

rf6b6ee7	r49234af
49	49	//
50	50	// 2012-06-12 Gregory Soyez <soyez@fastjet.fr>
51		//
52	51	// * Replaced addItem(...) by this->addItem(...) to allow
53	52	// compilation with gcc 4.7 which no longer performs

external/fastjet/plugins/D0RunIICone/fastjet/D0RunIIConePlugin.hh

-              rf6b6ee7
+              r49234af
 #define __D0RUNIICONEPLUGIN_HH__
 //STARTHEADER
 // $Id: D0RunIIConePlugin.hh 2761 2011-11-24 13:54:05Z soyez $
+//FJSTARTHEADER
+// $Id: D0RunIIConePlugin.hh 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include "fastjet/JetDefinition.hh"

external/fastjet/plugins/EECambridge/EECambridgePlugin.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
+//FJSTARTHEADER
+// $Id: EECambridgePlugin.cc 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2007-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2007-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 // fastjet stuff

external/fastjet/plugins/EECambridge/fastjet/EECambridgePlugin.hh

-              rf6b6ee7
+              r49234af
 #define __EECAMBRIDGEPLUGIN_HH__
 //STARTHEADER
 // $Id: EECambridgePlugin.hh 2692 2011-11-14 16:27:44Z soyez $
+//FJSTARTHEADER
+// $Id: EECambridgePlugin.hh 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2009, Matteo Cacciari, Gavin Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 …
   virtual bool exclusive_sequence_meaningful() const {return true;}
+  /// returns true because this plugin is intended for spherical
+  /// geometries (i.e. it's an e+e- algorithm).
+  virtual bool is_spherical() const {return true;}
 private:
   double _ycut;

external/fastjet/plugins/GridJet/GridJetPlugin.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
 //
 // Copyright (c) 2011, Matteo Cacciari, Gavin Salam and Gregory Soyez
+//FJSTARTHEADER
+// $Id: GridJetPlugin.cc 2268 2011-06-20 15:12:26Z salam $
+//
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 // fastjet stuff
 …
                               double requested_grid_spacing,
                               const JetDefinition & post_jet_def) :
+#ifdef FASTJET_GRIDJET_USEFJGRID
+  RectangularGrid(ymax, requested_grid_spacing), _post_jet_def(post_jet_def) {
+}
+#else
   _ymin(-ymax), _ymax(ymax),
   _requested_grid_spacing(requested_grid_spacing) ,
 …
   setup_grid();
+}
+#endif
+#ifdef FASTJET_GRIDJET_USEFJGRID
+GridJetPlugin::GridJetPlugin (const RectangularGrid & grid,
+                              const JetDefinition & post_jet_def) :
+  RectangularGrid(grid), _post_jet_def(post_jet_def) {
+  if (!RectangularGrid::is_initialised())
+    throw Error("attempt to construct GridJetPlugin with uninitialised RectangularGrid");
+}
+#endif // FASTJET_GRIDJET_USEFJGRID
+#ifndef FASTJET_GRIDJET_USEFJGRID
 void GridJetPlugin::setup_grid() {
   // since we've exchanged the arguments of the constructor,
 …
+}
+//----------------------------------------------------------------------
+string GridJetPlugin::description () const {
+  ostringstream desc;
+  desc << "GridJetPlugin plugin with ymax = " << _ymax << ", dy = " << _dy << ", dphi = " << _dphi << " (requested grid spacing was " << _requested_grid_spacing << ")";
+  if (_post_jet_def.jet_algorithm() != undefined_jet_algorithm) {
+    desc << ", followed by " << _post_jet_def.description();
+  }
+  return desc.str();
+}
+//----------------------------------------------------------------------
+double GridJetPlugin::R() const {return sqrt(_dy*_dphi/pi);}
+//----------------------------------------------------------------------
+int GridJetPlugin::igrid(const PseudoJet & p) const {
+//----------------------------------------------------------------------
+int GridJetPlugin::tile_index(const PseudoJet & p) const {
   // directly taking int does not work for values between -1 and 0
   // so use floor instead
 …
   return igrid_res;
+}
+#endif // not FASTJET_GRIDJET_USEFJGRID
+//----------------------------------------------------------------------
+string GridJetPlugin::description () const {
+  ostringstream desc;
+  desc << "GridJetPlugin plugin with ";
+#ifndef FASTJET_GRIDJET_USEFJGRID
+  desc << "ymax = " << _ymax << ", dy = " << _dy << ", dphi = " << _dphi << " (requested grid spacing was " << _requested_grid_spacing << ")";
+#else
+  desc << RectangularGrid::description();
+#endif
+  if (_post_jet_def.jet_algorithm() != undefined_jet_algorithm) {
+    desc << ", followed by " << _post_jet_def.description();
+  }
+  return desc.str();
+}
+//----------------------------------------------------------------------
+double GridJetPlugin::R() const {return sqrt(drap()*dphi()/pi);}
 …
   //  * a number >= 0 will mean that particle indicated by the index
   //    is currently the jet on the grid
   vector<int> grid(_ntotal, -1);
+  vector<int> grid(n_tiles(), -1);
   int nparticles = cs.jets().size();
 …
   // combine particles with whatever is in the grid
   for (int i = 0; i < nparticles; i++) {
     int igrd = igrid(cs.jets()[i]);
+    int igrd = tile_index(cs.jets()[i]);
     //cout << i << " " << cs.jets()[i].rap() << " " << cs.jets()[i].phi()
     //   << " " << igrd << " " << grid.size() << " " << _ntotal << endl;
     if (igrd < 0) continue;
     assert(igrd <= _ntotal);
+    assert(igrd <= n_tiles());
     if (grid[igrd] == -1) {
       grid[igrd] = i; // jet index of initial particle i is i
 …
     // make the final jets via iB recombinations
     for (unsigned igrd = 0; igrd < grid.size(); igrd++) {
       if (grid[igrd] != -1) cs.plugin_record_iB_recombination(grid[igrd],
                                                               dij_or_diB);
+      if (grid[igrd] != -1 && tile_is_good(igrd))
+                   cs.plugin_record_iB_recombination(grid[igrd], dij_or_diB);
+    }
   } else {

external/fastjet/plugins/GridJet/fastjet/GridJetPlugin.hh

-              rf6b6ee7
+              r49234af
 #ifndef __GRIDJETPLUGIN_HH__
 #define __GRIDJETPLUGIN_HH__
+#ifndef __FASTJET_GRIDJETPLUGIN_HH__
+#define __FASTJET_GRIDJETPLUGIN_HH__
 //STARTHEADER
+//FJSTARTHEADER
 // $Id: GridJetPlugin.hh 2267 2011-06-20 15:10:23Z salam $
 //
 // Copyright (c) 2011, Matteo Cacciari, Gavin Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include "fastjet/JetDefinition.hh"
+// makes it easy to switch back and forth between use of
+// RectangularGrid or not; this got enabled in FJ3.1
+#define FASTJET_GRIDJET_USEFJGRID
+#ifdef FASTJET_GRIDJET_USEFJGRID
+#include "fastjet/RectangularGrid.hh"
+#endif
 FASTJET_BEGIN_NAMESPACE      // defined in fastjet/internal/base.hh
 …
 /// but is rather provided for comparison purposes with the
 /// GridMedianBackgroundEstimator (which is even faster).
+class GridJetPlugin : public JetDefinition::Plugin {
+class GridJetPlugin : public JetDefinition::Plugin
+#ifdef FASTJET_GRIDJET_USEFJGRID
+                                      , RectangularGrid
+#endif
+{
 public:
   /// Main constructor for the GridJetPlugin Plugin class.
+  /// Basic constructor for the GridJetPlugin Plugin class.
   ///
   /// \param ymax           The maximal rapidity extent of the grid
 …
                  const JetDefinition & post_jet_def = JetDefinition());
+  /// copy constructor
+  GridJetPlugin (const GridJetPlugin & plugin) {
+    *this = plugin;
+  }
+#ifdef FASTJET_GRIDJET_USEFJGRID
+  /// Constructor for the GridJetPlugin Plugin class that allows
+  /// full control over the underlying grid. New in FastJet 3.1.
+  ///
+  /// \param grid           The maximal rapidity extent of the grid
+  /// \param post_jet_def   if present, and not == JetDefinition()
+  ///                       (which has undefined_jet_algorithm), then
+  ///                       run the post_jet_def on the result of the grid
+  ///                       clustering.
+  GridJetPlugin (const RectangularGrid & grid,
+                 const JetDefinition & post_jet_def = JetDefinition());
+#endif // FASTJET_GRIDJET_USEFJGRID
+  // /// copy constructor
+  // GridJetPlugin (const GridJetPlugin & plugin) {
+  //   *this = plugin;
+  // }
   // the things that are required by base class
 …
   virtual double R() const;
+  // As of FastJet 3.1 the following functions become available through
+  // the underlying RectangularGrid class.
+#ifndef FASTJET_GRIDJET_USEFJGRID
   /// returns the actual rapidity spacing of the grid
   double drap()   const {return _dy;}
 …
   /// returns the maximum rapidity of the grid
   double rapmax() const {return _ymax;}
+#endif
 private:
+#ifndef FASTJET_GRIDJET_USEFJGRID
   void setup_grid();
+  int igrid(const PseudoJet & p) const;
+  int n_tiles() const {return _ntotal;}
+  int n_good_tiles() const {return _ntotal;}
+  int tile_index(const PseudoJet & p) const;
+  bool tile_is_good(int /* itile */) const {return true;}
   double _ymin, _ymax, _dy, _dphi, _requested_grid_spacing;
   int _ny, _nphi, _ntotal;
+#endif
   JetDefinition _post_jet_def;
 …
 FASTJET_END_NAMESPACE        // defined in fastjet/internal/base.hh
 #endif // __GRIDJETPLUGIN_HH__
+#endif // __FASTJET_GRIDJETPLUGIN_HH__

external/fastjet/plugins/Jade/JadePlugin.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
+//FJSTARTHEADER
+// $Id: JadePlugin.cc 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2007-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2007-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 // fastjet stuff

external/fastjet/plugins/Jade/fastjet/JadePlugin.hh

-              rf6b6ee7
+              r49234af
 #define __JADEPLUGIN_HH__
 //STARTHEADER
 // $Id: JadePlugin.hh 2577 2011-09-13 15:11:38Z salam $
+//FJSTARTHEADER
+// $Id: JadePlugin.hh 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2009, Matteo Cacciari, Gavin Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include "fastjet/JetDefinition.hh"

external/fastjet/plugins/NestedDefs/NestedDefsPlugin.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
+//FJSTARTHEADER
+// $Id: NestedDefsPlugin.cc 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2007-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2007-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 // TODO

external/fastjet/plugins/NestedDefs/fastjet/NestedDefsPlugin.hh

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id: NestedDefsPlugin.hh 2577 2011-09-13 15:11:38Z salam $
+//FJSTARTHEADER
+// $Id: NestedDefsPlugin.hh 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2007-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2007-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #ifndef __NESTEDALGSPLUGIN_HH__

external/fastjet/plugins/SISCone/SISConePlugin.cc

-              rf6b6ee7
+              r49234af
                       four_vector.E);
+}
+//======================================================================
+// wrap-up around siscone's user-defined scales
+namespace siscone_plugin_internal{
+  /// @ingroup internal
+  /// \class SISConeUserScale
+  /// class that makes the transition between the internal SISCone
+  /// user-defined scale choice (using SISCone's Cjet) and
+  /// user-defined scale choices in the plugn above (using FastJet's
+  /// PseudoJets)
+  class SISConeUserScale  : public siscone::Csplit_merge::Cuser_scale_base{
+  public:
+    /// ctor takes the "fastjet-style" user-defined scale as well as a
+    /// reference to the current cluster sequence (to access the
+    /// particles if needed)
+    SISConeUserScale(const SISConePlugin::UserScaleBase *user_scale,
+                     const ClusterSequence &cs)
+      : _user_scale(user_scale), _cs(cs){}
+    /// returns the scale associated to a given jet
+    virtual double operator()(const siscone::Cjet &jet) const{
+      return _user_scale->result(_build_PJ_from_Cjet(jet));
+    }
+    /// returns true id the scasle associated to jet a is larger than
+    /// the scale associated to jet b
+    virtual bool is_larger(const siscone::Cjet &a, const siscone::Cjet &b) const{
+      return _user_scale->is_larger(_build_PJ_from_Cjet(a), _build_PJ_from_Cjet(b));
+    }
+  private:
+    /// constructs a PseudoJet from a siscone::Cjet
+    ///
+    /// Note that it is tempting to overload the PseudoJet ctor. This
+    /// would not work because down the line we need to access the
+    /// original PseudoJet through the ClusterSequence and therefore
+    /// the PseudoJet structure needs to be aware of the
+    /// ClusterSequence.
+    PseudoJet _build_PJ_from_Cjet(const siscone::Cjet &jet) const{
+      PseudoJet j(jet.v.px, jet.v.py, jet.v.pz, jet.v.E);
+      j.set_structure_shared_ptr(SharedPtr<PseudoJetStructureBase>(
+                                   new SISConePlugin::UserScaleBaseStructureType<siscone::Cjet>(jet,_cs)));
+      return j;
+    }
+    const SISConePlugin::UserScaleBase *_user_scale;
+    const ClusterSequence & _cs;
+  };
+}
+// end of the internal material
+//======================================================================
 …
   desc << "SISCone jet algorithm with " ;
   desc << "cone_radius = "       << cone_radius        () << ", ";
+  desc << "overlap_threshold = " << overlap_threshold  () << ", ";
+  if (_progressive_removal)
+    desc << "progressive-removal mode, ";
+  else
+    desc << "overlap_threshold = " << overlap_threshold  () << ", ";
   desc << "n_pass_max = "        << n_pass_max         () << ", ";
   desc << "protojet_ptmin = "    << protojet_ptmin()      << ", ";
+  desc <<  sm_scale_string                                << ", ";
+  desc << "caching turned "      << (caching() ? on : off);
+  desc << ", SM stop scale = "     << _split_merge_stopping_scale;
+  if (_progressive_removal && _user_scale) {
+    desc << "using a user-defined scale for ordering of stable cones";
+    string user_scale_desc = _user_scale->description();
+    if (user_scale_desc != "") desc << " (" << user_scale_desc << ")";
+  } else {
+    desc <<  sm_scale_string;
+  }
+  if (!_progressive_removal){
+    desc << ", caching turned "      << (caching() ? on : off);
+    desc << ", SM stop scale = "     << _split_merge_stopping_scale;
+  }
   // add a note to the description if we use the pt-weighted splitting
 …
   bool new_siscone = true; // by default we'll be running it
   if (caching()) {
+  if (caching() && !_progressive_removal) {
     // Establish if we have a cached run with the same R, npass and
 …
     // run the jet finding
     //cout << "plg sms: " << split_merge_scale() << endl;
+    siscone->compute_jets(siscone_momenta, cone_radius(), overlap_threshold(),
+                          n_pass_max(), protojet_or_ghost_ptmin(),
+                          Esplit_merge_scale(split_merge_scale()));
+    if (_progressive_removal){
+      // handle the optional user-defined scale choice
+      SharedPtr<siscone_plugin_internal::SISConeUserScale> internal_scale;
+      if (_user_scale){
+        internal_scale.reset(new siscone_plugin_internal::SISConeUserScale(_user_scale, clust_seq));
+        siscone->set_user_scale(internal_scale.get());
+      }
+      siscone->compute_jets_progressive_removal(siscone_momenta, cone_radius(),
+                                                n_pass_max(), protojet_or_ghost_ptmin(),
+                                                Esplit_merge_scale(split_merge_scale()));
+    } else {
+      siscone->compute_jets(siscone_momenta, cone_radius(), overlap_threshold(),
+                            n_pass_max(), protojet_or_ghost_ptmin(),
+                            Esplit_merge_scale(split_merge_scale()));
+    }
   } else {
     // rerun the jet finding
 …
   SISConeExtras * extras = new SISConeExtras(n);
+  // the ordering in which the inclusive jets are transfered here is
+  // deliberate and ensures that when a user asks for
+  // inclusive_jets(), they are provided in the order in which SISCone
+  // created them.
   for (int ijet = njet-1; ijet >= 0; ijet--) {
     const Cjet & jet = siscone->jets[ijet]; // shorthand
 …
   // give the extras object to the cluster sequence.
+  clust_seq.plugin_associate_extras(std::auto_ptr<ClusterSequence::Extras>(extras));
+  //
+  // As of v3.1 of FastJet, extras are automatically owned (as
+  // SharedPtr) by the ClusterSequence and auto_ptr is deprecated. So
+  // we can use a simple pointer here
+  //clust_seq.plugin_associate_extras(std::auto_ptr<ClusterSequence::Extras>(extras));
+  clust_seq.plugin_associate_extras(extras);
+}
 …
+}
+// //======================================================================
+// // material to handle user-defined scales
+//
+// //--------------------------------------------------
+// // SISCone structure type
+//
+// // the textual descripotion
+// std::string SISConePlugin::UserScaleBase::StructureType::description() const{
+//   return "PseudoJet wrapping a siscone::Cjet stable cone";
+// }
+//
+// // retrieve the constituents
+// //
+// // if you simply need to iterate over the constituents, it will be
+// // faster to access them via constituent(i)
+// vector<PseudoJet> SISConePlugin::UserScaleBase::StructureType::constituents(const PseudoJet &) const{
+//   vector<PseudoJet> constits;
+//   constits.reserve(_jet.n);
+//   for (unsigned int i=0; i<(unsigned int)_jet.n;i++)
+//     constits.push_back(constituent(i));
+//   return constits;
+// }
+//
+// // returns the number of constituents
+// unsigned int SISConePlugin::UserScaleBase::StructureType::size() const{
+//   return _jet.n;
+// }
+//
+// // returns the index (in the original particle list) of the ith
+// // constituent
+// int SISConePlugin::UserScaleBase::StructureType::constituent_index(unsigned int i) const{
+//   return _jet.contents[i];
+// }
+//
+// // returns the ith constituent (as a PseusoJet)
+// const PseudoJet & SISConePlugin::UserScaleBase::StructureType::constituent(unsigned int i) const{
+//   return _cs.jets()[_jet.contents[i]];
+// }
+//
+// // returns the scalar pt of this stable cone
+// double SISConePlugin::UserScaleBase::StructureType::pt_tilde() const{
+//   return _jet.pt_tilde;
+// }
+//
+// // returns the sm_var2 (signed ordering variable squared) for this stable cone
+// double SISConePlugin::UserScaleBase::StructureType::ordering_var2() const{
+//   return _jet.sm_var2;
+// }
 FASTJET_END_NAMESPACE      // defined in fastjet/internal/base.hh

external/fastjet/plugins/SISCone/area.cc

-              rf6b6ee7
+              r49234af
 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
 //                                                                           //
 // $Revision::                                                              $//
 // $Date::                                                                  $//
+// $Revision:: 149                                                          $//
+// $Date:: 2007-03-15 00:13:58 +0100 (Thu, 15 Mar 2007)                     $//
 ///////////////////////////////////////////////////////////////////////////////

external/fastjet/plugins/SISCone/area.h

-              rf6b6ee7
+              r49234af
 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
 //                                                                           //
 // $Revision::                                                              $//
 // $Date::                                                                  $//
+// $Revision:: 149                                                          $//
+// $Date:: 2007-03-15 00:13:58 +0100 (Thu, 15 Mar 2007)                     $//
 ///////////////////////////////////////////////////////////////////////////////

external/fastjet/plugins/SISCone/circulator.h

-              rf6b6ee7
+              r49234af
 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
 //                                                                           //
 // $Revision::                                                              $//
 // $Date::                                                                  $//
+// $Revision:: 103                                                          $//
+// $Date:: 2007-02-18 17:07:34 +0100 (Sun, 18 Feb 2007)                     $//
 ///////////////////////////////////////////////////////////////////////////////

external/fastjet/plugins/SISCone/config.h

-              rf6b6ee7
+              r49234af
 /* Define to the full name and version of this package. */
 #define PACKAGE_STRING "SISCone 2.0.6"
+#define PACKAGE_STRING "SISCone 3.0.0"
 /* Define to the one symbol short name of this package. */
 …
 /* Define to the version of this package. */
 #define PACKAGE_VERSION "2.0.6"
+#define PACKAGE_VERSION "3.0.0"
 /* Define to 1 if you have the ANSI C header files. */
 …
 /* Version number of package */
 #define VERSION "2.0.6"
+#define VERSION "3.0.0"

external/fastjet/plugins/SISCone/defines.h

-              rf6b6ee7
+              r49234af
 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
 //                                                                           //
 // $Revision::                                                              $//
 // $Date::                                                                  $//
+// $Revision:: 225                                                          $//
+// $Date:: 2008-05-20 16:59:47 +0200 (Tue, 20 May 2008)                     $//
 ///////////////////////////////////////////////////////////////////////////////

external/fastjet/plugins/SISCone/fastjet/SISConeBasePlugin.hh

-              rf6b6ee7
+              r49234af
   SISConeBasePlugin (){
     _use_jet_def_recombiner = false;
+    set_progressive_removal(false);
+  }
 …
     *this = plugin;
+  }
+  /// set whether to use SISCone with progressive removal instead of
+  /// the default split_merge step.
+  ///
+  /// If progressive removal is enabled, the following SISCone
+  /// variables are not used:
+  ///
+  /// - overlap_threshold
+  /// - caching
+  /// - split_merge_stopping_scale
+  ///
+  /// The split_merge_scale choice is reinterpreted as the ordering
+  /// variable for progressive removal. It is also possible for the
+  /// user to supply his/her own function for the scale that orders
+  /// progressive removal, with set_user_scale(...)
+  void set_progressive_removal(bool progressive_removal_in=true){
+    _progressive_removal = progressive_removal_in;
+  }
+  /// returns true if progressive_removal is enabled
+  bool progressive_removal() const{ return _progressive_removal;}
   /// the cone radius
 …
+  }
+  // user-defined scale for progressive removal
+  //------------------------------------------------------------
+  /// \class UserScaleBase
+  /// base class for user-defined ordering of stable cones (used for
+  /// prorgessive removal)
+  ///
+  /// derived classes have to implement the () operator that returns
+  /// the scale associated with a given jet.
+  ///
+  /// It is also highly recommended to implement the is_larger()
+  /// method whenever possible, in order to avoid rounding issues
+  /// known to lead to possible infrared unsafeties.
+  ///
+  /// The jets that are passed to this class will carry the structure
+  /// of type SISConePlugin::StructureType which allows to retreive
+  /// easily the following information:
+  ///
+  ///   vector<PseudoJet> constituents = jet.constituents();
+  ///   unsigned int n_constituents = jet.structure_of<SISConePlugin::UserScaleBase>().size();
+  ///   int index = jet.structure_of<SISConePlugin::UserScaleBase>().constituent_index(index i);
+  ///   const PseudoJet & p = jet.structure_of<SISConePlugin::UserScaleBase>().constituent(index i);
+  ///   double scalar_pt = jet.structure_of<SISConePlugin::UserScaleBase>().pt_tilde();
+  ///
+  /// see SISConePlugin::StructureType below for further details
+  class UserScaleBase : public FunctionOfPseudoJet<double>{
+  public:
+    /// empty virtual dtor
+    virtual ~UserScaleBase(){}
+    /// returns the scale associated with a given jet
+    ///
+    /// "progressive removal" iteratively removes the stable cone with
+    /// the largest scale
+    virtual double result(const PseudoJet & jet) const = 0;
+    /// returns true when the scale associated with jet a is larger than
+    /// the scale associated with jet b
+    ///
+    /// By default this does a simple direct comparison but it can be
+    /// overloaded for higher precision [recommended if possible]
+    virtual bool is_larger(const PseudoJet & a, const PseudoJet & b) const;
+    class StructureType; // defined below
+  };
+  // template class derived from UserScaleBase::StryctureType that
+  // works for both SISCone jet classes
+  // implemented below
+  template<class Tjet>
+  class UserScaleBaseStructureType;
+  /// set a user-defined scale for stable-cone ordering in
+  /// progressive removal
+  void set_user_scale(const UserScaleBase *user_scale_in){ _user_scale = user_scale_in;}
+  /// returns the user-defined scale in use (0 if none)
+  const UserScaleBase * user_scale() const{ return _user_scale;}
   // the things that one MUST overload required by base class
   //---------------------------------------------------------
 …
   double _split_merge_stopping_scale;
   bool   _use_jet_def_recombiner;
+  bool   _progressive_removal;
   mutable double _ghost_sep_scale;
 …
   /// call the re-clustering itself
   virtual void reset_stored_plugin() const =0;
+  const UserScaleBase * _user_scale;
 };
 …
 inline SISConeBaseExtras::~SISConeBaseExtras(){}
+//----------------------------------------------------------------------
+// implementation of the structure type associated with the UserScaleBase class
+/// \class SISConeBasePlugin::UserScaleBase::StructureType
+/// the structure that allows to store the information contained
+/// into a siscone::Cjet (built internally in SISCone from a stable
+/// cone) into a PseudoJet
+class SISConeBasePlugin::UserScaleBase::StructureType : public PseudoJetStructureBase {
+public:
+  /// base ctor (constructed from a ClusterSequence tin order to have
+  /// access to the initial particles
+  StructureType(const ClusterSequence &cs)
+    : _cs(cs){}
+  /// empty virtual dtor
+  virtual ~StructureType(){}
+  //--------------------------------------------------
+  // members inherited from the base class
+  /// the textual descripotion
+  virtual std::string description() const{
+    return "PseudoJet wrapping a siscone jet from a stable cone";
+  }
+  /// this structure has constituents
+  virtual bool has_constituents() const {return true;}
+  /// retrieve the constituents
+  ///
+  /// if you simply need to iterate over the constituents, it will be
+  /// faster to access them via constituent(i)
+  virtual std::vector<PseudoJet> constituents(const PseudoJet & /*reference*/) const{
+    std::vector<PseudoJet> constits;
+    constits.reserve(size());
+    for (unsigned int i=0; i<size();i++)
+      constits.push_back(constituent(i));
+    return constits;
+  }
+  //--------------------------------------------------
+  // additional information relevant for this structure
+  /// returns the number of constituents
+  virtual unsigned int size() const = 0;
+  /// returns the index (in the original particle list) of the ith
+  /// constituent
+  virtual int constituent_index(unsigned int i) const = 0;
+  /// returns the ith constituent (as a PseusoJet)
+  const PseudoJet & constituent(unsigned int i) const{
+    return _cs.jets()[constituent_index(i)];
+  }
+  // /// returns the scalar pt of this stable cone
+  // virtual double pt_tilde() const = 0;
+  /// returns the sm_var2 (signed ordering variable squared) for this stable cone
+  virtual double ordering_var2() const = 0;
+protected:
+  const ClusterSequence &_cs; ///< a reference to the CS (for access to the particles)
+};
+///@ingroup internal
+/// template class derived from UserScaleBase::StryctureType that
+/// works for both SISCone jet classes
+/// implemented below
+template<class Tjet>
+class SISConeBasePlugin::UserScaleBaseStructureType : public UserScaleBase::StructureType{
+public:
+  UserScaleBaseStructureType(const Tjet &jet, const ClusterSequence &cs)
+    : UserScaleBase::StructureType(cs), _jet(jet){}
+  /// empty virtual dtor
+  virtual ~UserScaleBaseStructureType(){}
+  //--------------------------------------------------
+  // additional information relevant for this structure
+  /// returns the number of constituents
+  virtual unsigned int size() const{
+    return _jet.n;
+  }
+  /// returns the index (in the original particle list) of the ith
+  /// constituent
+  virtual int constituent_index(unsigned int i) const{
+    return _jet.contents[i];
+  }
+  // /// returns the scalar pt of this stable cone
+  // virtual double pt_tilde() const{
+  //   return _jet.pt_tilde;
+  // }
+  /// returns the sm_var2 (signed ordering variable squared) for this stable cone
+  virtual double ordering_var2() const{
+    return _jet.sm_var2;
+  }
+protected:
+  const Tjet &_jet; ///< a reference to the internal jet in SISCone
+};
 FASTJET_END_NAMESPACE        // defined in fastjet/internal/base.hh

external/fastjet/plugins/SISCone/fastjet/SISConePlugin.hh

-              rf6b6ee7
+              r49234af
 namespace siscone{
   class Csiscone;
+  class Cjet;
+}
 …
   /// enum for the different split-merge scale choices;
   /// Note that order _must_ be the same as in siscone
+  enum SplitMergeScale {SM_pt,     ///< transverse momentum (E-scheme), IR unsafe
+                        SM_Et,     ///< transverse energy (E-scheme), not long. boost invariant
+                                   ///< original run-II choice [may not be implemented]
+                        SM_mt,     ///< transverse mass (E-scheme), IR safe except
+                                   ///< in decays of two identical narrow heavy particles
+                        SM_pttilde ///< pt-scheme pt = \sum_{i in jet} |p_{ti}|, should
+                                   ///< be IR safe in all cases
+  enum SplitMergeScale {
+    SM_pt,     ///< transverse momentum (E-scheme), IR unsafe
+    SM_Et,     ///< transverse energy (E-scheme), not long. boost invariant
+               ///< original run-II choice [may not be implemented]
+    SM_mt,     ///< transverse mass (E-scheme), IR safe except
+               ///< in decays of two identical narrow heavy particles
+    SM_pttilde ///< pt-scheme pt = \sum_{i in jet} |p_{ti}|, should
+               ///< be IR safe in all cases
   };
 …
     _split_merge_stopping_scale = split_merge_stopping_scale_in;
     _ghost_sep_scale       = 0.0;
+    _use_pt_weighted_splitting = false;}
+    _use_pt_weighted_splitting = false;
+    _user_scale = 0;}
 …
     _split_merge_stopping_scale = 0.0;
     _split_merge_scale     = split_merge_on_transverse_mass_in ? SM_mt : SM_pttilde;
+    _ghost_sep_scale       = 0.0;}
+    _ghost_sep_scale       = 0.0;
+    _user_scale = 0;}
   /// backwards compatible constructor for the SISCone Plugin class
 …
     _split_merge_stopping_scale = 0.0;
     _ghost_sep_scale       = 0.0;
+    _use_pt_weighted_splitting = false;}
+    _use_pt_weighted_splitting = false;
+    _user_scale = 0;}
   /// minimum pt for a protojet to be considered in the split-merge step
 …
 };
+/////\class SISConePlugin::UserScaleBase::StructureType
+///// the structure that allows to store the information contained
+///// into a siscone::Cjet (built internally in SISCone from a stable
+///// cone) into a PseudoJet
+//class SISConePlugin::UserScaleBase::StructureType : public PseudoJetStructureBase {
+//public:
+//  StructureType(const siscone::Cjet & jet, const ClusterSequence &cs)
+//    : _jet(jet), _cs(cs){}
+//
+//  //--------------------------------------------------
+//  // members inherited from the base class
+//  /// the textual descripotion
+//  virtual std::string description() const;
+//
+//  /// this structure has constituents
+//  virtual bool has_constituents() const {return true;}
+//
+//  /// retrieve the constituents
+//  ///
+//  /// if you simply need to iterate over the constituents, it will be
+//  /// faster to access them via constituent(i)
+//  virtual std::vector<PseudoJet> constituents(const PseudoJet & /*reference*/) const;
+//
+//  //--------------------------------------------------
+//  // additional information relevant for this structure
+//
+//  /// returns the number of constituents
+//  unsigned int size() const;
+//
+//  /// returns the index (in the original particle list) of the ith
+//  /// constituent
+//  int constituent_index(unsigned int i) const;
+//
+//  /// returns the ith constituent (as a PseusoJet)
+//  const PseudoJet & constituent(unsigned int i) const;
+//
+//  /// returns the scalar pt of this stable cone
+//  double pt_tilde() const;
+//
+//  /// returns the sm_var2 (signed ordering variable squared) for this stable cone
+//  double ordering_var2() const;
+//
+//protected:
+//  const siscone::Cjet &_jet;  ///< a dreference to the internal jet in SISCone
+//  const ClusterSequence &_cs; ///< a reference to the CS (for access to the particles)
+//};
 //======================================================================

external/fastjet/plugins/SISCone/fastjet/SISConeSphericalPlugin.hh

-              rf6b6ee7
+              r49234af
   virtual void run_clustering(ClusterSequence &) const ;
+  /// returns true because this plugin is intended for spherical
+  /// geometries (i.e. it's an e+e- algorithm).
+  virtual bool is_spherical() const {return true;}
 protected:
   virtual void reset_stored_plugin() const;

external/fastjet/plugins/SISCone/geom_2d.cc

-              rf6b6ee7
+              r49234af
 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
 //                                                                           //
 // $Revision::                                                              $//
 // $Date::                                                                  $//
+// $Revision:: 171                                                          $//
+// $Date:: 2007-06-19 16:26:05 +0200 (Tue, 19 Jun 2007)                     $//
 ///////////////////////////////////////////////////////////////////////////////

external/fastjet/plugins/SISCone/geom_2d.h

-              rf6b6ee7
+              r49234af
 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
 //                                                                           //
 // $Revision::                                                              $//
 // $Date::                                                                  $//
+// $Revision:: 268                                                          $//
+// $Date:: 2009-03-12 21:24:16 +0100 (Thu, 12 Mar 2009)                     $//
 ///////////////////////////////////////////////////////////////////////////////

external/fastjet/plugins/SISCone/hash.cc

-              rf6b6ee7
+              r49234af
 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
 //                                                                           //
 // $Revision::                                                              $//
 // $Date::                                                                  $//
+// $Revision:: 225                                                          $//
+// $Date:: 2008-05-20 16:59:47 +0200 (Tue, 20 May 2008)                     $//
 ///////////////////////////////////////////////////////////////////////////////

external/fastjet/plugins/SISCone/hash.h

-              rf6b6ee7
+              r49234af
 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
 //                                                                           //
 // $Revision::                                                              $//
 // $Date::                                                                  $//
+// $Revision:: 224                                                          $//
+// $Date:: 2008-05-16 19:58:30 +0200 (Fri, 16 May 2008)                     $//
 ///////////////////////////////////////////////////////////////////////////////

external/fastjet/plugins/SISCone/momentum.cc

-              rf6b6ee7
+              r49234af
 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
 //                                                                           //
 // $Revision::                                                              $//
 // $Date::                                                                  $//
+// $Revision:: 123                                                          $//
+// $Date:: 2007-03-01 02:52:16 +0100 (Thu, 01 Mar 2007)                     $//
 ///////////////////////////////////////////////////////////////////////////////

external/fastjet/plugins/SISCone/momentum.h

-              rf6b6ee7
+              r49234af
 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
 //                                                                           //
 // $Revision::                                                              $//
 // $Date::                                                                  $//
+// $Revision:: 163                                                          $//
+// $Date:: 2007-04-26 22:31:02 +0200 (Thu, 26 Apr 2007)                     $//
 ///////////////////////////////////////////////////////////////////////////////

external/fastjet/plugins/SISCone/protocones.cc

-              rf6b6ee7
+              r49234af
 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
 //                                                                           //
 // $Revision::                                                              $//
 // $Date::                                                                  $//
+// $Revision:: 322                                                          $//
+// $Date:: 2011-11-15 10:12:36 +0100 (Tue, 15 Nov 2011)                     $//
 ///////////////////////////////////////////////////////////////////////////////

external/fastjet/plugins/SISCone/protocones.h

-              rf6b6ee7
+              r49234af
 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
 //                                                                           //
 // $Revision::                                                              $//
 // $Date::                                                                  $//
+// $Revision:: 224                                                          $//
+// $Date:: 2008-05-16 19:58:30 +0200 (Fri, 16 May 2008)                     $//
 ///////////////////////////////////////////////////////////////////////////////

external/fastjet/plugins/SISCone/quadtree.cc

-              rf6b6ee7
+              r49234af
 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
 //                                                                           //
 // $Revision::                                                              $//
 // $Date::                                                                  $//
+// $Revision:: 320                                                          $//
+// $Date:: 2011-11-15 09:54:50 +0100 (Tue, 15 Nov 2011)                     $//
 ///////////////////////////////////////////////////////////////////////////////

external/fastjet/plugins/SISCone/quadtree.h

-              rf6b6ee7
+              r49234af
 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
 //                                                                           //
 // $Revision::                                                              $//
 // $Date::                                                                  $//
+// $Revision:: 123                                                          $//
+// $Date:: 2007-03-01 02:52:16 +0100 (Thu, 01 Mar 2007)                     $//
 ///////////////////////////////////////////////////////////////////////////////

external/fastjet/plugins/SISCone/reference.cc

-              rf6b6ee7
+              r49234af
 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
 //                                                                           //
 // $Revision::                                                              $//
 // $Date::                                                                  $//
+// $Revision:: 311                                                          $//
+// $Date:: 2011-10-05 23:27:09 +0200 (Wed, 05 Oct 2011)                     $//
 ///////////////////////////////////////////////////////////////////////////////

external/fastjet/plugins/SISCone/reference.h

-              rf6b6ee7
+              r49234af
 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
 //                                                                           //
 // $Revision::                                                              $//
 // $Date::                                                                  $//
+// $Revision:: 123                                                          $//
+// $Date:: 2007-03-01 02:52:16 +0100 (Thu, 01 Mar 2007)                     $//
 ///////////////////////////////////////////////////////////////////////////////

external/fastjet/plugins/SISCone/siscone.cc

-              rf6b6ee7
+              r49234af
 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
 //                                                                           //
 // $Revision::                                                              $//
 // $Date::                                                                  $//
+// $Revision:: 371                                                          $//
+// $Date:: 2014-09-09 10:05:32 +0200 (Tue, 09 Sep 2014)                     $//
 ///////////////////////////////////////////////////////////////////////////////
 …
 //#else
 //#define PACKAGE_NAME "SISCone"
 //#define VERSION "2.0.6"
+//#define VERSION "3.0.0"
 //#warning "No config.h file available, using preset values"
 //#endif
 …
                            int _n_pass_max, double _ptmin,
                            Esplit_merge_scale _split_merge_scale){
+  // initialise random number generator
+  if (!init_done){
+    // initialise random number generator
+    ranlux_init();
+    // do not do this again
+    init_done=true;
+    // print the banner
+    if (_banner_ostr != 0){
+      (*_banner_ostr) << "#ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo" << endl;
+      (*_banner_ostr) << "#                    SISCone   version " << setw(28) << left << siscone_version() << "o" << endl;
+      (*_banner_ostr) << "#              http://projects.hepforge.org/siscone                o" << endl;
+      (*_banner_ostr) << "#                                                                  o" << endl;
+      (*_banner_ostr) << "# This is SISCone: the Seedless Infrared Safe Cone Jet Algorithm   o" << endl;
+      (*_banner_ostr) << "# SISCone was written by Gavin Salam and Gregory Soyez             o" << endl;
+      (*_banner_ostr) << "# It is released under the terms of the GNU General Public License o" << endl;
+      (*_banner_ostr) << "#                                                                  o" << endl;
+      (*_banner_ostr) << "# A description of the algorithm is available in the publication   o" << endl;
+      (*_banner_ostr) << "# JHEP 05 (2007) 086 [arXiv:0704.0292 (hep-ph)].                   o" << endl;
+      (*_banner_ostr) << "# Please cite it if you use SISCone.                               o" << endl;
+      (*_banner_ostr) << "#ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo" << endl;
+      (*_banner_ostr) << endl;
+      _banner_ostr->flush();
+    }
+  }
+  _initialise_if_needed();
   // run some general safety tests (NB: f will be checked in split-merge)
 …
+}
+/*
+ * compute the jets from a given particle set doing multiple passes
+ * such pass N looks for jets among all particles not put into jets
+ * during previous passes.
+ *  - _particles   list of particles
+ *  - _radius      cone radius
+ *  - _n_pass_max  maximum number of runs
+ *  - _ptmin       minimum pT of the protojets
+ *  - _ordering_scale    the ordering scale to decide which stable
+ *                       cone is removed
+ * return the number of jets found.
+ **********************************************************************/
+int Csiscone::compute_jets_progressive_removal(vector<Cmomentum> &_particles, double _radius,
+                                               int _n_pass_max, double _ptmin,
+                                               Esplit_merge_scale _ordering_scale){
+  _initialise_if_needed();
+  // run some general safety tests (NB: f will be checked in split-merge)
+  if (_radius <= 0.0 || _radius >= 0.5*M_PI) {
+    ostringstream message;
+    message << "Illegal value for cone radius, R = " << _radius
+            << " (legal values are 0<R<pi/2)";
+    throw Csiscone_error(message.str());
+  }
+  ptcomparison.split_merge_scale = _ordering_scale;
+  partial_clear(); // make sure some things are initialised properly
+  // init the split_merge algorithm with the initial list of particles
+  // this initialises particle list p_left of remaining particles to deal with
+  //
+  // this stores the "processed" particles in p_uncol_hard
+  init_particles(_particles);
+  jets.clear();
+  bool unclustered_left;
+  rerun_allowed = false;
+  protocones_list.clear();
+  do{
+    //cout << n_left << " particle left" << endl;
+    // initialise stable_cone finder
+    // here we use the list of remaining particles
+    // AFTER COLLINEAR CLUSTERING !!!!!!
+    Cstable_cones::init(p_uncol_hard);
+    // get stable cones (stored in 'protocones')
+    unclustered_left = get_stable_cones(_radius);
+    // add the hardest stable cone to the list of jets
+    if (add_hardest_protocone_to_jets(&protocones, R2, _ptmin)) break;
+    _n_pass_max--;
+  } while ((unclustered_left) && (n_left>0) && (_n_pass_max!=0));
+  // split & merge
+  return jets.size();
+}
 /*
  * recompute the jets with a different overlap parameter.
 …
+}
+// ensure things are initialised
+void Csiscone::_initialise_if_needed(){
+  // initialise random number generator
+  if (init_done) return;
+  // initialise random number generator
+  ranlux_init();
+  // do not do this again
+  init_done=true;
+  // print the banner
+  if (_banner_ostr != 0){
+    (*_banner_ostr) << "#ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo" << endl;
+    (*_banner_ostr) << "#                    SISCone   version " << setw(28) << left << siscone_version() << "o" << endl;
+    (*_banner_ostr) << "#              http://projects.hepforge.org/siscone                o" << endl;
+    (*_banner_ostr) << "#                                                                  o" << endl;
+    (*_banner_ostr) << "# This is SISCone: the Seedless Infrared Safe Cone Jet Algorithm   o" << endl;
+    (*_banner_ostr) << "# SISCone was written by Gavin Salam and Gregory Soyez             o" << endl;
+    (*_banner_ostr) << "# It is released under the terms of the GNU General Public License o" << endl;
+    (*_banner_ostr) << "#                                                                  o" << endl;
+    (*_banner_ostr) << "# A description of the algorithm is available in the publication   o" << endl;
+    (*_banner_ostr) << "# JHEP 05 (2007) 086 [arXiv:0704.0292 (hep-ph)].                   o" << endl;
+    (*_banner_ostr) << "# Please cite it if you use SISCone.                               o" << endl;
+    (*_banner_ostr) << "#ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo" << endl;
+    (*_banner_ostr) << endl;
+    _banner_ostr->flush();
+  }
+}
 // finally, a bunch of functions to access to

external/fastjet/plugins/SISCone/siscone.h

-              rf6b6ee7
+              r49234af
 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
 //                                                                           //
 // $Revision::                                                              $//
 // $Date::                                                                  $//
+// $Revision:: 369                                                          $//
+// $Date:: 2014-09-04 16:57:55 +0200 (Thu, 04 Sep 2014)                     $//
 ///////////////////////////////////////////////////////////////////////////////
 …
   /**
+   * compute the jets from a given particle set.
+   * We are doing multiple passes such pass n_pass looks for jets among
+   * all particles not put into jets during previous passes.
+   * By default the number of passes is infinite (0).
+   * \param _particles   list of particles
+   * \param _radius      cone radius
+   * \param _n_pass_max  maximum number of passes (0=full search)
+   * \param _ptmin       minimum pT of the protojets
+   * \param _ordering_scale    the ordering scale to decide which stable
+   *                           cone is removed
+   *
+   * Note that the Csplit_merge::SM_var2_hardest_cut_off cut is not
+   * used in the progressive removal variant.
+   *
+   * \return the number of jets found.
+   */
+  int compute_jets_progressive_removal(std::vector<Cmomentum> &_particles, double _radius,
+                                       int _n_pass_max=0, double _ptmin=0.0,
+                                       Esplit_merge_scale _ordering_scale=SM_pttilde);
+  /**
    * recompute the jets with a different overlap parameter.
    * we use the same particles and R as in the preceeding call.
 …
                      Esplit_merge_scale _split_merge_scale=SM_pttilde);
   /// list of protocones found pass-by-pass
+  /// list of protocones found pass-by-pass (not filled by compute_jets_progressive_removal)
   std::vector<std::vector<Cmomentum> > protocones_list;
 …
   bool rerun_allowed;         ///< is recompute_jets allowed ?
   static std::ostream * _banner_ostr; ///< stream to use for banners
+  /// ensure things are initialised
+  void _initialise_if_needed();
 };

external/fastjet/plugins/SISCone/siscone_error.cc

-              rf6b6ee7
+              r49234af
 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
 //                                                                           //
 // $Revision::                                                              $//
 // $Date::                                                                  $//
+// $Revision:: 123                                                          $//
+// $Date:: 2007-03-01 02:52:16 +0100 (Thu, 01 Mar 2007)                     $//
 ///////////////////////////////////////////////////////////////////////////////

external/fastjet/plugins/SISCone/siscone_error.h

-              rf6b6ee7
+              r49234af
 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
 //                                                                           //
 // $Revision::                                                              $//
 // $Date::                                                                  $//
+// $Revision:: 327                                                          $//
+// $Date:: 2011-11-25 15:19:39 +0100 (Fri, 25 Nov 2011)                     $//
 ///////////////////////////////////////////////////////////////////////////////

external/fastjet/plugins/SISCone/split_merge.cc

-              rf6b6ee7
+              r49234af
 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
 //                                                                           //
 // $Revision::                                                              $//
 // $Date::                                                                  $//
+// $Revision:: 370                                                          $//
+// $Date:: 2014-09-04 17:03:15 +0200 (Thu, 04 Sep 2014)                     $//
 ///////////////////////////////////////////////////////////////////////////////
 …
 #include "siscone_error.h"
 #include "momentum.h"
-#include <math.h>
 #include <limits>   // for max
 #include <iostream>
 …
 #include <sstream>
 #include <cassert>
+#include <cmath>
 namespace siscone{
 …
 #endif
 #endif
+  _user_scale = NULL;
   indices = NULL;
 …
   // no hardest cut (col-unsafe)
   SM_var2_hardest_cut_off = -1.0;
+  SM_var2_hardest_cut_off = -numeric_limits<double>::max();
   // no pt cutoff for the particles to put in p_uncol_hard
 …
+}
+/*
+ * remove the hardest protocone and declare it a a jet
+ *  - protocones  list of protocones (initial jet candidates)
+ *  - R2          cone radius (squared)
+ *  - ptmin       minimal pT allowed for jets
+ * return 0 on success, 1 on error
+ *
+ * The list of remaining particles (and the uncollinear-hard ones)
+ * is updated.
+ */
+int Csplit_merge::add_hardest_protocone_to_jets(std::vector<Cmomentum> *protocones, double R2, double ptmin){
+  int i;
+  Cmomentum *c;
+  Cmomentum *v;
+  double eta, phi;
+  double dx, dy;
+  double R;
+  Cjet jet, jet_candidate;
+  bool found_jet = false;
+  if (protocones->size()==0)
+    return 1;
+  pt_min2 = ptmin*ptmin;
+  R = sqrt(R2);
+  // browse protocones
+  // for each of them, build the list of particles in them
+  for (vector<Cmomentum>::iterator p_it = protocones->begin();p_it != protocones->end();p_it++){
+    // initialise variables
+    c = &(*p_it);
+    // note: cones have been tested => their (eta,phi) coordinates are computed
+    eta = c->eta;
+    phi = c->phi;
+    // NOTE: this is common to this method and add_protocones, so it
+    // could be moved into a 'build_jet_from_protocone' method
+    //
+    // browse particles to create cone contents
+    jet_candidate.v = Cmomentum();
+    jet_candidate.pt_tilde=0;
+    jet_candidate.contents.clear();
+    for (i=0;i<n_left;i++){
+      v = &(p_remain[i]);
+      // for security, avoid including particles with infinite rapidity)
+      // NO NEEDED ANYMORE SINCE REMOVED FROM p_remain FROM THE BEGINNING
+      //if (fabs(v->pz)!=v->E){
+      dx = eta - v->eta;
+      dy = fabs(phi - v->phi);
+      if (dy>M_PI)
+        dy -= twopi;
+      if (dx*dx+dy*dy<R2){
+        jet_candidate.contents.push_back(v->parent_index);
+        jet_candidate.v+= *v;
+        jet_candidate.pt_tilde+= pt[v->parent_index];
+        v->index=0;
+      }
+    }
+    jet_candidate.n=jet_candidate.contents.size();
+    // set the momentum in protocones
+    // (it was only known through eta and phi up to now)
+    *c = jet_candidate.v;
+    c->eta = eta; // restore exact original coords
+    c->phi = phi; // to avoid rounding error inconsistencies
+    // set the jet range
+    jet_candidate.range=Ceta_phi_range(eta,phi,R);
+    // check that the protojet has large enough pt
+    if (jet_candidate.v.perp2()<pt_min2)
+      continue;
+    // assign the split-merge (or progressive-removal) squared scale variable
+    if (_user_scale) {
+      // sm_var2 is the signed square of the user scale returned
+      // for the jet candidate
+      jet_candidate.sm_var2 = (*_user_scale)(jet_candidate);
+      jet_candidate.sm_var2 *= abs(jet_candidate.sm_var2);
+    } else {
+      jet_candidate.sm_var2 = get_sm_var2(jet_candidate.v, jet_candidate.pt_tilde);
+    }
+    // now check if it is possibly the hardest
+    if ((! found_jet) ||
+        (_user_scale ? _user_scale->is_larger(jet_candidate, jet)
+                     : ptcomparison(jet_candidate, jet))){
+      jet = jet_candidate;
+      found_jet = true;
+    }
+  }
+  // make sure at least one of the jets has passed the selection
+  if (!found_jet) return 1;
+  // add the jet to the list of jets
+  jets.push_back(jet);
+  jets[jets.size()-1].v.build_etaphi();
+#ifdef DEBUG_SPLIT_MERGE
+  cout << "PR-Jet " << jets.size() << " [size " << next_jet.contents.size() << "]:";
+#endif
+  // update the list of what particles are left
+  int p_remain_index = 0;
+  int contents_index = 0;
+  //sort(next_jet.contents.begin(),next_jet.contents.end());
+  for (int index=0;index<n_left;index++){
+    if ((contents_index<(int) jet.contents.size()) &&
+        (p_remain[index].parent_index == jet.contents[contents_index])){
+      // this particle belongs to the newly found jet
+      // set pass in initial list
+      particles[p_remain[index].parent_index].index = n_pass;
+#ifdef DEBUG_SPLIT_MERGE
+      cout << " " << jet.contents[contents_index];
+#endif
+      contents_index++;
+    } else {
+      // this particle still has to be clustered
+      p_remain[p_remain_index] = p_remain[index];
+      p_remain[p_remain_index].parent_index = p_remain[index].parent_index;
+      p_remain[p_remain_index].index=1;
+      p_remain_index++;
+    }
+  }
+  p_remain.resize(n_left-jet.contents.size());
+  n_left = p_remain.size();
+  jets[jets.size()-1].pass = particles[jet.contents[0]].index;
+  // increase the pass index
+  n_pass++;
+#ifdef DEBUG_SPLIT_MERGE
+  cout << endl;
+#endif
+  // male sure the list of uncol_hard particles (used for the next
+  // stable cone finding) is updated [could probably be more
+  // efficient]
+  merge_collinear_and_remove_soft();
+  return 0;
+}
 /*

external/fastjet/plugins/SISCone/split_merge.h

-              rf6b6ee7
+              r49234af
 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
 //                                                                           //
 // $Revision::                                                              $//
 // $Date::                                                                  $//
+// $Revision:: 367                                                          $//
+// $Date:: 2014-09-04 15:57:37 +0200 (Thu, 04 Sep 2014)                     $//
 ///////////////////////////////////////////////////////////////////////////////
 …
   /// the split-merge process i.e. the variable we use for
   ///  1. ordering jet candidates;
   ///  2. computing te overlap fraction of two candidates.
+  ///  2. computing the overlap fraction of two candidates.
   /// The default value uses pttile (p-scheme pt). Other alternatives are
   /// pt, mt=sqrt(pt^2+m^2)=sqrt(E^2-pz^2) or Et.
 …
   ///   the default value i.e.  to use pt only for the purpose of
   ///   investigating the IR issue
   /// - using Et is safe but do not respect boost invariance
+  /// - using Et is safe but does not respect boost invariance
   /// - using mt solves the IR unsafety issues with the pt variable
   ///   for QCD jets but the IR unsafety remains for nack-to-back
 …
   int full_clear();
+  ///////////////////////////////////////
+  // user-defined stable-cone ordering //
+  ///////////////////////////////////////
+  /// \class Cuser_scale_base
+  /// base class for user-defined ordering of stable cones
+  ///
+  /// derived classes have to implement the () operator that returns
+  /// the scale associated with a given jet.
+  class Cuser_scale_base{
+  public:
+    /// empty virtual dtor
+    virtual ~Cuser_scale_base(){}
+    /// the scale associated with a given jet
+    ///
+    /// "progressive removal" iteratively removes the stable cone with
+    /// the largest scale
+    virtual double operator()(const Cjet & jet) const = 0;
+    /// returns true when the scale associated with jet a is larger than
+    /// the scale associated with jet b
+    ///
+    /// By default this does a simple direct comparison but it can be
+    /// overloaded for higher precision [recommended if possible]
+    ///
+    /// This function assumes that a.sm_var2 and b.sm_var2 have been
+    /// correctly initialised with the signed squared output of
+    /// operator(), as is by default the case when is_larger is called
+    /// from within siscone.
+    virtual bool is_larger(const Cjet & a, const Cjet & b) const{
+      return (a.sm_var2 > b.sm_var2);
+    }
+  };
+  /// associate a user-defined scale to order the stable cones
+  ///
+  /// Note that this is only used in "progressive-removal mode",
+  /// e.g. in add_hardest_protocone_to_jets().
+  void set_user_scale(const Cuser_scale_base * user_scale_in){
+    _user_scale = user_scale_in;
+  }
+  /// return the user-defined scale (NULL if none)
+  const Cuser_scale_base * user_scale() const { return _user_scale; }
   /////////////////////////////////
 …
    */
   int add_protocones(std::vector<Cmomentum> *protocones, double R2, double ptmin=0.0);
+  /**
+   * remove the hardest protocone and declare it a jet
+   * \param protocones  list of protocones (initial jet candidates)
+   * \param R2          cone radius (squared)
+   * \param ptmin       minimal pT allowed for jets
+   * \return 0 on success, 1 on error
+   *
+   * The list of remaining particles (and the uncollinear-hard ones)
+   * is updated.
+   */
+  int add_hardest_protocone_to_jets(std::vector<Cmomentum> *protocones, double R2, double ptmin=0.0);
   /**
 …
   Csplit_merge_ptcomparison ptcomparison;
+  /// stop split--merge when the SM_var of the hardest protojet
+  /// is below this cut-off.
+  /// stop split--merge or progressive-removal when the squared SM_var
+  /// of the hardest protojet is below this cut-off. Note that this is
+  /// a signed square (ie SM_var*|SM_var|) to be able to handle
+  /// negative values.
+  ///
+  /// Note that the cut-off is set on the variable squared.
+  double SM_var2_hardest_cut_off;
+  /// pt cutoff for the particles to put in p_uncol_hard
+  /// this is meant to allow removing soft particles in the
+  /// stable-cone search.
+  ///
   /// This is not collinear-safe so you should not use this
   /// variable unless you really know what you are doing
   /// Note that the cut-off is set on the variable squared.
-  double SM_var2_hardest_cut_off;
-  /// pt cutoff for the particles to put in p_uncol_hard
-  /// this is meant to allow removing soft particles in the
-  /// stable-cone search.
   double stable_cone_soft_pt2_cutoff;
 …
   bool use_pt_weighted_splitting;
+  /// use a user-defined scale to order the stable cones and jet
+  /// candidates
+  const Cuser_scale_base *_user_scale;
 #ifdef ALLOW_MERGE_IDENTICAL_PROTOCONES
   /// checkxor for the candidates (to avoid having twice the same contents)

external/fastjet/plugins/SISCone/vicinity.cc

-              rf6b6ee7
+              r49234af
 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
 //                                                                           //
 // $Revision::                                                              $//
 // $Date::                                                                  $//
+// $Revision:: 123                                                          $//
+// $Date:: 2007-03-01 02:52:16 +0100 (Thu, 01 Mar 2007)                     $//
 ///////////////////////////////////////////////////////////////////////////////

external/fastjet/plugins/SISCone/vicinity.h

-              rf6b6ee7
+              r49234af
 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
 //                                                                           //
 // $Revision::                                                              $//
 // $Date::                                                                  $//
+// $Revision:: 123                                                          $//
+// $Date:: 2007-03-01 02:52:16 +0100 (Thu, 01 Mar 2007)                     $//
 ///////////////////////////////////////////////////////////////////////////////

external/fastjet/plugins/TrackJet/TrackJetPlugin.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
 //
 // Copyright (c) 2007-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+//FJSTARTHEADER
+// $Id: TrackJetPlugin.cc 3433 2014-07-23 08:17:03Z salam $
+//
+// Copyright (c) 2007-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
+// This file is part of FastJet. It contains code that has been
+// obtained from the Rivet project by Leif Lonnblad, Andy Buckley and
+// Jon Butterworth. See http://www.hepforge.org/downloads/rivet.
+// Rivet is free software released under the terms of the GNU Public
+// License(v2).
+// Changes from the original file are listed below.
+// This file is part of FastJet.
 //
 //  FastJet is free software; you can redistribute it and/or modify
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 // History of changes from the original TrackJet.cc file in Rivet <=1.1.2

external/fastjet/plugins/TrackJet/fastjet/TrackJetPlugin.hh

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id: TrackJetPlugin.hh 2758 2011-11-24 08:31:58Z soyez $
+//FJSTARTHEADER
+// $Id: TrackJetPlugin.hh 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2007-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2007-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #ifndef __TRACKJETPLUGIN_HH__

external/fastjet/tools/BackgroundEstimatorBase.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
+//FJSTARTHEADER
+// $Id: BackgroundEstimatorBase.cc 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER

external/fastjet/tools/BackgroundEstimatorBase.hh

-              rf6b6ee7
+              r49234af
 #define __FASTJET_BACKGROUND_ESTIMATOR_BASE_HH__
 //STARTHEADER
 // $Id: BackgroundEstimatorBase.hh 2689 2011-11-14 14:51:06Z soyez $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+//FJSTARTHEADER
+// $Id: BackgroundEstimatorBase.hh 3516 2014-08-01 14:07:58Z salam $
+//
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include <fastjet/ClusterSequenceAreaBase.hh>
 …
 ///
 /// Abstract base class that provides the basic interface for classes
 /// that estimate levels of background radiation in hadrion and
+/// that estimate levels of background radiation in hadron and
 /// heavy-ion collider events.
-///
 ///
 class BackgroundEstimatorBase {
 …
   /// determination of sigma
   virtual bool has_sigma() {return false;}
+  //\}
+  //----------------------------------------------------------------
+  // now do the same thing for rho_m and sigma_m
+  /// returns rho_m, the purely longitudinal, particle-mass-induced
+  /// component of the background density per unit area
+  virtual double rho_m() const{
+    throw Error("rho_m() not supported for this Background Estimator");
+  }
+  /// returns sigma_m, a measure of the fluctuations in the purely
+  /// longitudinal, particle-mass-induced component of the background
+  /// density per unit area; must be multipled by sqrt(area) to get
+  /// fluctuations for a region of a given area.
+  virtual double sigma_m() const {
+    throw Error("sigma_m() not supported for this Background Estimator");
+  }
+  /// Returns rho_m locally at the jet position. As for rho(jet), it is non-const.
+  virtual double rho_m(const PseudoJet & /*jet*/){
+    throw Error("rho_m(jet) not supported for this Background Estimator");
+  }
+  /// Returns sigma_m locally at the jet position. As for rho(jet), it is non-const.
+  virtual double sigma_m(const PseudoJet & /*jet*/) {
+    throw Error("sigma_m(jet) not supported for this Background Estimator");
+  }
+  /// Returns true if this background estimator has support for
+  /// determination of rho_m.
+  ///
+  /// Note that support for sigma_m is automatic is one has sigma and
+  /// rho_m support.
+  virtual bool has_rho_m() const {return false;}
+  //\}
   /// @name configuring the behaviour
 …
   /// The BackgroundRescalingYPolynomial class can be used to get a
   /// rescaling that depends just on rapidity.
+  ///
+  /// There is currently no support for different rescaling classes
+  /// for rho and rho_m determinations.
   virtual void set_rescaling_class(const FunctionOfPseudoJet<double> * rescaling_class_in) { _rescaling_class = rescaling_class_in; }

external/fastjet/tools/Boost.hh

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id: Boost.hh 2689 2011-11-14 14:51:06Z soyez $
+//FJSTARTHEADER
+// $Id: Boost.hh 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #ifndef __FASTJET_TOOL_BOOST_HH__

external/fastjet/tools/CASubJetTagger.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
+//FJSTARTHEADER
+// $Id: CASubJetTagger.cc 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include <fastjet/tools/CASubJetTagger.hh>

external/fastjet/tools/CASubJetTagger.hh

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id: CASubJetTagger.hh 2616 2011-09-30 18:03:40Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+//FJSTARTHEADER
+// $Id: CASubJetTagger.hh 3433 2014-07-23 08:17:03Z salam $
+//
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #ifndef __CASUBJET_TAGGER_HH__

external/fastjet/tools/Filter.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
+//FJSTARTHEADER
+// $Id: Filter.cc 3633 2014-08-15 13:23:52Z soyez $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include "fastjet/tools/Filter.hh"
+#include "fastjet/tools/Recluster.hh"
 #include <fastjet/ClusterSequenceActiveAreaExplicitGhosts.hh>
 #include <cassert>
 …
 // class description
 string Filter::description() const {
+  if (!_initialised){
+    return "uninitialised Filter";
+  }
   ostringstream ostr;
   ostr << "Filter with subjet_def = ";
 …
 // by the filtering
 PseudoJet Filter::result(const PseudoJet &jet) const {
+  if (!_initialised){
+    //Q: do we throw or do we return an empty PJ?
+    throw Error("uninitialised Filter");
+  }
   // start by getting the list of subjets (including a list of sanity
   // checks)
 …
   //     _set_filtered_elements_cafilt)
   vector<PseudoJet> subjets;
+  JetDefinition subjet_def;
+  bool discard_area;
+  // NB: on return, subjet_def is set to the jet definition actually
+  //     used (so that we can make use of its recombination scheme
+  //     when joining the jets to be kept).
+  _set_filtered_elements(jet, subjets, subjet_def, discard_area);
+  //JetDefinition subjet_def;
+  bool ca_optimised = _set_filtered_elements(jet, subjets);
+  // apply subtraction if needed:
+  if (_subtractor){
+    subjets = (*_subtractor)(subjets);
+  } else if (_rho!=0){
+    if (subjets.size()>0){
+      const ClusterSequenceAreaBase *csab = subjets[0].validated_csab();
+      for (unsigned int i=0;i<subjets.size();i++){
+        subjets[i]=csab->subtracted_jet(subjets[i], _rho);
+      }
+    }
+  }
   // now build the vector of kept and rejected subjets
 …
   // gather the info under the form of a PseudoJet
   return _finalise(jet, kept, rejected, subjet_def, discard_area);
+  return _finalise(jet, kept, rejected, ca_optimised);
+}
 // sets filtered_elements to be all the subjets on which filtering will work
+void Filter::_set_filtered_elements(const PseudoJet & jet,
+                                    vector<PseudoJet> & filtered_elements,
+                                    JetDefinition & subjet_def,
+                                    bool & discard_area) const {
+  // sanity checks
+  //-------------------------------------------------------------------
+  // make sure that the jet has constituents
+  if (! jet.has_constituents())
+    throw Error("Filter can only be applied on jets having constituents");
+//
+// return true when the subjets have been optained using teh optimised
+// method for C/A
+bool Filter::_set_filtered_elements(const PseudoJet & jet,
+                                    vector<PseudoJet> & filtered_elements) const {
+  // create the recluster instance
+  Recluster recluster;
+  if ((_Rfilt>=0) || (_Rfiltfunc))
+    recluster = Recluster(cambridge_algorithm, (_Rfiltfunc) ? (*_Rfiltfunc)(jet) : _Rfilt, Recluster::keep_all);
+  else
+    recluster = Recluster(_subjet_def, false, Recluster::keep_all);
+  // for a whole variety of checks, we shall need the "recursive"
+  // pieces of the jet (the jet itself or recursing down to its most
+  // fundamental pieces).
+  // So we do compute these once and for all
+  vector<PseudoJet> all_pieces; //.clear();
+  if ((!_get_all_pieces(jet, all_pieces)) || (all_pieces.size()==0))
+    throw Error("Attempt to filter a jet that has no associated ClusterSequence or is not a superposition of jets associated with a ClusterSequence");
+  // if the filter uses subtraction, make sure we have a CS that supports area and has
+  // explicit ghosts
+  if (_uses_subtraction()) {
+    if (!jet.has_area())
+      throw Error("Attempt to filter and subtract (non-zero rho or subtractor) without area info for the original jet");
+    if (!_check_explicit_ghosts(all_pieces))
+      throw Error("Attempt to filter and subtract (non-zero rho or subtractor) without explicit ghosts");
+  }
+  // if we're dealing with a dynamic determination of the filtering
+  // radius, do it now
+  if ((_Rfilt>=0) || (_Rfiltfunc)){
+    double Rfilt = (_Rfiltfunc) ? (*_Rfiltfunc)(jet) : _Rfilt;
+    const JetDefinition::Recombiner * common_recombiner = _get_common_recombiner(all_pieces);
+    if (common_recombiner) {
+      if (typeid(*common_recombiner) == typeid(JetDefinition::DefaultRecombiner)) {
+        RecombinationScheme scheme =
+          static_cast<const JetDefinition::DefaultRecombiner *>(common_recombiner)->scheme();
+        subjet_def = JetDefinition(cambridge_algorithm, Rfilt, scheme);
+      } else {
+        subjet_def = JetDefinition(cambridge_algorithm, Rfilt, common_recombiner);
+      }
+    } else {
+      subjet_def = JetDefinition(cambridge_algorithm, Rfilt);
+    }
+  } else {
+    subjet_def = _subjet_def;
+  }
+  // get the jet definition to be use and whether we can apply our
+  // simplified C/A+C/A filter
+  //
+  // we apply C/A clustering iff
+  //  - the request subjet_def is C/A
+  //  - the jet is either directly coming from C/A or if it is a
+  //    superposition of C/A jets
+  //  - the pieces agree with the recombination scheme of subjet_def
+  //------------------------------------------------------------------
+  bool simple_cafilt = _check_ca(all_pieces);
+  // extract the subjets
+  //-------------------------------------------------------------------
+  discard_area = false;
+  if (simple_cafilt){
+    // first make sure that 'filtered_elements' is empty
+    filtered_elements.clear();
+    _set_filtered_elements_cafilt(jet, filtered_elements, subjet_def.R());
+    // in the following case, areas can be erroneous and will be discarded
+    discard_area = (!_uses_subtraction()) && (jet.has_area()) && (!_check_explicit_ghosts(all_pieces));
+  } else {
+    // here we'll simply recluster the jets.
+    //
+    // To include an area support we need
+    //  - the jet to have an area
+    //  - subtraction requested or explicit ghosts
+    bool do_areas = (jet.has_area()) && ((_uses_subtraction()) || (_check_explicit_ghosts(all_pieces)));
+    _set_filtered_elements_generic(jet, filtered_elements, subjet_def, do_areas);
+  }
+  // order the filtered elements in pt
+  filtered_elements = sorted_by_pt(filtered_elements);
+  // get the subjets
+  //JetDefinition subjet_def;
+  return recluster.get_new_jets_and_def(jet, filtered_elements);
+}
-// set the filtered elements in the simple case of C/A+C/A
-//
-// WATCH OUT: this could be recursively called, so filtered elements
-//            of 'jet' are APPENDED to 'filtered_elements'
-void Filter::_set_filtered_elements_cafilt(const PseudoJet & jet,
-                                           vector<PseudoJet> & filtered_elements,
-                                           double Rfilt) const{
-  // we know that the jet is either a C/A jet or a superposition of
-  // such pieces
-  if (jet.has_associated_cluster_sequence()){
-    // just extract the exclusive subjets of 'jet'
-    const ClusterSequence *cs = jet.associated_cluster_sequence();
-    vector<PseudoJet> local_fe;
-    double dcut = Rfilt / cs->jet_def().R();
-    if (dcut>=1.0){
-      local_fe.push_back(jet);
-    } else {
-      dcut *= dcut;
-      local_fe = jet.exclusive_subjets(dcut);
+    }
-    // subtract the jets if needed
-    // Note that this one would work on pieces!!
-    //-----------------------------------------------------------------
-    if (_uses_subtraction()){
-      const ClusterSequenceAreaBase * csab = jet.validated_csab();
-      for (unsigned int i=0;i<local_fe.size();i++) {
-        if (_subtractor) {
-          local_fe[i] = (*_subtractor)(local_fe[i]);
-        } else {
-          local_fe[i] = csab->subtracted_jet(local_fe[i], _rho);
+        }
+      }
+    }
-    copy(local_fe.begin(), local_fe.end(), back_inserter(filtered_elements));
-    return;
+  }
-  // just recurse into the pieces
-  const vector<PseudoJet> & pieces = jet.pieces();
-  for (vector<PseudoJet>::const_iterator it = pieces.begin();
-       it!=pieces.end(); it++)
-    _set_filtered_elements_cafilt(*it, filtered_elements, Rfilt);
+}
-// set the filtered elements in the generic re-clustering case (wo
-// subtraction)
-void Filter::_set_filtered_elements_generic(const PseudoJet & jet,
-                                            vector<PseudoJet> & filtered_elements,
-                                            const JetDefinition & subjet_def,
-                                            bool do_areas) const{
-  // create a new, internal, ClusterSequence from the jet constituents
-  // get the subjets directly from there
-  //
-  // If the jet has area support then we separate the ghosts from the
-  // "regular" particles so the subjets will also have area
-  // support. Note that we do this regardless of whether rho is zero
-  // or not.
-  //
-  // Note that to be able to separate the ghosts, one needs explicit
-  // ghosts!!
-  // ---------------------------------------------------------------
-  if (do_areas){
-    vector<PseudoJet> all_constituents = jet.constituents();
-    vector<PseudoJet> regular_constituents, ghosts;
-    for (vector<PseudoJet>::iterator it = all_constituents.begin();
-         it != all_constituents.end(); it++){
-      if (it->is_pure_ghost())
-        ghosts.push_back(*it);
-      else
-        regular_constituents.push_back(*it);
+    }
-    // figure out the ghost area from the 1st ghost (if none, any value
-    // would probably do as the area will be 0 and subtraction will have
-    // no effect!)
-    double ghost_area = (ghosts.size()) ? ghosts[0].area() : 0.01;
-    ClusterSequenceActiveAreaExplicitGhosts * csa
-      = new ClusterSequenceActiveAreaExplicitGhosts(regular_constituents,
-                                                    subjet_def,
-                                                    ghosts, ghost_area);
-    // get the subjets: we use the subtracted or unsubtracted ones
-    // depending on rho or _subtractor being non-zero
-    if (_uses_subtraction()) {
-      if (_subtractor) {
-        filtered_elements = (*_subtractor)(csa->inclusive_jets());
-      } else {
-        filtered_elements = csa->subtracted_jets(_rho);
+      }
-    } else {
-      filtered_elements = csa->inclusive_jets();
+    }
-    // allow the cs to be deleted when it's no longer used
-    csa->delete_self_when_unused();
-  } else {
-    ClusterSequence * cs = new ClusterSequence(jet.constituents(), subjet_def);
-    filtered_elements = cs->inclusive_jets();
-    // allow the cs to be deleted when it's no longer used
-    cs->delete_self_when_unused();
+  }
+}
 // gather the information about what is kept and rejected under the
 …
                             vector<PseudoJet> & kept,
                             vector<PseudoJet> & rejected,
+                            const JetDefinition & subjet_def,
+                            const bool discard_area) const {
+  // figure out which recombiner to use
+  const JetDefinition::Recombiner &rec = *(subjet_def.recombiner());
+                            bool ca_optimisation_used) const {
+  PseudoJet filtered_jet;
+  // create an appropriate structure and transfer the info to it
+  PseudoJet filtered_jet = join<StructureType>(kept, rec);
+  if (kept.size()+rejected.size()>0){
+    // figure out which recombiner to use
+    const JetDefinition::Recombiner &rec = (kept.size()>0)
+      ? *(kept[0].associated_cs()->jet_def().recombiner())
+      : *(rejected[0].associated_cs()->jet_def().recombiner());
+    // create an appropriate structure and transfer the info to it
+    filtered_jet = join<StructureType>(kept, rec);
+  } else {
+    filtered_jet = join<StructureType>(kept);
+  }
   StructureType *fs = (StructureType*) filtered_jet.structure_non_const_ptr();
-//  fs->_original_jet = jet;
   fs->_rejected = rejected;
+  // if we've used C/A optimisation, we need to get rid of the area
+  // information if it comes from a non-explicit-ghost clustering.
+  // (because in that case it can be erroneous due the lack of
+  // information about empty areas)
+  if ((ca_optimisation_used) && (kept.size()+rejected.size()>0)){
+    bool has_non_explicit_ghost_area = (kept.size()>0)
+      ? (kept[0].has_area()     && kept[0].validated_csab()->has_explicit_ghosts())
+      : (rejected[0].has_area() && rejected[0].validated_csab()->has_explicit_ghosts());
+    if (has_non_explicit_ghost_area)
+      fs->discard_area();
+  }
-  if (discard_area){
-    // safety check: make sure there is an area to discard!!!
-    assert(fs->_area_4vector_ptr);
-    delete fs->_area_4vector_ptr;
-    fs->_area_4vector_ptr=0;
+  }
   return filtered_jet;
+}
-// various checks
-//----------------------------------------------------------------------
-// get the pieces down to the fundamental pieces
-//
-// Note that this just checks that there is an associated CS to the
-// fundamental pieces, not that it is still valid
-bool Filter::_get_all_pieces(const PseudoJet &jet, vector<PseudoJet> &all_pieces) const{
-  if (jet.has_associated_cluster_sequence()){
-    all_pieces.push_back(jet);
-    return true;
+  }
-  if (jet.has_pieces()){
-    const vector<PseudoJet> pieces = jet.pieces();
-    for (vector<PseudoJet>::const_iterator it=pieces.begin(); it!=pieces.end(); it++)
-      if (!_get_all_pieces(*it, all_pieces)) return false;
-    return true;
+  }
-  return false;
+}
-// get the common recombiner to all pieces (NULL if none)
-//
-// Note that if the jet has an associated cluster sequence that is no
-// longer valid, an error will be thrown (needed since it could be the
-// 1st check called after the enumeration of the pieces)
-const JetDefinition::Recombiner* Filter::_get_common_recombiner(const vector<PseudoJet> &all_pieces) const{
-  const JetDefinition & jd_ref = all_pieces[0].validated_cs()->jet_def();
-  for (unsigned int i=1; i<all_pieces.size(); i++)
-    if (!all_pieces[i].validated_cs()->jet_def().has_same_recombiner(jd_ref)) return NULL;
-  return jd_ref.recombiner();
+}
-// check if the jet (or all its pieces) have explicit ghosts
-// (assuming the jet has area support
-//
-// Note that if the jet has an associated cluster sequence that is no
-// longer valid, an error will be thrown (needed since it could be the
-// 1st check called after the enumeration of the pieces)
-bool Filter::_check_explicit_ghosts(const vector<PseudoJet> &all_pieces) const{
-  for (vector<PseudoJet>::const_iterator it=all_pieces.begin(); it!=all_pieces.end(); it++)
-    if (! it->validated_csab()->has_explicit_ghosts()) return false;
-  return true;
+}
-// check if one can apply the simplification for C/A subjets
-//
-// This includes:
-//  - the subjet definition asks for C/A subjets
-//  - all the pieces share the same CS
-//  - that CS is C/A with the same recombiner as the subjet def
-//  - the filtering radius is not larger than any of the pairwise
-//    distance between the pieces
-//
-// Note that if the jet has an associated cluster sequence that is no
-// longer valid, an error will be thrown (needed since it could be the
-// 1st check called after the enumeration of the pieces)
-bool Filter::_check_ca(const vector<PseudoJet> &all_pieces) const{
-  if (_subjet_def.jet_algorithm() != cambridge_algorithm) return false;
-  // check that the 1st of all the pieces (we're sure there is at
-  // least one) is coming from a C/A clustering. Then check that all
-  // the following pieces share the same ClusterSequence
-  const ClusterSequence * cs_ref = all_pieces[0].validated_cs();
-  if (cs_ref->jet_def().jet_algorithm() != cambridge_algorithm) return false;
-  for (unsigned int i=1; i<all_pieces.size(); i++)
-    if (all_pieces[i].validated_cs() != cs_ref) return false;
-  // check that the 1st peice has the same recombiner as the one used
-  // for the subjet clustering
-  // Note that since they share the same CS, checking the 2st one is enough
-  if (!cs_ref->jet_def().has_same_recombiner(_subjet_def)) return false;
-  // we also have to make sure that the filtering radius is not larger
-  // than any of the inter-pieces distance
-  double Rfilt2 = _subjet_def.R();
-  Rfilt2 *= Rfilt2;
-  for (unsigned int i=0; i<all_pieces.size()-1; i++){
-    for (unsigned int j=i+1; j<all_pieces.size(); j++){
-      if (all_pieces[i].squared_distance(all_pieces[j]) <  Rfilt2) return false;
+    }
+  }
-  return true;
+}
-//----------------------------------------------------------------------
-// FilterInterface implementation
-//----------------------------------------------------------------------
 FASTJET_END_NAMESPACE      // defined in fastjet/internal/base.hh

external/fastjet/tools/Filter.hh

-              rf6b6ee7
+              r49234af
 #define __FASTJET_TOOLS_FILTER_HH__
 //STARTHEADER
 // $Id: Filter.hh 2694 2011-11-14 22:27:51Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+//FJSTARTHEADER
+// $Id: Filter.hh 3494 2014-07-30 20:38:48Z soyez $
+//
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include <fastjet/ClusterSequence.hh>
 …
   /// Note: this is just for derived classes
   ///       a Filter initialised through this constructor will not work!
   Filter() : _Rfiltfunc(0){};
+  Filter() : _Rfiltfunc(0), _initialised(false){};
   /// define a filter that decomposes a jet into subjets using a
 …
   /// ghosts
   Filter(JetDefinition subjet_def, Selector selector, double rho = 0.0) :
     _subjet_def(subjet_def), _Rfiltfunc(0), _Rfilt(-1), _selector(selector), _rho(rho), _subtractor(0) {}
+    _subjet_def(subjet_def), _Rfiltfunc(0), _Rfilt(-1), _selector(selector), _rho(rho), _subtractor(0), _initialised(true) {}
   /// Same as the full constructor (see above) but just specifying the radius
 …
   ///  \param Rfilt   the filtering radius
   Filter(double Rfilt, Selector selector, double rho = 0.0) :
     _Rfiltfunc(0), _Rfilt(Rfilt), _selector(selector), _rho(rho), _subtractor(0) {
+    _Rfiltfunc(0), _Rfilt(Rfilt), _selector(selector), _rho(rho), _subtractor(0), _initialised(true) {
     if (_Rfilt<0)
       throw Error("Attempt to create a Filter with a negative filtering radius");
 …
   ///  \param Rfilt_func   the filtering radius function of a PseudoJet
   Filter(FunctionOfPseudoJet<double> *Rfilt_func, Selector selector, double rho = 0.0) :
     _Rfiltfunc(Rfilt_func), _Rfilt(-1), _selector(selector), _rho(rho), _subtractor(0) {}
+    _Rfiltfunc(Rfilt_func), _Rfilt(-1), _selector(selector), _rho(rho), _subtractor(0), _initialised(true) {}
   /// default dtor
 …
   /// Set a subtractor that is applied to all individual subjets before
   /// deciding which ones to keep. It takes precedence over a non-zero rho.
   void set_subtractor(const Transformer * subtractor) {_subtractor = subtractor;}
+  void set_subtractor(const FunctionOfPseudoJet<PseudoJet> * subtractor) {_subtractor = subtractor;}
   /// runs the filtering and sets kept and rejected to be the jets of interest
 …
   /// It also sets the subjet_def to be used in joining things (the bit of
   /// subjet def that is of interest for later is the recombiner).
   void _set_filtered_elements(const PseudoJet & jet,
                               std::vector<PseudoJet> & filtered_elements,
                               JetDefinition & subjet_def,
                               bool & discard_area) const;
+  ///
+  /// this returns true if teh optimisation trick for C/A reclustering has been used
+  bool _set_filtered_elements(const PseudoJet & jet,
+                              std::vector<PseudoJet> & filtered_elements) const;
-  /// set the filtered elements in the simple case of C/A+C/A
-  void _set_filtered_elements_cafilt(const PseudoJet & jet,
-                                     std::vector<PseudoJet> & filtered_elements,
-                                     double Rfilt) const;
-  /// set the filtered elements in the generic re-clustering case
-  void _set_filtered_elements_generic(const PseudoJet & jet,
-                                      std::vector<PseudoJet> & filtered_elements,
-                                      const JetDefinition & subjet_def,
-                                      bool do_areas) const;
   /// gather the information about what is kept and rejected under the
   /// form of a PseudoJet with a special ClusterSequenceInfo
+  ///
+  /// The last argument (ca_optimisation_used) should be true if the
+  /// optimisation trick for C/A reclustering has been used (in which
+  /// case some extra tests have to be run for non-explicit-ghost
+  /// areas)
   PseudoJet _finalise(const PseudoJet & jet,
                       std::vector<PseudoJet> & kept,
                       std::vector<PseudoJet> & rejected,
+                      const JetDefinition & subjet_def,
+                      const bool discard_area) const;
+  // a series of checks
+  //--------------------------------------------------------------------
+  /// get the pieces down to the fundamental pieces
+  bool _get_all_pieces(const PseudoJet &jet, std::vector<PseudoJet> &all_pieces) const;
+  /// get the common recombiner to all pieces (NULL if none)
+  const JetDefinition::Recombiner* _get_common_recombiner(const std::vector<PseudoJet> &all_pieces) const;
+  /// check if one can apply the simplified trick for C/A subjets
+  bool _check_ca(const std::vector<PseudoJet> &all_pieces) const;
+  /// check if the jet (or all its pieces) have explicit ghosts
+  /// (assuming the jet has area support
+  ///
+  /// Note that if the jet has an associated cluster sequence that is no
+  /// longer valid, an error will be thrown
+  bool _check_explicit_ghosts(const std::vector<PseudoJet> &all_pieces) const;
+                      bool ca_optimisation_used) const;
   bool _uses_subtraction() const {return (_subtractor || _rho != 0);}
 …
   Selector _selector;  ///< the subjet selection criterium
   double _rho;                 ///< the background density (used for subtraction when possible)
+  const Transformer * _subtractor; ///< for subtracting bkgd density from subjets
+  const FunctionOfPseudoJet<PseudoJet> * _subtractor; ///< for subtracting bkgd density from subjets
+  bool _initialised;    ///< true when the Filter has been properly intialised
 };

external/fastjet/tools/GridMedianBackgroundEstimator.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+//FJSTARTHEADER
+// $Id: GridMedianBackgroundEstimator.cc 3555 2014-08-11 09:56:35Z salam $
+//
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 …
 FASTJET_BEGIN_NAMESPACE      // defined in fastjet/internal/base.hh
 //----------------------------------------------------------------------
 …
 // of the specified particles.
 void GridMedianBackgroundEstimator::set_particles(const vector<PseudoJet> & particles) {
+  fill(_scalar_pt.begin(), _scalar_pt.end(), 0.0);
+  for (unsigned i = 0; i < particles.size(); i++) {
+    int j = igrid(particles[i]);
+    if (j >= 0){
+      if (_rescaling_class == 0)
+        _scalar_pt[j] += particles[i].perp();
+      else
+        _scalar_pt[j] += particles[i].perp()/(*_rescaling_class)(particles[i]);
+  vector<double> scalar_pt(n_tiles(), 0.0);
+#ifdef FASTJET_GMBGE_USEFJGRID
+  assert(all_tiles_equal_area());
+  //assert(n_good_tiles() == n_tiles()); // not needed now that we have an implementation
+#endif
+  // check if we need to compute only rho or both rho and rho_m
+  if (_enable_rho_m){
+    // both rho and rho_m
+    //
+    // this requires a few other variables
+    vector<double> scalar_dt(n_tiles(), 0.0);
+    double pt, dt;
+    for (unsigned i = 0; i < particles.size(); i++) {
+      int j = tile_index(particles[i]);
+      if (j >= 0){
+        pt = particles[i].pt();
+        dt = particles[i].mt() - pt;
+        if (_rescaling_class == 0){
+          scalar_pt[j] += pt;
+          scalar_dt[j] += dt;
+        } else {
+          double r = (*_rescaling_class)(particles[i]);
+          scalar_pt[j] += pt/r;
+          scalar_dt[j] += dt/r;
+        }
+      }
+    }
+    // sort things for _percentile
+    sort(scalar_dt.begin(), scalar_dt.end());
+    // compute rho_m and sigma_m (see comment below for the
+    // normaliosation of sigma)
+    double p50 = _percentile(scalar_dt, 0.5);
+    _rho_m   = p50 / mean_tile_area();
+    _sigma_m = (p50-_percentile(scalar_dt, (1.0-0.6827)/2.0))/sqrt(mean_tile_area());
+  } else {
+    // only rho
+    //fill(_scalar_pt.begin(), _scalar_pt.end(), 0.0);
+    for (unsigned i = 0; i < particles.size(); i++) {
+      int j = tile_index(particles[i]);
+      if (j >= 0){
+        if (_rescaling_class == 0){
+          scalar_pt[j] += particles[i].pt();
+        } else {
+          scalar_pt[j] += particles[i].pt()/(*_rescaling_class)(particles[i]);
+        }
+      }
+    }
+  }
+  sort(_scalar_pt.begin(), _scalar_pt.end());
+  // if there are some "bad" tiles, then we need to exclude them from
+  // the calculation of the median. We'll do this by condensing the
+  // scalar_pt vector down to just the values for the tiles that are
+  // good.
+  //
+  // tested answers look right in "issue" 2014-08-08-testing-rect-grid
+  if (n_good_tiles() != n_tiles()) {
+    int newn = 0;
+    for (unsigned i = 0; i < scalar_pt.size(); i++) {
+      if (tile_is_good(i)) {
+        // clang gets confused with the SharedPtr swap if we don't
+        // have std:: here
+        std::swap(scalar_pt[i],scalar_pt[newn]);
+        newn++;
+      }
+    }
+    scalar_pt.resize(newn);
+  }
+  // in all cases, carry on with the computation of rho
+  //
+  // first sort
+  sort(scalar_pt.begin(), scalar_pt.end());
+  // then compute rho
+  //
+  // watch out: by definition, our sigma is the standard deviation of
+  // the pt density multiplied by the square root of the cell area
+  double p50 = _percentile(scalar_pt, 0.5);
+  _rho   = p50 / mean_tile_area();
+  _sigma = (p50-_percentile(scalar_pt, (1.0-0.6827)/2.0))/sqrt(mean_tile_area());
   _has_particles = true;
 …
 double GridMedianBackgroundEstimator::rho() const {
   verify_particles_set();
   return _percentile(_scalar_pt, 0.5) / _cell_area;
+  return _rho;
+}
 …
 double GridMedianBackgroundEstimator::sigma() const{
   verify_particles_set();
+  // watch out: by definition, our sigma is the standard deviation of
+  // the pt density multiplied by the square root of the cell area
+  return (_percentile(_scalar_pt, 0.5) -
+          _percentile(_scalar_pt, (1.0-0.6827)/2.0)
+          )/sqrt(_cell_area);
+  return _sigma;
+}
 …
 // determination.
 double GridMedianBackgroundEstimator::rho(const PseudoJet & jet)  {
   verify_particles_set();
+  //verify_particles_set();
   double rescaling = (_rescaling_class == 0) ? 1.0 : (*_rescaling_class)(jet);
   return rescaling*rho();
 …
 // the position of a given jet. As for rho(jet), it is non-const.
 double GridMedianBackgroundEstimator::sigma(const PseudoJet & jet){
   verify_particles_set();
+  //verify_particles_set();
   double rescaling = (_rescaling_class == 0) ? 1.0 : (*_rescaling_class)(jet);
   return rescaling*sigma();
+}
+//----------------------------------------------------------------------
+// returns rho_m (particle-masses contribution to the 4-vector density)
+double GridMedianBackgroundEstimator::rho_m() const {
+  if (! _enable_rho_m){
+    throw Error("GridMediamBackgroundEstimator: rho_m requested but rho_m calculation has been disabled.");
+  }
+  verify_particles_set();
+  return _rho_m;
+}
+//----------------------------------------------------------------------
+// returns sigma_m (particle-masses contribution to the 4-vector
+// density); must be multipled by sqrt(area) to get fluctuations
+// for a region of a given area.
+double GridMedianBackgroundEstimator::sigma_m() const{
+  if (! _enable_rho_m){
+    throw Error("GridMediamBackgroundEstimator: sigma_m requested but rho_m/sigma_m calculation has been disabled.");
+  }
+  verify_particles_set();
+  return _sigma_m;
+}
+//----------------------------------------------------------------------
+// returns rho_m locally at the position of a given jet. As for
+// rho(jet), it is non-const.
+double GridMedianBackgroundEstimator::rho_m(const PseudoJet & jet)  {
+  //verify_particles_set();
+  double rescaling = (_rescaling_class == 0) ? 1.0 : (*_rescaling_class)(jet);
+  return rescaling*rho_m();
+}
+//----------------------------------------------------------------------
+// returns sigma_m locally at the position of a given jet. As for
+// rho(jet), it is non-const.
+double GridMedianBackgroundEstimator::sigma_m(const PseudoJet & jet){
+  //verify_particles_set();
+  double rescaling = (_rescaling_class == 0) ? 1.0 : (*_rescaling_class)(jet);
+  return rescaling*sigma_m();
+}
 …
 string GridMedianBackgroundEstimator::description() const {
   ostringstream desc;
+#ifdef FASTJET_GMBGE_USEFJGRID
+  desc << "GridMedianBackgroundEstimator, with " << RectangularGrid::description();
+#else
   desc << "GridMedianBackgroundEstimator, with grid extension |y| < " << _ymax
+       << " and requested grid spacing = " << _requested_grid_spacing;
+       << ", and grid cells of size dy x dphi = " << _dy << " x " << _dphi
+       << " (requested size = " << _requested_grid_spacing << ")";
+#endif
   return desc.str();
+}
 …
+#ifndef FASTJET_GMBGE_USEFJGRID
 //----------------------------------------------------------------------
 // protected material
 …
   _ntotal = _nphi * _ny;
   _scalar_pt.resize(_ntotal);
   _cell_area = _dy * _dphi;
+}
 //----------------------------------------------------------------------
 // retrieve the grid cell index for a given PseudoJet
 int GridMedianBackgroundEstimator::igrid(const PseudoJet & p) const {
+  //_scalar_pt.resize(_ntotal);
+  _tile_area = _dy * _dphi;
+}
+//----------------------------------------------------------------------
+// retrieve the grid tile index for a given PseudoJet
+int GridMedianBackgroundEstimator::tile_index(const PseudoJet & p) const {
   // directly taking int does not work for values between -1 and 0
   // so use floor instead
 …
   if (iphi == _nphi) iphi = 0; // just in case of rounding errors
+  int igrid_res = iy*_nphi + iphi;
+  assert (igrid_res >= 0 && igrid_res < _ny*_nphi);
+  return igrid_res;
+}
+  int index_res = iy*_nphi + iphi;
+  assert (index_res >= 0 && index_res < _ny*_nphi);
+  return index_res;
+}
+#endif // FASTJET_GMBGE_USEFJGRID

external/fastjet/tools/GridMedianBackgroundEstimator.hh

-              rf6b6ee7
+              r49234af
 #define __GRID_MEDIAN_BACKGROUND_ESTIMATOR_HH__
 //STARTHEADER
 // $Id: GridMedianBackgroundEstimator.hh 2580 2011-09-13 17:25:43Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+//FJSTARTHEADER
+// $Id: GridMedianBackgroundEstimator.hh 3610 2014-08-13 09:49:28Z salam $
+//
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include "fastjet/tools/BackgroundEstimatorBase.hh"
+// if defined then we'll use the RectangularGrid class
+//
+// (For FastJet 3.2, maybe remove the symbol and simply clean up the
+// code below to use exclusively the RectangularGrid)
+#define FASTJET_GMBGE_USEFJGRID
+#ifdef FASTJET_GMBGE_USEFJGRID
+#include "fastjet/RectangularGrid.hh"
+#endif
 FASTJET_BEGIN_NAMESPACE      // defined in fastjet/internal/base.hh
 …
 ///   rho() [Without rescaling, they are identical]
 ///
+class GridMedianBackgroundEstimator : public BackgroundEstimatorBase {
+class GridMedianBackgroundEstimator : public BackgroundEstimatorBase
+#ifdef FASTJET_GMBGE_USEFJGRID
+                                                                    , RectangularGrid
+#endif
+{
 public:
   /// @name  constructors and destructors
   //\{
+#ifdef FASTJET_GMBGE_USEFJGRID
   //----------------------------------------------------------------
   ///   \param ymax   maximal absolute rapidity extent of the grid
 …
   ///             periodicity in azimuthal angle (size, not area)
   GridMedianBackgroundEstimator(double ymax, double requested_grid_spacing) :
+    RectangularGrid(ymax, requested_grid_spacing),
+    _has_particles(false), _enable_rho_m(true) {}
+  //----------------------------------------------------------------
+  /// Constructor based on a user's fully specified RectangularGrid
+  GridMedianBackgroundEstimator(const RectangularGrid & grid) :
+    RectangularGrid(grid),
+    _has_particles(false), _enable_rho_m(true) {
+    if (!RectangularGrid::is_initialised())
+      throw Error("attempt to construct GridMedianBackgroundEstimator with uninitialised RectangularGrid");
+  }
+#else  // alternative in old framework where we didn't have the rectangular grid
+  GridMedianBackgroundEstimator(double ymax, double requested_grid_spacing) :
     _ymin(-ymax), _ymax(ymax),
     _requested_grid_spacing(requested_grid_spacing),
+    _has_particles(false){setup_grid();}
+    _has_particles(false), _enable_rho_m(true)
+  {
+     setup_grid();
+  }
+#endif // FASTJET_GMBGE_USEFJGRID
   //\}
 …
   /// of the specified particles.
   void set_particles(const std::vector<PseudoJet> & particles);
+  /// determine whether the automatic calculation of rho_m and sigma_m
+  /// is enabled (by default true)
+  void set_compute_rho_m(bool enable){ _enable_rho_m = enable;}
   //\}
 …
   bool has_sigma() {return true;}
+  //-----------------------------------------------------------------
+  /// Returns rho_m, the purely longitudinal, particle-mass-induced
+  /// component of the background density per unit area
+  double rho_m() const;
+  /// returns sigma_m, a measure of the fluctuations in the purely
+  /// longitudinal, particle-mass-induced component of the background
+  /// density per unit area; must be multipled by sqrt(area) to get
+  /// fluctuations for a region of a given area.
+  double sigma_m() const;
+  /// Returns rho_m locally at the jet position. As for rho(jet), it is non-const.
+  double rho_m(const PseudoJet & jet);
+  /// Returns sigma_m locally at the jet position. As for rho(jet), it is non-const.
+  double sigma_m(const PseudoJet & jet);
+  /// Returns true if this background estimator has support for
+  /// determination of rho_m.
+  ///
+  /// Note that support for sigma_m is automatic is one has sigma and
+  /// rho_m support.
+  bool has_rho_m() const {return _enable_rho_m;}
   /// returns the area of the grid cells (all identical, but
   /// referred to as "mean" area for uniformity with JetMedianBGE).
   double mean_area() const {return _cell_area;}
+  double mean_area() const {return mean_tile_area();}
   //\}
 …
   /// Note that this has to be called BEFORE any attempt to do an
   /// actual computation
+  ///
+  /// The same profile will be used for both pt and mt (this is
+  /// probabaly a good approximation since the particle density
+  /// changes is what dominates the rapidity profile)
   virtual void set_rescaling_class(const FunctionOfPseudoJet<double> * rescaling_class);
 …
 private:
+#ifndef FASTJET_GMBGE_USEFJGRID
   /// configure the grid
   void setup_grid();
   /// retrieve the grid cell index for a given PseudoJet
+  int igrid(const PseudoJet & p) const;
+  int tile_index(const PseudoJet & p) const;
+  // information about the grid
+  double _ymin, _ymax, _dy, _dphi, _requested_grid_spacing, _tile_area;
+  int _ny, _nphi, _ntotal;
+  int n_tiles() const {return _ntotal;}
+  int n_good_tiles() const {return n_tiles();}
+  int tile_is_good(int /* itile */) const {return true;}
+  double mean_tile_area() const {return _tile_area;}
+#endif // FASTJET_GMBGE_USEFJGRID
   /// verify that particles have been set and throw an error if not
   void verify_particles_set() const;
-  // information about the grid
-  double _ymin, _ymax, _dy, _dphi, _requested_grid_spacing, _cell_area;
-  int _ny, _nphi, _ntotal;
   // information abotu the event
+  std::vector<double> _scalar_pt;
+  //std::vector<double> _scalar_pt;
+  double _rho, _sigma, _rho_m, _sigma_m;
   bool _has_particles;
+  // various warnings to let people aware of potential dangers
+  bool _enable_rho_m;
+  // various warnings to inform people of potential dangers
   LimitedWarning _warning_rho_of_jet;
   LimitedWarning _warning_rescaling;

external/fastjet/tools/JHTopTagger.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
+//FJSTARTHEADER
+// $Id: JHTopTagger.cc 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include <fastjet/tools/JHTopTagger.hh>

external/fastjet/tools/JHTopTagger.hh

-              rf6b6ee7
+              r49234af
 #define __FASTJET_JH_TOP_TAGGER_HH__
 //STARTHEADER
 // $Id: JHTopTagger.hh 2689 2011-11-14 14:51:06Z soyez $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+//FJSTARTHEADER
+// $Id: JHTopTagger.hh 3433 2014-07-23 08:17:03Z salam $
+//
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER

external/fastjet/tools/JetMedianBackgroundEstimator.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+//FJSTARTHEADER
+// $Id: JetMedianBackgroundEstimator.cc 3517 2014-08-01 14:23:13Z soyez $
+//
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include "fastjet/tools/JetMedianBackgroundEstimator.hh"
 …
 #include <fastjet/ClusterSequenceStructure.hh>
 #include <iostream>
+#include <sstream>
 FASTJET_BEGIN_NAMESPACE     // defined in fastjet/internal/base.hh
 …
 double BackgroundJetScalarPtDensity::result(const PseudoJet & jet) const {
+  std::vector<PseudoJet> constituents = jet.constituents();
+  // do not include the ghosts in the list of constituents to have a
+  // correct behaviour when _pt_power is <= 0
+  std::vector<PseudoJet> constituents = (!SelectorIsPureGhost())(jet.constituents());
   double scalar_pt = 0;
   for (unsigned i = 0; i < constituents.size(); i++) {
 …
+  }
   return scalar_pt / jet.area();
+}
+std::string BackgroundJetScalarPtDensity::description() const {
+  ostringstream oss;
+  oss << "BackgroundScalarJetPtDensity";
+  if (_pt_power != 1.0) oss << " with pt_power = " << _pt_power;
+  return oss.str();
+}
 …
                                          const JetDefinition &jet_def,
                                          const AreaDefinition &area_def)
   : _rho_range(rho_range), _jet_def(jet_def), _area_def(area_def) {
+  : _rho_range(rho_range), _jet_def(jet_def), _area_def(area_def){
   // initialise things decently
 …
 //----------------------------------------------------------------------
+// returns rho_m (particle-masses contribution to the 4-vector density)
+double JetMedianBackgroundEstimator::rho_m() const {
+  if (! has_rho_m()){
+    throw Error("JetMediamBackgroundEstimator: rho_m requested but rho_m calculation is disabled (either eplicitly or due to the presence of a jet density class).");
+  }
+  if (_rho_range.takes_reference())
+    throw Error("The background estimation is obtained from a selector that takes a reference jet. rho(PseudoJet) should be used in that case");
+  _recompute_if_needed();
+  return _rho_m;
+}
+//----------------------------------------------------------------------
+// returns sigma_m (particle-masses contribution to the 4-vector
+// density); must be multipled by sqrt(area) to get fluctuations
+// for a region of a given area.
+double JetMedianBackgroundEstimator::sigma_m() const{
+  if (! has_rho_m()){
+    throw Error("JetMediamBackgroundEstimator: sigma_m requested but rho_m/sigma_m calculation is disabled (either explicitly or due to the presence of a jet density class).");
+  }
+  if (_rho_range.takes_reference())
+    throw Error("The background estimation is obtained from a selector that takes a reference jet. rho(PseudoJet) should be used in that case");
+  _recompute_if_needed();
+  return _sigma_m;
+}
+//----------------------------------------------------------------------
+// returns rho_m locally at the position of a given jet. As for
+// rho(jet), it is non-const.
+double JetMedianBackgroundEstimator::rho_m(const PseudoJet & jet)  {
+  _recompute_if_needed(jet);
+  double our_rho = _rho_m;
+  if (_rescaling_class != 0) {
+    our_rho *= (*_rescaling_class)(jet);
+  }
+  return our_rho;
+}
+//----------------------------------------------------------------------
+// returns sigma_m locally at the position of a given jet. As for
+// rho(jet), it is non-const.
+double JetMedianBackgroundEstimator::sigma_m(const PseudoJet & jet){
+  _recompute_if_needed(jet);
+  double our_sigma = _sigma_m;
+  if (_rescaling_class != 0) {
+    our_sigma *= (*_rescaling_class)(jet);
+  }
+  return our_sigma;
+}
+//----------------------------------------------------------------------
 // configuring behaviour
 //----------------------------------------------------------------------
 …
   set_provide_fj2_sigma(false);
+  _enable_rho_m = true;
   // reset the computed values
   _rho = _sigma = 0.0;
+  _rho_m = _sigma_m = 0.0;
   _n_jets_used = _n_empty_jets = 0;
   _empty_area = _mean_area = 0.0;
 …
 // is used (as occurs also if this function is not called).
 void JetMedianBackgroundEstimator::set_jet_density_class(const FunctionOfPseudoJet<double> * jet_density_class_in) {
   _warnings_preliminary.warn("JetMedianBackgroundEstimator::set_jet_density_class: density classes are still preliminary in FastJet 3.0. Their interface may differ in future releases (without guaranteeing backward compatibility).");
+  _warnings_preliminary.warn("JetMedianBackgroundEstimator::set_jet_density_class: density classes are still preliminary in FastJet 3.1. Their interface may differ in future releases (without guaranteeing backward compatibility). Note that since FastJet 3.1, rho_m and sigma_m are accessible direclty in JetMedianBackgroundEstimator and GridMedianBackgroundEstimator(with no need for a density class).");
   _jet_density_class = jet_density_class_in;
   _uptodate = false;
 …
   // fill the vector of pt/area (or the quantity from the jet density class)
   //  - in the range
+  vector<double> vector_for_median;
+  vector<double> vector_for_median_pt;
+  vector<double> vector_for_median_dt;
   double total_area  = 0.0;
   _n_jets_used = 0;
 …
   // compute the pt/area for the selected jets
+  double median_input_pt, median_input_dt=0.0;
+  BackgroundJetPtMDensity m_density;
+  bool do_rho_m = has_rho_m();
   for (unsigned i = 0; i < selected_jets.size(); i++) {
     const PseudoJet & current_jet = selected_jets[i];
     double this_area = (_use_area_4vector) ? current_jet.area_4vector().perp() : current_jet.area();
     if (this_area>0){
+      double median_input;
+      // for the pt component, we either use pt or the user-provided
+      // density class
       if (_jet_density_class == 0) {
         median_input = current_jet.perp()/this_area;
+        median_input_pt = current_jet.perp()/this_area;
       } else {
         median_input = (*_jet_density_class)(current_jet);
+        median_input_pt = (*_jet_density_class)(current_jet);
+      }
+      // handle the rho_m part if requested
+      // note that we're using the scalar area as a normalisation inside the
+      // density class!
+      if (do_rho_m)
+        median_input_dt = m_density(current_jet);
+      // perform rescaling if needed
       if (_rescaling_class != 0) {
+        median_input /= (*_rescaling_class)(current_jet);
+        double resc = (*_rescaling_class)(current_jet);;
+        median_input_pt /= resc;
+        median_input_dt /= resc;
+      }
+      vector_for_median.push_back(median_input);
+      // store the result for future computation of the median
+      vector_for_median_pt.push_back(median_input_pt);
+      if (do_rho_m)
+        vector_for_median_dt.push_back(median_input_dt);
       total_area  += this_area;
       _n_jets_used++;
 …
       _warnings_zero_area.warn("JetMedianBackgroundEstimator::_compute(...): discarded jet with zero area. Zero-area jets may be due to (i) too large a ghost area (ii) a jet being outside the ghost range (iii) the computation not being done using an appropriate algorithm (kt;C/A).");
+    }
+  }
   // there is nothing inside our region, so answer will always be zero
   if (vector_for_median.size() == 0) {
+  if (vector_for_median_pt.size() == 0) {
     _rho        = 0.0;
     _sigma      = 0.0;
+    _rho_m      = 0.0;
+    _sigma_m    = 0.0;
     _mean_area  = 0.0;
     return;
 …
   double stand_dev;
   _median_and_stddev(vector_for_median, _n_empty_jets, _rho, stand_dev,
+  _median_and_stddev(vector_for_median_pt, _n_empty_jets, _rho, stand_dev,
                      _provide_fj2_sigma);
 …
   _mean_area  = total_area / total_njets;
   _sigma      = stand_dev * sqrt(_mean_area);
+  // compute the rho_m part now
+  if (do_rho_m){
+    _median_and_stddev(vector_for_median_dt, _n_empty_jets, _rho_m, stand_dev,
+                       _provide_fj2_sigma);
+    _sigma_m = stand_dev * sqrt(_mean_area);
+  }
   // record that the computation has been performed
 …
 FASTJET_END_NAMESPACE

external/fastjet/tools/JetMedianBackgroundEstimator.hh

-              rf6b6ee7
+              r49234af
 #define __FASTJET_BACKGROUND_ESTIMATOR_HH__
 //STARTHEADER
 // $Id: JetMedianBackgroundEstimator.hh 2689 2011-11-14 14:51:06Z soyez $
+//FJSTARTHEADER
+// $Id: JetMedianBackgroundEstimator.hh 3517 2014-08-01 14:23:13Z soyez $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include <fastjet/ClusterSequenceAreaBase.hh>
 …
   ///
   JetMedianBackgroundEstimator(const Selector &rho_range = SelectorIdentity())
+    : _rho_range(rho_range), _jet_def(JetDefinition()) { reset(); }
+    : _rho_range(rho_range), _jet_def(JetDefinition()),
+      _enable_rho_m(true){ reset(); }
 …
+  }
+  /// determine whether the automatic calculation of rho_m and sigma_m
+  /// is enabled (by default true)
+  void set_compute_rho_m(bool enable){ _enable_rho_m = enable;}
   //\}
 …
   virtual bool has_sigma() {return true;}
+  //----------------------------------------------------------------
+  // now do the same thing for rho_m and sigma_m
+  /// returns rho_m, the purely longitudinal, particle-mass-induced
+  /// component of the background density per unit area
+  virtual double rho_m() const;
+  /// returns sigma_m, a measure of the fluctuations in the purely
+  /// longitudinal, particle-mass-induced component of the background
+  /// density per unit area; must be multipled by sqrt(area) to get
+  /// fluctuations for a region of a given area.
+  virtual double sigma_m() const;
+  /// Returns rho_m locally at the jet position. As for rho(jet), it is non-const.
+  virtual double rho_m(const PseudoJet & /*jet*/);
+  /// Returns sigma_m locally at the jet position. As for rho(jet), it is non-const.
+  virtual double sigma_m(const PseudoJet & /*jet*/);
+  /// Returns true if this background estimator has support for
+  /// determination of rho_m.
+  ///
+  /// In te presence of a density class, support for rho_m is
+  /// automatically disabled
+  ///
+  /// Note that support for sigma_m is automatic is one has sigma and
+  /// rho_m support.
+  virtual bool has_rho_m() const {return _enable_rho_m && (_jet_density_class == 0);}
   //\}
 …
   /// Returns the mean area of the jets used to actually compute the
   /// background properties in the last call of rho() or sigma()
+  /// If the configuration has changed in the meantime, throw an error.
   double mean_area() const{
+    _recompute_if_needed();
+    if (!_uptodate)
+      throw Error("JetMedianBackgroundEstimator::mean_area(): one may not retrieve information about the last call to rho() or sigma() when the configuration has changed in the meantime.");
+    //_recompute_if_needed();
     return _mean_area;
+  }
 …
   /// returns the number of jets used to actually compute the
   /// background properties in the last call of rho() or sigma()
+  /// If the configuration has changed in the meantime, throw an error.
   unsigned int n_jets_used() const{
+    _recompute_if_needed();
+    if (!_uptodate)
+      throw Error("JetMedianBackgroundEstimator::n_jets_used(): one may not retrieve information about the last call to rho() or sigma() when the configuration has changed in the meantime.");
+    //_recompute_if_needed();
     return _n_jets_used;
+  }
+  /// returns the jets used to actually compute the background
+  /// properties
+  std::vector<PseudoJet> jets_used() const{
+    if (!_uptodate) throw Error("JetMedianBackgroundEstimator::n_jets_used(): one may not retrieve information about the last call to rho() or sigma() when the configuration has changed in the meantime.");
+    _check_csa_alive();
+    std::vector<PseudoJet> tmp_jets = _rho_range(_included_jets);
+    std::vector<PseudoJet> used_jets;
+    for (unsigned int i=0; i<tmp_jets.size(); i++){
+      if (tmp_jets[i].area()>0) used_jets.push_back(tmp_jets[i]);
+    }
+    return used_jets;
+  }
 …
   /// the selector) that is not occupied by jets. The value is that
   /// for the last call of rho() or sigma()
+  /// If the configuration has changed in the meantime, throw an error.
   ///
   /// The answer is defined to be zero if the area calculation
 …
   /// call to the ClusterSequenceAreaBase function.
   double empty_area() const{
+    _recompute_if_needed();
+    if (!_uptodate)
+      throw Error("JetMedianBackgroundEstimator::empty_area(): one may not retrieve information about the last call to rho() or sigma() when the configuration has changed in the meantime.");
+    //_recompute_if_needed();
     return _empty_area;
+  }
 …
   /// background properties. The value is that for the last call of
   /// rho() or sigma().
+  /// If the configuration has changed in the meantime, throw an error.
   ///
   /// If the area has explicit ghosts the result is zero; for active
 …
   /// call to the ClusterSequenceAreaBase function.
   double n_empty_jets() const{
+    _recompute_if_needed();
+    if (!_uptodate)
+      throw Error("JetMedianBackgroundEstimator::n_empty_jets(): one may not retrieve information about the last call to rho() or sigma() when the configuration has changed in the meantime.");
+    //_recompute_if_needed();
     return _n_empty_jets;
+  }
 …
   /// Issue a warning otherwise
   void _check_jet_alg_good_for_median() const;
   // the basic parameters of this class (passed through the variou ctors)
   Selector _rho_range;                   ///< range to compute the background in
 …
   std::vector<PseudoJet> _included_jets; ///< jets to be used
   // the tunable aprameters of the class
+  // the tunable parameters of the class
   bool _use_area_4vector;
   bool _provide_fj2_sigma;
   const FunctionOfPseudoJet<double> * _jet_density_class;
   //SharedPtr<BackgroundRescalingBase> _rescaling_class_sharedptr;
+  bool _enable_rho_m;
   // the actual results of the computation
   mutable double _rho;               ///< background estimated density per unit area
   mutable double _sigma;             ///< background estimated fluctuations
+  mutable double _rho_m;             ///< "mass" background estimated density per unit area
+  mutable double _sigma_m;           ///< "mass" background estimated fluctuations
   mutable double _mean_area;         ///< mean area of the jets used to estimate the background
   mutable unsigned int _n_jets_used; ///< number of jets used to estimate the background
 …
   virtual double result(const PseudoJet & jet) const;
   virtual std::string description() const {return "BackgroundScalarJetPtDensity";}
+  virtual std::string description() const;
 private:

external/fastjet/tools/MassDropTagger.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
+//FJSTARTHEADER
+// $Id: MassDropTagger.cc 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include <fastjet/tools/MassDropTagger.hh>

external/fastjet/tools/MassDropTagger.hh

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id: MassDropTagger.hh 2731 2011-11-21 12:15:21Z soyez $
+//FJSTARTHEADER
+// $Id: MassDropTagger.hh 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #ifndef __FASTJET_MASS_DROP_TAGGER_HH__

external/fastjet/tools/Pruner.cc

-              rf6b6ee7
+              r49234af
 //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
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include "fastjet/tools/Pruner.hh"
 …
 //----------------------------------------------------------------------
 // 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)  {
 …
   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);
 …
   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));
 …
+}
+// 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;
+}

external/fastjet/tools/Pruner.hh

-              rf6b6ee7
+              r49234af
 #define __FASTJET_TOOLS_PRUNER_HH__
 //STARTHEADER
 // $Id: Pruner.hh 2616 2011-09-30 18:03:40Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+//FJSTARTHEADER
+// $Id: Pruner.hh 3481 2014-07-29 17:24:12Z soyez $
+//
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include "fastjet/ClusterSequence.hh"
 …
 class PruningRecombiner;
 class PruningPlugin;
+// This tells third-party code that the pruner structure
+// stores Rcut info; the alternative is for the user to
+// get the information from the version number
+#define FASTJET_PRUNER_STRUCTURE_STORES_RCUT
 //----------------------------------------------------------------------
 …
   ///  \param Rcut_dyn    dynamic angular distance cut in the pruning
   Pruner(const JetDefinition &jet_def,
          FunctionOfPseudoJet<double> *zcut_dyn,
          FunctionOfPseudoJet<double> *Rcut_dyn);
+         const FunctionOfPseudoJet<double> *zcut_dyn,
+         const FunctionOfPseudoJet<double> *Rcut_dyn);
   /// action on a single jet
 …
   bool _check_explicit_ghosts(const PseudoJet &jet) const;
+  /// return a pointer to a "common" recombiner if there is one,
+  /// alternatively a null pointer.
+  const JetDefinition::Recombiner * _get_common_recombiner(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 _zcut;           ///< the pt-fraction cut
   double _Rcut_factor;    ///< the angular separation cut factor
   FunctionOfPseudoJet<double> *_zcut_dyn; ///< dynamic zcut
   FunctionOfPseudoJet<double> *_Rcut_dyn; ///< dynamic Rcut
+  const FunctionOfPseudoJet<double> *_zcut_dyn; ///< dynamic zcut
+  const FunctionOfPseudoJet<double> *_Rcut_dyn; ///< dynamic Rcut
   bool   _get_recombiner_from_jet; ///< true for minimal constructor,
                                    ///< causes recombiner to be set equal
 …
   std::vector<PseudoJet> extra_jets() const;
+  /// return the value of Rcut that was used for this specific pruning.
+  double Rcut() const {return _Rcut;}
+  /// return the value of Rcut that was used for this specific pruning.
+  double zcut() const {return _zcut;}
 protected:
   friend class Pruner; ///< to allow setting the internal information
+private:
+  double _Rcut, _zcut;
 };

external/fastjet/tools/RestFrameNSubjettinessTagger.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
+//FJSTARTHEADER
+// $Id: RestFrameNSubjettinessTagger.cc 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include <fastjet/tools/RestFrameNSubjettinessTagger.hh>

external/fastjet/tools/RestFrameNSubjettinessTagger.hh

-              rf6b6ee7
+              r49234af
 #define __FASTJET_RESTFRAMENSUBJETTINESS_TAGGER_HH__
 //STARTHEADER
 // $Id: RestFrameNSubjettinessTagger.hh 2689 2011-11-14 14:51:06Z soyez $
+//FJSTARTHEADER
+// $Id: RestFrameNSubjettinessTagger.hh 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include <fastjet/PseudoJet.hh>

external/fastjet/tools/Subtractor.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+//FJSTARTHEADER
+// $Id: Subtractor.cc 3670 2014-09-08 14:17:59Z soyez $
+//
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include "fastjet/tools/Subtractor.hh"
 …
+//----------------------------------------------------------------------
+// ctor
 Subtractor::Subtractor(double rho) : _bge(0), _rho(rho) {
+  assert(_rho>0.0);
+}
+  if (_rho<0.0) throw Error("Subtractor(rho) was passed a negative rho value; rho should be >= 0");
+  set_defaults();
+}
+//----------------------------------------------------------------------
+// ctor
+Subtractor::Subtractor(double rho, double rho_m) : _bge(0), _rho(rho) {
+  if (_rho<0.0) throw Error("Subtractor(rho, rho_m) was passed a negative rho value; rho should be >= 0");
+  if (rho_m<0.0) throw Error("Subtractor(rho, rho_m) was passed a negative rho_m value; rho_m should be >= 0");
+  set_defaults();
+  _rho_m = rho_m;
+  set_use_rho_m(true);
+}
+//----------------------------------------------------------------------
+void Subtractor::set_defaults(){
+  _rho_m = _invalid_rho;
+  _use_rho_m = false; // likely to change in future releases!!
+  _safe_mass = false; // likely to change in future releases!!
+  _sel_known_vertex = Selector();
+  _sel_leading_vertex = Selector();
+}
+//----------------------------------------------------------------------
+// perform the subtraction of a given jet
 PseudoJet Subtractor::result(const PseudoJet & jet) const {
   if (!jet.has_area()){
+    throw Error("Trying to subtract a jet without area support");
+  }
+    throw Error("Subtractor::result(...): Trying to subtract a jet without area support");
+  }
+  PseudoJet known_lv, known_pu;
+  PseudoJet unknown = jet;
+  if (_sel_known_vertex.worker()){
+    // separate the jet constituents in 3 groups:
+    //   unknown vertex
+    //   known vertex, leading vertex
+    //   known vertex, non-leading vertex (PU)
+    vector<PseudoJet> constits_unknown, constits_known;
+    _sel_known_vertex.sift(jet.constituents(),
+                           constits_known,
+                           constits_unknown);
+    vector<PseudoJet> constits_known_lv, constits_known_pu;
+    _sel_leading_vertex.sift(constits_known,
+                             constits_known_lv,
+                             constits_known_pu);
+    // For the parts related to the known vertices (LV or PU), we just
+    // sum the 4-momenta. For the unknown part, we assign it the full
+    // jet area.
+    known_lv = (constits_known_lv.size()!=0)
+      ? SelectorIdentity().sum(constits_known_lv) : 0.0*jet;
+    known_pu = (constits_known_pu.size()!=0)
+      ? SelectorIdentity().sum(constits_known_pu) : 0.0*jet;
+    if (constits_unknown.size()==0){
+      // no need for any form of subtraction!
+      PseudoJet subtracted_jet = jet;
+      subtracted_jet.reset_momentum(known_lv);
+      return subtracted_jet;
+    }
+    unknown = jet; // that keeps all info including area
+    unknown.reset_momentum(SelectorIdentity().sum(constits_unknown));
+  } else {
+    known_lv = jet; // ensures correct rap-phi!
+    known_lv *= 0.0;
+    known_pu = known_lv;
+  }
+  // prepare for the subtraction and compute the 4-vector to be
+  // subtracted
+  PseudoJet subtracted_jet = jet;
+  PseudoJet to_subtract = known_pu + _amount_to_subtract(unknown);
+  // sanity check for the transverse momentum
+  if (to_subtract.pt2() < jet.pt2() ) {
+    // this subtraction should retain the jet's structural
+    // information
+    subtracted_jet -= to_subtract;
+  } else {
+    // this sets the jet's momentum while maintaining all of the jet's
+    // structural information
+    subtracted_jet.reset_momentum(known_lv);
+    return subtracted_jet;
+  }
+  // make sure that in the end the pt is at least the one known to
+  // come from the leading vertex
+  if (subtracted_jet.pt2() < known_lv.pt2()){
+    subtracted_jet.reset_momentum(known_lv);
+    return subtracted_jet;
+  }
+  // sanity check for the mass (if needed)
+  if ((_safe_mass) && (subtracted_jet.m2() < known_lv.m2())){
+    // in this case, we keep pt and phi as obtained from the
+    // subtraction above and take rap and m from the part that comes
+    // from the leading vertex (or the original jet if nothing comes
+    // from the leading vertex)
+    subtracted_jet.reset_momentum(PtYPhiM(subtracted_jet.pt(),
+                                          known_lv.rap(),
+                                          subtracted_jet.phi(),
+                                          known_lv.m()));
+  }
+  return subtracted_jet;
+}
+//----------------------------------------------------------------------
+std::string Subtractor::description() const{
+  if (_bge != 0) {
+    string desc = "Subtractor that uses the following background estimator to determine rho: "+_bge->description();
+    if (use_rho_m()) desc += "; including the rho_m correction";
+    if (safe_mass()) desc += "; including mass safety tests";
+    if (_sel_known_vertex.worker()){
+      desc += "; using known vertex selection: "+_sel_known_vertex.description()+" and leading vertex selection: "+_sel_leading_vertex.description();
+    }
+    return desc;
+  } else if (_rho != _invalid_rho) {
+    ostringstream ostr;
+    ostr << "Subtractor that uses a fixed value of rho = " << _rho;
+    if (use_rho_m()) ostr << " and rho_m = " << _rho_m;
+    return ostr.str();
+  } else {
+    return "Uninitialised subtractor";
+  }
+}
+//----------------------------------------------------------------------
+// compute the 4-vector that should be subtracted from the given
+// jet
+PseudoJet Subtractor::_amount_to_subtract(const PseudoJet &jet) const{
+  // the "transverse momentum" part
   double rho;
   if (_bge != 0) {
 …
     rho = _rho;
   } else {
     throw Error("default Subtractor does not have any information about the background, which is needed to perform the subtraction");
+  }
   PseudoJet subtracted_jet = jet;
   PseudoJet area4vect = jet.area_4vector();
+  // sanity check
   if (rho*area4vect.perp() < jet.perp() ) {
+    // this subtraction should retain the jet's structural
     // information
     subtracted_jet -= rho*area4vect;
   } else {
     // this sets the jet's momentum to zero while
     // maintaining all of the jet's structural information
     subtracted_jet *= 0;
+  }
   return subtracted_jet;
+}
+//----------------------------------------------------------------------
+std::string Subtractor::description() const{
   if (_bge != 0) {
     return "Subtractor that uses the following background estimator to determine rho: "+_bge->description();
   } else if (_rho != _invalid_rho) {
     ostringstream ostr;
     ostr << "Subtractor that uses a fixed value of rho = " << _rho;
     return ostr.str();
+  } else {
     return "Uninitialised subtractor";
+  }
+}
+    throw Error("Subtractor::_amount_to_subtract(...): default Subtractor does not have any information about the background, needed to perform the subtraction");
+  }
+  PseudoJet area = jet.area_4vector();
+  PseudoJet to_subtract = rho*area;
+  double const rho_m_warning_threshold = 1e-5;
+  // add an optional contribution from the unknown particles masses
+  if (_use_rho_m) {
+    double rho_m;
+    if (_bge != 0) {
+      if (!_bge->has_rho_m()) throw Error("Subtractor::_amount_to_subtract(...): requested subtraction with rho_m from a background estimator, but the estimator does not have rho_m support");
+      rho_m = _bge->rho_m(jet);
+    } else if (_rho_m != _invalid_rho) {
+      rho_m = _rho_m;
+    } else {
+      throw Error("Subtractor::_amount_to_subtract(...): default Subtractor does not have any information about the background rho_m, needed to perform the rho_m subtraction");
+    }
+    to_subtract += rho_m * PseudoJet(0.0, 0.0, area.pz(), area.E());
+  } else if (_bge &&
+             _bge->has_rho_m() &&
+             _bge->rho_m(jet) > rho_m_warning_threshold * rho) {
+    _unused_rho_m_warning.warn("Subtractor::_amount_to_subtract(...): Background estimator indicates non-zero rho_m, but use_rho_m()==false in subtractor; consider calling set_use_rho_m(true) to include the rho_m information");
+  }
+  return to_subtract;
+}
 FASTJET_END_NAMESPACE

external/fastjet/tools/Subtractor.hh

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id: Subtractor.hh 2577 2011-09-13 15:11:38Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+//FJSTARTHEADER
+// $Id: Subtractor.hh 3670 2014-09-08 14:17:59Z soyez $
+//
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #ifndef __FASTJET_TOOLS_SUBTRACTOR_HH__
 #define __FASTJET_TOOLS_SUBTRACTOR_HH__
+#include "fastjet/internal/base.hh"     // namespace macros (include explicitly to help Doxygen)
 #include "fastjet/tools/Transformer.hh" // to derive Subtractor from Transformer
 #include "fastjet/tools/BackgroundEstimatorBase.hh" // used as a ctor argument
 …
   /// define a subtractor based on a BackgroundEstimator
   Subtractor(BackgroundEstimatorBase * bge) :
     _bge(bge), _rho(-1.0) {}
+    _bge(bge), _rho(-1.0) { set_defaults(); }
   /// define a subtractor that uses a fixed value of rho, the background
 …
   Subtractor(double rho);
+  /// define a subtractor that uses a fixed value of rho and rho_m;
+  /// both must be >= 0;
+  Subtractor(double rho, double rho_m);
   /// default constructor
   Subtractor() : _bge(0), _rho(_invalid_rho) {}
+  Subtractor() : _bge(0), _rho(_invalid_rho) { set_defaults(); }
   /// default dtor
   virtual ~Subtractor(){};
+  /// @name configuring the behaviour
+  //\{
+  //----------------------------------------------------------------
+  /// reset all parameters to default values
+  ///
+  /// Note: by default, the rho_m term is not included and the safety
+  /// test for the mass is not done. This is mostly for backwards
+  /// compatibility with FastJet 3.0 and is highly likely to change in
+  /// a future release of FastJet
+  void set_defaults();
+  /// when 'use_rho_m' is true, include in the subtraction the
+  /// correction from rho_m, the purely longitudinal,
+  /// particle-mass-induced component of the background density per
+  /// unit area
+  ///
+  /// Note: this will be switched off by default (for backwards
+  /// compatibility with FastJet 3.0) but is highly likely to change
+  /// in a future release of FastJet
+  void set_use_rho_m(bool use_rho_m_in = true){
+    if (_bge == 0  && _rho_m < 0) {
+      throw Error("Subtractor: rho_m support works only for Subtractors constructed with a background estimator or an explicit rho_m value");
+    }
+    _use_rho_m=use_rho_m_in;
+  }
+  /// returns whether or not the rho_m component is used
+  bool use_rho_m() const{ return _use_rho_m;}
+  /// when 'safe_mass' is true, ensure that the mass of the subtracted
+  /// 4-vector remain positive
+  ///
+  /// when true, if the subtracted mass is negative, we return a
+  /// 4-vector with 0 mass, pt and phi from the subtracted 4-vector
+  /// and the rapidity of the original, unsubtracted jet.
+  ///
+  /// Note: this will be switched off by default (for backwards
+  /// compatibility with FastJet 3.0) but is highly likely to change
+  /// in a future release of FastJet
+  void set_safe_mass(bool safe_mass_in=true){ _safe_mass=safe_mass_in;}
+  /// returns whether or not safety tests on the mass are included
+  bool safe_mass() const{ return _safe_mass;}
+  /// This is mostly intended for cherge-hadron-subtracted type of
+  /// events where we wich to use vertex information to improve the
+  /// subtraction.
+  ///
+  /// Given the following parameters:
+  ///   \param sel_known_vertex    selects the particles with a
+  ///                              known vertex origin
+  ///   \param sel_leading_vertex  amongst the particles with a
+  ///                              known vertex origin, select those
+  ///                              coming from the leading vertex
+  /// Momentum identified as coming from the leading vertex will be
+  /// kept, momentum identified as coming from a non-leading vertex
+  /// will be eliminated and a regular area-median subtraction will be
+  /// applied on the 4-vector sum of the particles with unknown vertex
+  /// origin.
+  ///
+  /// When this is set, we shall ensure that the pt of the subtracted
+  /// 4-vector is at least the pt of the particles that are known to
+  /// come from the leading vertex (if it fails, subtraction returns
+  /// the component that is known to come from the leading vertex ---
+  /// or, the original unsubtracted jet if it contains no particles
+  /// from the leading vertex).  Furthermore, when safe_mass() is on, we
+  /// also impose a similar constraint on the mass of the subtracted
+  /// 4-vector (if the test fails, the longitudinal part of the
+  /// subtracted 4-vector is taken from the component that is known to
+  /// come from the leading vertex).
+  void set_known_selectors(const Selector &sel_known_vertex,
+                           const Selector &sel_leading_vertex){
+    _sel_known_vertex   = sel_known_vertex;
+    _sel_leading_vertex = sel_leading_vertex;
+  }
+  //\}
+  /// @name description and action
+  //\{
+  //----------------------------------------------------------------
   /// returns a jet that's subtracted
 …
   virtual std::string description() const;
+  //\}
 protected:
+  /// compute the 4-vector that should be subtracted from the given
+  /// jet
+  PseudoJet _amount_to_subtract(const PseudoJet &jet) const;
   /// the tool used to estimate the background
   /// if has to be mutable in case its underlying selector takes a reference jet
   mutable BackgroundEstimatorBase * _bge;
+  /// the fixed value of rho to use if the user has selected that option
+  double _rho;
+  /// the fixed value of rho and/or rho_m to use if the user has selected that option
+  double _rho, _rho_m;
+  // configuration parameters/flags
+  bool _use_rho_m;   ///< include the rho_m correction
+  bool _safe_mass;   ///< ensures that the subtracted mass is +ve
+  Selector _sel_known_vertex;   ///< selects the particles with a
+                                ///< known vertex origin
+  Selector _sel_leading_vertex; ///< amongst the particles with a
+                                ///< known vertex origin, select those
+                                ///< coming from the leading vertex
   /// a value of rho that is used as a default to label that the stored
 …
   // that's not allowed in an include file.
   static const double _invalid_rho;
+  mutable LimitedWarning _unused_rho_m_warning;
 };

external/fastjet/tools/TopTaggerBase.cc

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id$
+//FJSTARTHEADER
+// $Id: TopTaggerBase.cc 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include <fastjet/tools/TopTaggerBase.hh>

external/fastjet/tools/TopTaggerBase.hh

-              rf6b6ee7
+              r49234af
 #define __FASTJET_TOP_TAGGER_BASE_HH__
 //STARTHEADER
 // $Id: TopTaggerBase.hh 2689 2011-11-14 14:51:06Z soyez $
+//FJSTARTHEADER
+// $Id: TopTaggerBase.hh 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #include <fastjet/internal/base.hh>

external/fastjet/tools/Transformer.hh

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id: Transformer.hh 2577 2011-09-13 15:11:38Z salam $
+//FJSTARTHEADER
+// $Id: Transformer.hh 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #ifndef __FASTJET_TRANSFORMER_HH__

external/fastjet/version.hh

-              rf6b6ee7
+              r49234af
 //STARTHEADER
 // $Id: version.hh 2577 2011-09-13 15:11:38Z salam $
+//FJSTARTHEADER
+// $Id: version.hh 3433 2014-07-23 08:17:03Z salam $
 //
 // Copyright (c) 2005-2011, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
+// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 //
 //----------------------------------------------------------------------
 …
 //
 //  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,
 …
 //  along with FastJet. If not, see <http://www.gnu.org/licenses/>.
 //----------------------------------------------------------------------
 //ENDHEADER
+//FJENDHEADER
 #ifndef __FASTJET_VERSION_HH__

Context Navigation

Changeset 49234af in git for external

Legend: