Changeset 973b92a for external – Delphes

external/fastjet/ClusterSequence.hh

-              rf118021
+              r973b92a
 //FJSTARTHEADER
 // $Id: ClusterSequence.hh 3709 2014-09-29 13:19:11Z soyez $
+// $Id: ClusterSequence.hh 3911 2015-07-02 12:09:58Z salam $
 //
 // Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 …
 // implementation of JetDefinition::operator() is here to avoid nasty
 // issues of order of implementations and includes
+#ifndef __CINT__
 template<class L>
 std::vector<PseudoJet> JetDefinition::operator()(const std::vector<L> & particles) const {
 …
   return jets;
+}
+#endif // __CINT__

external/fastjet/ClusterSequence_Delaunay.cc

-              rf118021
+              r973b92a
 //FJSTARTHEADER
 // $Id: ClusterSequence_Delaunay.cc 3475 2014-07-29 11:57:23Z salam $
+// $Id: ClusterSequence_Delaunay.cc 3918 2015-07-03 14:19:13Z salam $
 //
 // Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 …
   // initialise our DNN structure with the set of points
   auto_ptr<DynamicNearestNeighbours> DNN;
+  bool verbose = false;
 #ifndef DROP_CGAL // strategy = NlnN* are not supported if we drop CGAL...
-  bool verbose = false;
   bool ignore_nearest_is_mirror = (_Rparam < twopi);
   if (_strategy == NlnN4pi) {
 …
       jet_i = SmallestDijPair.first;
       jet_j = SmallestDijPair.second;
+      if (verbose) cout << "CS_Delaunay found recombination candidate: " << jet_i << " " << jet_j << " " << SmallestDij << endl; // GPS debugging
       // distance is immediately removed regardless of whether or not
       // it is used.
 …
       if (!recombine_with_beam) {Valid2 = DNN->Valid(jet_j);}
       else {Valid2 = true;}
+      if (verbose) cout << "CS_Delaunay validities i & j: " << DNN->Valid(jet_i) << " " << Valid2 << endl;
     } while ( !DNN->Valid(jet_i) || !Valid2);
 …
     if (! recombine_with_beam) {
       int nn; // will be index of new jet
+      if (verbose) cout << "CS_Delaunay call _do_ij_recomb: " << jet_i << " " << jet_j << " " << SmallestDij << endl; // GPS debug
       _do_ij_recombination_step(jet_i, jet_j, SmallestDij, nn);
       //OBS // merge the two jets, add new jet, remove old ones
 …
     } else {
       // recombine the jet with the beam
+      if (verbose) cout << "CS_Delaunay call _do_iB_recomb: " << jet_i << " " << SmallestDij << endl; // GPS debug
       _do_iB_recombination_step(jet_i, SmallestDij);
       //OBS _add_step_to_history(n+i,_jets[jet_i].cluster_hist_index(),BeamJet,

external/fastjet/DnnPlane.cc

-              rf118021
+              r973b92a
 //FJSTARTHEADER
 // $Id: DnnPlane.cc 3442 2014-07-24 07:20:49Z salam $
+// $Id: DnnPlane.cc 3918 2015-07-03 14:19:13Z salam $
 //
 // Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 …
     // to reflect the fact that the points are no longer valid.
     _TR.remove(_supervertex[index].vertex);
+    if (_verbose) cout << "DnnPlane about to set _supervertex["<< index<<"].vertex to NULL" << endl;
     _supervertex[index].vertex = NULL;
+    if (_verbose) cout << "                 value is " << (_is_not_null(_supervertex[index].vertex)) << endl;
+  }
 …
     int index = _supervertex.size()-1;
     indices_added.push_back(index);
+    if (_verbose) cout << "  adding " << index << endl;
+    if (_verbose) cout << "  adding " << index << " at "
+                       << points_to_add[ia].first<< " " << points_to_add[ia].second << endl;
     //if (indices_to_remove.size() > 0) {

external/fastjet/VERSION

rf118021	r973b92a
1		3.1.2
	1	3.1.3

external/fastjet/config_auto.h

-              rf118021
+              r973b92a
 #endif
+/* defined if C++11 features have been enabled */
+/* #undef HAVE_CXX11_FEATURES */
 /* defined if demangling is enabled at configure time and is supported through
    the GNU C++ ABI */
 …
 /* Define to the full name and version of this package. */
 #ifndef FASTJET_PACKAGE_STRING
 #define FASTJET_PACKAGE_STRING  "FastJet 3.1.2"
+#define FASTJET_PACKAGE_STRING  "FastJet 3.1.3"
 #endif
 …
 /* Define to the version of this package. */
 #ifndef FASTJET_PACKAGE_VERSION
 #define FASTJET_PACKAGE_VERSION  "3.1.2"
+#define FASTJET_PACKAGE_VERSION  "3.1.3"
 #endif
 …
 /* Version number of package */
 #ifndef FASTJET_VERSION
 #define FASTJET_VERSION  "3.1.2"
+#define FASTJET_VERSION  "3.1.3"
 #endif
 …
 /* Version of the package under the form XYYZZ (instead of X.Y.Z) */
 #ifndef FASTJET_VERSION_NUMBER
 #define FASTJET_VERSION_NUMBER  30102
+#define FASTJET_VERSION_NUMBER  30103
 #endif
 /* Patch version of this package */
 #ifndef FASTJET_VERSION_PATCHLEVEL
 #define FASTJET_VERSION_PATCHLEVEL  2
+#define FASTJET_VERSION_PATCHLEVEL  3
 #endif

external/fastjet/config_raw.h

-              rf118021
+              r973b92a
 /* The TrackJet plugin is enabled */
 #define ENABLE_PLUGIN_TRACKJET /**/
+/* defined if C++11 features have been enabled */
+/* #undef HAVE_CXX11_FEATURES */
 /* defined if demangling is enabled at configure time and is supported through
 …
 /* Define to the full name and version of this package. */
 #define PACKAGE_STRING "FastJet 3.1.2"
+#define PACKAGE_STRING "FastJet 3.1.3"
 /* Define to the one symbol short name of this package. */
 …
 /* Define to the version of this package. */
 #define PACKAGE_VERSION "3.1.2"
+#define PACKAGE_VERSION "3.1.3"
 /* Define to 1 if you have the ANSI C header files. */
 …
 /* Version number of package */
 #define VERSION "3.1.2"
+#define VERSION "3.1.3"
 /* Major version of this package */
 …
 /* Version of the package under the form XYYZZ (instead of X.Y.Z) */
 #define VERSION_NUMBER 30102
+#define VERSION_NUMBER 30103
 /* Patch version of this package */
 #define VERSION_PATCHLEVEL 2
+#define VERSION_PATCHLEVEL 3
 /* Pre-release version of this package */

external/fastjet/config_win.h

-              rf118021
+              r973b92a
+#define FASTJET_PACKAGE_STRING  "FastJet 3.1.2"
+#define FASTJET_PACKAGE_VERSION  "3.1.2"
+#define FASTJET_VERSION  "3.1.2"
+#define FASTJET_VERSION_MAJOR       3
+#define FASTJET_VERSION_MINOR       1
+#define FASTJET_VERSION_PATCHLEVEL  2
+#define FASTJET_VERSION_NUMBER      30102
+#define FASTJET_PACKAGE_STRING  "FastJet 3.1.3"
+#define FASTJET_PACKAGE_VERSION  "3.1.3"
+#define FASTJET_VERSION  "3.1.3"
+#define FASTJET_VERSION_MAJOR       3.1.3
+#define FASTJET_VERSION_MINOR       3.1.3
+#define FASTJET_VERSION_PATCHLEVEL  3.1.3
+#define FASTJET_VERSION_PRERELEASE  "3.1.3"
+#define FASTJET_VERSION_NUMBER      00000
 /* The ATLASCone plugin is disabled by default*/

external/fastjet/contribs/Nsubjettiness/AUTHORS

-              rf118021
+              r973b92a
+The Nsubjettiness FastJet contrib was written and is maintained and developed by:
+-------------------------------------------------------------------------------
+   Jesse Thaler <jthaler@jthaler.net>
+The Nsubjettiness FastJet contrib was written, maintained, and developed by:
+   Jesse Thaler <jthaler@mit.edu>
    Ken Van Tilburg <kenvt@stanford.edu>
    Christopher K. Vermilion <christopher.vermilion@gmail.com>
    TJ Wilkason <tjwilk@mit.edu>
 Questions and comments should be directed to:  jthaler@jthaler.net.
+Questions and comments should be directed to:  jthaler@mit.edu.
+For physics details, see:
+-------------------------------------------------------------------------------
+For physics details on N-subjettiness, see:
    Identifying Boosted Objects with N-subjettiness.
 …
 New in v2.0 is the winner-take-all axis, described in:
+   Jet Observables Without Jet Algorithms.
+   Daniele Bertolini, Tucker Chan, and Jesse Thaler.
+   JHEP 1404:013 (2014), arXiv:1310.7584.
    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.
+   Unpublished work by Gavin Salam.
+----------------------------------------------------------------------
+New in v2.2 is the XCone jet algorithm, described in:
+   XCone: N-jettiness as an Exclusive Cone Jet Algorithm.
+   Iain W. Stewart, Frank J. Tackmann, Jesse Thaler,
+   Christopher K. Vermilion, and Thomas F. Wilkason.
+   arXiv:1508.01516.
+   Resolving Boosted Jets with XCone.
+   Jesse Thaler and Thomas F. Wilkason.
+   arXiv:1508.01518.
+-------------------------------------------------------------------------------

external/fastjet/contribs/Nsubjettiness/COPYING

-              rf118021
+              r973b92a
 to
+N-subjettiness:
   arXiv:1011.2268
   arXiv:1108.2701
+Winner-take-all axes:
+  arXiv:1310.7584
+  arXiv:1401.2158
+XCone:
+  arXiv:1508.01516
+  arXiv:1508.01518

external/fastjet/contribs/Nsubjettiness/ChangeLog

-              rf118021
+              r973b92a
+-09-28 <jthaler>
+   Updated NEWS for 2.2.1 release.
+-09-18 <jthaler>
+   Fixed duplicate XConePlugin entry in Makefile.
+-08-20 <jthaler>
+   Trying to fix "abs" bug in ExtraRecombiners.cc
+-08-19 <jthaler>
+   Adding arXiv numbers to XCone papers
+   Used this_jet in example_basic_usage.
+   Fixed typo in example_advanced_usage header.
+   Added copy/paste code in README file.
+-08-13 <jthaler>
+   Ready for 2.2.0 release
+-07-23 <jthaler>
+   Fixed typo in GenET_GenKT_Axes error message
+   Added _too_few_axes_warning to ExclusiveJetAxes and ExclusiveCombinatorialJetAxes
+   Switched to ../data/single_event_ee.dat for make check
+-07-20 <jthaler>
+   Renamed WinnerTakeAllRecombiner.hh/cc to ExtraRecombiners.hh/cc
+   Added _too_few_axes_warning to HardestJetAxes
+   Added GenKT_Axes and OnePass_GenKT_Axes and Comb_GenKT_Axes (using E-scheme recombination).
+   Added warning about p < 0 or delta <=0 in GenKT axes finders.
+   Added warning about beta <= 0 in all measures.
+-07-10 <jthaler>
+   Putting in small tweaks in documentation to get ready for 2.2 release candidate 1.
+-06-15 <jthaler>
+   Starting doxygen file for eventual improved documentation.
+   Starting long process of improving documentation throughout.
+   Made the basic usage file a bit easier to read.
+   Adding in LimitedWarnings for old style constructors
+-06-12 <jthaler>
+   Synchronized definition of new measures with XCone paper.
+   In MeasureDefinition, added default values of jet_distance_squared and beam_distance_squared for cases where we don't want to optimize specifically.
+   Fixed bug in OriginalGeometricMeasure and ModifiedGeometric Measure
+   Commented out DeprecatedGeometricMeasure and DeprecatedGeometricCutoffMeasure since they were only causing confusion
+-05-26 <TJW>
+   Removed axis_scale_factor(), added bool to calculate this value if needed to save computation time
+   Defined small offset in denominator of axis scaling according to accuracy of refinement
+   Updated advanced examples to include tau values and number of jet constituents
+-05-25 <jthaler>
+   Clean up of AxesDefinition
+   Splitting get_axes into get_starting_axes and get_refined axes
+   Putting in proper noise ranges (hopefully) for MultiPass
+   Clean up of MeasureDefinition, rename jet_gamma to beam_gamma
+   Put in zero checking for jet_distance in ConicalGeometricMeasure
+   Added in ConicalMeasure for consistency
+   Changing OnePass Minimization to allow for temporary uphill
+-05-24 <TJW>
+   Added Combinatorial GenET_GenKT_Axes and MultiPass_Manual_Axes
+   Moved Axes refining information into MeasureDefinition, associated each measure with corresponding axes refiner
+   Moved get_one_pass_axes into MeasureDefinition, removed any mention of Npass
+   Moved all information on number of passes to AxesDefinition
+   Made AxesRefiner.hh/.cc into defunct files
+-05-22 <jthaler>
+   Cleaning out commented text.  Renaming classes to be consistent with recommended usage.
+-05-22 <TJW>
+   Added XConePlugin as a specific implementation of NjettinessPlugin
+   Added usage of XCone beta = 1.0 and beta = 2.0 to both basic and advanced example files
+   Added OriginalGeometric, ModifiedGeometric, ConicalGeometric, and XCone measures to list of test measures
+   Added OnePass_GenRecomb_GenKT_Axes to list of test axes
+   Added description to XCone measure in MeasureDefinition
+-05-21 <TJW>
+   Updated minimization scheme to avoid divide-by-zero errors
+   Fixed various factors of 2 in the definition of the measures
+-04-19 <TJW>
+   Fixed bug in minimization scheme for GeneralAxesRefiner
+   Moved measure_type to DefaultMeasure, removed geometric measure from e+e- example file
+-03-22 <TJW>
+   Added OriginalGeometricMeasure and ModifiedGeometricMeasure definitions
+   Changed all instances of GeometricMeasure to DeprecatedGeometricMeasure, and added error statements
+   Made GeneralAxesRefiner the default axes refiner for Measure Definition, overwritten by DefaultMeasure and GeometricMeasure
+   Created DefaultMeasure class for all the conical measure subclasses
+   Separated out e+e- and pp measures into separate example files
+-03-09 <TJW>
+   Added ConicalGeometric measures with jet_beta and jet_gamma definitions
+   Added XCone measures derived from ConicalGeometric with jet_gamma = 1.0
+   Added GeneralAxesRefiner for use with any measure (currently defined with XCone measure)
+   Added axes_numerator in MeasureDefinition to define the momentum scaling for minimization (currently only defined for Conical Geometric measure)
+-11-28 <TJW>
+   Minor change to default parameters in axes definition
+-10-08 <TJW>
+   Updated example file with new e+e- measure definitions
+   Added measure type to measure definition descriptions
+   Changed order of parameters in new axes definitions
+   Added standard C++ epsilon definition to GeneralERecombiner
+-10-07 <TJW>
+   Updated example_advanced_usage with new axes choices
+   Reversed inheritance of NormalizedMeasure and NormalizedCutoffMeasure (and Geometric) back to original
+   Storing _RcutoffSq as separate variable, and recalculating it in NormalizedMeasure
+   Cleaning up ExclusiveCombinatorialJetAxes and added comments to explain the process
+   Fixed memory leaks using delete_recombiner_when_unused()
+   Fixed manual axes bug in Njettiness
+   Cleaned up enum definitions
+-10-01 <TJW>
+   Added new parameterized recombination scheme to Winner-Take-All recombiner
+   Created Winner-Take-All GenKT and general Recomb GenKT axes finders and onepass versions
+   Created new N choose M minimization axis finder, created N choose M WTA GenKT axis finder as example
+   Removed NPass as constructor argument in AxesDefinition, made it set through protected method
+   Removed TauMode as constructor argument in MeasureDefinition, made it set through protected method
+   Flipped inheritance of NormalizedMeasure and NormalizedCutoffMeasure (same for Geometric) to remove error of squaring the integer maximum
+   Created new MeasureType enum to allow user to choose between pp and ee variables (ee variables need testing)
+   Updated MeasureDefinition constructors to take in extra MeasureType parameter (but defaulted to pp variables)
+   Added new Default TauMode argument
+   Fixed unsigned integers in various places
+   Added setAxes method to NjettinessPlugin
+-08-26 <JDT>
+   Enhanced TauComponents to include more infomation
+   NjettinessExtras now inherits from TauComponents
+   Removed getPartition from Njettiness, to avoid code duplication
+   Fixed double calculating issue in NjettinessPlugin::run_clustering()
+   Now AxesDefinition can use measure information without running AxesRefiner
+   Added TauStructure so the jets returned by TauComponents can know their tau value.
+-08-25 <JDT>
+   Merged MeasureDefinition and MeasureFunction into new MeasureDefinition.
+   Merged StartingAxesFinder and AxesDefinition into new AxesDefinition.
+   Renamed AxesFinder.cc/hh to AxesRefiner.cc/hh
+   Renamed NjettinessDefinition.cc/hh to AxesDefinition.cc/hh
+   Renamed MeasureFunction.cc/hh to MeasureDefinition.cc/hh
+   Renaming result() function in MeasureDefinition to be consistent with Nsubjettiness interface.
+   Split off TauComponents into separate header
+   Added TauPartition class for readability of partitioning
+   Moved NjettinessExtras into TauComponents, as this will eventually be the logical location
+   Added cross check of new MeasureDefinition and AxesDefinition in example_advanced_usage.
+   Lots of comments updated.
+   Changed version number to 2.2.0-alpha-dev, since this is going to be a bigger update than I had originally thought
+-08-20 <JDT>
+   Incorporated code in NjettinessPlugin to handle FJ3.1 treatment of auto_ptr (thanks Gregory)
+   Changed version number to 2.1.1-alpha-dev
+   Split AxesFinder into StartingAxesFinder and RefiningAxesFinder for clarity.
+   Manual axes mode now corresponds to a NULL StartingAxesFinder in Njettiness (so removed AxesFinderFromUserInput)
+   Added AxesRefiningMode to make selection of minimization routine more transparent in Njettiness
+   Moved sq() to more appropriate place in AxesFinder.hh
+   Rearranged Nsubjettiness.hh to make the old code less visible.
+   Renamed AxesFinderFromOnePassMinimization -> AxesFinderFromConicalMinimization
+   Renamed DefaultUnnormalizedMeasureFunction -> ConicalUnnormalizedMeasureFunction
+   Removed supportsMultiPassMinimization() from MeasureDefinition since any One Pass algorithm can be multipass.
 -07-09 <JDT>
    Changed version for 2.1.0 release.

external/fastjet/contribs/Nsubjettiness/ExtraRecombiners.cc

-              rf118021
+              r973b92a
 //  Jesse Thaler, Ken Van Tilburg, Christopher K. Vermilion, and TJ Wilkason
 //
 //  $Id: WinnerTakeAllRecombiner.cc 597 2014-04-16 23:07:55Z jthaler $
+//  $Id: ExtraRecombiners.cc 842 2015-08-20 13:44:31Z jthaler $
 //----------------------------------------------------------------------
 // This file is part of FastJet contrib.
 …
 //----------------------------------------------------------------------
 #include "WinnerTakeAllRecombiner.hh"
+#include "ExtraRecombiners.hh"
 FASTJET_BEGIN_NAMESPACE      // defined in fastjet/internal/base.hh
 namespace contrib{
+std::string GeneralEtSchemeRecombiner::description() const {
+   return "General Et-scheme recombination";
+}
+// recombine pa and pb according to a generalized Et-scheme parameterized by the power delta
+void GeneralEtSchemeRecombiner::recombine(const fastjet::PseudoJet & pa, const fastjet::PseudoJet & pb, fastjet::PseudoJet & pab) const {
+   // Define new weights for recombination according to delta
+   // definition of ratio done so that we do not encounter issues about numbers being too large for huge values of delta
+   double ratio;
+   if (std::abs(_delta - 1.0) < std::numeric_limits<double>::epsilon()) ratio = pb.perp()/pa.perp(); // save computation time of pow()
+   else ratio = pow(pb.perp()/pa.perp(), _delta);
+   double weighta = 1.0/(1.0 + ratio);
+   double weightb = 1.0/(1.0 + 1.0/ratio);
+   double perp_ab = pa.perp() + pb.perp();
+   // reweight the phi and rap sums according to the weights above
+   if (perp_ab != 0.0) {
+      double y_ab = (weighta * pa.rap() + weightb * pb.rap());
+      double phi_a = pa.phi(), phi_b = pb.phi();
+      if (phi_a - phi_b > pi)  phi_b += twopi;
+      if (phi_a - phi_b < -pi) phi_b -= twopi;
+      double phi_ab = (weighta * phi_a + weightb * phi_b);
+      pab.reset_PtYPhiM(perp_ab, y_ab, phi_ab);
+   }
+   else {
+      pab.reset(0.0,0.0,0.0,0.0);
+   }
+}
 std::string WinnerTakeAllRecombiner::description() const {
    return "Winner Take All scheme recombination";
+   return "Winner-Take-All recombination";
+}

external/fastjet/contribs/Nsubjettiness/NEWS

-              rf118021
+              r973b92a
 Note that we have maintain backwards compatibility for the typical ways that
 Nsubjettiness was used.  In particular, all of the Nsubjettiness class code in
 the example file v1.0.3 from still compiles, as does the NjettinessPlugin class
+the example file from v1.0.3 still compiles, as does the NjettinessPlugin class
 code that uses the default measure.
 …
   * NsubjettinessRatio:  Direct access to tau_N / tau_M (the most requested
     feature)
   * MeasureDefinition to allow access to both normalized and unnormalized measures
+  * MeasureDefinition to allow access to normalized and unnormalized measures
   * AxesDefinition to allow for access to more general axes modes
   * Winner-Take-All recombination axes:  a faster way to find axes than beta = 1
+  * Winner-Take-All recombination axes:  a faster way to find axes than beta=1
     minimization, but with comparable performance.
   * TauComponents to get access to the pieces of the N-(sub)jettiness
     calculation.
+  * TauExtras to get complete access to get partitioning and axes information.
   * For clarity, split the example file into an example_basic_usage and
     example_advanced_usage
+    example_advanced_usage (and example_advanced_usage_ee for e+e- collisions).
   * In Nsubjettiness, access to seedAxes() and currentAxes() to figure out the
     axes used before and after minimization.
   * In Nsubjettiness, access to currentSubjets() to get the subjet fourvectors.
+  * (v2.2)  XConePlugin, which improves on the previous NjettinessPlugin to use
+    N-jettiness as a jet finder using the new ConicalGeometric measure.
+-- 2.2.1:  (Sept 28, 2015)  Fix of small Makefile bug
+-- 2.2.0:  (Sept 7, 2015)  Inclusion of the XCone jet algorithm, as well as a
+           few new measures, including the "conical geometric" measure and
+           options for e+e- colliders.  Improvement of the
+           Measure/AxesDefinition interface to allow for direct
+           use in calculations.
+           * Fixed bug where MultiPass_Axes did not actually minimize
+           * Fixed floating point error with infinity^2 in various measures
 -- 2.1.0:  (July 9, 2014) Inclusion of MeasureDefinition/AxesDefinition interface.
+-- 2.1.0:  (July 9, 2014) Inclusion of Measure/AxesDefinition interface.
            This was the first publicly available version of Nsubjettiness v2.
 -- 2.0.0:  Initial release of v2.0.  This was never officially made public.

external/fastjet/contribs/Nsubjettiness/Njettiness.cc

-              rf118021
+              r973b92a
 //  Jesse Thaler, Ken Van Tilburg, Christopher K. Vermilion, and TJ Wilkason
 //
 //  $Id: Njettiness.cc 677 2014-06-12 18:56:46Z jthaler $
+//  $Id: Njettiness.cc 821 2015-06-15 18:50:53Z jthaler $
 //----------------------------------------------------------------------
 // This file is part of FastJet contrib.
 …
 ///////
+LimitedWarning Njettiness::_old_measure_warning;
+LimitedWarning Njettiness::_old_axes_warning;
+// Constructor
 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
+}
+: _axes_def(axes_def.create()), _measure_def(measure_def.create()) {}
+// setAxes for Manual mode
+void Njettiness::setAxes(const std::vector<fastjet::PseudoJet> & myAxes) {
+   if (_axes_def()->needsManualAxes()) {
+      _currentAxes = myAxes;
+   } 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) const {
+   if (inputJets.size() <= n_jets) {  //if not enough particles, return zero
+      _currentAxes = inputJets;
+      _currentAxes.resize(n_jets,fastjet::PseudoJet(0.0,0.0,0.0,0.0));
+      _current_tau_components = TauComponents();
+      _seedAxes = _currentAxes;
+      _currentPartition = TauPartition(n_jets); // empty partition
+   } else {
+      assert(_axes_def()); // this should never fail.
+      if (_axes_def()->needsManualAxes()) { // if manual mode
+         // take current axes as seeds
+         _seedAxes = _currentAxes;
+         // refine axes if requested
+         _currentAxes = _axes_def->get_refined_axes(n_jets,inputJets,_seedAxes, _measure_def());
+      } else { // non-manual axes
+          //set starting point for minimization
+         _seedAxes = _axes_def->get_starting_axes(n_jets,inputJets,_measure_def());
+         // refine axes as needed
+         _currentAxes = _axes_def->get_refined_axes(n_jets,inputJets,_seedAxes, _measure_def());
+         // NOTE:  The above two function calls are combined in "AxesDefinition::get_axes"
+         // but are separated here to allow seed axes to be stored.
+      }
+      // Find and store partition
+      _currentPartition = _measure_def->get_partition(inputJets,_currentAxes);
+      // Find and store tau value
+      _current_tau_components = _measure_def->component_result_from_partition(_currentPartition, _currentAxes);  // sets current Tau Values
+   }
+   return _current_tau_components;
+}
+///////
+//
+// Below is code for backward compatibility to use the old interface.
+// May be deleted in a future version
+//
+///////
 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
+}
+: _axes_def(createAxesDef(axes_mode)), _measure_def(measure_def.create()) {}
 // 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 {
+   _old_measure_warning.warn("Njettiness::createMeasureDef:  You are using the old MeasureMode way of specifying N-subjettiness measures.  This is deprecated as of v2.1 and will be removed in v3.0.  Please use MeasureDefinition instead.");
    // definition of maximum Rcutoff for non-cutoff measures, changed later by other measures
    double Rcutoff = std::numeric_limits<double>::max();  //large number
 …
          break;
       case geometric_measure:
+         beta = para1;
+         if (num_para == 1) {
+            return new GeometricMeasure(beta);
+         } else {
+            throw Error("geometric_measure needs 1 parameter (beta)");
+         }
+         throw Error("This class has been removed. Please use OriginalGeometricMeasure, ModifiedGeometricMeasure, or ConicalGeometricMeasure with the new Njettiness constructor.");
          break;
       case normalized_cutoff_measure:
 …
          break;
       case geometric_cutoff_measure:
+         beta = para1;
+         Rcutoff = para2; //Rcutoff parameter is 2nd parameter in geometric_cutoff_measure
+         if(num_para == 2) {
+           return new GeometricCutoffMeasure(beta,Rcutoff);
+         } else {
+            throw Error("geometric_cutoff_measure has 2 parameters (beta, Rcutoff)");
+         }
+         break;
+         throw Error("This class has been removed. Please use OriginalGeometricMeasure, ModifiedGeometricMeasure, or ConicalGeometricMeasure with the new Njettiness constructor.");
       default:
          assert(false);
 …
 // This returns a pointer that will be claimed by a SharedPtr
 AxesDefinition* Njettiness::createAxesDef(Njettiness::AxesMode axes_mode) const {
+   _old_axes_warning.warn("Njettiness::createAxesDef:  You are using the old AxesMode way of specifying N-subjettiness axes.  This is deprecated as of v2.1 and will be removed in v3.0.  Please use AxesDefinition instead.");
    switch (axes_mode) {
 …
+}
+// 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(const std::vector<fastjet::PseudoJet> & myAxes) {
+   if (_axes_def->supportsManualAxes()) {
+      _currentAxes = myAxes;
+   } 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) const {
+   if (inputJets.size() <= n_jets) {  //if not enough particles, return zero
+      _currentAxes = inputJets;
+      _currentAxes.resize(n_jets,fastjet::PseudoJet(0.0,0.0,0.0,0.0));
+      _current_tau_components = TauComponents();
+      _seedAxes = _currentAxes;
+      _currentJets = _currentAxes;
+      _currentBeam = PseudoJet(0.0,0.0,0.0,0.0);
+   } else {
+      _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;
+}
+// Partition a list of particles according to which N-jettiness axis they are closest to.
+// Return a vector of length _currentAxes.size() (which should be N).
+// Each vector element is a list of ints corresponding to the indices in
+// particles of the particles belonging to that jet.
+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

-              rf118021
+              r973b92a
 //  Jesse Thaler, Ken Van Tilburg, Christopher K. Vermilion, and TJ Wilkason
 //
 //  $Id: Njettiness.hh 670 2014-06-06 01:24:42Z jthaler $
+//  $Id: Njettiness.hh 822 2015-06-15 23:52:57Z jthaler $
 //----------------------------------------------------------------------
 // This file is part of FastJet contrib.
 …
 #include "MeasureFunction.hh"
 #include "AxesFinder.hh"
 #include "NjettinessDefinition.hh"
+#include "MeasureDefinition.hh"
+#include "AxesDefinition.hh"
+#include "TauComponents.hh"
 #include "fastjet/PseudoJet.hh"
 …
 namespace contrib {
+/** \mainpage Nsubjettiness Documentation
+ *
+ * These Doxygen pages provide automatically generated documentation for the
+ * Nsubjettiness FastJet contrib.  This documentation is being slowly improved.
+ *
+ * \section core_classes Core Classes
+ *
+ * - Nsubjettiness:  Calculating N-subjettiness jet shapes
+ * - NsubjettinessRatio:  Calculating N-subjettiness ratios
+ * - XConePlugin:  Running the XCone jet algorithm
+ * - NjettinessPlugin:  Running generic N-jettiness as a jet algorithm
+ *
+ * \subsection core_classes_helper Helper Classes for Core
+ * - Njettiness:  Core code for all N-(sub)jettiness calculations
+ * - NjettinessExtras:  Way to access additional N-jettiness information
+ * - TauComponents:  Output format for all N-(sub)jettiness information
+ * - TauPartition:  Access to N-(sub)jettiness partitioning information
+ * - PseudoXConePlugin:  Testing code to compare to XConePlugin (doesn't use one-pass minimization)
+ *
+ * \section axes_classes Axes Definitions
+ *
+ * \subsection axes_classes_base Base Classes
+ * - AxesDefinition:  Defines generic axes definition
+ * - ExclusiveJetAxes:  Axes finder from exclusive jet algorithm
+ * - ExclusiveCombinatorialJetAxes:  Axes finder from exclusive jet algorithm (with extra axes to test combinatoric options)
+ * - HardestJetAxes:  Axes finder from inclusive jet algorithm
+ *
+ * \subsection axes_classes_derived Derived Classes
+ *
+ * \b OnePass means iterative improvement to a (local) N-(sub)jettiness minimum.
+ *
+ * \b MultiPass means using multiple random seed inputs
+ *
+ * \b Comb means checking N + Nextra choose N combinatorial options
+ *
+ * - KT_Axes / OnePass_KT_Axes:  Axes from exclusive kT
+ * - CA_Axes / OnePass_CA_Axes:  Axes from exclusive Cambridge/Aachen
+ * - AntiKT_Axes / OnePass_AntiKT_Axes:  Axes from inclusive anti-kT
+ * - WTA_KT_Axes / OnePass_WTA_KT_Axes:  Axes from exclusive kT, using winner-take-all recombination
+ * - WTA_CA_Axes / OnePass_WTA_CA_Axes:  Axes from exclusive CA, using winner-take-all recombination
+ *
+ * - GenET_GenKT_Axes / OnePass_GenET_GenKT_Axes / Comb_GenET_GenKT_Axes:  Axes from exclusive generalized kt, with generalized Et recombination
+ * - WTA_GenKT_Axes / OnePass_WTA_GenKT_Axes / Comb_WTA_GenKT_Axes:  Axes from exclusive generalized kt, with winner-take-all recombination
+ *
+ * - Manual_Axes / OnePass_Manual_Axes / MultiPass_Manual_Axes:  Use manual axes
+ * - MultiPass_Axes:  Multiple passes with random input seeds
+ *
+ * \subsection axes_classes_helper Helper Classes for Axes
+ * - GeneralEtSchemeRecombiner:  Generalized Et-scheme recombiner
+ * - WinnerTakeAllRecombiner:  Winner-take-all recombiner (similar functionality now in FastJet 3.1)
+ * - JetDefinitionWrapper:  Wrapper for Jet Definitions to handle memory management
+ *
+ * \section measure_classes Measure Definitions
+ *
+ * \subsection measure_classes_bases Base Classes
+ * - MeasureDefinition:  Defines generic measures
+ * - DefaultMeasure:  Base class for the original N-subjettiness measures
+ *
+ * \subsection measure_classes_derived Derived Classes
+ * - NormalizedMeasure / UnnormalizedMeasure / NormalizedCutoffMeasure / UnnormalizedCutoffMeasure : Variants on the default N-subjettiness measure.
+ * - ConicalMeasure: Similar to default measure, but intended as N-jettiness event shape
+ * - ConicalGeometricMeasure / XConeMeasure:  Measure used in XCone jet algorithm
+ * - OriginalGeometricMeasure / ModifiedGeometricMeasure:  Dot product measures useful for theoretical calcualtions
+ *
+ * \subsection measure_classes_helper Helper Classes for Measures
+ * - LightLikeAxis : Defines light-like axis
+ */
 ///////
 //
 …
 ///////
 //------------------------------------------------------------------------
+///------------------------------------------------------------------------
 /// \class Njettiness
+// Njettiness uses AxesFinder and MeasureFunction together in order to find tau_N for the event. The user specifies
+// which AxesFinder and which MeasureFunction to use in the calculation, and then Njettiness returns tau_N for the event.
+// It also can return information about the axes and jets it used in the calculation, as well as information about
+// how the event was partitioned.
+/// \brief Core class for N-(sub)jettiness calculations
+///
+/**
+ * The N-jettiness event shape.
+ *
+ * This is the core class used to perform N-jettiness jet finding (via NjettinessPlugin or XConePluggin)
+ * as well as find the N-subjettiness jet shape (via Nsubjettiness).
+ *
+ * In general, the user should never need to call this object.  In addition, its API should not be considered
+ * fixed, since all code improvements effectively happen from reorganizing this class.
+ *
+ * Njettiness uses AxesDefinition and MeasureDefinition together in order to find tau_N for the event.
+ * It also can return information about the axes and jets it used in the calculation, as well as
+ * information about how the event was partitioned.
+ */
 class Njettiness {
 public:
+   // The various axes choices available to the user
+   // It is recommended to use AxesDefinition instead of these.
+   /// 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);
+   /// Destructor
+   ~Njettiness() {};
+   /// setAxes for Manual mode
+   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) 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) const {
+      return getTauComponents(n_jets, inputJets).tau();
+   }
+   /// Return all relevant information about tau components
+   TauComponents currentTauComponents() const {return _current_tau_components;}
+   /// Return axes found by getTauComponents.
+   std::vector<fastjet::PseudoJet> currentAxes() const { return _currentAxes;}
+   /// Return seedAxes used if onepass minimization (otherwise, same as currentAxes)
+   std::vector<fastjet::PseudoJet> seedAxes() const { return _seedAxes;}
+   /// Return jet partition found by getTauComponents.
+   std::vector<fastjet::PseudoJet> currentJets() const {return _currentPartition.jets();}
+   /// Return beam partition found by getTauComponents.
+   fastjet::PseudoJet currentBeam() const {return _currentPartition.beam();}
+   /// Return beam partition found by getTauComponents.
+   TauPartition currentPartition() const {return _currentPartition;}
+private:
+   /// AxesDefinition to use.  Implemented as SharedPtrs to avoid memory management headaches
+   SharedPtr<const AxesDefinition> _axes_def;
+   /// MeasureDefinition to use.  Implemented as SharedPtrs to avoid memory management headaches
+   SharedPtr<const MeasureDefinition> _measure_def;
+   // Information about the current information
+   // Defined as mutables, so user should be aware that these change when getTau is called.
+   // TODO:  These are not thread safe and should be fixed somehow
+   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 TauPartition _currentPartition; //partitioning information
+   /// Warning if the user tries to use v1.0.3 measure style.
+   static LimitedWarning _old_measure_warning;
+   /// Warning if the user tries to use v1.0.3 axes style.
+   static LimitedWarning _old_axes_warning;
+public:
+   // These interfaces are included for backwards compability, and will be deprecated in a future release (scheduled for deletion in v3.0)
+   /// \deprecated
+   /// Deprecated enum to determine axes mode
+   /// The various axes choices available to the user
+   /// It is recommended to use AxesDefinition instead of these.
    enum AxesMode {
       kt_axes,             // exclusive kt axes
 …
       onepass_ca_axes,     // one-pass minimization from ca starting point
       onepass_antikt_0p2_axes,  // one-pass minimization from antikt-0.2 starting point
       onepass_wta_kt_axes, //one-pass minimization of WTA axes with kt
       onepass_wta_ca_axes, //one-pass minimization of WTA axes with ca
+      onepass_wta_kt_axes, //one-pass minimization of WTA axes with kt
+      onepass_wta_ca_axes, //one-pass minimization of WTA axes with ca
       min_axes,            // axes that minimize N-subjettiness (100 passes by default)
       manual_axes,         // set your own axes with setAxes()
       onepass_manual_axes  // one-pass minimization from manual starting point
-      //  These options are commented out because they have not been fully tested
-      //      wta2_kt_axes,        // Winner Take All (alpha = 2) with kt
-      //      wta2_ca_axes,         // Winner Take All (alpha = 2) with CA
-      //      onepass_wta2_kt_axes, //one-pass minimization of WTA (alpha = 2) axes with kt
-      //      onepass_wta2_ca_axes, //one-pass minimization of WTA (alpha = 2) axes with ca
    };
+   // The measures available to the user.
+   // "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.
+   /// \deprecated
+   /// Deprecated enum to determine measure mode
+   /// The measures available to the user.
+   /// "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
 …
       geometric_cutoff_measure      //geometric measure with explicit Rcutoff
    };
+   // 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);
+   // Intermediate constructor (needed to enable v1.0.3 backwards compatibility?)
+   /// \deprecated
+   /// Intermediate constructor (needed to enable v1.0.3 backwards compatibility?)
    Njettiness(AxesMode axes_mode, const MeasureDefinition & measure_def);
+   // Alternative constructor which takes axes/measure information as enums with measure parameters
+   // This version is not recommended
+   /// \deprecated
+   /// Old-style constructor which takes axes/measure information as enums with measure parameters
+   /// This version absolutely is not recommended
    Njettiness(AxesMode axes_mode,
               MeasureMode measure_mode,
 …
               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
+   }
+   // destructor
+   ~Njettiness() {};
+   // setAxes for Manual mode
+   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) 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) const {
+      return getTauComponents(n_jets, inputJets).tau();
+   }
+   // Return all relevant information about tau components
+   TauComponents currentTauComponents() const {return _current_tau_components;}
+   // Return axes found by getTauComponents.
+   std::vector<fastjet::PseudoJet> currentAxes() const { return _currentAxes;}
+   // Return seedAxes used if onepass minimization (otherwise, same as currentAxes)
+   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> > getPartitionList(const std::vector<fastjet::PseudoJet> & inputJets) const;
+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
+   /// \deprecated
+   /// Convert old style enums into new style MeasureDefinition
    AxesDefinition* createAxesDef(AxesMode axes_mode) const;
+   // Convert old style enums into new style MeasureDefinition
+   /// \deprecated
+   /// Convert old style enums into new style MeasureDefinition
    MeasureDefinition* createMeasureDef(MeasureMode measure_mode, int num_para, double para1, double para2, double para3) const;

external/fastjet/contribs/Nsubjettiness/NjettinessPlugin.cc

-              rf118021
+              r973b92a
 //  Jesse Thaler, Ken Van Tilburg, Christopher K. Vermilion, and TJ Wilkason
 //
 //  $Id: NjettinessPlugin.cc 663 2014-06-03 21:26:41Z jthaler $
+//  $Id: NjettinessPlugin.cc 821 2015-06-15 18:50:53Z jthaler $
 //----------------------------------------------------------------------
 // This file is part of FastJet contrib.
 …
 namespace contrib{
+LimitedWarning NjettinessPlugin::_old_constructor_warning;
 std::string NjettinessPlugin::description() const {return "N-jettiness jet finder";}
 …
    _njettinessFinder.getTau(_N, particles);
    std::vector<std::list<int> > partition = _njettinessFinder.getPartitionList(particles);
    std::vector<fastjet::PseudoJet> jet_indices_for_extras;
+   TauComponents tau_components = _njettinessFinder.getTauComponents(_N, particles);
+   TauPartition tau_partition = _njettinessFinder.currentPartition();
+   std::vector<std::list<int> > partition = tau_partition.jets_list();
+   std::vector<int> jet_indices_for_extras;
    // output clusterings for each jet
 …
       int finalJet = indices.back();
       cs.plugin_record_iB_recombination(finalJet, fakeDib);
       jet_indices_for_extras.push_back(cs.jets()[finalJet]);  // Get the four vector for the final jets to compare later.
+      jet_indices_for_extras.push_back(cs.jets()[finalJet].cluster_hist_index());  // Get the four vector for the final jets to compare later.
+   }
 …
    reverse(jet_indices_for_extras.begin(),jet_indices_for_extras.end());
+   NjettinessExtras * extras = new NjettinessExtras(_njettinessFinder.currentTauComponents(),jet_indices_for_extras,_njettinessFinder.currentAxes());
+   // Store extra information about jets
+   NjettinessExtras * extras = new NjettinessExtras(tau_components,jet_indices_for_extras);
+#if FASTJET_VERSION_NUMBER>=30100
+   cs.plugin_associate_extras(extras);
+#else
+   // auto_ptr no longer supported, apparently
    cs.plugin_associate_extras(std::auto_ptr<ClusterSequence::Extras>(extras));
+#endif
+}

external/fastjet/contribs/Nsubjettiness/NjettinessPlugin.hh

-              rf118021
+              r973b92a
 //  Jesse Thaler, Ken Van Tilburg, Christopher K. Vermilion, and TJ Wilkason
 //
 //  $Id: NjettinessPlugin.hh 671 2014-06-10 17:47:52Z jthaler $
+//  $Id: NjettinessPlugin.hh 822 2015-06-15 23:52:57Z jthaler $
 //----------------------------------------------------------------------
 // This file is part of FastJet contrib.
 …
 #define __FASTJET_CONTRIB_NJETTINESSPLUGIN_HH__
+#include <fastjet/config.h>
 #include "Njettiness.hh"
+#include "MeasureFunction.hh"
+#include "AxesFinder.hh"
+#include "MeasureDefinition.hh"
+#include "AxesDefinition.hh"
+#include "TauComponents.hh"
 #include "fastjet/ClusterSequence.hh"
 …
 namespace contrib {
-//------------------------------------------------------------------------
-/// \class NjettinessExtras
-// This class contains the same information as Njettiness, but redoes it in terms of the ClusterSequence::Extras class.
-// This is done in order to help improve the interface for the main NjettinessPlugin class.
-// TODO:  This class should probably be merged with TauComponents, since both have access
-// to similar information
-class NjettinessExtras : public ClusterSequence::Extras {
-   public:
-      NjettinessExtras(TauComponents tau_components, std::vector<fastjet::PseudoJet> jets, std::vector<fastjet::PseudoJet> axes) : _tau_components(tau_components), _jets(jets), _axes(axes) {}
-      double totalTau() const {return _tau_components.tau();}
-      std::vector<double> subTaus() const {return _tau_components.jet_pieces();}
-      std::vector<fastjet::PseudoJet> jets() const {return _jets;}
-      std::vector<fastjet::PseudoJet> axes() const {return _axes;}
-      double totalTau(const fastjet::PseudoJet& /*jet*/) const {
-         return _tau_components.tau();
+      }
-      double subTau(const fastjet::PseudoJet& jet) const {
-         if (labelOf(jet) == -1) return std::numeric_limits<double>::quiet_NaN(); // nonsense
-         return _tau_components.jet_pieces()[labelOf(jet)];
+      }
-      double beamTau() const {
-         return _tau_components.beam_piece();
+      }
-      fastjet::PseudoJet axis(const fastjet::PseudoJet& jet) const {
-         return _axes[labelOf(jet)];
+      }
+      bool has_njettiness_extras(const fastjet::PseudoJet& jet) const {
+         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;
+   }
+};
+inline const NjettinessExtras * njettiness_extras(const fastjet::PseudoJet& jet) {
+   const ClusterSequence * myCS = jet.associated_cluster_sequence();
+   if (myCS == NULL) return NULL;
+   const NjettinessExtras* extras = dynamic_cast<const NjettinessExtras*>(myCS->extras());
+   return extras;
+}
+inline const NjettinessExtras * njettiness_extras(const fastjet::ClusterSequence& myCS) {
+   const NjettinessExtras* extras = dynamic_cast<const NjettinessExtras*>(myCS.extras());
+   return extras;
+}
+/// The Njettiness jet algorithm
+/// \class NjettinessPlugin
+/// \brief Implements the N-jettiness Jet Algorithm
 /**
  * An exclusive jet finder that identifies N jets; first N axes are found, then
 …
  * corresponding jet is simply the four-momentum sum of these particles.
+ *
  * Axes can be found in several ways, specified by the AxesMode argument.  The
  * recommended choices are
+ * As of version 2.2, it is recommended to use the XConePlugin, which has
+ * sensible default values for jet finding.
+ *
+ * kt_axes              : exclusive kT
+ * wta_kt_axes          : exclusive kT with winner-take-all-recombination
+ * onepass_kt_axes      : one-pass minimization seeded by kt (pretty good)
+ * onepass_wta_kt_axes  : one-pass minimization seeded by wta_kt
+ * Axes can be found in several ways, specified by the AxesDefinition argument.
+ * The recommended AxesDefinitions for jet finding (different than for jet shapes)
+ *    OnePass_AntiKT(R0)  :  one-pass minimization from anti-kT starting point
+ *    OnePass_GenET_GenKT_Axes(delta, p, R0) : one-pass min. from GenET/KT
+ *    OnePass_WTA_GenKT_Axes(p, R0)          : one-pass min from WTA/GenKT
+ * For recommendations on which axes to use, please see the README file.
+ *
+ * Jet regions are determined by the MeasureDefinition.  The recommended choices
+ * for jet finding are
+ *    ConicalMeasure(beta,R0) : perfect cones in rapidity/azimuth plane
+ *    XConeMeasure(beta,R0)   : approximate cones based on dot product distances.
+ *
+ * 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, ...)
+ *
+ *   DR_ij is the distance sqrt(Delta_phi^2 + Delta_rap^2) between particle i
+ *   and jet j.
+ * Other measures introduced in version 2.2 include OriginalGeometricMeasure,
+ * ModifiedGeometricMeasure, and ConicalGeometricMeasure, which define N-jettiness
+ * through dot products of particle momenta with light-like axes. OriginalGeometricMeasure
+ * produces football-shaped jets due to its central weighting of the beam measure,
+ * but ModifiedGeometric and ConicalGeometric both deform the original geometric measure
+ * to allow for cone-shaped jets. The size of these cones can be controlled through Rcutoff
+ * just as in the other measures. See the README file or MeasureDefinition.hh for information
+ * on how to call these measures.
+ *
- * 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.
+ *
  */
 class NjettinessPlugin : public JetDefinition::Plugin {
 public:
    // Constructor with same arguments as Nsubjettiness.
+   /// Constructor with same arguments as Nsubjettiness (N, AxesDefinition, MeasureDefinition)
    NjettinessPlugin(int N,
                     const AxesDefinition & axes_def,
 …
    : _njettinessFinder(axes_def, measure_def), _N(N) {}
+   /// Description
+   virtual std::string description () const;
+   /// Jet radius (this does not make sense yet)
+   virtual double R() const {return -1.0;} // TODO: make this not stupid
+   /// The actually clustering, which first called Njettiness and then creates a dummy ClusterSequence
+   virtual void run_clustering(ClusterSequence&) const;
+   /// For using manual axes with Njettiness Plugin
+   void setAxes(const std::vector<fastjet::PseudoJet> & myAxes) {
+      // Cross check that manual axes are being used is in Njettiness
+      _njettinessFinder.setAxes(myAxes);
+   }
+   /// Destructor
+   virtual ~NjettinessPlugin() {}
+private:
+   Njettiness _njettinessFinder;  ///< The core Njettiness that does the heavy lifting
+   int _N;  ///< Number of exclusive jets to find.
+   /// Warning if the user tries to use v1.0.3 constructor.
+   static LimitedWarning _old_constructor_warning;
+public:
    // Alternative constructors that define the measure via enums and parameters
+   // These constructors are likely be removed
+   // These constructors are deprecated and will be removed in a future version.
+   /// \deprecated
+   /// Old-style constructor with 0 arguments (DEPRECATED)
    NjettinessPlugin(int N,
+                 Njettiness::AxesMode axes_mode,
+                 Njettiness::MeasureMode measure_mode)
+   : _njettinessFinder(axes_mode, measure_mode, 0), _N(N) {}
+                    Njettiness::AxesMode axes_mode,
+                    Njettiness::MeasureMode measure_mode)
+   : _njettinessFinder(axes_mode, measure_mode, 0), _N(N) {
+      _old_constructor_warning.warn("NjettinessPlugin:  You are using the old style constructor.  This is deprecated as of v2.1 and will be removed in v3.0.  Please use the NjettinessPlugin constructor based on AxesDefinition and MeasureDefinition instead.");
+   }
+   /// \deprecated
+   /// Old-style constructor with 1 argument (DEPRECATED)
+      NjettinessPlugin(int N,
+                    Njettiness::AxesMode axes_mode,
+                    Njettiness::MeasureMode measure_mode,
+                    double para1)
+   : _njettinessFinder(axes_mode, measure_mode, 1, para1), _N(N) {
+      _old_constructor_warning.warn("NjettinessPlugin:  You are using the old style constructor.  This is deprecated as of v2.1 and will be removed in v3.0.  Please use the NjettinessPlugin constructor based on AxesDefinition and MeasureDefinition instead.");
+   }
+   /// \deprecated
+   /// Old-style constructor with 2 arguments (DEPRECATED)
    NjettinessPlugin(int N,
+                 Njettiness::AxesMode axes_mode,
+                 Njettiness::MeasureMode measure_mode,
+                 double para1)
+   : _njettinessFinder(axes_mode, measure_mode, 1, para1), _N(N) {}
+                    Njettiness::AxesMode axes_mode,
+                    Njettiness::MeasureMode measure_mode,
+                    double para1,
+                    double para2)
+   : _njettinessFinder(axes_mode, measure_mode, 2, para1, para2), _N(N) {
+      _old_constructor_warning.warn("NjettinessPlugin:  You are using the old style constructor.  This is deprecated as of v2.1 and will be removed in v3.0.  Please use the NjettinessPlugin constructor based on AxesDefinition and MeasureDefinition instead.");
+   }
+   /// \deprecated
+   /// Old-style constructor with 3 arguments (DEPRECATED)
    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) {}
+                    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_warning.warn("NjettinessPlugin:  You are using the old style constructor.  This is deprecated as of v2.1 and will be removed in v3.0.  Please use the NjettinessPlugin constructor based on AxesDefinition and MeasureDefinition instead.");
+   }
+   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 NormalizedCutoffMeasure was the only option
+   /// \deprecated
+   /// Old-style constructor for backwards compatibility with v1.0, when NormalizedCutoffMeasure was the only option
    NjettinessPlugin(int N,
                     Njettiness::AxesMode mode,
 …
                     double R0,
                     double Rcutoff=std::numeric_limits<double>::max())
+   : _njettinessFinder(mode, NormalizedCutoffMeasure(beta, R0, Rcutoff)), _N(N) {}
+   : _njettinessFinder(mode, NormalizedCutoffMeasure(beta, R0, Rcutoff)), _N(N) {
+      _old_constructor_warning.warn("NjettinessPlugin:  You are using the old style constructor.  This is deprecated as of v2.1 and will be removed in v3.0.  Please use the NjettinessPlugin constructor based on AxesDefinition and MeasureDefinition instead.");
+   }
-   // The things that are required by base class.
-   virtual std::string description () const;
-   virtual double R() const {return -1.0;} // TODO: make this not stupid
-   virtual void run_clustering(ClusterSequence&) const;
-   virtual ~NjettinessPlugin() {}
-private:
-   Njettiness _njettinessFinder;
-   int _N;
 };

external/fastjet/contribs/Nsubjettiness/Nsubjettiness.cc

-              rf118021
+              r973b92a
 //  Jesse Thaler, Ken Van Tilburg, Christopher K. Vermilion, and TJ Wilkason
 //
 //  $Id: Nsubjettiness.cc 597 2014-04-16 23:07:55Z jthaler $
+//  $Id: Nsubjettiness.cc 821 2015-06-15 18:50:53Z jthaler $
 //----------------------------------------------------------------------
 // This file is part of FastJet contrib.
 …
 namespace contrib {
+LimitedWarning Nsubjettiness::_old_constructor_warning;
 //result returns tau_N with normalization dependent on what is specified in constructor
 double Nsubjettiness::result(const PseudoJet& jet) const {

external/fastjet/contribs/Nsubjettiness/Nsubjettiness.hh

-              rf118021
+              r973b92a
 //  Jesse Thaler, Ken Van Tilburg, Christopher K. Vermilion, and TJ Wilkason
 //
 //  $Id: Nsubjettiness.hh 670 2014-06-06 01:24:42Z jthaler $
+//  $Id: Nsubjettiness.hh 822 2015-06-15 23:52:57Z jthaler $
 //----------------------------------------------------------------------
 // This file is part of FastJet contrib.
 …
 namespace contrib {
+//------------------------------------------------------------------------
+// Classes defined in this file.
+class Nsubjettiness;
+class NsubjettinessRatio;
+///------------------------------------------------------------------------
 /// \class Nsubjettiness
+/// Nsubjettiness extends the concept of Njettiness to a jet shape, but other
+/// than the set of particles considered, they are identical.  This class
+/// wraps the core Njettiness code to provide the fastjet::FunctionOfPseudoJet
+/// interface for convenience in larger analyses.  See NjettinessPlugin.hh for
+/// definitions of tau_N and the constructor options.
+/// \brief Implements the N-subjettiness jet shape
+///
+/**
+ * The N-jettiness jet shape.
+ *
+ * Nsubjettiness extends the concept of Njettiness to a jet shape, but other
+ * than the set of particles considered, they are identical.  This class
+ * wraps the core Njettiness code to provide the fastjet::FunctionOfPseudoJet
+ * interface for convenience in larger analyses.
+ *
+ * The recommended AxesDefinitions are:
+ *   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
+ * More AxesDefinitions are listed in the README and defined in AxesDefinition.hh
+ *
+ * The recommended MeasureDefinitions 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
+ * More MeasureDefinitions are listed in the README and defined in MeasureDefinition.hh
+ *
+ * For example, for the UnnormalizedMeasure(beta), N-subjettiness is defined as:
+ *
+ * tau_N = Sum_{i in jet} p_T^i min((DR_i1)^beta, (DR_i2)^beta, ...)
+ *
+ *   DR_ij is the distance sqrt(Delta_phi^2 + Delta_rap^2) between particle i
+ *   and jet j.
+ *
+ * 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.
+ */
 class Nsubjettiness : public FunctionOfPseudoJet<double> {
 public:
+   // 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
+   /// Main constructor, which takes N, the AxesDefinition, and the MeasureDefinition.
+   /// The Definitions are given in AxesDefinition.hh and MeasureDefinition.hh
    Nsubjettiness(int N,
                  const AxesDefinition& axes_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)
+   /// Returns tau_N, measured on the constituents of this jet
+   double result(const PseudoJet& jet) const;
+   /// Returns components of tau_N, so that user can find individual tau values.
+   TauComponents component_result(const PseudoJet& jet) const;
+   /// To set axes in manual mode
+   void setAxes(const std::vector<fastjet::PseudoJet> & myAxes) {
+      // Note that cross check that manual mode has been set is in Njettiness
+        _njettinessFinder.setAxes(myAxes);
+   }
+   /// returns seed axes used for onepass minimization (otherwise same as currentAxes)
+   std::vector<fastjet::PseudoJet> seedAxes() const {
+      return _njettinessFinder.seedAxes();
+   }
+   /// returns current axes found by result() calculation
+   std::vector<fastjet::PseudoJet> currentAxes() const {
+      return _njettinessFinder.currentAxes();
+   }
+   /// 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();
+   }
+   /// returns components of tau_N without recalculating anything
+   TauPartition currentPartition() const {
+      return _njettinessFinder.currentPartition();
+   }
+private:
+   /// Core Njettiness code that is called
+   Njettiness _njettinessFinder; // TODO:  should muck with this so result can be const without this mutable
+   /// Number of subjets to find
+   int _N;
+   /// Warning if the user tries to use v1.0.3 constructor.
+   static LimitedWarning _old_constructor_warning;
+public:
+   // The following interfaces are included for backwards compatibility, but no longer recommended.
+   // They may be deleted in a future release
+   /// \deprecated
+   /// Alternative constructors that define the measure via enums and parameters
+   /// These constructors will be removed in v3.0
+   /// 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)
+   : _njettinessFinder(axes_mode, measure_mode, 0), _N(N) {
+      _old_constructor_warning.warn("Nsubjettiness:  You are using the old style constructor.  This is deprecated as of v2.1 and will be removed in v3.0.  Please use the Nsubjettiness constructor based on AxesDefinition and MeasureDefinition instead.");
+   }
+   /// \deprecated
+   /// Construcotr for one parameter argument
+   /// (for unnormalized_measure, para1=beta)
    Nsubjettiness(int N,
                  Njettiness::AxesMode axes_mode,
                  Njettiness::MeasureMode measure_mode,
                  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)
+   : _njettinessFinder(axes_mode, measure_mode, 1, para1), _N(N) {
+      _old_constructor_warning.warn("Nsubjettiness:  You are using the old style constructor.  This is deprecated as of v2.1 and will be removed in v3.0.  Please use the Nsubjettiness constructor based on AxesDefinition and MeasureDefinition instead.");
+   }
+   /// \deprecated
+   /// Constructor for 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,
 …
                  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)
+   : _njettinessFinder(axes_mode, measure_mode, 2, para1, para2), _N(N) {
+      _old_constructor_warning.warn("Nsubjettiness:  You are using the old style constructor.  This is deprecated as of v2.1 and will be removed in v3.0.  Please use the Nsubjettiness constructor based on AxesDefinition and MeasureDefinition instead.");
+   }
+   /// \deprecated
+   /// Constructor for three parameter arguments
+   /// (for unnormalized_cutoff_measure, para1=beta, para2=R0, para3=Rcutoff)
    Nsubjettiness(int N,
                  Njettiness::AxesMode axes_mode,
 …
                  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
+   : _njettinessFinder(axes_mode, measure_mode, 3, para1, para2, para3), _N(N) {
+      _old_constructor_warning.warn("Nsubjettiness:  You are using the old style constructor.  This is deprecated as of v2.1 and will be removed in v3.0.  Please use the Nsubjettiness constructor based on AxesDefinition and MeasureDefinition instead.");
+   }
+   /// \deprecated
+   /// Old constructor for backwards compatibility with v1.0,
+   /// where normalized_cutoff_measure was the only option
    Nsubjettiness(int N,
                  Njettiness::AxesMode axes_mode,
 …
                  double R0,
                  double Rcutoff=std::numeric_limits<double>::max())
+   : _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 components of tau_N, so that user can find individual tau values.
+   TauComponents component_result(const PseudoJet& jet) const;
+   /// returns current axes found by result() calculation
+   std::vector<fastjet::PseudoJet> currentAxes() const {
+      return _njettinessFinder.currentAxes();
+   }
+   /// returns seed axes used for onepass minimization (otherwise same as currentAxes)
+   std::vector<fastjet::PseudoJet> seedAxes() const {
+      return _njettinessFinder.seedAxes();
+   }
+   /// 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(const std::vector<fastjet::PseudoJet> & myAxes) {
+      // Cross check that manual axes are being used is in Njettiness
+        _njettinessFinder.setAxes(myAxes);
+   }
+private:
+   Njettiness _njettinessFinder; // TODO:  should muck with this so result can be const without this mutable
+   int _N;
+   : _njettinessFinder(axes_mode, NormalizedCutoffMeasure(beta,R0,Rcutoff)), _N(N) {
+      _old_constructor_warning.warn("Nsubjettiness:  You are using the old style constructor.  This is deprecated as of v2.1 and will be removed in v3.0.  Please use the Nsubjettiness constructor based on AxesDefinition and MeasureDefinition instead.");
+   }
 };
 //------------------------------------------------------------------------
+///------------------------------------------------------------------------
 /// \class NsubjettinessRatio
+// NsubjettinessRatio uses the results from Nsubjettiness to calculate the ratio
+// tau_N/tau_M, where N and M are specified by the user. The ratio of different tau values
+// is often used in analyses, so this class is helpful to streamline code.
+/// \brief Implements ratios of N-subjettiness jet shapes
+///
+/// NsubjettinessRatio uses the results from Nsubjettiness to calculate the ratio
+/// tau_N/tau_M, where N and M are specified by the user. The ratio of different tau values
+/// is often used in analyses, so this class is helpful to streamline code.  Note that
+/// manual axis mode is not supported
 class NsubjettinessRatio : public FunctionOfPseudoJet<double> {
 public:
    // Main constructor.  Apart from specifying both N and M, the same options as Nsubjettiness
+   /// Main constructor.  Apart from specifying both N and M, the same options as Nsubjettiness
    NsubjettinessRatio(int N,
                       int M,
 …
                       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
+   _nsub_denominator(M,axes_def,measure_def) {
+      if (axes_def.needsManualAxes()) {
+         throw Error("NsubjettinessRatio does not support ManualAxes mode.");
+      }
+   }
+   /// Returns tau_N/tau_M based off the input jet using result function from Nsubjettiness
+   double result(const PseudoJet& jet) const;
+private:
+   Nsubjettiness _nsub_numerator;   ///< Function for numerator
+   Nsubjettiness _nsub_denominator; ///< Function for denominator
+public:
+   // The following interfaces are included for backwards compatibility, but no longer recommended.
+   // They may be deprecated at some point.
+   /// \deprecated
+   /// Old-style constructor for zero arguments
+   /// Alternative constructor with enums and parameters
+   /// Again, likely to be removed
    NsubjettinessRatio(int N,
                       int M,
 …
    : _nsub_numerator(N, axes_mode, measure_mode),
    _nsub_denominator(M, axes_mode, measure_mode) {}
+   /// \deprecated
+   /// Old-style constructor for one argument
    NsubjettinessRatio(int N,
                       int M,
 …
    : _nsub_numerator(N, axes_mode, measure_mode, para1),
    _nsub_denominator(M, axes_mode, measure_mode, para1) {}
+   /// \deprecated
+   /// Old-style constructor for 2 arguments
    NsubjettinessRatio(int N,
                       int M,
 …
    _nsub_denominator(M, axes_mode, measure_mode, para1, para2) {}
+   /// \deprecated
+   /// Old-style constructor for 3 arguments
    NsubjettinessRatio(int N,
                       int M,
 …
    _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;
+private:
+   Nsubjettiness _nsub_numerator;
+   Nsubjettiness _nsub_denominator;
 };

external/fastjet/contribs/Nsubjettiness/README

-              rf118021
+              r973b92a
 New in v2.0 is the winner-take-all axis, which is described in:
+   Jet Observables Without Jet Algorithms.
+   Daniele Bertolini, Tucker Chan, and Jesse Thaler.
+   JHEP 1404:013 (2014), arXiv:1310.7584.
    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.
+   Unpublished work by Gavin Salam
+New in v2.2 are new measures used in the XCone jet algorithm, described in:
+   XCone: N-jettiness as an Exclusive Cone Jet Algorithm.
+   Iain W. Stewart, Frank J. Tackmann, Jesse Thaler,
+   Christopher K. Vermilion, and Thomas F. Wilkason.
+   arXiv:1508.01516.
+   Resolving Boosted Jets with XCone.
+   Jesse Thaler and Thomas F. Wilkason.
+   arXiv:1508.01518.
 --------------------------------------------------------------------------------
 …
 Nsubjettiness       [Nsubjettiness.hh]:
+   A FunctionOfPseudoJet<double> interface to measure N-subjettiness
+   A FunctionOfPseudoJet<double> interface to measure the
+   N-subjettiness jet shape
    (Recommended for most users)
 NsubjettinessRatio  [Nsubjettiness.hh]:
    A FunctionOfPseudoJet<double> interface to measure ratios of
    two different N-subjettiness (i.e. tau3/tau2)
+   (Recommended for most users)
+XConePlugin         [XConePlugin.hh]:
+   A FastJet plugin for using the XCone jet algorithm.
+   (Recommended for most users)
 NjettinessPlugin    [NjettinessPlugin.hh]:
+   A FastJet plugin for finding jets by minimizing N-jettiness
+   (Recommended for advanced users)
+   A FastJet plugin for finding jets by minimizing N-jettiness.
+   Same basic philosophy as XCone, but many more options.
+   (Recommended for advanced users only.)
 Njettiness          [Njettiness.hh]:
    Access to the core Njettiness code.
    (Not recommended for users, since the interface might change)
 The code assumes that you have FastJet 3.
+The code assumes that you have FastJet 3, but does not (yet) require FastJet 3.1
 --------------------------------------------------------------------------------
 …
     // N and M give tau_N / tau_M, all other options the same
+For example, if you just want the tau_2/tau_1 value of a jet, using recommended
+parameter choices, do this:
+    PseudoJet this_jet = /*from your favorite jet algorithm*/;
+    double beta = 1.0;
+    NsubjettinessRatio nSub21(2,1,
+                              OnePass_WTA_KT_Axes(),
+                              UnnormalizedMeasure(beta));
+    double tau21 = nSub21(this_jet);
 --------------------------------------------------------------------------------
 AxesDefinition  [NjettinessDefinition.hh]
 …
 recommended. Arguments in parentheses are parameters that the user must set.
+Axes can be found using standard recursive clustering procedures.  New is the
+option to use the "winner-take-all" recombination scheme:
+(*) KT_Axes           // exclusive kt axes
+    CA_Axes           // exclusive ca axes
+    AntiKT_Axes(R0)   // inclusive hardest axes with antikt, R0 = radius
+(*) WTA_KT_Axes       // exclusive kt with winner-take-all recombination
+    WTA_CA_Axes       // exclusive ca with winner-take-all recombination
+One can also run a minimization routine to find a (local) minimum of
+N-(sub)jettiness:
+Axes can be found using standard recursive clustering procedures.  New in v2 is
+the option to use the "winner-take-all" recombination scheme:
+(*) KT_Axes          // exclusive kt axes
+    CA_Axes          // exclusive ca axes
+    AntiKT_Axes(R0)  // inclusive hardest axes with antikt, R0 = radius
+(*) WTA_KT_Axes      // exclusive kt with winner-take-all recombination
+    WTA_CA_Axes      // exclusive ca with winner-take-all recombination
+New in v2.2 are generalized recombination/clustering schemes:
+    GenET_GenKT_Axes(delta, p, R0 = inf)
+    WTA_GenKT_Axes(p, R0 = inf)
+    GenKT_Axes(p, R0 = inf)
+Here, delta > 0 labels the generalized ET recombination scheme (delta = 1 for
+standard ET scheme, delta = 2 for ET^2 scheme, delta = infinity for WTA scheme)
+p >= 0 labels the generalized KT clustering metric (p = 0 for ca, p = 1 for kt),
+R0 is the radius parameter, and the clustering is run in exclusive mode.  The
+GenKT_Axes mode uses standard E-scheme recombination.  By default the value of
+R0 is set to "infinity", namely fastjet::JetDefinition::max_allowable_R.
+Also new in v2.2 is option of identifying nExtra axes through exclusive
+clustering and then looking at all (N + nExtra) choose N axes and finding the
+one that gives the smallest N-(sub)jettiness value:
+    Comb_GenET_GenKT_Axes(nExtra, delta, p, R0 = inf)
+    Comb_WTA_GenKT_Axes(nExtra, p, R0 = inf)
+    Comb_GenKT_Axes(nExtra, p, R0 = inf)
+These modes are not recommended for reasons of speed.
+Starting from any set of seed axes, one can run a minimization routine to find
+a (local) minimum of N-(sub)jettiness.  Note that the one-pass minimization
+routine is tied to the choice of MeasureDefinition.
 (*) OnePass_KT_Axes          // one-pass minimization from kt starting point
     OnePass_CA_Axes          // one-pass min. from ca starting point
 …
 (*) OnePass_WTA_KT_Axes      // one-pass min. from wta_kt starting point
     OnePass_WTA_CA_Axes      // one-pass min. from wta_ca starting point
+In general, it is difficult to finding the global minimum, but this mode
+attempts to do so
+    MultiPass_Axes(Npass)    // axes that (attempt to) minimize N-subjettiness
+                             // (NPass = 100 is typical)
+    OnePass_GenET_GenKT_Axes(delta, p, R0 = inf) // one-pass min. from GenET/KT
+    OnePass_WTA_GenKT_Axes(p, R0 = inf)          // one-pass min from WTA/GenKT
+    OnePass_GenKT_Axes(p, R0 = inf)              // one-pass min from GenKT
+For one-pass minimization, OnePass_CA_Axes and OnePass_WTA_CA_Axes are not
+recommended as they provide a poor choice of seed axes.
+In general, it is difficult to find the global minimum, but this mode attempts
+to do so:
+    MultiPass_Axes(NPass) // axes that (attempt to) minimize N-subjettiness
+                          // (NPass = 100 is typical)
+This does multi-pass minimization from KT_Axes starting points.
 Finally, one can set manual axes:
+    Manual_Axes          // set your own axes with setAxes()
+    OnePass_Manual_Axes  // one-pass minimization from manual starting point
+    Manual_Axes              // set your own axes with setAxes()
+    OnePass_Manual_Axes      // one-pass minimization from manual starting point
+    MultiPass_Manual_Axes(Npass) // multi-pass min. from manual
+If one wants to change the number of passes used by any of the axes finders, one
+can call the function
+    setNPass(NPass,nAttempts,accuracy,noise_range)
+where NPass = 0 only uses the seed axes, NPass = 1 is one-pass minimization, and
+NPass = 100 is the default multi-pass.  nAttempts is the number of iterations to
+use in each pass, accuracy is how close to the minimum one tries to get, and
+noise_range is how much in rapidity/azimuth the random axes are jiggled.
 For most cases, running with OnePass_KT_Axes or OnePass_WTA_KT_Axes gives
 reasonable results (and the results are IRC safe).  Because it uses random
 number seeds, MultiPass_Axes is not IRC safe (and the code is rather slow).  Note
+that for the minimization routines, beta = 1.1 is faster than beta = 1, with
 comparable performance.
+number seeds, MultiPass_Axes is not IRC safe (and the code is rather slow).
+Note that for the minimization routines, beta = 1.1 is faster than beta = 1,
+with comparable performance.
 --------------------------------------------------------------------------------
 …
 --------------------------------------------------------------------------------
+At the moment, there are only a few measures.  Note that each one has a
+different number of parameters.  The one indicated by (*)
+is the one recommended for use by users new to Nsubjettiness.
+The value of N-(sub)jettiness depends crucially on the choice of measure.  Each
+measure has a different number of parameters, so one has to be careful when
+switching between measures  The one indicated by (*) is the one recommended for
+use by users new to Nsubjettiness.
 The original N-subjettiness measures are:
 …
     UnnormalizedCutoffMeasure(beta,Rcutoff)  //unnormalized measure with
                                              //additional Rcutoff
+In beta testing are "geometric" measures where distances are measured using the
+Lorentz dot product (N.B. the formula for the geometric measure is likely to
+change since there should be separate beam and jet beta factors.)
+    GeometricMeasure(beta)               //geometric measure with exponent beta
+    GeometricCutoffMeasure(beta,Rcutoff) //geometric measure with Rcutoff
+For all of the above measures, there is an optional argument to change from the
+ordinary pt_R distance measure recommended for pp collisions to an
+E_theta distance measure recommended for ee collisions.  There are also
+lorentz_dot and perp_lorentz_dot distance measures recommended only for
+advanced users.
+New for v2.2 is a set of measures defined in arXiv:1508.01516.  First, there is
+the "conical measure":
+    ConicalMeasure(beta,R0) // same jets as UnnormalizedCutoffMeasure
+                            // but differs in normalization and specifics
+                            // of one-pass minimization
+Next, there is the geometric measure (as well as a modified version to yield
+more conical jet regions):
+    OriginalGeometricMeasure(R) // not recommended for analysis
+    ModifiedGeometricMeasure(R)
+(Prior to v2.2, there was a "GeometricMeasure" which unfortunately had the wrong
+definition.  These have been commented out in the code as
+"DeprecatedGeometricMeasure" and "DeprecatedGeometricCutoffMeasure", but they
+should not be used.)
+Next, there is a "conical geometric" measure:
+    ConicalGeometricMeasure(beta, gamma, Rcutoff)
+This is a hybrid between the conical and geometric measures and is the basis for
+the XCone jet algorithm.  Finally, setting to the gamma = 1 default gives the
+XCone default measure, which is used in the XConePlugin jet finder
+(*)  XConeMeasure(beta,Rcutoff)
+where beta = 2 is the recommended default value and beta = 1 is the recoil-free
+default.
 --------------------------------------------------------------------------------
 …
 beta = 1:  aka broadening/girth/width measure
+   the axes behave like the "median" in that they point to the hardest cluster
    wta_kt_axes are approximately the same as minimizing beta = 1 measure
 beta = 2:  aka thrust/mass measure
+   the axes behave like the "mean" in that they point along the jet momentum
    kt_axes are approximately the same as minimizing beta = 2 measure
 …
 --------------------------------------------------------------------------------
+TauComponents  [MeasureFunction.hh]
+--------------------------------------------------------------------------------
+For most users, they will only need the value of N-subjettiness (i.e. tau)
+itself.  For advanced users, they can access individual tau components (i.e.
+the individual numerator pieces, the denominator, etc.)
+   TauComponents tauComp = nSub.component_result(jet);
+   vector<double> numer = tauComp.jet_pieces_numerator(); //tau for each subjet
+   double denom = tauComp.denominator();  //normalization factor
+--------------------------------------------------------------------------------
+WinnerTakeAllRecombiner  [WinnerTakeAllRecombiner.hh]
+--------------------------------------------------------------------------------
+New for version 2.0 of Nsubjettiness are winner-take-all axes.  They are found
+with the help of the WinnerTakeAllRecombiner. This class defines a new
+recombination scheme for clustering particles. This scheme recombines two
+PseudoJets into a PseudoJet with pT of the sum of the two input PseudoJet pTs
+and direction of the harder PseudoJet.  This is a "recoil-free" recombination
+scheme that guarantees that the axes is aligned with one of the input particles.
+It is IRC safe.  Axes found with the standard E-scheme recombiner at similar to
+the beta = 2 minimization, while winner-take-all is similar to the beta = 1
+measure.
+Note that the WinnerTakeAllRecombiner can be used outside of Nsubjettiness
+itself for jet finding.  For example, the direction of anti-kT jets found
+with the WinnerTakeAllRecombiner is particularly robust against soft jet
+contamination.
+XConePlugin  [XConePlugin.hh]
+--------------------------------------------------------------------------------
+The XCone FastJet plugin is an exclusive cone jet finder which yields a
+fixed N number of jets which approximately conical boundaries. The algorithm
+finds N axes, and jets are simply the sum of particles closest to a given axis
+(or unclustered if they are closest to the beam).  Unlike the NjettinessPlugin
+below, the user is restricted to using the XConeMeasure.
+   XConePlugin plugin(N,R,beta=2);
+   JetDefinition def(&plugin);
+   ClusterSequence cs(vector<PseudoJet>,def);
+   vector<PseudoJet> jets = cs.inclusive_jets();
+Note that despite being an exclusive jet algorithm, one finds the jets using the
+inclusive_jets() call.
+The AxesDefinition and MeasureDefinition are defaulted in this measure to
+OnePass_GenET_GenKT_Axes and XConeMeasure, respectively. The parameters chosen
+for the OnePass_GenET_GenKT_Axes are defined according to the chosen value of
+beta as delta = 1/(beta - 1) and p = 1/beta. These have been shown to give the
+optimal choice of seed axes. The R value for finding the axes is chosen to be
+the same as the R for the jet algorithm, although in principle, these two radii
+could be different.
+N.B.:  The order of the R, beta arguments is *reversed* from the XConeMeasure
+itself, since this ordering is the more natural one to use for Plugins.  We
+apologize in advance for any confusion this might cause.
 --------------------------------------------------------------------------------
 …
 --------------------------------------------------------------------------------
+The Njettiness FastJet plugin represents an exclusive jet finder (yielding a
+fixed N number of jets). The algorithm finds N axes, and jets are simply the sum
+of particles closest to a given axis (or unclustered if they are closest to the
+beam).  The axes finding methods and measures are the same as for Nsubjettiness.
+Same as the XConePlugin, but the axes finding methods and measures are the same
+as for Nsubjettiness, allowing more flexibility.
    NjettinessPlugin plugin(N, AxesDefinition, MeasureDefinition);
 …
    vector<PseudoJet> jets = cs.inclusive_jets();
-Note that despite being an exclusive jet algorithm, one finds the jets using the
-inclusive_jets() call.
 --------------------------------------------------------------------------------
 Very Advanced Usage:  Njettiness  [Njettiness.hh]
 …
 Most users will want to use the Nsubjettiness or NjettinessPlugin classes to
 access N-(sub)jettiness information.  For direct access to the Njettiness class,
+one can use Njettiness.hh directly. This class is still evolving, so users who
+wish to extend its functionality should contact the authors first.
+one can use Njettiness.hh directly. This class is in constant evolution, so
+users who wish to extend its functionality should contact the authors first.
+--------------------------------------------------------------------------------
+TauComponents  [MeasureDefinition.hh]
+--------------------------------------------------------------------------------
+For most users, they will only need the value of N-subjettiness (i.e. tau)
+itself.  For advanced users, they can access individual tau components (i.e.
+the individual numerator pieces, the denominator, etc.)
+   TauComponents tauComp = nSub.component_result(jet);
+   vector<double> numer = tauComp.jet_pieces_numerator(); //tau for each subjet
+   double denom = tauComp.denominator();  //normalization factor
+--------------------------------------------------------------------------------
+Extra Recombiners  [ExtraRecombiners.hh]
+--------------------------------------------------------------------------------
+New in v2.0 are winner-take-all axes.  (These have now been included in
+FastJet 3.1, but we have left the code here to allow the plugin to work under
+FJ 3.0).  These axes are found with the help of the WinnerTakeAllRecombiner.
+This class defines a new recombination scheme for clustering particles. This
+scheme recombines two PseudoJets into a PseudoJet with pT of the sum of the two
+input PseudoJet pTs and direction of the harder PseudoJet.  This is a
+"recoil-free" recombination scheme that guarantees that the axes is aligned with
+one of the input particles. It is IRC safe.  Axes found with the standard
+E-scheme recombiner at similar to the beta = 2 minimization, while
+winner-take-all is similar to the beta = 1 measure.
+New in v2.2 is the GeneralEtSchemeRecombiner, as defined in arxiv:1506.XXXX.
+This functions similarly to the Et-scheme defined in Fastjet, but the reweighting
+of the sum of rap and phi is parameterized by an exponent delta. Thus, delta = 1
+is the normal Et-scheme recombination, delta = 2 is Et^2 recombination, and
+delta = infinity is the winner-take-all recombination. This recombination scheme
+is used in GenET_GenKT_Axes, and we find that optimal seed axes for minimization
+can be found by using delta = 1/(beta - 1).
+Note that the WinnerTakeAllRecombiner can be used outside of Nsubjettiness
+itself for jet finding.  For example, the direction of anti-kT jets found
+with the WinnerTakeAllRecombiner is particularly robust against soft jet
+contamination.  That said, this functionality is now included in FJ 3.1, so this
+code is likely to be deprecated in a future version.
 --------------------------------------------------------------------------------
 …
 N-(sub)jettiness:
 AxesFinder.hh:
 The AxesFinder class (and derived classes) defines the axes used in the
+AxesDefinition.hh:
+The AxesDefinition class (and derived classes) defines the axes used in the
 calculation of N-(sub)jettiness.  These axes can be defined from the exclusive
 jets from a kT or CA algorithm, the hardest jets from an anti-kT algorithm,
 …
 AxesDefinition.
 MeasureFunction.hh:
 The MeasureFunction class (and derived classes) defines the measure by which
+MeasureDefinition.hh:
+The MeasureDefinition class (and derived classes) defines the measure by which
 N-(sub)jettiness is calculated. This measure is calculated between each
 particle and its corresponding axis, and then summed and normalized to
 …
 and its axis, and beta is the angular exponent.  Again, in the future the user
 will be able to write their own measures, but for the time being, only the
+predefined MeasureDefinition values should be used.
+predefined MeasureDefinition values should be used.  Note that the one-pass
+minimization algorithms are defined within MeasureDefinition, since they are
+measure specific.
 --------------------------------------------------------------------------------
 …
 -- The MultiPass_Axes mode gives different answers on different runs, since
    random numbers are used.
+-- In rare cases, one pass minimization can give a larger value of Njettiness
+   than without minimization.
+-- For the default measures, in rare cases, one pass minimization can give a
+   larger value of Njettiness than without minimization. The reason is due
+   to the fact that axes in default measure are not defined as light-like
 -- Nsubjettiness is not thread safe, since there are mutables in Njettiness.
+-- If the AxesDefinition does not find N axes, then it adds zero vectors to the
+   list of axes to get the total up to N.  This can lead to unpredictable
+   results (including divide by zero issues), and a warning is thrown to alert
+   the user.
+--------------------------------------------------------------------------------
+--------------------------------------------------------------------------------

external/fastjet/contribs/Nsubjettiness/VERSION

rf118021	r973b92a
1		2.~~1.0~~
	1	2.2.1

external/fastjet/internal/DnnPlane.hh

-              rf118021
+              r973b92a
 //FJSTARTHEADER
 // $Id: DnnPlane.hh 3442 2014-07-24 07:20:49Z salam $
+// $Id: DnnPlane.hh 3918 2015-07-03 14:19:13Z salam $
 //
 // Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
 …
     // no crash... that's done by checking (near != NULL)
     if ((std::abs(dist-mindist)<DISTANCE_FOR_CGAL_CHECKS) &&
         (near != NULL) &&
+        _is_not_null(near) && // GPS cf. note below about != NULL with clang/CGAL
         (_euclid_distance(candidate, near->point())<DISTANCE_FOR_CGAL_CHECKS)){
       // we're in a situation where there might be a rounding issue,
 …
   /// then use CGAL to compare the distances.
   static const double DISTANCE_FOR_CGAL_CHECKS;
+  /// small routine to check if if a vertex handle is not null.
+  ///
+  /// This is centralised here because of the need for a not-very
+  /// readable workaround for certain CGAL/clang++ compiler
+  /// combinations.
+  inline static bool _is_not_null(const Vertex_handle & vh) {
+    // as found in issue 2015-07-clang61+CGAL, the form
+    //   vh != NULL
+    // appears to be broken with CGAL-3.6 and clang-3.6.0/.1
+    //
+    // The not very "readable"
+    //   vh.operator->()
+    // does the job instead
+    return vh.operator->();
+  }
 };
 …
 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;} }
+    return _is_not_null(_supervertex[index].vertex);
+  }
+  else {
+    return false;
+  }
+}
 inline EtaPhi DnnPlane::etaphi(const int i) const {

Context Navigation

Changeset 973b92a in git for external

Legend:

external/fastjet/ClusterSequence.hh

external/fastjet/ClusterSequence_Delaunay.cc

external/fastjet/DnnPlane.cc

external/fastjet/VERSION

external/fastjet/config_auto.h

external/fastjet/config_raw.h

external/fastjet/config_win.h

external/fastjet/contribs/Nsubjettiness/AUTHORS

external/fastjet/contribs/Nsubjettiness/COPYING

external/fastjet/contribs/Nsubjettiness/ChangeLog

external/fastjet/contribs/Nsubjettiness/ExtraRecombiners.cc

external/fastjet/contribs/Nsubjettiness/NEWS

external/fastjet/contribs/Nsubjettiness/Njettiness.cc

external/fastjet/contribs/Nsubjettiness/Njettiness.hh

external/fastjet/contribs/Nsubjettiness/NjettinessPlugin.cc

external/fastjet/contribs/Nsubjettiness/NjettinessPlugin.hh

external/fastjet/contribs/Nsubjettiness/Nsubjettiness.cc

external/fastjet/contribs/Nsubjettiness/Nsubjettiness.hh

external/fastjet/contribs/Nsubjettiness/README

external/fastjet/contribs/Nsubjettiness/VERSION

external/fastjet/internal/DnnPlane.hh

Download in other formats: