Fork me on GitHub

Changeset 1d208a2 in git for external/fastjet


Ignore:
Timestamp:
Aug 30, 2016, 12:36:00 AM (8 years ago)
Author:
Pavel Demin <pavel.demin@…>
Branches:
ImprovedOutputFile, Timing, dual_readout, llp, master
Children:
6be4bc0
Parents:
d091310
Message:

update FastJet library to 3.2.1 and Nsubjettiness library to 2.2.4

Location:
external/fastjet
Files:
5 added
1 deleted
68 edited

Legend:

Unmodified
Added
Removed

  • external/fastjet/CircularRange.hh

    rd091310 r1d208a2  
    11//FJSTARTHEADER
    2 // $Id: CircularRange.hh 3433 2014-07-23 08:17:03Z salam $
     2// $Id: CircularRange.hh 4074 2016-03-08 09:09:25Z soyez $
    33//
    44// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
    … …  
    3535#include "fastjet/RangeDefinition.hh"
    3636#include "fastjet/Error.hh"
     37#include "fastjet/internal/deprecated.hh"
    3738
    3839// for backwards compatibility: one should now use SelectorCircle,
    … …  
    5051public:
    5152  /// constructor
     53  FASTJET_DEPRECATED_MSG("CircularRange is deprecated since FastJet 3.0. Use SelectorCircle instead")
    5254  CircularRange() {_set_invalid_rapphi();}
    5355 
    5456  /// initialise CircularRange with a jet
     57  FASTJET_DEPRECATED_MSG("CircularRange is deprecated since FastJet 3.0. Use SelectorCircle instead")
    5558  CircularRange(const fastjet::PseudoJet & jet, double distance) {
    5659                _distance = distance;
    … …  
    6063
    6164  /// initialise CircularRange with a (rap,phi) point
     65  FASTJET_DEPRECATED_MSG("CircularRange is deprecated since FastJet 3.0. Use SelectorCircle instead")
    6266  CircularRange(double rap, double phi, double distance) {
    6367                _distance = distance;
    … …  
    6771
    6872  /// initialise CircularRange with just the radius parameter
     73  FASTJET_DEPRECATED_MSG("CircularRange is deprecated since FastJet 3.0. Use SelectorCircle instead")
    6974  CircularRange(double distance) {
    7075                _set_invalid_rapphi();
    … …  
    7681 
    7782  /// return description of range
    78   virtual inline std::string description() const {
     83  virtual inline std::string description() const FASTJET_OVERRIDE {
    7984    std::ostringstream ostr;
    8085    ostr << "CircularRange: within distance "<< _distance << " of given jet or point." ;
    … …  
    8388  /// returns true since this range is localizable (i.e. set_position
    8489  /// does something meaningful)
    85   virtual inline bool is_localizable() const { return true; }
     90  virtual inline bool is_localizable() const FASTJET_OVERRIDE { return true; }
    8691 
    8792  /// return bool according to whether (rap,phi) is in range
    88   virtual inline bool is_in_range(double rap, double phi) const {
     93  virtual inline bool is_in_range(double rap, double phi) const FASTJET_OVERRIDE {
    8994     if (! _rapphi_are_valid()) {
    9095       throw Error("Circular range used without a center having being defined (use set_position())");
    … …  
    98103
    99104  /// return the minimal and maximal rapidity of this range
    100   virtual inline void get_rap_limits(double & rapmin, double & rapmax) const {
     105  virtual inline void get_rap_limits(double & rapmin, double & rapmax) const FASTJET_OVERRIDE {
    101106     rapmin = _rapjet - _distance;
    102107     rapmax = _rapjet + _distance; }

  • external/fastjet/ClosestPair2D.cc

    rd091310 r1d208a2  
    11//FJSTARTHEADER
    2 // $Id: ClosestPair2D.cc 3433 2014-07-23 08:17:03Z salam $
     2// $Id: ClosestPair2D.cc 4059 2016-03-03 20:49:48Z soyez $
    33//
    44// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
    … …  
    145145
    146146    // and create the search tree
    147     _trees[ishift] = auto_ptr<Tree>(new Tree(shuffles, max_size));
     147    _trees[ishift] = SharedPtr<Tree>(new Tree(shuffles, max_size));
    148148
    149149    // now we look for the closest-pair candidates on this tree
    … …  
    174174    mindists2[i] = _points[i].neighbour_dist2;}
    175175 
    176   _heap = auto_ptr<MinHeap>(new MinHeap(mindists2, max_size));
     176  _heap = SharedPtr<MinHeap>(new MinHeap(mindists2, max_size));
    177177}
    178178

  • external/fastjet/ClusterSequence.cc

    rd091310 r1d208a2  
    11//FJSTARTHEADER
    2 // $Id: ClusterSequence.cc 3809 2015-02-20 13:05:13Z soyez $
     2// $Id: ClusterSequence.cc 4154 2016-07-20 16:20:48Z soyez $
    33//
    44// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
    … …  
    152152  // set the pointer in the wrapper to this object to NULL to say that
    153153  // we're going out of scope
    154   if (_structure_shared_ptr()){
    155     ClusterSequenceStructure* csi = dynamic_cast<ClusterSequenceStructure*>(_structure_shared_ptr());
     154  if (_structure_shared_ptr){
     155    ClusterSequenceStructure* csi = dynamic_cast<ClusterSequenceStructure*>(_structure_shared_ptr.get());
    156156    // normally the csi is purely internal so it really should not be
    157157    // NULL i.e assert should be OK
    … …  
    724724  }
    725725 
    726   bool code_should_never_reach_here = false;
    727   assert(code_should_never_reach_here);
     726  //bool code_should_never_reach_here = false;
     727  //assert(code_should_never_reach_here);
     728
     729  assert(0 && "Code should never reach here");
     730
    728731  return N2MHTLazy9;
    729732
    … …  
    775778
    776779
     780ClusterSequence & ClusterSequence::operator=(const ClusterSequence & cs) {
     781  // self assignment is trivial
     782  if (&cs != this) {
     783    _deletes_self_when_unused = false;
     784    transfer_from_sequence(cs);
     785  }
     786  return *this;
     787}
     788
    777789//----------------------------------------------------------------------
    778790// transfer the sequence contained in other_seq into our own;
    … …  
    815827
    816828  // clean up existing structure
    817   if (_structure_shared_ptr()) {
     829  if (_structure_shared_ptr) {
    818830    // If there are jets associated with an old version of the CS and
    819831    // a new one, keeping track of when to delete the CS becomes more
    … …  
    823835    // anything that is currently associated with the cluster sequence
    824836    // should be told that its cluster sequence no longer exists
    825     ClusterSequenceStructure* csi = dynamic_cast<ClusterSequenceStructure*>(_structure_shared_ptr());
     837    ClusterSequenceStructure* csi = dynamic_cast<ClusterSequenceStructure*>(_structure_shared_ptr.get());
    826838    assert(csi != NULL);
    827839    csi->set_associated_cs(NULL);
    … …  
    14551467// initialise the history in a standard way
    14561468void ClusterSequence::_add_step_to_history (
    1457                const int step_number, const int parent1,
     1469               //NO_LONGER_USED: const int step_number,
     1470               const int parent1,
    14581471               const int parent2, const int jetp_index,
    14591472               const double dij) {
    … …  
    14691482
    14701483  int local_step = _history.size()-1;
    1471   assert(local_step == step_number);
     1484  //#ifndef __NO_ASSERTS__
     1485  //assert(local_step == step_number);
     1486  //#endif
    14721487
    14731488  // sanity check: make sure the particles have not already been recombined
    … …  
    16691684  int hist_j = _jets[jet_j].cluster_hist_index();
    16701685
    1671   _add_step_to_history(newstep_k, min(hist_i, hist_j), max(hist_i,hist_j),
     1686  _add_step_to_history(min(hist_i, hist_j), max(hist_i,hist_j),
    16721687                       newjet_k, dij);
     1688
     1689  //  _add_step_to_history(newstep_k, min(hist_i, hist_j), max(hist_i,hist_j),
     1690  //                   newjet_k, dij);
     1691
    16731692
    16741693}
    … …  
    16801699void ClusterSequence::_do_iB_recombination_step(
    16811700                                  const int jet_i, const double diB) {
    1682   // get history index
    1683   int newstep_k = _history.size();
    1684 
    16851701  // recombine the jet with the beam
    1686   _add_step_to_history(newstep_k,_jets[jet_i].cluster_hist_index(),BeamJet,
     1702  _add_step_to_history(_jets[jet_i].cluster_hist_index(),BeamJet,
    16871703                       Invalid, diB);
     1704
     1705  // // get history index
     1706  // int newstep_k = _history.size();
     1707  //
     1708  // _add_step_to_history(newstep_k,_jets[jet_i].cluster_hist_index(),BeamJet,
     1709  //                   Invalid, diB);
    16881710
    16891711}

  • external/fastjet/ClusterSequence.hh

    rd091310 r1d208a2  
    33
    44//FJSTARTHEADER
    5 // $Id: ClusterSequence.hh 3911 2015-07-02 12:09:58Z salam $
     5// $Id: ClusterSequence.hh 4154 2016-07-20 16:20:48Z soyez $
    66//
    77// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
    … …  
    4949#include "fastjet/ClusterSequenceStructure.hh"
    5050
     51#include "fastjet/internal/deprecated.hh"
     52
    5153FASTJET_BEGIN_NAMESPACE      // defined in fastjet/internal/base.hh
    5254
    … …  
    8082  }
    8183
     84  /// explicit assignment operator for a ClusterSequence
     85  ClusterSequence & operator=(const ClusterSequence & cs);
     86 
    8287  // virtual ClusterSequence destructor, in case any derived class
    8388  // thinks of needing a destructor at some point
    … …  
    362367  /// As of FJ v3.1, this is deprecated, in line with the deprecation
    363368  /// of auto_ptr in C++11
    364   inline void plugin_associate_extras(std::auto_ptr<Extras> extras_in) {
     369#ifdef FASTJET_HAVE_AUTO_PTR_INTERFACE
     370  FASTJET_DEPRECATED_MSG("Please use ClusterSequence::plugin_associate_extras(Extras * extras_in)) instead")
     371  inline void plugin_associate_extras(std::auto_ptr<Extras> extras_in){
    365372    _extras.reset(extras_in.release());
    366373  }
     374#endif
    367375
    368376  /// returns true when the plugin is allowed to run the show.
    … …  
    730738  void _fast_NsqrtN_cluster();
    731739
    732   void _add_step_to_history(const int step_number, const int parent1,
    733                                const int parent2, const int jetp_index,
    734                                const double dij);
     740  void _add_step_to_history( //const int step_number,
     741                            const int parent1,
     742                            const int parent2, const int jetp_index,
     743                            const double dij);
    735744
    736745  /// internal routine associated with the construction of the unique
    … …  
    10371046template <class J> inline double ClusterSequence::_bj_dist(
    10381047                const J * const jetA, const J * const jetB) const {
     1048  //#define FASTJET_NEW_DELTA_PHI
     1049#ifndef FASTJET_NEW_DELTA_PHI
     1050  //GPS+MC old version of Delta phi calculation
    10391051  double dphi = std::abs(jetA->phi - jetB->phi);
    10401052  double deta = (jetA->eta - jetB->eta);
    10411053  if (dphi > pi) {dphi = twopi - dphi;}
     1054#else
     1055  //GPS+MC testing for 2015-02-faster-deltaR2
     1056  double dphi = pi-std::abs(pi-std::abs(jetA->phi - jetB->phi));
     1057  double deta = (jetA->eta - jetB->eta);
     1058#endif
    10421059  return dphi*dphi + deta*deta;
    10431060}

  • external/fastjet/ClusterSequence1GhostPassiveArea.hh

    rd091310 r1d208a2  
    11//FJSTARTHEADER
    2 // $Id: ClusterSequence1GhostPassiveArea.hh 3433 2014-07-23 08:17:03Z salam $
     2// $Id: ClusterSequence1GhostPassiveArea.hh 4047 2016-03-03 13:21:49Z soyez $
    33//
    44// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
    … …  
    7070  /// AreaBase one rather than the ActiveArea one (which for which we
    7171  /// do not have the information).
    72   virtual double n_empty_jets(const Selector & selector) const {
     72  virtual double n_empty_jets(const Selector & selector) const FASTJET_OVERRIDE {
    7373    return ClusterSequenceAreaBase::n_empty_jets(selector);
    7474  }

  • external/fastjet/ClusterSequenceActiveArea.hh

    rd091310 r1d208a2  
    11//FJSTARTHEADER
    2 // $Id: ClusterSequenceActiveArea.hh 3619 2014-08-13 14:17:19Z salam $
     2// $Id: ClusterSequenceActiveArea.hh 4047 2016-03-03 13:21:49Z soyez $
    33//
    44// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
    … …  
    7474          const bool & writeout_combinations = false) ;
    7575
    76   virtual double area (const PseudoJet & jet) const {
     76  virtual double area (const PseudoJet & jet) const FASTJET_OVERRIDE {
    7777                             return _average_area[jet.cluster_hist_index()];};
    78   virtual double area_error (const PseudoJet & jet) const {
     78  virtual double area_error (const PseudoJet & jet) const FASTJET_OVERRIDE {
    7979                             return _average_area2[jet.cluster_hist_index()];};
    8080
    81   virtual PseudoJet area_4vector (const PseudoJet & jet) const {
     81  virtual PseudoJet area_4vector (const PseudoJet & jet) const FASTJET_OVERRIDE {
    8282                    return _average_area_4vector[jet.cluster_hist_index()];};
    8383
    … …  
    110110  ///
    111111  /// The selector passed as an argument needs to apply jet by jet.
    112   virtual double empty_area(const Selector & selector) const;
     112  virtual double empty_area(const Selector & selector) const FASTJET_OVERRIDE;
    113113
    114114  /// return the true number of empty jets (replaces
    115115  /// ClusterSequenceAreaBase::n_empty_jets(...))
    116   virtual double n_empty_jets(const Selector & selector) const;
     116  virtual double n_empty_jets(const Selector & selector) const FASTJET_OVERRIDE;
    117117
    118118protected:

  • external/fastjet/ClusterSequenceActiveAreaExplicitGhosts.hh

    rd091310 r1d208a2  
    11//FJSTARTHEADER
    2 // $Id: ClusterSequenceActiveAreaExplicitGhosts.hh 3433 2014-07-23 08:17:03Z salam $
     2// $Id: ClusterSequenceActiveAreaExplicitGhosts.hh 4047 2016-03-03 13:21:49Z soyez $
    33//
    44// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
    … …  
    9797
    9898  /// returns the area of a jet
    99   virtual double area (const PseudoJet & jet) const;
     99  virtual double area (const PseudoJet & jet) const FASTJET_OVERRIDE;
    100100
    101101  /// returns a four vector corresponding to the sum (E-scheme) of the
    … …  
    103103  /// for a small contiguous area the p_t of the extended_area jet is
    104104  /// equal to area of the jet.
    105   virtual PseudoJet area_4vector (const PseudoJet & jet) const;
     105  virtual PseudoJet area_4vector (const PseudoJet & jet) const FASTJET_OVERRIDE;
    106106
    107107  /// true if a jet is made exclusively of ghosts
    108   virtual bool is_pure_ghost(const PseudoJet & jet) const;
     108  virtual bool is_pure_ghost(const PseudoJet & jet) const FASTJET_OVERRIDE;
    109109
    110110  /// true if the entry in the history index corresponds to a
    … …  
    114114
    115115  /// this class does have explicit ghosts
    116   virtual bool has_explicit_ghosts() const {return true;}
     116  virtual bool has_explicit_ghosts() const FASTJET_OVERRIDE {return true;}
    117117
    118118  /// return the total area, corresponding to a given Selector, that
    … …  
    120120  ///
    121121  /// The selector needs to apply jet by jet
    122   virtual double empty_area(const Selector & selector) const;
     122  virtual double empty_area(const Selector & selector) const FASTJET_OVERRIDE;
    123123
    124124  /// returns the total area under study

  • external/fastjet/ClusterSequenceArea.hh

    rd091310 r1d208a2  
    11//FJSTARTHEADER
    2 // $Id: ClusterSequenceArea.hh 3484 2014-07-29 21:39:39Z soyez $
     2// $Id: ClusterSequenceArea.hh 4098 2016-03-15 16:38:22Z salam $
    33//
    44// Copyright (c) 2006-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
    … …  
    8080
    8181  /// return the area associated with the given jet
    82   virtual double area       (const PseudoJet & jet) const {
     82  virtual double area       (const PseudoJet & jet) const FASTJET_OVERRIDE {
    8383    return _area_base->area(jet);}
    8484
    8585  /// return the error (uncertainty) associated with the determination
    8686  /// of the area of this jet
    87   virtual double area_error (const PseudoJet & jet) const {
     87  virtual double area_error (const PseudoJet & jet) const FASTJET_OVERRIDE {
    8888    return _area_base->area_error(jet);}
    8989
    9090  /// return the 4-vector area
    91   virtual PseudoJet area_4vector(const PseudoJet & jet) const {
     91  virtual PseudoJet area_4vector(const PseudoJet & jet) const FASTJET_OVERRIDE {
    9292    return _area_base->area_4vector(jet);}
    9393
    … …  
    110110  /// jet (see the BackgroundEstimator and Subtractor tools for more
    111111  /// advanced usage)
    112   virtual double empty_area(const Selector & selector) const {
     112  virtual double empty_area(const Selector & selector) const FASTJET_OVERRIDE {
    113113    return _area_base->empty_area(selector);}
    114114
    … …  
    122122  /// jet (see the BackgroundEstimator and Subtractor tools for more
    123123  /// advanced usage)
    124   virtual double n_empty_jets(const Selector & selector) const {
     124  virtual double n_empty_jets(const Selector & selector) const FASTJET_OVERRIDE {
    125125    return _area_base->n_empty_jets(selector);
    126126  }
    127127
    128128  /// true if a jet is made exclusively of ghosts
    129   virtual bool is_pure_ghost(const PseudoJet & jet) const {
     129  virtual bool is_pure_ghost(const PseudoJet & jet) const FASTJET_OVERRIDE {
    130130    return _area_base->is_pure_ghost(jet);
    131131  }
    132132
    133133  /// true if this ClusterSequence has explicit ghosts
    134   virtual bool has_explicit_ghosts() const {
     134  virtual bool has_explicit_ghosts() const FASTJET_OVERRIDE {
    135135    return _area_base->has_explicit_ghosts();
    136136  }
    … …  
    144144  /// jet (see the BackgroundEstimator and Subtractor tools for more
    145145  /// advanced usage)
     146  //FASTJET_DEPRECATED_MSG("ClusterSequenceArea::get_median_rho_and_sigma(...) is deprecated since FastJet 3.0. Use the BackgroundEstimator series of tools instead")
    146147  virtual void get_median_rho_and_sigma(const std::vector<PseudoJet> & all_jets,
    147148                                        const Selector & selector,
    … …  
    149150                                        double & median, double & sigma,
    150151                                        double & mean_area,
    151                                         bool all_are_incl = false) const {
     152                                        bool all_are_incl = false) const FASTJET_OVERRIDE {
    152153    _warn_if_range_unsuitable(selector);
    153     ClusterSequenceAreaBase::get_median_rho_and_sigma(
     154    ClusterSequenceAreaBase::_get_median_rho_and_sigma(
    154155                                 all_jets, selector, use_area_4vector,
    155156                                 median, sigma, mean_area, all_are_incl);
    … …  
    160161  /// since we've overridden the 5-argument version above, we have to
    161162  /// override the 4-argument version too.
     163  //FASTJET_DEPRECATED_MSG("ClusterSequenceArea::get_median_rho_and_sigma(...) is deprecated since FastJet 3.0. Use the BackgroundEstimator series of tools instead")
    162164  virtual void get_median_rho_and_sigma(const Selector & selector,
    163165                                        bool use_area_4vector,
    164                                         double & median, double & sigma) const {
    165     ClusterSequenceAreaBase::get_median_rho_and_sigma(selector,use_area_4vector,
    166                                                       median,sigma);
     166                                        double & median, double & sigma) const FASTJET_OVERRIDE {
     167    ClusterSequenceAreaBase::_get_median_rho_and_sigma(selector,use_area_4vector,
     168                                                       median,sigma);
    167169  }
    168170
    … …  
    171173  /// since we've overridden the multi-argument version above, we have to
    172174  /// override the 5-argument version too.
     175  //FASTJET_DEPRECATED_MSG("ClusterSequenceArea::get_median_rho_and_sigma(...) is deprecated since FastJet 3.0. Use the BackgroundEstimator series of tools instead")
    173176  virtual void get_median_rho_and_sigma(const Selector & selector,
    174177                                        bool use_area_4vector,
    175178                                        double & median, double & sigma,
    176                                         double & mean_area) const {
    177     ClusterSequenceAreaBase::get_median_rho_and_sigma(selector,use_area_4vector,
    178                                                       median,sigma, mean_area);
     179                                        double & mean_area) const FASTJET_OVERRIDE {
     180    ClusterSequenceAreaBase::_get_median_rho_and_sigma(selector,use_area_4vector,
     181                                                       median,sigma, mean_area);
    179182  }
    180183
    … …  
    183186  /// additionally checks compatibility between "range" and region in which
    184187  /// ghosts are thrown.
     188  //FASTJET_DEPRECATED_MSG("ClusterSequenceArea::parabolic_pt_per_unit_area(...) is deprecated since FastJet 3.0. Use the BackgroundEstimator series of tools instead") 
    185189  virtual void parabolic_pt_per_unit_area(double & a, double & b,
    186190                                          const Selector & selector,
    187191                                          double exclude_above=-1.0,
    188                                           bool use_area_4vector=false) const {
    189     _warn_if_range_unsuitable(selector);
    190     ClusterSequenceAreaBase::parabolic_pt_per_unit_area(
    191                                 a,b,selector, exclude_above, use_area_4vector);
     192                                          bool use_area_4vector=false) const FASTJET_OVERRIDE {
     193    return _parabolic_pt_per_unit_area(a,b,selector,exclude_above,use_area_4vector);
    192194  }
    193195
    … …  
    204206                                 const JetDefinition & jet_def);
    205207
    206   std::auto_ptr<ClusterSequenceAreaBase> _area_base;
     208  SharedPtr<ClusterSequenceAreaBase> _area_base;
    207209  AreaDefinition _area_def;
    208210  static LimitedWarning _range_warnings;
    209211  static LimitedWarning _explicit_ghosts_repeats_warnings;
     212
     213  // the following set of private methods are all deprecated. Their
     214  // role is simply to hide the corresponding methods (without the
     215  // first underscore) from the public interface so that they can be
     216  // used internally until all the deprecated methods are removed.
     217  // DO NOT USE ANY OF THESE METHODS: THEY ARE DEPRECATED AND WILL BE
     218  // REMOVED.
     219  virtual void _parabolic_pt_per_unit_area(double & a, double & b,
     220                                          const Selector & selector,
     221                                          double exclude_above=-1.0,
     222                                          bool use_area_4vector=false) const FASTJET_OVERRIDE {
     223    _warn_if_range_unsuitable(selector);
     224    ClusterSequenceAreaBase::_parabolic_pt_per_unit_area(
     225                                a,b,selector, exclude_above, use_area_4vector);
     226  }
    210227
    211228};
    … …  
    254271  }
    255272  // now copy across the information from the area base class
    256   _area_base = std::auto_ptr<ClusterSequenceAreaBase>(_area_base_ptr);
     273  _area_base = SharedPtr<ClusterSequenceAreaBase>(_area_base_ptr);
    257274  transfer_from_sequence(*_area_base);
    258275}

  • external/fastjet/ClusterSequenceAreaBase.cc

    rd091310 r1d208a2  
    11
    22//FJSTARTHEADER
    3 // $Id: ClusterSequenceAreaBase.cc 3433 2014-07-23 08:17:03Z salam $
     3// $Id: ClusterSequenceAreaBase.cc 4079 2016-03-09 12:20:03Z soyez $
    44//
    55// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
    … …  
    7979}
    8080
     81// this is deprecated but used by other deprecated methods. So we hide
     82// the implementation in a protected method so that (i) it can still
     83// be used internally (without generating a compile-time warning when
     84// building FastJet) and the interface can be marked as deprecated.
     85// This can disappear once all the public interfaces have disappeared.
    8186double ClusterSequenceAreaBase::median_pt_per_unit_area(const Selector & selector) const {
    82   return median_pt_per_unit_something(selector,false);
    83 }
    84 
     87  return _median_pt_per_unit_area(selector);
     88}
     89
     90// the hidden implementation
     91double ClusterSequenceAreaBase::_median_pt_per_unit_area(const Selector & selector) const {
     92  return _median_pt_per_unit_something(selector,false);
     93}
     94
     95
     96
     97// this is deprecated but used by other deprecated methods. So we hide
     98// the implementation in a protected method so that (i) it can still
     99// be used internally (without generating a compile-time warning when
     100// building FastJet) and the interface can be marked as deprecated.
     101// This can disappear once all the public interfaces have disappeared.
    85102double ClusterSequenceAreaBase::median_pt_per_unit_area_4vector(const Selector & selector) const {
    86   return median_pt_per_unit_something(selector,true);
    87 }
    88 
    89 
    90 //----------------------------------------------------------------------
    91 /// the median of (pt/area) for jets contained within range, counting
    92 /// the empty area as if it were made up of a collection of empty
    93 /// jets each of area (0.55 * pi R^2).
     103  return _median_pt_per_unit_area_4vector(selector);
     104}
     105
     106// the deprecated interface
     107double ClusterSequenceAreaBase::_median_pt_per_unit_area_4vector(const Selector & selector) const {
     108  return _median_pt_per_unit_something(selector,true);
     109}
     110
     111
     112//----------------------------------------------------------------------
     113// this is deprecated but used by other deprecated methods. So we hide
     114// the implementation in a protected method so that (i) it can still
     115// be used internally (without generating a compile-time warning when
     116// building FastJet) and the interface can be marked as deprecated.
     117// This can disappear once all the public interfaces have disappeared.
    94118double ClusterSequenceAreaBase::median_pt_per_unit_something(
    95119                const Selector & selector, bool use_area_4vector) const {
    96 
     120  return _median_pt_per_unit_something(selector, use_area_4vector);
     121}
     122
     123// the median of (pt/area) for jets contained within range, counting
     124// the empty area as if it were made up of a collection of empty
     125// jets each of area (0.55 * pi R^2).
     126double ClusterSequenceAreaBase::_median_pt_per_unit_something(
     127                const Selector & selector, bool use_area_4vector) const {
    97128  double median, sigma, mean_area;
    98   get_median_rho_and_sigma(selector, use_area_4vector, median, sigma, mean_area);
     129  _get_median_rho_and_sigma(selector, use_area_4vector, median, sigma, mean_area);
    99130  return median;
    100 
    101 }
    102 
    103 
    104 //----------------------------------------------------------------------
    105 /// fits a form pt_per_unit_area(y) = a + b*y^2 for jets in range.
    106 /// exclude_above allows one to exclude large values of pt/area from fit.
    107 /// use_area_4vector = true uses the 4vector areas.
     131}
     132
     133
     134//----------------------------------------------------------------------
     135/// fits a form pt_per_unit_area(y) = a + b*y^2 for jets in range.
     136/// exclude_above allows one to exclude large values of pt/area from
     137/// fit.  use_area_4vector = true uses the 4vector areas.
    108138void ClusterSequenceAreaBase::parabolic_pt_per_unit_area(
     139       double & a, double & b, const Selector & selector,
     140       double exclude_above, bool use_area_4vector) const {
     141  return _parabolic_pt_per_unit_area(a, b, selector, exclude_above, use_area_4vector);
     142}
     143
     144void ClusterSequenceAreaBase::_parabolic_pt_per_unit_area(
    109145       double & a, double & b, const Selector & selector,
    110146       double exclude_above, bool use_area_4vector) const {
    … …  
    161197
    162198
    163 
     199//----------------------------------------------------------------------
    164200void ClusterSequenceAreaBase::get_median_rho_and_sigma(
    165201            const Selector & selector, bool use_area_4vector,
    166202            double & median, double & sigma, double & mean_area) const {
     203  _get_median_rho_and_sigma(selector, use_area_4vector, median, sigma, mean_area);
     204}
     205
     206void ClusterSequenceAreaBase::_get_median_rho_and_sigma(
     207            const Selector & selector, bool use_area_4vector,
     208            double & median, double & sigma, double & mean_area) const {
    167209
    168210  vector<PseudoJet> incl_jets = inclusive_jets();
    169   get_median_rho_and_sigma(incl_jets, selector, use_area_4vector,
    170                            median, sigma, mean_area, true);
    171 }
    172 
     211  _get_median_rho_and_sigma(incl_jets, selector, use_area_4vector,
     212                            median, sigma, mean_area, true);
     213}
    173214
    174215void ClusterSequenceAreaBase::get_median_rho_and_sigma(
     216            const vector<PseudoJet> & all_jets,
     217            const Selector & selector, bool use_area_4vector,
     218            double & median, double & sigma, double & mean_area,
     219            bool all_are_incl) const {
     220  _get_median_rho_and_sigma(all_jets, selector, use_area_4vector,
     221                            median, sigma, mean_area, all_are_incl);
     222}
     223
     224void ClusterSequenceAreaBase::_get_median_rho_and_sigma(
    175225            const vector<PseudoJet> & all_jets,
    176226            const Selector & selector, bool use_area_4vector,
    … …  
    288338
    289339
    290 /// return a vector of all subtracted jets, using area_4vector, given rho.
    291 /// Only inclusive_jets above ptmin are subtracted and returned.
    292 /// the ordering is the same as that of sorted_by_pt(cs.inclusive_jets()),
    293 /// i.e. not necessarily ordered in pt once subtracted
     340// return a vector of all subtracted jets, using area_4vector, given rho.
     341// Only inclusive_jets above ptmin are subtracted and returned.
     342// the ordering is the same as that of sorted_by_pt(cs.inclusive_jets()),
     343// i.e. not necessarily ordered in pt once subtracted
    294344vector<PseudoJet> ClusterSequenceAreaBase::subtracted_jets(const double rho,
    295345                                                           const double ptmin)
    296346                                                           const {
     347  return _subtracted_jets(rho,ptmin);
     348}
     349
     350vector<PseudoJet> ClusterSequenceAreaBase::_subtracted_jets(const double rho,
     351                                                            const double ptmin)
     352  const {
    297353  vector<PseudoJet> sub_jets;
    298354  vector<PseudoJet> jets_local = sorted_by_pt(inclusive_jets(ptmin));
    299355  for (unsigned i=0; i<jets_local.size(); i++) {
    300      PseudoJet sub_jet = subtracted_jet(jets_local[i],rho);
     356     PseudoJet sub_jet = _subtracted_jet(jets_local[i],rho);
    301357     sub_jets.push_back(sub_jet);
    302358  }
    … …  
    304360}
    305361
    306 /// return a vector of subtracted jets, using area_4vector.
    307 /// Only inclusive_jets above ptmin are subtracted and returned.
    308 /// the ordering is the same as that of sorted_by_pt(cs.inclusive_jets()),
    309 /// i.e. not necessarily ordered in pt once subtracted
     362// return a vector of subtracted jets, using area_4vector.
     363// Only inclusive_jets above ptmin are subtracted and returned.
     364// the ordering is the same as that of sorted_by_pt(cs.inclusive_jets()),
     365// i.e. not necessarily ordered in pt once subtracted
    310366vector<PseudoJet> ClusterSequenceAreaBase::subtracted_jets(
    311367                                                 const Selector & selector,
    312368                                                 const double ptmin)
    313369                                                 const {
    314   double rho = median_pt_per_unit_area_4vector(selector);
    315   return subtracted_jets(rho,ptmin);
     370  double rho = _median_pt_per_unit_area_4vector(selector);
     371  return _subtracted_jets(rho,ptmin);
    316372}
    317373
    … …  
    320376PseudoJet ClusterSequenceAreaBase::subtracted_jet(const PseudoJet & jet,
    321377                                                  const double rho) const {
     378  return _subtracted_jet(jet, rho);
     379}
     380
     381PseudoJet ClusterSequenceAreaBase::_subtracted_jet(const PseudoJet & jet,
     382                                                   const double rho) const {
    322383  PseudoJet area4vect = area_4vector(jet);
    323384  PseudoJet sub_jet;
    … …  
    343404PseudoJet ClusterSequenceAreaBase::subtracted_jet(const PseudoJet & jet,
    344405                                       const Selector & selector) const {
    345   double rho = median_pt_per_unit_area_4vector(selector);
    346   PseudoJet sub_jet = subtracted_jet(jet, rho);
     406  return _subtracted_jet(jet, selector);
     407}
     408
     409PseudoJet ClusterSequenceAreaBase::_subtracted_jet(const PseudoJet & jet,
     410                                       const Selector & selector) const {
     411  double rho = _median_pt_per_unit_area_4vector(selector);
     412  PseudoJet sub_jet = _subtracted_jet(jet, rho);
    347413  return sub_jet;
    348414}
    … …  
    353419                                              const double rho,
    354420                                              bool use_area_4vector) const {
     421  return _subtracted_pt(jet, rho, use_area_4vector);
     422}
     423
     424double ClusterSequenceAreaBase::_subtracted_pt(const PseudoJet & jet,
     425                                              const double rho,
     426                                              bool use_area_4vector) const {
    355427  if ( use_area_4vector ) {
    356      PseudoJet sub_jet = subtracted_jet(jet,rho);
     428     PseudoJet sub_jet = _subtracted_jet(jet,rho);
    357429     return sub_jet.perp();
    358430  } else {
    … …  
    369441                                              bool use_area_4vector) const {
    370442  if ( use_area_4vector ) {
    371      PseudoJet sub_jet = subtracted_jet(jet,selector);
     443     PseudoJet sub_jet = _subtracted_jet(jet,selector);
    372444     return sub_jet.perp();
    373445  } else {
    374      double rho = median_pt_per_unit_area(selector);
    375      return subtracted_pt(jet,rho,false);
     446     double rho = _median_pt_per_unit_area(selector);
     447     return _subtracted_pt(jet,rho,false);
    376448  }
    377449} 

  • external/fastjet/ClusterSequenceAreaBase.hh

    rd091310 r1d208a2  
    11//FJSTARTHEADER
    2 // $Id: ClusterSequenceAreaBase.hh 3433 2014-07-23 08:17:03Z salam $
     2// $Id: ClusterSequenceAreaBase.hh 4098 2016-03-15 16:38:22Z salam $
    33//
    44// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
    … …  
    3535#include "fastjet/LimitedWarning.hh"
    3636#include "fastjet/Selector.hh"
     37#include "fastjet/internal/deprecated.hh"
    3738
    3839FASTJET_BEGIN_NAMESPACE
    … …  
    144145  /// apply jet-by-jet (see the BackgroundEstimator and Subtractor
    145146  /// tools for more generic usages)
     147  FASTJET_DEPRECATED_MSG("ClusterSequenceAreaBase::median_pt_per_unit_area(...) is deprecated since FastJet 3.0. Use the BackgroundEstimator series of tools instead")
    146148  double median_pt_per_unit_area(const Selector & selector) const;
    147149
    … …  
    151153  /// The selector passed as an argument has to have a finite area and
    152154  /// apply jet-by-jet
     155  FASTJET_DEPRECATED_MSG("ClusterSequenceAreaBase::median_pt_per_unit_area_4vector(...) is deprecated since FastJet 3.0. Use the BackgroundEstimator series of tools instead")
    153156  double median_pt_per_unit_area_4vector(const Selector & selector) const;
    154157 
    … …  
    157160  /// - something_is_area_4vect = false -> use plain area
    158161  /// - something_is_area_4vect = true  -> use 4-vector area
    159   double median_pt_per_unit_something(
    160                     const Selector & selector, bool use_area_4vector) const;
     162  FASTJET_DEPRECATED_MSG("ClusterSequenceAreaBase::median_pt_per_unit_something(...) is deprecated since FastJet 3.0. Use the BackgroundEstimator series of tools instead")
     163  double median_pt_per_unit_something(const Selector & selector,
     164                                      bool use_area_4vector) const;
    161165
    162166  /// using jets withing the selector range (and with 4-vector areas if
    … …  
    184188  /// using a scalar area causes one to neglect terms of relative
    185189  /// order $R^2/8$ in the jet $p_t$.
     190  //FASTJET_DEPRECATED_MSG("ClusterSequenceAreaBase::get_median_rho_and_sigma(...) is deprecated since FastJet 3.0. Use the BackgroundEstimator series of tools instead")
    186191  virtual void get_median_rho_and_sigma(const Selector & selector,
    187192                                        bool use_area_4vector,
    … …  
    208213  /// apply jet-by-jet (see the BackgroundEstimator and Subtractor
    209214  /// tools for more generic usages)
     215  //FASTJET_DEPRECATED_MSG("ClusterSequenceAreaBase::get_median_rho_and_sigma(...) is deprecated since FastJet 3.0. Use the BackgroundEstimator series of tools instead")
    210216  virtual void get_median_rho_and_sigma(const std::vector<PseudoJet> & all_jets,
    211217                                        const Selector & selector,
    … …  
    221227  /// apply jet-by-jet (see the BackgroundEstimator and Subtractor
    222228  /// tools for more generic usages)
     229  //FASTJET_DEPRECATED_MSG("ClusterSequenceAreaBase::get_median_rho_and_sigma(...) is deprecated since FastJet 3.0. Use the BackgroundEstimator series of tools instead")
    223230  virtual void get_median_rho_and_sigma(const Selector & selector,
    224                                 bool use_area_4vector,
    225                                 double & median, double & sigma) const {
    226     double mean_area;
    227     get_median_rho_and_sigma(selector,  use_area_4vector,
    228                              median,  sigma, mean_area);
     231                                        bool use_area_4vector,
     232                                        double & median, double & sigma) const{
     233    return _get_median_rho_and_sigma(selector, use_area_4vector, median, sigma);
    229234  }
    230235 
    … …  
    238243  /// apply jet-by-jet (see the BackgroundEstimator and Subtractor
    239244  /// tools for more generic usages)
     245  //FASTJET_DEPRECATED_MSG("ClusterSequenceAreaBase::parabolic_pt_per_unit_area(...) is deprecated since FastJet 3.0. Use the BackgroundEstimator series of tools instead")
    240246  virtual void parabolic_pt_per_unit_area(double & a, double & b,
    241247                                          const Selector & selector,
    … …  
    247253  /// the ordering is the same as that of sorted_by_pt(cs.inclusive_jets()),
    248254  /// i.e. not necessarily ordered in pt once subtracted
     255  FASTJET_DEPRECATED_MSG("ClusterSequenceAreaBase::subtracted_jets(...) is deprecated since FastJet 3.0. Use the Subtractor tool (with the BackgroundEstimator series of tools) instead")
    249256  std::vector<PseudoJet> subtracted_jets(const double rho,
    250257                                         const double ptmin=0.0) const;
    … …  
    258265  /// apply jet-by-jet (see the BackgroundEstimator and Subtractor
    259266  /// tools for more generic usages)
     267  FASTJET_DEPRECATED_MSG("ClusterSequenceAreaBase::subtracted_jets(...) is deprecated since FastJet 3.0. Use the Subtractor tool (with the BackgroundEstimator series of tools) instead")
    260268  std::vector<PseudoJet> subtracted_jets(const Selector & selector,
    261269                                         const double ptmin=0.0) const;
    262270
    263271  /// return a subtracted jet, using area_4vector, given rho
     272  FASTJET_DEPRECATED_MSG("ClusterSequenceAreaBase::subtracted_jet(...) is deprecated since FastJet 3.0. Use the Subtractor tool (with the BackgroundEstimator series of tools) instead")
    264273  PseudoJet subtracted_jet(const PseudoJet & jet,
    265274                           const double rho) const;
    … …  
    273282  /// apply jet-by-jet (see the BackgroundEstimator and Subtractor
    274283  /// tools for more generic usages)
     284  FASTJET_DEPRECATED_MSG("ClusterSequenceAreaBase::subtracted_jet(...) is deprecated since FastJet 3.0. Use the Subtractor tool (with the BackgroundEstimator series of tools) instead")
    275285  PseudoJet subtracted_jet(const PseudoJet & jet,
    276286                           const Selector & selector) const;
    277287
    278288  /// return the subtracted pt, given rho
     289  FASTJET_DEPRECATED_MSG("ClusterSequenceAreaBase::subtracted_pt(...) is deprecated since FastJet 3.0. Use the Subtractor tool (with the BackgroundEstimator series of tools) instead")
    279290  double subtracted_pt(const PseudoJet & jet,
    280291                       const double rho,
    … …  
    288299  /// apply jet-by-jet (see the BackgroundEstimator and Subtractor
    289300  /// tools for more generic usages)
     301  FASTJET_DEPRECATED_MSG("ClusterSequenceAreaBase::subtracted_pt(...) is deprecated since FastJet 3.0. Use the Subtractor tool (with the BackgroundEstimator series of tools) instead")
    290302  double subtracted_pt(const PseudoJet & jet,
    291303                       const Selector & selector,
    … …  
    296308  void _check_selector_good_for_median(const Selector &selector) const;
    297309
     310  // the following set of protected methods are all deprecated. Their
     311  // role is simply to hide the corresponding methods (without the
     312  // first underscore) from the public interface so that they can be
     313  // used internally until all the deprecated methods are removed.
     314  // DO NOT USE ANY OF THESE METHODS: THEY ARE DEPRECATED AND WILL BE
     315  // REMOVED.
     316  virtual void _get_median_rho_and_sigma(const Selector & selector,
     317                                         bool use_area_4vector,
     318                                         double & median, double & sigma,
     319                                         double & mean_area) const;
     320  virtual void _get_median_rho_and_sigma(const std::vector<PseudoJet> & all_jets,
     321                                         const Selector & selector,
     322                                         bool use_area_4vector,
     323                                         double & median, double & sigma,
     324                                         double & mean_area,
     325                                         bool all_are_inclusive = false) const;
     326  virtual void _get_median_rho_and_sigma(const Selector & selector,
     327                                         bool use_area_4vector,
     328                                         double & median, double & sigma) const {
     329    double mean_area;
     330    _get_median_rho_and_sigma(selector,  use_area_4vector,
     331                              median,  sigma, mean_area);
     332  }
     333  virtual void _parabolic_pt_per_unit_area(double & a, double & b,
     334                                           const Selector & selector,
     335                                           double exclude_above=-1.0,
     336                                           bool use_area_4vector=false) const;
    298337
    299338private:
    … …  
    305344  /// check the jet algorithm is suitable (and if not issue a warning)
    306345  void _check_jet_alg_good_for_median() const;
    307  
     346
     347  // the following set of private methods are all deprecated. Their
     348  // role is simply to hide the corresponding methods (without the
     349  // first underscore) from the public interface so that they can be
     350  // used internally until all the deprecated methods are removed.
     351  // DO NOT USE ANY OF THESE METHODS: THEY ARE DEPRECATED AND WILL BE
     352  // REMOVED.
     353  double _median_pt_per_unit_area(const Selector & selector) const;
     354  double _median_pt_per_unit_area_4vector(const Selector & selector) const;
     355  double _median_pt_per_unit_something(const Selector & selector,
     356                                       bool use_area_4vector) const;
     357  std::vector<PseudoJet> _subtracted_jets(const double rho,
     358                                          const double ptmin=0.0) const;
     359  PseudoJet _subtracted_jet(const PseudoJet & jet,
     360                            const double rho) const;
     361  PseudoJet _subtracted_jet(const PseudoJet & jet,
     362                            const Selector & selector) const;
     363  double _subtracted_pt(const PseudoJet & jet,
     364                        const double rho,
     365                        bool use_area_4vector=false) const;
    308366};
    309367

  • external/fastjet/ClusterSequencePassiveArea.hh

    rd091310 r1d208a2  
    11//FJSTARTHEADER
    2 // $Id: ClusterSequencePassiveArea.hh 3433 2014-07-23 08:17:03Z salam $
     2// $Id: ClusterSequencePassiveArea.hh 4047 2016-03-03 13:21:49Z soyez $
    33//
    44// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
    … …  
    6565  /// return an empty area that's appropriate to the passive area
    6666  /// determination carried out
    67   virtual double empty_area(const Selector & selector) const;
     67  virtual double empty_area(const Selector & selector) const FASTJET_OVERRIDE;
    6868
    6969private:

  • external/fastjet/ClusterSequenceStructure.hh

    rd091310 r1d208a2  
    11//FJSTARTHEADER
    2 // $Id: ClusterSequenceStructure.hh 3433 2014-07-23 08:17:03Z salam $
     2// $Id: ClusterSequenceStructure.hh 4047 2016-03-03 13:21:49Z soyez $
    33//
    44// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
    … …  
    7676
    7777  /// description
    78   virtual std::string description() const{ return "PseudoJet with an associated ClusterSequence"; }
     78  virtual std::string description() const FASTJET_OVERRIDE{
     79    return "PseudoJet with an associated ClusterSequence";
     80  }
    7981
    8082  //-------------------------------------------------------------
    … …  
    8587  //-------------------------------------------------------------
    8688  /// returns true if there is an associated ClusterSequence
    87   virtual bool has_associated_cluster_sequence() const{ return true;}
     89  virtual bool has_associated_cluster_sequence() const FASTJET_OVERRIDE{ return true;}
    8890
    8991  /// get a (const) pointer to the parent ClusterSequence (NULL if
    9092  /// inexistent)
    91   virtual const ClusterSequence* associated_cluster_sequence() const;
     93  virtual const ClusterSequence* associated_cluster_sequence() const FASTJET_OVERRIDE;
    9294 
    9395  /// returns true if there is a valid associated ClusterSequence
    94   virtual bool has_valid_cluster_sequence() const;
     96  virtual bool has_valid_cluster_sequence() const FASTJET_OVERRIDE;
    9597
    9698  /// if the jet has a valid associated cluster sequence then return a
    9799  /// pointer to it; otherwise throw an error
    98   virtual const ClusterSequence * validated_cs() const;
     100  virtual const ClusterSequence * validated_cs() const FASTJET_OVERRIDE;
    99101
    100102#ifndef __FJCORE__
    101103  /// if the jet has valid area information then return a pointer to
    102104  /// the associated ClusterSequenceAreaBase object; otherwise throw an error
    103   virtual const ClusterSequenceAreaBase * validated_csab() const;
     105  virtual const ClusterSequenceAreaBase * validated_csab() const FASTJET_OVERRIDE;
    104106#endif  // __FJCORE__
    105107
    … …  
    125127  /// an Error is thrown if this PseudoJet has no currently valid
    126128  /// associated ClusterSequence
    127   virtual bool has_partner(const PseudoJet &reference, PseudoJet &partner) const;
     129  virtual bool has_partner(const PseudoJet &reference, PseudoJet &partner) const FASTJET_OVERRIDE;
    128130
    129131  /// check if it has been recombined with another PseudoJet in which
    … …  
    133135  /// an Error is thrown if this PseudoJet has no currently valid
    134136  /// associated ClusterSequence
    135   virtual bool has_child(const PseudoJet &reference, PseudoJet &child) const;
     137  virtual bool has_child(const PseudoJet &reference, PseudoJet &child) const FASTJET_OVERRIDE;
    136138
    137139  /// check if it is the product of a recombination, in which case
    … …  
    141143  /// an Error is thrown if this PseudoJet has no currently valid
    142144  /// associated ClusterSequence
    143   virtual bool has_parents(const PseudoJet &reference, PseudoJet &parent1, PseudoJet &parent2) const;
     145  virtual bool has_parents(const PseudoJet &reference, PseudoJet &parent1, PseudoJet &parent2) const FASTJET_OVERRIDE;
    144146
    145147  /// check if the reference PseudoJet is contained in the second one
    … …  
    151153  /// false is returned if the 2 PseudoJet do not belong the same
    152154  /// ClusterSequence
    153   virtual bool object_in_jet(const PseudoJet &reference, const PseudoJet &jet) const;
     155  virtual bool object_in_jet(const PseudoJet &reference, const PseudoJet &jet) const FASTJET_OVERRIDE;
    154156
    155157  /// return true if the structure supports constituents.
    … …  
    157159  /// an Error is thrown if this PseudoJet has no currently valid
    158160  /// associated ClusterSequence
    159   virtual bool has_constituents() const;
     161  virtual bool has_constituents() const FASTJET_OVERRIDE;
    160162
    161163  /// retrieve the constituents.
    … …  
    163165  /// an Error is thrown if this PseudoJet has no currently valid
    164166  /// associated ClusterSequence
    165   virtual std::vector<PseudoJet> constituents(const PseudoJet &reference) const;
     167  virtual std::vector<PseudoJet> constituents(const PseudoJet &reference) const FASTJET_OVERRIDE;
    166168
    167169
    … …  
    170172  /// an Error is thrown if this PseudoJet has no currently valid
    171173  /// associated ClusterSequence
    172   virtual bool has_exclusive_subjets() const;
     174  virtual bool has_exclusive_subjets() const FASTJET_OVERRIDE;
    173175
    174176  /// return a vector of all subjets of the current jet (in the sense
    … …  
    183185  /// an Error is thrown if this PseudoJet has no currently valid
    184186  /// associated ClusterSequence
    185   virtual std::vector<PseudoJet> exclusive_subjets(const PseudoJet &reference, const double & dcut) const;
     187  virtual std::vector<PseudoJet> exclusive_subjets(const PseudoJet &reference, const double & dcut) const FASTJET_OVERRIDE;
    186188
    187189  /// return the size of exclusive_subjets(...); still n ln n with same
    … …  
    191193  /// an Error is thrown if this PseudoJet has no currently valid
    192194  /// associated ClusterSequence
    193   virtual int n_exclusive_subjets(const PseudoJet &reference, const double & dcut) const;
     195  virtual int n_exclusive_subjets(const PseudoJet &reference, const double & dcut) const FASTJET_OVERRIDE;
    194196
    195197  /// return the list of subjets obtained by unclustering the supplied
    … …  
    201203  /// an Error is thrown if this PseudoJet has no currently valid
    202204  /// associated ClusterSequence
    203   virtual std::vector<PseudoJet> exclusive_subjets_up_to (const PseudoJet &reference, int nsub) const;
     205  virtual std::vector<PseudoJet> exclusive_subjets_up_to (const PseudoJet &reference, int nsub) const FASTJET_OVERRIDE;
    204206
    205207  /// return the dij that was present in the merging nsub+1 -> nsub
    … …  
    208210  /// an Error is thrown if this PseudoJet has no currently valid
    209211  /// associated ClusterSequence
    210   virtual double exclusive_subdmerge(const PseudoJet &reference, int nsub) const;
     212  virtual double exclusive_subdmerge(const PseudoJet &reference, int nsub) const FASTJET_OVERRIDE;
    211213
    212214  /// return the maximum dij that occurred in the whole event at the
    … …  
    216218  /// an Error is thrown if this PseudoJet has no currently valid
    217219  /// associated ClusterSequence
    218   virtual double exclusive_subdmerge_max(const PseudoJet &reference, int nsub) const;
     220  virtual double exclusive_subdmerge_max(const PseudoJet &reference, int nsub) const FASTJET_OVERRIDE;
    219221
    220222
    … …  
    224226  /// by convention, a jet associated with a ClusterSequence will have
    225227  /// its parents as pieces
    226   virtual bool has_pieces(const PseudoJet &reference) const;
     228  virtual bool has_pieces(const PseudoJet &reference) const FASTJET_OVERRIDE;
    227229
    228230  /// by convention, a jet associated with a ClusterSequence will have
    … …  
    235237  /// sequence. If the cluster sequence has gone out of scope, an
    236238  /// error will be thrown
    237   virtual std::vector<PseudoJet> pieces(const PseudoJet &reference) const;
     239  virtual std::vector<PseudoJet> pieces(const PseudoJet &reference) const FASTJET_OVERRIDE;
    238240
    239241
    … …  
    244246
    245247  /// check if it has a defined area
    246   virtual bool has_area() const;
     248  virtual bool has_area() const FASTJET_OVERRIDE;
    247249
    248250  /// return the jet (scalar) area.
    249251  /// throws an Error if there is no support for area in the parent CS
    250   virtual double area(const PseudoJet &reference) const;
     252  virtual double area(const PseudoJet &reference) const FASTJET_OVERRIDE;
    251253
    252254  /// return the error (uncertainty) associated with the determination
    253255  /// of the area of this jet.
    254256  /// throws an Error if there is no support for area in the parent CS
    255   virtual double area_error(const PseudoJet &reference) const;
     257  virtual double area_error(const PseudoJet &reference) const FASTJET_OVERRIDE;
    256258
    257259  /// return the jet 4-vector area.
    258260  /// throws an Error if there is no support for area in the parent CS
    259   virtual PseudoJet area_4vector(const PseudoJet &reference) const;
     261  virtual PseudoJet area_4vector(const PseudoJet &reference) const FASTJET_OVERRIDE;
    260262
    261263  /// true if this jet is made exclusively of ghosts.
    262264  /// throws an Error if there is no support for area in the parent CS
    263   virtual bool is_pure_ghost(const PseudoJet &reference) const;
     265  virtual bool is_pure_ghost(const PseudoJet &reference) const FASTJET_OVERRIDE;
    264266
    265267#endif  // __FJCORE__

  • external/fastjet/ClusterSequenceVoronoiArea.hh

    rd091310 r1d208a2  
    11//FJSTARTHEADER
    2 // $Id: ClusterSequenceVoronoiArea.hh 3433 2014-07-23 08:17:03Z salam $
     2// $Id: ClusterSequenceVoronoiArea.hh 4047 2016-03-03 13:21:49Z soyez $
    33//
    44// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
    … …  
    6565
    6666  /// return the area associated with the given jet
    67   virtual inline double area(const PseudoJet & jet) const {
     67  virtual inline double area(const PseudoJet & jet) const FASTJET_OVERRIDE {
    6868    return _voronoi_area[jet.cluster_hist_index()];}
    6969
    … …  
    7272  /// made of sums of centres of all Voronoi cells in jet, each
    7373  /// contributing with a normalisation equal to the area of the cell
    74   virtual inline PseudoJet area_4vector(const PseudoJet & jet) const {
     74  virtual inline PseudoJet area_4vector(const PseudoJet & jet) const FASTJET_OVERRIDE {
    7575    return _voronoi_area_4vector[jet.cluster_hist_index()];}
    7676
    7777  /// return the error of the area associated with the given jet
    7878  /// (0 by definition for a voronoi area)
    79   virtual inline double area_error(const PseudoJet & /*jet*/) const {
     79  virtual inline double area_error(const PseudoJet & /*jet*/) const FASTJET_OVERRIDE {
    8080    return 0.0;}
    8181

  • external/fastjet/ClusterSequence_CP2DChan.cc

    rd091310 r1d208a2  
    11//FJSTARTHEADER
    2 // $Id: ClusterSequence_CP2DChan.cc 3433 2014-07-23 08:17:03Z salam $
     2// $Id: ClusterSequence_CP2DChan.cc 4045 2016-03-03 10:01:55Z salam $
    33//
    44// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
    … …  
    4646  public:
    4747    int orig, mirror;
    48     MirrorInfo(int a, int b) : orig(a), mirror(b) {};
    49     MirrorInfo() {};
     48    MirrorInfo(int a, int b) : orig(a), mirror(b) {}
     49    MirrorInfo() : orig(0), mirror(0) {} // set dummy values to keep static code checkers happy
    5050  };
    5151

  • external/fastjet/ClusterSequence_Delaunay.cc

    rd091310 r1d208a2  
    11//FJSTARTHEADER
    2 // $Id: ClusterSequence_Delaunay.cc 3918 2015-07-03 14:19:13Z salam $
     2// $Id: ClusterSequence_Delaunay.cc 4059 2016-03-03 20:49:48Z soyez $
    33//
    44// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
    … …  
    6969
    7070  // initialise our DNN structure with the set of points
    71   auto_ptr<DynamicNearestNeighbours> DNN;
    72   bool verbose = false;
     71  SharedPtr<DynamicNearestNeighbours> DNN;
     72  const bool verbose = false;
    7373#ifndef DROP_CGAL // strategy = NlnN* are not supported if we drop CGAL...
    7474  bool ignore_nearest_is_mirror = (_Rparam < twopi);

  • external/fastjet/CompositeJetStructure.hh

    rd091310 r1d208a2  
    11//FJSTARTHEADER
    2 // $Id: CompositeJetStructure.hh 3652 2014-09-03 13:31:13Z salam $
     2// $Id: CompositeJetStructure.hh 4047 2016-03-03 13:21:49Z soyez $
    33//
    44// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
    … …  
    6464
    6565  /// description
    66   virtual std::string description() const;
     66  virtual std::string description() const FASTJET_OVERRIDE;
    6767
    6868  // things reimplemented from the base structure
    … …  
    7070  /// true unless the jet has no pieces (see also the description of
    7171  /// constituents() below)
    72   virtual bool has_constituents() const;
     72  virtual bool has_constituents() const FASTJET_OVERRIDE;
    7373
    7474  /// return the constituents (i.e. the union of the constituents of each piece)
    … …  
    7878  /// Note that as a consequence, a composite jet with no pieces will
    7979  /// have an empty vector as constituents
    80   virtual std::vector<PseudoJet> constituents(const PseudoJet &jet) const;
     80  virtual std::vector<PseudoJet> constituents(const PseudoJet &jet) const FASTJET_OVERRIDE;
    8181
    8282  //-------------------------------------------------------------------
    … …  
    8484  //-------------------------------------------------------------------
    8585  /// true if it has pieces (always the case)
    86   virtual bool has_pieces(const PseudoJet & /*jet*/) const {return true;}
     86  virtual bool has_pieces(const PseudoJet & /*jet*/) const FASTJET_OVERRIDE {return true;}
    8787
    8888  /// returns the pieces
    89   virtual std::vector<PseudoJet> pieces(const PseudoJet &jet) const;
     89  virtual std::vector<PseudoJet> pieces(const PseudoJet &jet) const FASTJET_OVERRIDE;
    9090
    9191  // area-related material
    … …  
    9393
    9494  /// check if it has a well-defined area
    95   virtual bool has_area() const;
     95  virtual bool has_area() const FASTJET_OVERRIDE;
    9696
    9797  /// return the jet (scalar) area.
    98   virtual double area(const PseudoJet &reference) const;
     98  virtual double area(const PseudoJet &reference) const FASTJET_OVERRIDE;
    9999
    100100  /// return the error (uncertainty) associated with the determination
    … …  
    102102  ///
    103103  /// Be conservative: return the sum of the errors
    104   virtual double area_error(const PseudoJet &reference) const;
     104  virtual double area_error(const PseudoJet &reference) const FASTJET_OVERRIDE;
    105105
    106106  /// return the jet 4-vector area.
    107   virtual PseudoJet area_4vector(const PseudoJet &reference) const;
     107  virtual PseudoJet area_4vector(const PseudoJet &reference) const FASTJET_OVERRIDE;
    108108
    109109  /// true if this jet is made exclusively of ghosts.
    110110  ///
    111111  /// In this case, it will be true if all pieces are pure ghost
    112   virtual bool is_pure_ghost(const PseudoJet &reference) const;
     112  virtual bool is_pure_ghost(const PseudoJet &reference) const FASTJET_OVERRIDE;
    113113
    114114  //unused: // allows one to modify the area information

  • external/fastjet/DnnPlane.cc

    rd091310 r1d208a2  
    11//FJSTARTHEADER
    2 // $Id: DnnPlane.cc 3918 2015-07-03 14:19:13Z salam $
     2// $Id: DnnPlane.cc 3917 2015-07-03 14:07:50Z salam $
    33//
    44// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez

  • external/fastjet/Error.hh

    rd091310 r1d208a2  
    33
    44//FJSTARTHEADER
    5 // $Id: Error.hh 3809 2015-02-20 13:05:13Z soyez $
     5// $Id: Error.hh 3807 2015-02-20 11:16:55Z soyez $
    66//
    77// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
    … …  
    114114};
    115115
    116 
    117116FASTJET_END_NAMESPACE
    118117

  • external/fastjet/GhostedAreaSpec.hh

    rd091310 r1d208a2  
    11//FJSTARTHEADER
    2 // $Id: GhostedAreaSpec.hh 3433 2014-07-23 08:17:03Z salam $
     2// $Id: GhostedAreaSpec.hh 4074 2016-03-08 09:09:25Z soyez $
    33//
    44// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
    … …  
    3939#include "fastjet/Selector.hh"
    4040#include "fastjet/LimitedWarning.hh"
     41#include "fastjet/internal/deprecated.hh"
    4142
    4243//
    … …  
    173174  ///
    174175  /// FJ2 placement is now deprecated.
     176  FASTJET_DEPRECATED_MSG("This is deprecated since we strongly recomment to use the new ghost placement instead")
    175177  void set_fj2_placement(bool  val);
    176178

  • external/fastjet/JetDefinition.cc

    rd091310 r1d208a2  
    11//FJSTARTHEADER
    2 // $Id: JetDefinition.cc 3677 2014-09-09 22:45:25Z soyez $
     2// $Id: JetDefinition.cc 4074 2016-03-08 09:09:25Z soyez $
    33//
    44// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
    … …  
    4545JetDefinition::JetDefinition(JetAlgorithm jet_algorithm_in,
    4646                             double R_in,
     47                             RecombinationScheme recomb_scheme_in,
    4748                             Strategy strategy_in,
    48                              RecombinationScheme recomb_scheme_in,
    4949                             int nparameters) :
    5050  _jet_algorithm(jet_algorithm_in), _Rparam(R_in), _strategy(strategy_in) {
    … …  
    185185
    186186  // do not forget to delete the existing recombiner if needed
    187   if (_shared_recombiner()) _shared_recombiner.reset();
     187  if (_shared_recombiner) _shared_recombiner.reset();
    188188
    189189  _recombiner = 0;

  • external/fastjet/JetDefinition.hh

    rd091310 r1d208a2  
    33
    44//FJSTARTHEADER
    5 // $Id: JetDefinition.hh 3677 2014-09-09 22:45:25Z soyez $
     5// $Id: JetDefinition.hh 4074 2016-03-08 09:09:25Z soyez $
    66//
    77// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
    … …  
    3535#include "fastjet/internal/numconsts.hh"
    3636#include "fastjet/PseudoJet.hh"
     37#include "fastjet/internal/deprecated.hh"
    3738#include<string>
    3839#include<memory>
    … …  
    268269                RecombinationScheme recomb_scheme_in = E_scheme,
    269270                Strategy strategy_in = Best) {
    270     *this = JetDefinition(jet_algorithm_in, R_in, strategy_in, recomb_scheme_in, 1);
     271    *this = JetDefinition(jet_algorithm_in, R_in, recomb_scheme_in, strategy_in, 1);
    271272  }
    272273
    … …  
    277278                Strategy strategy_in = Best) {
    278279    double dummyR = 0.0;
    279     *this = JetDefinition(jet_algorithm_in, dummyR, strategy_in, recomb_scheme_in, 0);
     280    *this = JetDefinition(jet_algorithm_in, dummyR, recomb_scheme_in, strategy_in, 0);
    280281  }
    281282
    … …  
    287288                RecombinationScheme recomb_scheme_in = E_scheme,
    288289                Strategy strategy_in = Best) {
    289     *this = JetDefinition(jet_algorithm_in, R_in, strategy_in, recomb_scheme_in, 2);
     290    *this = JetDefinition(jet_algorithm_in, R_in, recomb_scheme_in, strategy_in, 2);
    290291    set_extra_param(xtra_param_in);
    291292  }
    … …  
    344345    _strategy = plugin_strategy;
    345346    _Rparam = _plugin->R();
     347    _extra_param = 0.0; // a dummy value to keep static code checkers happy
    346348    _jet_algorithm = plugin_algorithm;
    347349    set_recombination_scheme(E_scheme);
    348350  }
    349351
    350 
    351352  /// constructor to fully specify a jet-definition (together with
    352353  /// information about how algorithically to run it).
     354  JetDefinition(JetAlgorithm jet_algorithm_in,
     355                double R_in,
     356                RecombinationScheme recomb_scheme_in,
     357                Strategy strategy_in,
     358                int nparameters_in);
     359
     360  /// constructor to fully specify a jet-definition (together with
     361  /// information about how algorithically to run it).
    353362  ///
    354363  /// the ordering of arguments here is old and deprecated (except
    355364  /// as the common constructor for internal use)
     365  FASTJET_DEPRECATED_MSG("This argument ordering is deprecated. Use JetDefinition(alg, R, strategy, scheme[, n_parameters]) instead")
    356366  JetDefinition(JetAlgorithm jet_algorithm_in,
    357367                double R_in,
    358368                Strategy strategy_in,
    359369                RecombinationScheme recomb_scheme_in = E_scheme,
    360                 int nparameters_in = 1);
     370                int nparameters_in = 1){
     371    (*this) = JetDefinition(jet_algorithm_in,R_in,recomb_scheme_in,strategy_in,nparameters_in);
     372  }
     373
    361374
    362375  /// cluster the supplied particles and returns a vector of resulting
    … …  
    388401  /// Recombiner *) may lead to memory corruption.
    389402  void set_recombiner(const Recombiner * recomb) {
    390     if (_shared_recombiner()) _shared_recombiner.reset(recomb);
     403    if (_shared_recombiner) _shared_recombiner.reset(recomb);
    391404    _recombiner = recomb;
    392405    _default_recombiner = DefaultRecombiner(external_scheme);
    … …  
    521534      _recomb_scheme(recomb_scheme) {}
    522535   
    523     virtual std::string description() const;
     536    virtual std::string description() const FASTJET_OVERRIDE;
    524537   
    525538    /// recombine pa and pb and put result into pab
    526539    virtual void recombine(const PseudoJet & pa, const PseudoJet & pb,
    527                            PseudoJet & pab) const;
    528 
    529     virtual void preprocess(PseudoJet & p) const;
     540                           PseudoJet & pab) const FASTJET_OVERRIDE;
     541
     542    virtual void preprocess(PseudoJet & p) const FASTJET_OVERRIDE;
    530543
    531544    /// return the index of the recombination scheme

  • external/fastjet/LazyTiling25.cc

    rd091310 r1d208a2  
    11//FJSTARTHEADER
    2 // $Id: LazyTiling25.cc 3808 2015-02-20 11:24:53Z soyez $
     2// $Id: LazyTiling25.cc 3807 2015-02-20 11:16:55Z soyez $
    33//
    44// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
    … …  
    369369    double dist = _distance_to_tile(jet, *near_tile) - tile_edge_security_margin;
    370370    // cout << "      max info looked at tile " << *near_tile - &_tiles[0]
    371     //   << ", dist = " << dist << " " << (*near_tile)->max_NN_dist
    372     //   << endl;
     371    //     << ", dist = " << dist << " " << (*near_tile)->max_NN_dist
     372    //      << " -> diff = " << dist-(*near_tile)->max_NN_dist << endl;
    373373    if (dist > (*near_tile)->max_NN_dist) continue;
    374374
    … …  
    665665    int n_near_tiles = 0;
    666666
     667    // GS comment:
     668    //
     669    // At this stage, we have perforned the clustering in
     670    // ClusterSequence and we need to update the NNs. The objects we
     671    // deal with are jetA and oldB (the once that have been clustered)
     672    // as well as jetB (the result of the clustering)
     673    //
     674    // There are two types of objects we need to update:
     675    //  - find jetB NN
     676    //  - update the NN of points which had jetA or jetB as their NN
     677    //
     678    // Wile we find jetB's NN, browsing relevant tiles near jetB, we
     679    // also search for points which had jetA or jetB as their
     680    // NN. These are tagged. Then we list the relevant tiles where we
     681    // can potentially have points to update (i.e. points which had
     682    // jetA and oldB as NN) in the yet untagged relevant tiles near
     683    // jetA and oldB.
     684    //
     685    // DEBUG:
     686    // if (jetB != NULL) {
     687    //   cout << "jetA = " << jetA->_jets_index << " (tile " << jetA->tile_index << "), "
     688    //        << "oldB = " << oldB._jets_index  << " (tile " << oldB. tile_index << "), "
     689    //        << "jetB = " << jetB->_jets_index << " (tile " << jetB->tile_index << ")" << endl;
     690    // } else {
     691    //   cout << "jetA = " << jetA->_jets_index << " (tile " << jetA->tile_index << ")" << endl;
     692    // }
     693   
    667694    // Initialise jetB's NN distance as well as updating it for other
    668695    // particles. While doing so, examine whether jetA or old jetB was
    … …  
    679706        bool relevant_for_near_tile = dist_to_tile <= (*near_tile)->max_NN_dist;
    680707        bool relevant = relevant_for_jetB || relevant_for_near_tile;
     708
     709        // cout << "  Relevance of tile " << *near_tile - & _tiles[0]
     710        //      << " wrt jetB is " << relevant << endl;
     711
    681712        if (! relevant) continue;
    682713        // now label this tile as having been considered (so that we
    … …  
    702733    // and one new jet.
    703734    int n_done_tiles = n_near_tiles;
     735    //cout << "Looking at relevant tiles to update for jetA" << endl;
    704736    _add_untagged_neighbours_to_tile_union_using_max_info(jetA,
    705737                                           tile_union, n_near_tiles);
    706738    if (jetB != NULL) {
     739      // cout << "Looking at relevant tiles to update for oldB" << endl;
    707740        _add_untagged_neighbours_to_tile_union_using_max_info(&oldB,
    708741                                                              tile_union,n_near_tiles);

  • external/fastjet/LazyTiling9.cc

    rd091310 r1d208a2  
    11//FJSTARTHEADER
    2 // $Id: LazyTiling9.cc 3808 2015-02-20 11:24:53Z soyez $
     2// $Id: LazyTiling9.cc 3807 2015-02-20 11:16:55Z soyez $
    33//
    44// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez

  • external/fastjet/LazyTiling9Alt.cc

    rd091310 r1d208a2  
    11//FJSTARTHEADER
    2 // $Id: LazyTiling9Alt.cc 3808 2015-02-20 11:24:53Z soyez $
     2// $Id: LazyTiling9Alt.cc 3807 2015-02-20 11:16:55Z soyez $
    33//
    44// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez

  • external/fastjet/LazyTiling9SeparateGhosts.cc

    rd091310 r1d208a2  
    11//FJSTARTHEADER
    2 // $Id: LazyTiling9SeparateGhosts.cc 3808 2015-02-20 11:24:53Z soyez $
     2// $Id: LazyTiling9SeparateGhosts.cc 3807 2015-02-20 11:16:55Z soyez $
    33//
    44// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez

  • external/fastjet/NNH.hh

    rd091310 r1d208a2  
    33
    44//FJSTARTHEADER
    5 // $Id: NNH.hh 3433 2014-07-23 08:17:03Z salam $
     5// $Id: NNH.hh 4034 2016-03-02 00:20:27Z soyez $
    66//
    77// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
    … …  
    3232//FJENDHEADER
    3333
    34 #include<fastjet/ClusterSequence.hh>
    35 
     34#include <fastjet/NNBase.hh>
    3635
    3736FASTJET_BEGIN_NAMESPACE      // defined in fastjet/internal/base.hh
    38 
    39 /// @ingroup advanced_usage
    40 /// \class _NoInfo
    41 /// dummy class, used as a default template argument
    42 class _NoInfo {};
    43 
    44 /// @ingroup advanced_usage
    45 /// \class NNHInfo
    46 /// template that will help initialise a BJ with a PseudoJet and extra information
    47 template<class I> class NNHInfo {
    48 public:
    49   NNHInfo()         : _info(NULL) {}
    50   NNHInfo(I * info) : _info(info) {}
    51   template<class NNBJ> void init_jet(NNBJ * briefjet, const fastjet::PseudoJet & jet, int index) { briefjet->init(jet, index, _info);}
    52 private:
    53   I * _info;
    54 };
    55 
    56 /// @ingroup advanced_usage
    57 /// Specialisation of NNHInfo for cases where there is no extra info
    58 template<> class NNHInfo<_NoInfo>  {
    59 public:
    60   NNHInfo()           {}
    61   NNHInfo(_NoInfo * ) {}
    62   template<class NNBJ> void init_jet(NNBJ * briefjet, const fastjet::PseudoJet & jet, int index) { briefjet->init(jet, index);}
    63 };
    64 
    6537
    6638//----------------------------------------------------------------------
    … …  
    6840/// \class NNH
    6941/// Help solve closest pair problems with generic interparticle and
    70 /// beam distance.
    71 ///
    72 /// Class to help solve closest pair problems with generic interparticle
    73 /// distances and a beam distance, using Anderberg's Nearest Neighbour
    74 /// Heuristic.
    75 ///
    76 /// It is templated with a BJ (brief jet) class --- BJ should
    77 /// basically cache the minimal amount of information that is needed
    78 /// to efficiently calculate interparticle distances and particle-beam
    79 /// distances.
    80 ///
    81 /// This class can be used with or without an extra "Information" template,
    82 /// i.e. NNB<BJ> or NNH<BJ,I>
     42/// beam distance (generic case)
     43///
     44/// (see NNBase.hh for an introductory description)
     45///
     46/// This variant provides an implementation for any distance measure.
     47/// It is templated with a BJ (brief jet) classand can be used with or
     48/// without an extra "Information" template, i.e. NNH<BJ> or NNH<BJ,I>
    8349///
    8450/// For the NNH<BJ> version of the class to function, BJ must provide
    … …  
    8854///  - double BJ::distance(const BJ * other_bj_jet); // distance between this and other_bj_jet
    8955///  - double BJ::beam_distance()                  ; // distance to the beam
    90 ///
     56/// 
    9157/// For the NNH<BJ,I> version to function, the BJ::init(...) member
    9258/// must accept an extra argument
    … …  
    9460///  - void   BJ::init(const PseudoJet & jet, I * info);   // initialise with a PseudoJet + info
    9561///
    96 /// where info might be a pointer to a class that contains, e.g., information
    97 /// about R, or other parameters of the jet algorithm
     62/// NOTE: THE DISTANCE MUST BE SYMMETRIC I.E. SATISFY
     63///     a.distance(b) == b.distance(a)
    9864///
    9965/// For an example of how the NNH<BJ> class is used, see the Jade (and
    … …  
    10773/// implementations.
    10874///
    109 ///
    110 /// Implementation note: this class derives from NNHInfo, which deals
    111 /// with storing any global information that is needed during the clustering
    112 
    113 template<class BJ, class I = _NoInfo> class NNH : public NNHInfo<I> {
     75template<class BJ, class I = _NoInfo> class NNH : public NNBase<I> {
    11476public:
    11577
    11678  /// constructor with an initial set of jets (which will be assigned indices
    11779  /// 0 ... jets.size()-1
    118   NNH(const std::vector<PseudoJet> & jets) {start(jets);}
    119   NNH(const std::vector<PseudoJet> & jets, I * info) : NNHInfo<I>(info) {start(jets);}
    120  
     80  NNH(const std::vector<PseudoJet> & jets)           : NNBase<I>()     {start(jets);}
     81  NNH(const std::vector<PseudoJet> & jets, I * info) : NNBase<I>(info) {start(jets);}
     82
     83  // initialisation from a given list of particles
    12184  void start(const std::vector<PseudoJet> & jets);
    12285

  • external/fastjet/PseudoJet.cc

    rd091310 r1d208a2  
    11//FJSTARTHEADER
    2 // $Id: PseudoJet.cc 3652 2014-09-03 13:31:13Z salam $
     2// $Id: PseudoJet.cc 4100 2016-03-15 20:50:22Z salam $
    33//
    44// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
    … …  
    409409string PseudoJet::description() const{
    410410  // the "default" case of a PJ which does not belong to any cluster sequence
    411   if (!_structure())
     411  if (!_structure)
    412412    return "standard PseudoJet (with no associated clustering information)";
    413413 
    414414  // for all the other cases, the description comes from the structure
    415   return _structure()->description();
     415  return _structure->description();
    416416}
    417417
    … …  
    429429// ClusterSequence
    430430bool PseudoJet::has_associated_cluster_sequence() const{
    431   return (_structure()) && (_structure->has_associated_cluster_sequence());
     431  return (_structure) && (_structure->has_associated_cluster_sequence());
    432432}
    433433
    … …  
    446446// ClusterSequence that is still valid
    447447bool PseudoJet::has_valid_cluster_sequence() const{
    448   return (_structure()) && (_structure->has_valid_cluster_sequence());
     448  return (_structure) && (_structure->has_valid_cluster_sequence());
    449449}
    450450
    … …  
    467467
    468468//----------------------------------------------------------------------
    469 // return true if there is some strusture associated with this PseudoJet
     469// return true if there is some structure associated with this PseudoJet
    470470bool PseudoJet::has_structure() const{
    471   return _structure();
     471  return bool(_structure);
    472472}
    473473
    … …  
    478478// return NULL if there is no associated structure
    479479const PseudoJetStructureBase* PseudoJet::structure_ptr() const {
    480   if (!_structure()) return NULL;
    481   return _structure();
     480  //if (!_structure) return NULL;
     481  return _structure.get();
    482482}
    483483 
    … …  
    493493// underlying structure.
    494494PseudoJetStructureBase* PseudoJet::structure_non_const_ptr(){
    495   if (!_structure()) return NULL;
    496   return _structure();
     495  //if (!_structure) return NULL;
     496  return _structure.get();
    497497}
    498498 
    … …  
    503503// throw an error if there is no associated structure
    504504const PseudoJetStructureBase* PseudoJet::validated_structure_ptr() const {
    505   if (!_structure())
     505  if (!_structure)
    506506    throw Error("Trying to access the structure of a PseudoJet which has no associated structure");
    507   return _structure();
     507  return _structure.get();
    508508}
    509509 
    … …  
    573573// returns true if the PseudoJet has constituents
    574574bool PseudoJet::has_constituents() const{
    575   return (_structure()) && (_structure->has_constituents());
     575  return (_structure) && (_structure->has_constituents());
    576576}
    577577
    … …  
    586586// returns true if the PseudoJet has support for exclusive subjets
    587587bool PseudoJet::has_exclusive_subjets() const{
    588   return (_structure()) && (_structure->has_exclusive_subjets());
     588  return (_structure) && (_structure->has_exclusive_subjets());
    589589}
    590590
    … …  
    670670// ClusterSequence have no pieces and this methos will return false.
    671671bool PseudoJet::has_pieces() const{
    672   return ((_structure()) && (_structure->has_pieces(*this)));
     672  return ((_structure) && (_structure->has_pieces(*this)));
    673673}
    674674
    … …  
    766766
    767767
    768 
    769 //----------------------------------------------------------------------
    770 /// given a vector of values with a one-to-one correspondence with the
    771 /// vector of objects, sort objects into an order such that the
    772 /// associated values would be in increasing order
    773 template<class T> vector<T>  objects_sorted_by_values(
    774                        const vector<T> & objects,
    775                        const vector<double> & values) {
    776 
    777   assert(objects.size() == values.size());
    778 
    779   // get a vector of indices
    780   vector<int> indices(values.size());
    781   for (size_t i = 0; i < indices.size(); i++) {indices[i] = i;}
    782  
    783   // sort the indices
    784   sort_indices(indices, values);
    785  
    786   // copy the objects
    787   vector<T> objects_sorted(objects.size());
    788  
    789   // place the objects in the correct order
    790   for (size_t i = 0; i < indices.size(); i++) {
    791     objects_sorted[i] = objects[indices[i]];
    792   }
    793 
    794   return objects_sorted;
    795 }
    796 
    797768//----------------------------------------------------------------------
    798769/// return a vector of jets sorted into decreasing kt2

  • external/fastjet/PseudoJet.hh

    rd091310 r1d208a2  
    11//FJSTARTHEADER
    2 // $Id: PseudoJet.hh 3566 2014-08-11 15:36:34Z salam $
     2// $Id: PseudoJet.hh 4047 2016-03-03 13:21:49Z soyez $
    33//
    44// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
    … …  
    437437  /// retrieve a pointer to the (const) user information
    438438  const UserInfoBase * user_info_ptr() const{
    439     if (!_user_info()) return NULL;
     439    // the line below is not needed since the next line would anyway
     440    // return NULL in that case
     441    //if (!_user_info) return NULL;
    440442    return _user_info.get();
    441443  }
    … …  
    841843inline bool operator!=( const double val, const PseudoJet & a) {return !(a==val);}
    842844
     845/// returns the 4-vector dot product of a and b
    843846inline double dot_product(const PseudoJet & a, const PseudoJet & b) {
    844847  return a.E()*b.E() - a.px()*b.px() - a.py()*b.py() - a.pz()*b.pz();
    … …  
    880883/// touch the values vector in the process).
    881884template<class T> std::vector<T> objects_sorted_by_values(const std::vector<T> & objects,
    882                                               const std::vector<double> & values);
     885                                              const std::vector<double> & values) {
     886  //assert(objects.size() == values.size());
     887  if (objects.size() != values.size()){
     888    throw Error("fastjet::objects_sorted_by_values(...): the size of the 'objects' vector must match the size of the 'values' vector");
     889  }
     890 
     891  // get a vector of indices
     892  std::vector<int> indices(values.size());
     893  for (size_t i = 0; i < indices.size(); i++) {indices[i] = i;}
     894 
     895  // sort the indices
     896  sort_indices(indices, values);
     897 
     898  // copy the objects
     899  std::vector<T> objects_sorted(objects.size());
     900 
     901  // place the objects in the correct order
     902  for (size_t i = 0; i < indices.size(); i++) {
     903    objects_sorted[i] = objects[indices[i]];
     904  }
     905
     906  return objects_sorted;
     907}
    883908
    884909/// \if internal_doc
    … …  
    970995template<typename TransformerType>
    971996bool PseudoJet::has_structure_of() const{
    972   if (!_structure()) return false;
     997  if (!_structure) return false;
    973998
    974999  return dynamic_cast<const typename TransformerType::StructureType *>(_structure.get()) != 0;
    … …  
    9801005template<typename TransformerType>
    9811006const typename TransformerType::StructureType & PseudoJet::structure_of() const{
    982   if (!_structure())
     1007  if (!_structure)
    9831008    throw Error("Trying to access the structure of a PseudoJet without an associated structure");
    9841009

  • external/fastjet/RangeDefinition.hh

    rd091310 r1d208a2  
    11//FJSTARTHEADER
    2 // $Id: RangeDefinition.hh 3433 2014-07-23 08:17:03Z salam $
     2// $Id: RangeDefinition.hh 4074 2016-03-08 09:09:25Z soyez $
    33//
    44// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
    … …  
    3535#include "fastjet/Error.hh"
    3636#include "fastjet/LimitedWarning.hh"
     37#include "fastjet/internal/deprecated.hh"
    3738#include<sstream>
    3839#include<iostream>
    … …  
    5152public:
    5253  /// default constructor
     54  FASTJET_DEPRECATED_MSG("RangeDefinition is deprecated since FastJet 3.0. Use the Selector mechanism instead")
    5355  RangeDefinition() { _warn_deprecated(); }
    5456
    5557  /// constructor for a range definition given by |y|<rapmax
     58  FASTJET_DEPRECATED_MSG("RangeDefinition is deprecated since FastJet 3.0. Use the Selector mechanism instead")
    5659  RangeDefinition(double rapmax) {  _warn_deprecated();
    5760                     assert ( rapmax > 0.0 );

  • external/fastjet/RectangularGrid.cc

    rd091310 r1d208a2  
    11//FJSTARTHEADER
    2 // $Id: RectangularGrid.cc 3771 2014-12-22 21:13:22Z salam $
     2// $Id: RectangularGrid.cc 3773 2014-12-22 22:44:46Z soyez $
    33//
    44// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez

  • external/fastjet/RectangularGrid.hh

    rd091310 r1d208a2  
    33
    44//FJSTARTHEADER
    5 // $Id: RectangularGrid.hh 3771 2014-12-22 21:13:22Z salam $
     5// $Id: RectangularGrid.hh 4047 2016-03-03 13:21:49Z soyez $
    66//
    77// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
    … …  
    118118  RectangularGrid();
    119119
    120   virtual int n_tiles() const {return _ntotal;}
     120  virtual int n_tiles() const FASTJET_OVERRIDE {return _ntotal;}
    121121
    122   virtual int n_good_tiles() const {return _ngood;}
     122  virtual int n_good_tiles() const FASTJET_OVERRIDE {return _ngood;}
    123123
    124124  // this was being kept inline, but it seems to make little
    125125  // difference whether it is or not (at least on Gavin's mac)
    126   virtual int tile_index(const PseudoJet & p) const;
     126  virtual int tile_index(const PseudoJet & p) const FASTJET_OVERRIDE;
    127127
    128128  /// returns whether a given tile is good
    129129  // tested in "issue" 2014-08-08-testing-rect-grid
    130   virtual bool tile_is_good(int itile) const {return _tile_selector.worker() ? _is_good[itile] : true;}
     130  virtual bool tile_is_good(int itile) const FASTJET_OVERRIDE {
     131    return _tile_selector.worker() ? _is_good[itile] : true;
     132  }
    131133
    132134  /// returns the area of tile itile.
    133   virtual double tile_area(int /* itile */) const {return mean_tile_area();}
     135  virtual double tile_area(int /* itile */) const FASTJET_OVERRIDE {
     136    return mean_tile_area();
     137  }
    134138
    135139  /// returns the mean area of tiles.
    136   virtual double mean_tile_area() const {return _dphi*_dy;};
     140  virtual double mean_tile_area() const FASTJET_OVERRIDE {return _dphi*_dy;};
    137141
    138142  /// returns a textual description of the grid
    139   virtual std::string description() const;
     143  virtual std::string description() const FASTJET_OVERRIDE;
    140144 
    141145  /// returns the minimum rapidity extent of the grid
    … …  
    149153
    150154  /// returns true if the grid is in a suitably initialised state
    151   virtual bool is_initialised() const {return _ntotal > 0;}
     155  virtual bool is_initialised() const FASTJET_OVERRIDE {return _ntotal > 0;}
    152156
    153157private:

  • external/fastjet/SharedPtr.hh

    rd091310 r1d208a2  
    33
    44//FJSTARTHEADER
    5 // $Id: SharedPtr.hh 3433 2014-07-23 08:17:03Z salam $
     5// $Id: SharedPtr.hh 4051 2016-03-03 14:33:38Z soyez $
    66//
    77// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
    … …  
    3838// for our SharedPtr simply to be derived from the STL TR1 one.
    3939// #define __FASTJET_USETR1SHAREDPTR
     40
     41#include "fastjet/internal/deprecated.hh"
    4042
    4143#ifdef __FASTJET_USETR1SHAREDPTR
    … …  
    7274  SharedPtr(const SharedPtr<T> & t) : std::tr1::shared_ptr<T>(t) {}
    7375  // for some reason operator() doesn't get inherited
     76  #ifdef FASTJET_HAVE_EXPLICIT_FOR_OPERATORS
     77  explicit
     78  #endif
    7479  inline operator bool() const {return (this->get()!=NULL);}
    7580  /// return the pointer we're pointing to 
    … …  
    211216  }
    212217 
    213   /// return the pointer we're pointing to 
     218  /// return the pointer we're pointing to
     219  ///
     220  /// Since FastJet 3.2.0, this is depracated since it is no longer
     221  /// part of std::shared_ptr<T>. Use SharedPtr<T>::get() instead
     222  FASTJET_DEPRECATED_MSG("Use SharedPtr<T>::get() instead")
    214223  T* operator ()() const{
    215224    if (_ptr==NULL) return NULL;
    … …  
    257266  /// conversion to bool
    258267  /// This will allow you to use the indirection nicely
     268  #ifdef FASTJET_HAVE_EXPLICIT_FOR_OPERATORS
     269  explicit
     270  #endif
    259271  inline operator bool() const{
    260272    return (get()!=NULL);

  • external/fastjet/TilingExtent.cc

    rd091310 r1d208a2  
    11//FJSTARTHEADER
    2 // $Id: TilingExtent.cc 3433 2014-07-23 08:17:03Z salam $
     2// $Id: TilingExtent.cc 4034 2016-03-02 00:20:27Z soyez $
    33//
    44// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
    … …  
    4141  _determine_rapidity_extent(cs.jets());
    4242}
    43  
     43
     44TilingExtent::TilingExtent(const vector<PseudoJet> &particles) {
     45  _determine_rapidity_extent(particles);
     46}
     47
    4448void TilingExtent::_determine_rapidity_extent(const vector<PseudoJet> & particles) {
    4549  // have a binning of rapidity that goes from -nrap to nrap

  • external/fastjet/VERSION

    rd091310 r1d208a2  
    1 3.1.3
     13.2.1

  • external/fastjet/WrappedStructure.hh

    rd091310 r1d208a2  
    11//FJSTARTHEADER
    2 // $Id: WrappedStructure.hh 3433 2014-07-23 08:17:03Z salam $
     2// $Id: WrappedStructure.hh 4047 2016-03-03 13:21:49Z soyez $
    33//
    44// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
    … …  
    5757  WrappedStructure(const SharedPtr<PseudoJetStructureBase> & to_be_shared)
    5858    : _structure(to_be_shared){
    59     if (!_structure())
     59    if (!_structure)
    6060      throw Error("Trying to construct a wrapped structure around an empty (NULL) structure");
    6161  }
    … …  
    6565
    6666  /// description
    67   virtual std::string description() const{
     67  virtual std::string description() const FASTJET_OVERRIDE{
    6868    return "PseudoJet wrapping the structure ("+_structure->description()+")";
    6969  }
    … …  
    7676  //-------------------------------------------------------------
    7777  /// returns true if there is an associated ClusterSequence
    78   virtual bool has_associated_cluster_sequence() const {
     78  virtual bool has_associated_cluster_sequence() const FASTJET_OVERRIDE {
    7979    return _structure->has_associated_cluster_sequence();
    8080  }
    … …  
    8282  /// get a (const) pointer to the parent ClusterSequence (NULL if
    8383  /// inexistent)
    84   virtual const ClusterSequence* associated_cluster_sequence() const{
     84  virtual const ClusterSequence* associated_cluster_sequence() const FASTJET_OVERRIDE{
    8585    return _structure->associated_cluster_sequence();
    8686  }
    … …  
    8888  /// returns true if this PseudoJet has an associated and still
    8989  /// valid ClusterSequence.
    90   virtual bool has_valid_cluster_sequence() const {
     90  virtual bool has_valid_cluster_sequence() const FASTJET_OVERRIDE {
    9191    return _structure->has_valid_cluster_sequence();
    9292  }
    … …  
    9494  /// if the jet has a valid associated cluster sequence then return a
    9595  /// pointer to it; otherwise throw an error
    96   virtual const ClusterSequence * validated_cs() const{
     96  virtual const ClusterSequence * validated_cs() const FASTJET_OVERRIDE{
    9797    return _structure->validated_cs();
    9898  }
    … …  
    100100  /// if the jet has valid area information then return a pointer to
    101101  /// the associated ClusterSequenceAreaBase object; otherwise throw an error
    102   virtual const ClusterSequenceAreaBase * validated_csab() const{
     102  virtual const ClusterSequenceAreaBase * validated_csab() const FASTJET_OVERRIDE{
    103103    return _structure->validated_csab();
    104104  }
    … …  
    120120  ///
    121121  /// By default, throws an Error
    122   virtual bool has_partner(const PseudoJet &reference, PseudoJet &partner) const{
     122  virtual bool has_partner(const PseudoJet &reference, PseudoJet &partner) const FASTJET_OVERRIDE{
    123123    return _structure->has_partner(reference, partner);
    124124  }
    … …  
    129129  ///
    130130  /// By default, throws an Error
    131   virtual bool has_child(const PseudoJet &reference, PseudoJet &child) const{
     131  virtual bool has_child(const PseudoJet &reference, PseudoJet &child) const FASTJET_OVERRIDE{
    132132    return _structure->has_child(reference, child);
    133133  }
    … …  
    138138  ///
    139139  /// By default, throws an Error
    140   virtual bool has_parents(const PseudoJet &reference, PseudoJet &parent1, PseudoJet &parent2) const{
     140  virtual bool has_parents(const PseudoJet &reference,
     141                           PseudoJet &parent1, PseudoJet &parent2) const FASTJET_OVERRIDE{
    141142    return _structure->has_parents(reference, parent1, parent2);
    142143  }
    … …  
    146147  ///
    147148  /// By default, throws an Error
    148   virtual bool object_in_jet(const PseudoJet &reference, const PseudoJet &jet) const{
     149  virtual bool object_in_jet(const PseudoJet &reference,
     150                             const PseudoJet &jet) const FASTJET_OVERRIDE{
    149151    return _structure->object_in_jet(reference, jet);
    150152  }
    … …  
    154156  ///
    155157  /// false by default
    156   virtual bool has_constituents() const {
     158  virtual bool has_constituents() const  FASTJET_OVERRIDE{
    157159    return _structure->has_constituents();
    158160  }
    … …  
    161163  ///
    162164  /// By default, throws an Error
    163   virtual std::vector<PseudoJet> constituents(const PseudoJet &reference) const{
     165  virtual std::vector<PseudoJet> constituents(const PseudoJet &reference) const FASTJET_OVERRIDE{
    164166    return _structure->constituents(reference);
    165167  }
    166168
    167169  /// return true if the structure supports exclusive_subjets.
    168   virtual bool has_exclusive_subjets() const {
     170  virtual bool has_exclusive_subjets() const  FASTJET_OVERRIDE{
    169171    return _structure->has_exclusive_subjets();
    170172  }
    … …  
    180182  ///
    181183  /// By default, throws an Error
    182   virtual std::vector<PseudoJet> exclusive_subjets(const PseudoJet &reference, const double & dcut) const{
     184  virtual std::vector<PseudoJet> exclusive_subjets(const PseudoJet &reference,
     185                                                   const double & dcut) const FASTJET_OVERRIDE{
    183186    return _structure->exclusive_subjets(reference, dcut);
    184187  }
    … …  
    189192  ///
    190193  /// By default, throws an Error
    191   virtual int n_exclusive_subjets(const PseudoJet &reference, const double & dcut) const{
     194  virtual int n_exclusive_subjets(const PseudoJet &reference,
     195                                  const double & dcut) const FASTJET_OVERRIDE{
    192196    return _structure->n_exclusive_subjets(reference, dcut);
    193197  }
    … …  
    198202  ///
    199203  /// By default, throws an Error
    200   virtual std::vector<PseudoJet> exclusive_subjets_up_to (const PseudoJet &reference, int nsub) const{
     204  virtual std::vector<PseudoJet> exclusive_subjets_up_to (const PseudoJet &reference,
     205                                                          int nsub) const FASTJET_OVERRIDE{
    201206    return _structure->exclusive_subjets_up_to (reference, nsub);
    202207  }
    … …  
    206211  ///
    207212  /// By default, throws an Error
    208   virtual double exclusive_subdmerge(const PseudoJet &reference, int nsub) const{
     213  virtual double exclusive_subdmerge(const PseudoJet &reference, int nsub) const FASTJET_OVERRIDE{
    209214    return _structure->exclusive_subdmerge(reference, nsub);
    210215  }
    … …  
    215220  ///
    216221  /// By default, throws an Error
    217   virtual double exclusive_subdmerge_max(const PseudoJet &reference, int nsub) const{
     222  virtual double exclusive_subdmerge_max(const PseudoJet &reference, int nsub) const FASTJET_OVERRIDE{
    218223    return _structure->exclusive_subdmerge_max(reference, nsub);
    219224  }
    … …  
    226231  ///
    227232  /// false by default
    228   virtual bool has_pieces(const PseudoJet &reference) const {
     233  virtual bool has_pieces(const PseudoJet &reference) const FASTJET_OVERRIDE {
    229234    return _structure->has_pieces(reference);
    230235  }
    … …  
    233238  ///
    234239  /// By default, throws an Error
    235   virtual std::vector<PseudoJet> pieces(const PseudoJet &reference) const{
     240  virtual std::vector<PseudoJet> pieces(const PseudoJet &reference) const FASTJET_OVERRIDE {
    236241    return _structure->pieces(reference);
    237242  }
    … …  
    244249  ///
    245250  /// false by default
    246   virtual bool has_area() const {
     251  virtual bool has_area() const FASTJET_OVERRIDE  {
    247252    return _structure->has_area();
    248253  }
    … …  
    251256  ///
    252257  /// By default, throws an Error
    253   virtual double area(const PseudoJet &reference) const{
     258  virtual double area(const PseudoJet &reference) const FASTJET_OVERRIDE{
    254259    return _structure->area(reference);
    255260  }
    … …  
    259264  ///
    260265  /// By default, throws an Error
    261   virtual double area_error(const PseudoJet &reference) const{
     266  virtual double area_error(const PseudoJet &reference) const FASTJET_OVERRIDE{
    262267    return _structure->area_error(reference);
    263268  }
    … …  
    266271  ///
    267272  /// By default, throws an Error
    268   virtual PseudoJet area_4vector(const PseudoJet &reference) const{
     273  virtual PseudoJet area_4vector(const PseudoJet &reference) const FASTJET_OVERRIDE{
    269274    return _structure->area_4vector(reference);
    270275  }
    … …  
    273278  ///
    274279  /// By default, throws an Error
    275   virtual bool is_pure_ghost(const PseudoJet &reference) const{
     280  virtual bool is_pure_ghost(const PseudoJet &reference) const FASTJET_OVERRIDE{
    276281    return _structure->is_pure_ghost(reference);
    277282  }

  • external/fastjet/config_auto.h

    rd091310 r1d208a2  
    6464#endif
    6565
    66 /* defined if C++11 features have been enabled */
    67 /* #undef HAVE_CXX11_FEATURES */
     66/* compile the deprecated parts of the interface using auto-ptr */
     67#ifndef FASTJET_HAVE_AUTO_PTR_INTERFACE
     68#define FASTJET_HAVE_AUTO_PTR_INTERFACE  /**/
     69#endif
     70
     71/* compiler supports c++14 deprecated keyword */
     72/* #undef HAVE_CXX14_DEPRECATED */
    6873
    6974/* defined if demangling is enabled at configure time and is supported through
    … …  
    8186#endif
    8287
     88/* compiler supports the "explicit" keyword for operators */
     89/* #undef HAVE_EXPLICIT_FOR_OPERATORS */
     90
     91/* compiler supports GNU c++ deprecated attribute */
     92#ifndef FASTJET_HAVE_GNUCXX_DEPRECATED
     93#define FASTJET_HAVE_GNUCXX_DEPRECATED  /**/
     94#endif
     95
    8396/* Define to 1 if you have the <inttypes.h> header file. */
    8497#ifndef FASTJET_HAVE_INTTYPES_H
    … …  
    96109#endif
    97110
     111/* compiler supports the "override" keyword */
     112/* #undef HAVE_OVERRIDE */
     113
    98114/* Define to 1 if you have the <stdint.h> header file. */
    99115#ifndef FASTJET_HAVE_STDINT_H
    … …  
    131147#endif
    132148
    133 /* Define to the sub-directory in which libtool stores uninstalled libraries.
    134    */
     149/* Define to the sub-directory where libtool stores uninstalled libraries. */
    135150#ifndef FASTJET_LT_OBJDIR
    136151#define FASTJET_LT_OBJDIR  ".libs/"
    … …  
    154169/* Define to the full name and version of this package. */
    155170#ifndef FASTJET_PACKAGE_STRING
    156 #define FASTJET_PACKAGE_STRING  "FastJet 3.1.3"
     171#define FASTJET_PACKAGE_STRING  "FastJet 3.2.1"
    157172#endif
    158173
    … …  
    162177#endif
    163178
     179/* Define to the home page for this package. */
     180#ifndef FASTJET_PACKAGE_URL
     181#define FASTJET_PACKAGE_URL  ""
     182#endif
     183
    164184/* Define to the version of this package. */
    165185#ifndef FASTJET_PACKAGE_VERSION
    166 #define FASTJET_PACKAGE_VERSION  "3.1.3"
     186#define FASTJET_PACKAGE_VERSION  "3.2.1"
    167187#endif
    168188
    … …  
    174194/* Version number of package */
    175195#ifndef FASTJET_VERSION
    176 #define FASTJET_VERSION  "3.1.3"
     196#define FASTJET_VERSION  "3.2.1"
    177197#endif
    178198
    … …  
    184204/* Minor version of this package */
    185205#ifndef FASTJET_VERSION_MINOR
    186 #define FASTJET_VERSION_MINOR  1
     206#define FASTJET_VERSION_MINOR  2
    187207#endif
    188208
    189209/* Version of the package under the form XYYZZ (instead of X.Y.Z) */
    190210#ifndef FASTJET_VERSION_NUMBER
    191 #define FASTJET_VERSION_NUMBER  30103
     211#define FASTJET_VERSION_NUMBER  30201
    192212#endif
    193213
    194214/* Patch version of this package */
    195215#ifndef FASTJET_VERSION_PATCHLEVEL
    196 #define FASTJET_VERSION_PATCHLEVEL  3
     216#define FASTJET_VERSION_PATCHLEVEL  1
    197217#endif
    198218

  • external/fastjet/config_raw.h

    rd091310 r1d208a2  
    3838#define ENABLE_PLUGIN_TRACKJET /**/
    3939
    40 /* defined if C++11 features have been enabled */
    41 /* #undef HAVE_CXX11_FEATURES */
     40/* compile the deprecated parts of the interface using auto-ptr */
     41#define HAVE_AUTO_PTR_INTERFACE /**/
     42
     43/* compiler supports c++14 deprecated keyword */
     44/* #undef HAVE_CXX14_DEPRECATED */
    4245
    4346/* defined if demangling is enabled at configure time and is supported through
    … …  
    5154#define HAVE_EXECINFO_H 1
    5255
     56/* compiler supports the "explicit" keyword for operators */
     57/* #undef HAVE_EXPLICIT_FOR_OPERATORS */
     58
     59/* compiler supports GNU c++ deprecated attribute */
     60#define HAVE_GNUCXX_DEPRECATED /**/
     61
    5362/* Define to 1 if you have the <inttypes.h> header file. */
    5463#define HAVE_INTTYPES_H 1
    … …  
    5968/* Define to 1 if you have the <memory.h> header file. */
    6069#define HAVE_MEMORY_H 1
     70
     71/* compiler supports the "override" keyword */
     72/* #undef HAVE_OVERRIDE */
    6173
    6274/* Define to 1 if you have the <stdint.h> header file. */
    … …  
    8193#define HAVE_UNISTD_H 1
    8294
    83 /* Define to the sub-directory in which libtool stores uninstalled libraries.
    84    */
     95/* Define to the sub-directory where libtool stores uninstalled libraries. */
    8596#define LT_OBJDIR ".libs/"
    8697
    … …  
    95106
    96107/* Define to the full name and version of this package. */
    97 #define PACKAGE_STRING "FastJet 3.1.3"
     108#define PACKAGE_STRING "FastJet 3.2.1"
    98109
    99110/* Define to the one symbol short name of this package. */
    100111#define PACKAGE_TARNAME "fastjet"
    101112
     113/* Define to the home page for this package. */
     114#define PACKAGE_URL ""
     115
    102116/* Define to the version of this package. */
    103 #define PACKAGE_VERSION "3.1.3"
     117#define PACKAGE_VERSION "3.2.1"
    104118
    105119/* Define to 1 if you have the ANSI C header files. */
    … …  
    107121
    108122/* Version number of package */
    109 #define VERSION "3.1.3"
     123#define VERSION "3.2.1"
    110124
    111125/* Major version of this package */
    … …  
    113127
    114128/* Minor version of this package */
    115 #define VERSION_MINOR 1
     129#define VERSION_MINOR 2
    116130
    117131/* Version of the package under the form XYYZZ (instead of X.Y.Z) */
    118 #define VERSION_NUMBER 30103
     132#define VERSION_NUMBER 30201
    119133
    120134/* Patch version of this package */
    121 #define VERSION_PATCHLEVEL 3
     135#define VERSION_PATCHLEVEL 1
    122136
    123137/* Pre-release version of this package */

  • external/fastjet/config_win.h

    rd091310 r1d208a2  
    1 #define FASTJET_PACKAGE_STRING  "FastJet 3.1.3"
    2 #define FASTJET_PACKAGE_VERSION  "3.1.3"
    3 #define FASTJET_VERSION  "3.1.3"
    4 #define FASTJET_VERSION_MAJOR       3.1.3
    5 #define FASTJET_VERSION_MINOR       3.1.3
    6 #define FASTJET_VERSION_PATCHLEVEL  3.1.3
    7 #define FASTJET_VERSION_PRERELEASE  "3.1.3"
    8 #define FASTJET_VERSION_NUMBER      00000
     1#define FASTJET_PACKAGE_STRING  "FastJet 3.2.1"
     2#define FASTJET_PACKAGE_VERSION  "3.2.1"
     3#define FASTJET_VERSION  "3.2.1"
     4#define FASTJET_VERSION_MAJOR       3
     5#define FASTJET_VERSION_MINOR       2
     6#define FASTJET_VERSION_PATCHLEVEL  1
     7#define FASTJET_VERSION_NUMBER      30201
    98
    109/* The ATLASCone plugin is disabled by default*/

  • external/fastjet/contribs/Nsubjettiness/ChangeLog

    rd091310 r1d208a2  
     12016-06-08 <jthaler>
     2   Fixed bug in MeasureDefinition.cc where axes were not completely defined,
     3      leading to problems with multi-pass axes
     42016-04-04 <jthaler>
     5   Fixed Njettiness.cc to give value of _current_tau_components even if less
     6      than N constituents
     7   Delete extraneous code in example_advanced_usage.cc
     82016-03-29 <jthaler>
     9   Update for FJ 3.2.0 to deal with SharedPtr () deprecation
    1102015-09-28 <jthaler>
    211   Updated NEWS for 2.2.1 release.

  • external/fastjet/contribs/Nsubjettiness/MeasureDefinition.cc

    rd091310 r1d208a2  
    55//  Jesse Thaler, Ken Van Tilburg, Christopher K. Vermilion, and TJ Wilkason
    66//
    7 //  $Id: MeasureDefinition.cc 819 2015-06-12 21:23:24Z jthaler $
     7//  $Id: MeasureDefinition.cc 946 2016-06-14 19:11:27Z jthaler $
    88//----------------------------------------------------------------------
    99// This file is part of FastJet contrib.
    … …  
    524524      old_axes[k].set_rap( seedAxes[k].rap() );
    525525      old_axes[k].set_phi( seedAxes[k].phi() );
     526      old_axes[k].set_mom( seedAxes[k].modp()  );
    526527   }
    527528   

  • external/fastjet/contribs/Nsubjettiness/NEWS

    rd091310 r1d208a2  
    3232    N-jettiness as a jet finder using the new ConicalGeometric measure.
    3333
     34-- 2.2.4:  (Jun 14, 2016) Fixed bug where multi-pass minimization could yield
     35           pathological axes (thanks Gregory Soyez)
     36-- 2.2.3:  (Apr 4, 2016) Fixed bug where a jet with fewer than N constituents
     37           could give random value for tau_N (thanks Nathan Hartland)
     38-- 2.2.2:  (Mar 29, 2016)  Updating SharedPtr interface for FJ 3.2
    3439-- 2.2.1:  (Sept 28, 2015)  Fix of small Makefile bug
    3540-- 2.2.0:  (Sept 7, 2015)  Inclusion of the XCone jet algorithm, as well as a

  • external/fastjet/contribs/Nsubjettiness/Njettiness.cc

    rd091310 r1d208a2  
    55//  Jesse Thaler, Ken Van Tilburg, Christopher K. Vermilion, and TJ Wilkason
    66//
    7 //  $Id: Njettiness.cc 821 2015-06-15 18:50:53Z jthaler $
     7//  $Id: Njettiness.cc 933 2016-04-04 22:23:32Z jthaler $
    88//----------------------------------------------------------------------
    99// This file is part of FastJet contrib.
    … …  
    4646// setAxes for Manual mode
    4747void Njettiness::setAxes(const std::vector<fastjet::PseudoJet> & myAxes) {
    48    if (_axes_def()->needsManualAxes()) {
     48   if (_axes_def->needsManualAxes()) {
    4949      _currentAxes = myAxes;
    5050   } else {
    … …  
    5959      _currentAxes = inputJets;
    6060      _currentAxes.resize(n_jets,fastjet::PseudoJet(0.0,0.0,0.0,0.0));
    61       _current_tau_components = TauComponents();
     61     
     62     // Put in empty tau components
     63     std::vector<double> dummy_jet_pieces;
     64     _current_tau_components = TauComponents(UNDEFINED_SHAPE,
     65                                             dummy_jet_pieces,
     66                                             0.0,
     67                                             1.0,
     68                                             _currentAxes,
     69                                             _currentAxes
     70                                             );
    6271      _seedAxes = _currentAxes;
    6372      _currentPartition = TauPartition(n_jets); // empty partition
    6473   } else {
    65       assert(_axes_def()); // this should never fail.
     74      assert(_axes_def); // this should never fail.
    6675     
    67       if (_axes_def()->needsManualAxes()) { // if manual mode
     76      if (_axes_def->needsManualAxes()) { // if manual mode
    6877         // take current axes as seeds
    6978         _seedAxes = _currentAxes;
    7079         
    7180         // refine axes if requested
    72          _currentAxes = _axes_def->get_refined_axes(n_jets,inputJets,_seedAxes, _measure_def());
     81         _currentAxes = _axes_def->get_refined_axes(n_jets,inputJets,_seedAxes, _measure_def.get());
    7382      } else { // non-manual axes
    7483         
    7584          //set starting point for minimization
    76          _seedAxes = _axes_def->get_starting_axes(n_jets,inputJets,_measure_def());
     85         _seedAxes = _axes_def->get_starting_axes(n_jets,inputJets,_measure_def.get());
    7786         
    7887         // refine axes as needed
    79          _currentAxes = _axes_def->get_refined_axes(n_jets,inputJets,_seedAxes, _measure_def());
     88         _currentAxes = _axes_def->get_refined_axes(n_jets,inputJets,_seedAxes, _measure_def.get());
    8089         
    8190         // NOTE:  The above two function calls are combined in "AxesDefinition::get_axes"

  • external/fastjet/contribs/Nsubjettiness/VERSION

    rd091310 r1d208a2  
    1 2.2.1
     12.2.4

  • external/fastjet/internal/ClosestPair2D.hh

    rd091310 r1d208a2  
    11//FJSTARTHEADER
    2 // $Id: ClosestPair2D.hh 3433 2014-07-23 08:17:03Z salam $
     2// $Id: ClosestPair2D.hh 4059 2016-03-03 20:49:48Z soyez $
    33//
    44// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
    … …  
    3838#include "fastjet/internal/SearchTree.hh"
    3939#include "fastjet/internal/MinHeap.hh"
     40#include "fastjet/SharedPtr.hh"
    4041
    4142FASTJET_BEGIN_NAMESPACE      // defined in fastjet/internal/base.hh
    … …  
    134135
    135136
    136   triplet<std::auto_ptr<Tree> >  _trees;
    137   std::auto_ptr<MinHeap> _heap;
     137  triplet<SharedPtr<Tree> >  _trees;
     138  SharedPtr<MinHeap>    _heap;
    138139  std::vector<Point>     _points;
    139140  std::stack<Point *>    _available_points;

  • external/fastjet/internal/ClosestPair2DBase.hh

    rd091310 r1d208a2  
    11//FJSTARTHEADER
    2 // $Id: ClosestPair2DBase.hh 3433 2014-07-23 08:17:03Z salam $
     2// $Id: ClosestPair2DBase.hh 4049 2016-03-03 13:45:47Z salam $
    33//
    44// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
    … …  
    4848  double x, y;
    4949
    50   Coord2D() {};
     50  Coord2D() : x(0.0), y(0.0) {};
    5151
    5252  Coord2D(double a, double b): x(a), y(b) {};

  • external/fastjet/internal/DnnPlane.hh

    rd091310 r1d208a2  
    11//FJSTARTHEADER
    2 // $Id: DnnPlane.hh 3918 2015-07-03 14:19:13Z salam $
     2// $Id: DnnPlane.hh 3917 2015-07-03 14:07:50Z salam $
    33//
    44// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez

  • external/fastjet/internal/LazyTiling9Alt.hh

    rd091310 r1d208a2  
    33
    44//FJSTARTHEADER
    5 // $Id: LazyTiling9Alt.hh 3808 2015-02-20 11:24:53Z soyez $
     5// $Id: LazyTiling9Alt.hh 3807 2015-02-20 11:16:55Z soyez $
    66//
    77// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez

  • external/fastjet/internal/TilingExtent.hh

    rd091310 r1d208a2  
    55
    66//FJSTARTHEADER
    7 // $Id: TilingExtent.hh 3433 2014-07-23 08:17:03Z salam $
     7// $Id: TilingExtent.hh 4034 2016-03-02 00:20:27Z soyez $
    88//
    99// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
    … …  
    4646  TilingExtent(ClusterSequence & cs);
    4747
     48  /// constructor that takes a list of PseudoJets
     49  TilingExtent(const std::vector<PseudoJet> &particles);
     50
    4851  /// returns the suggested minimum rapidity for the tiling
    4952  double minrap() const {return _minrap;}

  • external/fastjet/internal/base.hh

    rd091310 r1d208a2  
    11
    22//FJSTARTHEADER
    3 // $Id: base.hh 3433 2014-07-23 08:17:03Z salam $
     3// $Id: base.hh 4047 2016-03-03 13:21:49Z soyez $
    44//
    55// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
    … …  
    3333#define __FASTJET_FASTJET_BASE_HH__
    3434
     35#include "fastjet/config.h"
     36
    3537/// \namespace fastjet
    3638/// the FastJet namespace
    … …  
    4345#define FASTJET_END_NAMESPACE   }
    4446
     47// define a macro to mark virtual function in derived classes as
     48// overriding the base-class definition
     49#ifdef FASTJET_HAVE_OVERRIDE
     50#define FASTJET_OVERRIDE  override
     51#else
     52#define FASTJET_OVERRIDE 
     53#endif
     54
    4555#endif // __FASTJET_FASTJET_BASE_HH__

  • external/fastjet/plugins/Jade/JadePlugin.cc

    rd091310 r1d208a2  
    11//FJSTARTHEADER
    2 // $Id: JadePlugin.cc 3433 2014-07-23 08:17:03Z salam $
     2// $Id: JadePlugin.cc 4063 2016-03-04 10:31:40Z salam $
    33//
    44// Copyright (c) 2007-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
    … …  
    3535//#include "fastjet/internal/ClusterSequence_N2.icc"
    3636#include "fastjet/NNH.hh"
     37#include "fastjet/NNFJN2Plain.hh"
    3738
    3839// other stuff
    … …  
    5152//----------------------------------------------------------------------
    5253/// class to help run a JADE algorithm
     54///
     55/// This class works both with NNH and NNFJN2Plain clustering
     56/// helpers. They both use the same init(...) call, but for the
     57/// clustering:
     58///
     59/// - NNH uses distance(...) and beam_distance()
     60/// - NNFJPlainN2 uses geometrical_distance(...), momentum_factor()
     61///   and geometrical_beam_distance()
     62///
     63/// For NNFJPlainN2 the 2 E_i E_j (1-cos theta_{ij}) factor
     64/// gets broken up into
     65///
     66///     sqrt(2)*min(E_i,E_j) * [sqrt(2)*max(E_i,E_j) (1 - cos \theta_{ij})]
     67///
     68/// The second factor is what we call the "geometrical_distance" even
     69/// though it isn't actually purely geometrical. But the fact that it
     70/// gets multiplied by min(E_i,E_j) to get the full distance is
     71/// sufficient for the validity of the FJ lemma, allowing for the use
     72/// of NNFJN2Plain.
    5373class JadeBriefJet {
    5474public:
    … …  
    6989  }
    7090
     91  double geometrical_distance(const JadeBriefJet * jet) const {
     92    double dij = 1 - nx*jet->nx
     93                   - ny*jet->ny
     94                   - nz*jet->nz;
     95    dij *= max(rt2E,jet->rt2E);
     96    return dij;
     97  }
     98
     99  double momentum_factor() const {
     100    return rt2E;
     101  }
     102 
    71103  double beam_distance() const {
    72104    return numeric_limits<double>::max();
    73105  }
    74106
     107  double geometrical_beam_distance() const {
     108    // get a number that is almost the same as max(), just a little
     109    // smaller so as to ensure that when we divide it by rt2E and then
     110    // multiply it again, we won't get an overflow
     111    const double almost_max = numeric_limits<double>::max() * (1 - 1e-13);
     112    return almost_max / rt2E;
     113  }
     114 
    75115private:
    76116  double rt2E, nx, ny, nz;
    … …  
    82122  ostringstream desc;
    83123  desc << "e+e- JADE algorithm plugin";
     124  switch(_strategy) {
     125  case strategy_NNH:
     126    desc << ", using NNH strategy"; break;
     127  case strategy_NNFJN2Plain:
     128    desc << ", using NNFJN2Plain strategy"; break;
     129  default:
     130    throw Error("Unrecognized strategy in JadePlugin");
     131  }
     132
    84133  return desc.str();
    85134}
    86135
    87 //----------------------------------------------------------------------
    88 void JadePlugin::run_clustering(ClusterSequence & cs) const {
     136// //----------------------------------------------------------------------
     137// void JadePlugin::run_clustering(ClusterSequence & cs) const {
     138//   int njets = cs.jets().size();
     139//
     140//   //SharedPtr<NNBase<> > nn;
     141//   NNBase<> * nn;
     142//   switch(_strategy) {
     143//   case strategy_NNH:
     144//     //nn.reset(new NNH<JadeBriefJet>(cs.jets()));
     145//     nn = new NNH<JadeBriefJet>(cs.jets());
     146//     break;
     147//   case strategy_NNFJN2Plain:
     148//     //nn.reset(new NNFJN2Plain<JadeBriefJet>(cs.jets()));
     149//     nn = new NNFJN2Plain<JadeBriefJet>(cs.jets());
     150//     break;
     151//   default:
     152//     throw Error("Unrecognized strategy in JadePlugin");
     153//   }
     154//   //NNH<JadeBriefJet> nnh(cs.jets());
     155//   //NNFJN2Plain<JadeBriefJet> nnh(cs.jets());
     156//
     157//   // if testing against Hoeth's implementation, need to rescale the
     158//   // dij by Q^2.
     159//   //double Q2 = cs.Q2();
     160//
     161//   while (njets > 0) {
     162//     int i, j, k;
     163//     double dij = nn->dij_min(i, j);
     164//
     165//     if (j >= 0) {
     166//       cs.plugin_record_ij_recombination(i, j, dij, k);
     167//       nn->merge_jets(i, j, cs.jets()[k], k);
     168//     } else {
     169//       double diB = cs.jets()[i].E()*cs.jets()[i].E(); // get new diB
     170//       cs.plugin_record_iB_recombination(i, diB);
     171//       nn->remove_jet(i);
     172//     }
     173//     njets--;
     174//   }
     175//   delete nn;
     176// }
     177
     178
     179template<class N> void JadePlugin::_actual_run_clustering(ClusterSequence & cs) const {
     180
    89181  int njets = cs.jets().size();
    90   NNH<JadeBriefJet> nnh(cs.jets());
     182
     183  N nn(cs.jets());
    91184
    92185  // if testing against Hoeth's implementation, need to rescale the
    … …  
    96189  while (njets > 0) {
    97190    int i, j, k;
    98     double dij = nnh.dij_min(i, j);
     191    double dij = nn.dij_min(i, j);
    99192
    100193    if (j >= 0) {
    101194      cs.plugin_record_ij_recombination(i, j, dij, k);
    102       nnh.merge_jets(i, j, cs.jets()[k], k);
     195      nn.merge_jets(i, j, cs.jets()[k], k);
    103196    } else {
    104197      double diB = cs.jets()[i].E()*cs.jets()[i].E(); // get new diB
    105198      cs.plugin_record_iB_recombination(i, diB);
    106       nnh.remove_jet(i);
     199      nn.remove_jet(i);
    107200    }
    108201    njets--;
    109202  }
     203
    110204}
    111205
     206//----------------------------------------------------------------------
     207void JadePlugin::run_clustering(ClusterSequence & cs) const {
     208
     209  switch(_strategy) {
     210  case strategy_NNH:
     211    _actual_run_clustering<NNH<JadeBriefJet> >(cs);
     212    break;
     213  case strategy_NNFJN2Plain:
     214    _actual_run_clustering<NNFJN2Plain<JadeBriefJet> >(cs);
     215    break;
     216  default:
     217    throw Error("Unrecognized strategy in JadePlugin");
     218  }
     219}
     220
     221
    112222FASTJET_END_NAMESPACE      // defined in fastjet/internal/base.hh

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

    rd091310 r1d208a2  
    33
    44//FJSTARTHEADER
    5 // $Id: JadePlugin.hh 3433 2014-07-23 08:17:03Z salam $
     5// $Id: JadePlugin.hh 4061 2016-03-03 21:51:25Z salam $
    66//
    77// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
    … …  
    7777class JadePlugin : public JetDefinition::Plugin {
    7878public:
     79  /// enum that contains the two clustering strategy options; for
     80  /// higher multiplicities, strategy_NNFJN2Plain is about a factor of
     81  /// two faster.
     82  enum Strategy { strategy_NNH = 0, strategy_NNFJN2Plain = 1};
     83 
    7984  /// Main constructor for the Jade Plugin class. 
    80   JadePlugin (){}
     85  JadePlugin (Strategy strategy = strategy_NNFJN2Plain) : _strategy(strategy) {}
    8186
    8287  /// copy constructor
    … …  
    100105private:
    101106
     107  template<class N> void _actual_run_clustering(ClusterSequence &) const;
     108 
     109  Strategy _strategy;
    102110};
    103111

  • external/fastjet/plugins/SISCone/SISConePlugin.cc

    rd091310 r1d208a2  
    7878// static members declaration              //
    7979/////////////////////////////////////////////
    80 std::auto_ptr<SISConePlugin>           SISConePlugin::stored_plugin;
    81 std::auto_ptr<std::vector<PseudoJet> > SISConePlugin::stored_particles;
    82 std::auto_ptr<Csiscone>                SISConePlugin::stored_siscone;
     80SharedPtr<SISConePlugin>           SISConePlugin::stored_plugin;
     81SharedPtr<std::vector<PseudoJet> > SISConePlugin::stored_particles;
     82SharedPtr<Csiscone>                SISConePlugin::stored_siscone;
    8383
    8484

  • external/fastjet/plugins/SISCone/config.h

    rd091310 r1d208a2  
    1 /* siscone/config.h.  Generated from config.h.in by configure.  */
     1#ifndef _SISCONE_CONFIG_H
     2#define _SISCONE_CONFIG_H 1
     3 
     4/* siscone/config.h. Generated automatically at end of configure. */
     5/* siscone/config_raw.h.  Generated from config.h.in by configure.  */
    26/* config.h.in.  Generated from configure.ac by autoheader.  */
    37
    48/* Define to 1 if you have the <dlfcn.h> header file. */
    5 #define HAVE_DLFCN_H 1
     9#ifndef SISCONE_HAVE_DLFCN_H
     10#define SISCONE_HAVE_DLFCN_H  1
     11#endif
    612
    713/* Define to 1 if you have the <inttypes.h> header file. */
    8 #define HAVE_INTTYPES_H 1
     14#ifndef SISCONE_HAVE_INTTYPES_H
     15#define SISCONE_HAVE_INTTYPES_H  1
     16#endif
    917
    1018/* Define to 1 if you have the `m' library (-lm). */
    11 #define HAVE_LIBM 1
     19#ifndef SISCONE_HAVE_LIBM
     20#define SISCONE_HAVE_LIBM  1
     21#endif
    1222
    1323/* Define to 1 if you have the <memory.h> header file. */
    14 #define HAVE_MEMORY_H 1
     24#ifndef SISCONE_HAVE_MEMORY_H
     25#define SISCONE_HAVE_MEMORY_H  1
     26#endif
    1527
    1628/* Define to 1 if you have the <stdint.h> header file. */
    17 #define HAVE_STDINT_H 1
     29#ifndef SISCONE_HAVE_STDINT_H
     30#define SISCONE_HAVE_STDINT_H  1
     31#endif
    1832
    1933/* Define to 1 if you have the <stdlib.h> header file. */
    20 #define HAVE_STDLIB_H 1
     34#ifndef SISCONE_HAVE_STDLIB_H
     35#define SISCONE_HAVE_STDLIB_H  1
     36#endif
    2137
    2238/* Define to 1 if you have the <strings.h> header file. */
    23 #define HAVE_STRINGS_H 1
     39#ifndef SISCONE_HAVE_STRINGS_H
     40#define SISCONE_HAVE_STRINGS_H  1
     41#endif
    2442
    2543/* Define to 1 if you have the <string.h> header file. */
    26 #define HAVE_STRING_H 1
     44#ifndef SISCONE_HAVE_STRING_H
     45#define SISCONE_HAVE_STRING_H  1
     46#endif
    2747
    2848/* Define to 1 if you have the <sys/stat.h> header file. */
    29 #define HAVE_SYS_STAT_H 1
     49#ifndef SISCONE_HAVE_SYS_STAT_H
     50#define SISCONE_HAVE_SYS_STAT_H  1
     51#endif
    3052
    3153/* Define to 1 if you have the <sys/types.h> header file. */
    32 #define HAVE_SYS_TYPES_H 1
     54#ifndef SISCONE_HAVE_SYS_TYPES_H
     55#define SISCONE_HAVE_SYS_TYPES_H  1
     56#endif
    3357
    3458/* Define to 1 if you have the <unistd.h> header file. */
    35 #define HAVE_UNISTD_H 1
     59#ifndef SISCONE_HAVE_UNISTD_H
     60#define SISCONE_HAVE_UNISTD_H  1
     61#endif
    3662
    37 /* Define to the sub-directory in which libtool stores uninstalled libraries.
    38    */
    39 #define LT_OBJDIR ".libs/"
     63/* Define to the sub-directory where libtool stores uninstalled libraries. */
     64#ifndef SISCONE_LT_OBJDIR
     65#define SISCONE_LT_OBJDIR  ".libs/"
     66#endif
    4067
    4168/* Name of package */
    42 #define PACKAGE "siscone"
     69#ifndef SISCONE_PACKAGE
     70#define SISCONE_PACKAGE  "siscone"
     71#endif
    4372
    4473/* Define to the address where bug reports for this package should be sent. */
    45 #define PACKAGE_BUGREPORT ""
     74#ifndef SISCONE_PACKAGE_BUGREPORT
     75#define SISCONE_PACKAGE_BUGREPORT  ""
     76#endif
    4677
    4778/* Define to the full name of this package. */
    48 #define PACKAGE_NAME "SISCone"
     79#ifndef SISCONE_PACKAGE_NAME
     80#define SISCONE_PACKAGE_NAME  "SISCone"
     81#endif
    4982
    5083/* Define to the full name and version of this package. */
    51 #define PACKAGE_STRING "SISCone 3.0.0"
     84#ifndef SISCONE_PACKAGE_STRING
     85#define SISCONE_PACKAGE_STRING  "SISCone 3.0.3"
     86#endif
    5287
    5388/* Define to the one symbol short name of this package. */
    54 #define PACKAGE_TARNAME "siscone"
     89#ifndef SISCONE_PACKAGE_TARNAME
     90#define SISCONE_PACKAGE_TARNAME  "siscone"
     91#endif
     92
     93/* Define to the home page for this package. */
     94#ifndef SISCONE_PACKAGE_URL
     95#define SISCONE_PACKAGE_URL  ""
     96#endif
    5597
    5698/* Define to the version of this package. */
    57 #define PACKAGE_VERSION "3.0.0"
     99#ifndef SISCONE_PACKAGE_VERSION
     100#define SISCONE_PACKAGE_VERSION  "3.0.3"
     101#endif
    58102
    59103/* Define to 1 if you have the ANSI C header files. */
    60 #define STDC_HEADERS 1
     104#ifndef SISCONE_STDC_HEADERS
     105#define SISCONE_STDC_HEADERS  1
     106#endif
     107
     108/* use unique_ptr instead of auto_ptr */
     109/* #undef USES_UNIQUE_PTR_AS_AUTO_PTR */
    61110
    62111/* Version number of package */
    63 #define VERSION "3.0.0"
     112#ifndef SISCONE_VERSION
     113#define SISCONE_VERSION  "3.0.3"
     114#endif
     115 
     116/* once: _SISCONE_CONFIG_H */
     117#endif

  • external/fastjet/plugins/SISCone/defines.h

    rd091310 r1d208a2  
    2222// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
    2323//                                                                           //
    24 // $Revision:: 225                                                          $//
    25 // $Date:: 2008-05-20 16:59:47 +0200 (Tue, 20 May 2008)                     $//
     24// $Revision:: 401                                                          $//
     25// $Date:: 2016-05-19 16:44:37 +0200 (Thu, 19 May 2016)                     $//
    2626///////////////////////////////////////////////////////////////////////////////
    2727
    … …  
    3535// defined in siscone.h
    3636// Otherwise, config.h
    37 // It is also defined as "PACKAGE_NAME" in config.h but this method
     37// It is also defined as "SISCONE_PACKAGE_NAME" in config.h but this method
    3838// might lead to conflicts
    39 //#define PROGRAM   PACKAGE_NAME
     39//#define PROGRAM   SISCONE_PACKAGE_NAME
    4040
    4141// program version
    … …  
    4343//   siscone::siscone_version
    4444// defined in siscone.h
    45 // It is also defined as "VERSION" in config.h but this method
     45// It is also defined as "SISCONE_VERSION" in config.h but this method
    4646// might lead to conflicts
    4747

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

    rd091310 r1d208a2  
    191191  // part needed for the cache
    192192  // variables for caching the results and the input
    193   static std::auto_ptr<SISConePlugin          > stored_plugin;
    194   static std::auto_ptr<std::vector<PseudoJet> > stored_particles;
    195   static std::auto_ptr<siscone::Csiscone      > stored_siscone;
     193  static SharedPtr<SISConePlugin          > stored_plugin;
     194  static SharedPtr<std::vector<PseudoJet> > stored_particles;
     195  static SharedPtr<siscone::Csiscone      > stored_siscone;
    196196};
    197197

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

    rd091310 r1d208a2  
    166166  // part needed for the cache
    167167  // variables for caching the results and the input
    168   static std::auto_ptr<SISConeSphericalPlugin        > stored_plugin;
    169   static std::auto_ptr<std::vector<PseudoJet>        > stored_particles;
    170   static std::auto_ptr<siscone_spherical::CSphsiscone> stored_siscone;
     168  static SharedPtr<SISConeSphericalPlugin        > stored_plugin;
     169  static SharedPtr<std::vector<PseudoJet>        > stored_particles;
     170  static SharedPtr<siscone_spherical::CSphsiscone> stored_siscone;
    171171};
    172172

  • external/fastjet/plugins/SISCone/siscone.cc

    rd091310 r1d208a2  
    2121// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
    2222//                                                                           //
    23 // $Revision:: 371                                                          $//
    24 // $Date:: 2014-09-09 10:05:32 +0200 (Tue, 09 Sep 2014)                     $//
     23// $Revision:: 403                                                          $//
     24// $Date:: 2016-05-19 16:52:05 +0200 (Thu, 19 May 2016)                     $//
    2525///////////////////////////////////////////////////////////////////////////////
    2626
    27 //#ifdef HAVE_CONFIG_H
    2827#include "config.h"
    29 //#else
    30 //#define PACKAGE_NAME "SISCone"
    31 //#define VERSION "3.0.0"
    32 //#warning "No config.h file available, using preset values"
    33 //#endif
    34 
    3528#include "ranlux.h"
    3629#include "momentum.h"
    … …  
    254247  // print the banner
    255248  if (_banner_ostr != 0){
     249    ios::fmtflags flags_to_restore(_banner_ostr->flags());
     250
    256251    (*_banner_ostr) << "#ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo" << endl;
    257252    (*_banner_ostr) << "#                    SISCone   version " << setw(28) << left << siscone_version() << "o" << endl;
    … …  
    269264
    270265    _banner_ostr->flush();
     266    _banner_ostr->flags(flags_to_restore);
    271267  }
    272268}
    … …  
    279275 * return SISCone package name.
    280276 * This is nothing but "SISCone", it is a replacement to the
    281  * PACKAGE_NAME string defined in config.h and which is not
    282  * public by default.
     277 * SISCONE_PACKAGE_NAME string defined in config.h and which is not
     278 * guaranteed to be public.
    283279 * return the SISCone name as a string
    284280 */
    285281string siscone_package_name(){
    286   return PACKAGE_NAME;
     282  return SISCONE_PACKAGE_NAME;
    287283}
    288284
    … …  
    293289 */
    294290string siscone_version(){
    295   return VERSION;
    296 }
    297 
    298 }
     291  return SISCONE_VERSION;
     292}
     293
     294}

  • external/fastjet/plugins/SISCone/siscone.h

    rd091310 r1d208a2  
    2222// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
    2323//                                                                           //
    24 // $Revision:: 369                                                          $//
    25 // $Date:: 2014-09-04 16:57:55 +0200 (Thu, 04 Sep 2014)                     $//
     24// $Revision:: 401                                                          $//
     25// $Date:: 2016-05-19 16:44:37 +0200 (Thu, 19 May 2016)                     $//
    2626///////////////////////////////////////////////////////////////////////////////
    2727
    … …  
    160160 * return SISCone package name.
    161161 * This is nothing but "SISCone", it is a replacement to the
    162  * PACKAGE_NAME string defined in config.h and which is not
    163  * public by default.
     162 * SISCONE_PACKAGE_NAME string defined in config.h and which is not
     163 * guaranteed to be public.
    164164 * \return the SISCone name as a string
    165165 */

  • external/fastjet/plugins/SISCone/split_merge.cc

    rd091310 r1d208a2  
    2121// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
    2222//                                                                           //
    23 // $Revision:: 370                                                          $//
    24 // $Date:: 2014-09-04 17:03:15 +0200 (Thu, 04 Sep 2014)                     $//
     23// $Revision:: 390                                                          $//
     24// $Date:: 2016-03-03 11:06:52 +0100 (Thu, 03 Mar 2016)                     $//
    2525///////////////////////////////////////////////////////////////////////////////
    2626
    … …  
    5454  pt_tilde = 0.0;
    5555  sm_var2 = 0.0;
     56  pass = CJET_INEXISTENT_PASS; // initialised to a value that should
     57                               // notappear in the end (after clustering)
    5658}
    5759
    … …  
    659661
    660662#ifdef DEBUG_SPLIT_MERGE
    661   cout << "PR-Jet " << jets.size() << " [size " << next_jet.contents.size() << "]:";
     663  cout << "PR-Jet " << jets.size() << " [size " << jet.contents.size() << "]:";
    662664#endif
    663665   
    … …  
    11791181  }
    11801182
    1181   return 0.0;
    1182 }
    1183 
    1184 }
     1183  //return 0.0;
     1184}
     1185
     1186}

  • external/fastjet/plugins/SISCone/split_merge.h

    rd091310 r1d208a2  
    2222// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
    2323//                                                                           //
    24 // $Revision:: 367                                                          $//
    25 // $Date:: 2014-09-04 15:57:37 +0200 (Thu, 04 Sep 2014)                     $//
     24// $Revision:: 405                                                          $//
     25// $Date:: 2016-05-23 20:15:02 +0200 (Mon, 23 May 2016)                     $//
    2626///////////////////////////////////////////////////////////////////////////////
    2727
    … …  
    2929#define __SPLIT_MERGE_H__
    3030
     31#include "config.h"
    3132#include "defines.h"
    3233#include "geom_2d.h"
    … …  
    3940
    4041namespace siscone{
     42
     43const int CJET_INEXISTENT_PASS = -2;
    4144
    4245/**
    … …  
    7578  /// pass at which the jet has been found
    7679  /// It starts at 0 (first pass), -1 means infinite rapidity
     80  /// (it will be initialised to "CJET_INEXISTENT_PASS" which should
     81  /// never appear after clustering)
    7782  int pass;
    7883};
    … …  
    441446  // jet information
    442447  /// list of jet candidates
     448#ifdef SISCONE_USES_UNIQUE_PTR_AS_AUTO_PTR
     449  std::unique_ptr<std::multiset<Cjet,Csplit_merge_ptcomparison> > candidates;
     450#else
    443451  std::auto_ptr<std::multiset<Cjet,Csplit_merge_ptcomparison> > candidates;
    444 
     452#endif
     453 
    445454  /// minimal pt2
    446455  double pt_min2;

  • external/fastjet/plugins/SISCone/vicinity.cc

    rd091310 r1d208a2  
    2121// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA //
    2222//                                                                           //
    23 // $Revision:: 123                                                          $//
    24 // $Date:: 2007-03-01 02:52:16 +0100 (Thu, 01 Mar 2007)                     $//
     23// $Revision:: 388                                                          $//
     24// $Date:: 2016-03-03 10:42:25 +0100 (Thu, 03 Mar 2016)                     $//
    2525///////////////////////////////////////////////////////////////////////////////
    2626
    … …  
    8080  VR2 = VR = 0.0;
    8181
     82  ve_list = NULL;
    8283  set_particle_list(_particle_list);
    8384}

  • external/fastjet/tools/Filter.cc

    rd091310 r1d208a2  
    11//FJSTARTHEADER
    2 // $Id: Filter.cc 3760 2014-12-19 10:05:10Z soyez $
     2// $Id: Filter.cc 4080 2016-03-09 15:01:57Z soyez $
    33//
    44// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
    … …  
    3131#include "fastjet/tools/Filter.hh"
    3232#include "fastjet/tools/Recluster.hh"
     33#include "fastjet/tools/Subtractor.hh"
    3334#include <fastjet/ClusterSequenceActiveAreaExplicitGhosts.hh>
    3435#include <cassert>
    … …  
    9899  } else if (_rho!=0){
    99100    if (subjets.size()>0){
    100       const ClusterSequenceAreaBase *csab = subjets[0].validated_csab();
     101      //const ClusterSequenceAreaBase *csab = subjets[0].validated_csab();
    101102      for (unsigned int i=0;i<subjets.size();i++){
    102         subjets[i]=csab->subtracted_jet(subjets[i], _rho);
     103        //subjets[i]=csab->subtracted_jet(subjets[i], _rho);
     104        subjets[i]=Subtractor(_rho)(subjets[i]);
    103105      }
    104106    }

  • external/fastjet/tools/Filter.hh

    rd091310 r1d208a2  
    33
    44//FJSTARTHEADER
    5 // $Id: Filter.hh 3845 2015-03-08 08:35:36Z soyez $
     5// $Id: Filter.hh 3846 2015-03-08 08:35:43Z soyez $
    66//
    77// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
    … …  
    143143  /// deciding which ones to keep. It takes precedence over a non-zero rho.
    144144  void set_subtractor(const FunctionOfPseudoJet<PseudoJet> * subtractor_in) {_subtractor = subtractor_in;}
     145
     146  /// Set a subtractor that is applied to all individual subjets before
     147  /// deciding which ones to keep. It takes precedence over a non-zero rho.
     148  const FunctionOfPseudoJet<PseudoJet> * subtractor() const{ return _subtractor;}
    145149
    146150  /// runs the filtering and sets kept and rejected to be the jets of interest

  • external/fastjet/tools/GridMedianBackgroundEstimator.hh

    rd091310 r1d208a2  
    33
    44//FJSTARTHEADER
    5 // $Id: GridMedianBackgroundEstimator.hh 3778 2014-12-24 09:28:09Z salam $
     5// $Id: GridMedianBackgroundEstimator.hh 3969 2015-09-21 08:57:59Z salam $
    66//
    77// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
    … …  
    194194  /// determination of rho_m.
    195195  ///
    196   /// Note that support for sigma_m is automatic is one has sigma and
     196  /// Note that support for sigma_m is automatic if one has sigma and
    197197  /// rho_m support.
    198198  bool has_rho_m() const {return _enable_rho_m;}

  • external/fastjet/tools/JetMedianBackgroundEstimator.cc

    rd091310 r1d208a2  
    11//FJSTARTHEADER
    2 // $Id: JetMedianBackgroundEstimator.cc 3517 2014-08-01 14:23:13Z soyez $
     2// $Id: JetMedianBackgroundEstimator.cc 4047 2016-03-03 13:21:49Z soyez $
    33//
    44// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
    … …  
    194194
    195195  _csi = jets[0].structure_shared_ptr();
    196   ClusterSequenceStructure * csi = dynamic_cast<ClusterSequenceStructure*>(_csi());
     196  ClusterSequenceStructure * csi = dynamic_cast<ClusterSequenceStructure*>(_csi.get());
    197197  const ClusterSequenceAreaBase * csab = csi->validated_csab();
    198198
    … …  
    467467
    468468  // determine the number of empty jets
    469   const ClusterSequenceAreaBase * csab = (dynamic_cast<ClusterSequenceStructure*>(_csi()))->validated_csab();
     469  const ClusterSequenceAreaBase * csab = (dynamic_cast<ClusterSequenceStructure*>(_csi.get()))->validated_csab();
    470470  if (csab->has_explicit_ghosts()) {
    471471    _empty_area = 0.0;
    … …  
    503503// throw an error otherwise
    504504void JetMedianBackgroundEstimator::_check_csa_alive() const{
    505   ClusterSequenceStructure* csa = dynamic_cast<ClusterSequenceStructure*>(_csi());
     505  ClusterSequenceStructure* csa = dynamic_cast<ClusterSequenceStructure*>(_csi.get());
    506506  if (csa == 0) {
    507507    throw Error("JetMedianBackgroundEstimator: there is no cluster sequence associated with the JetMedianBackgroundEstimator");
    508508  }
    509   if (! dynamic_cast<ClusterSequenceStructure*>(_csi())->has_associated_cluster_sequence())
     509  if (! dynamic_cast<ClusterSequenceStructure*>(_csi.get())->has_associated_cluster_sequence())
    510510    throw Error("JetMedianBackgroundEstimator: modifications are no longer possible as the underlying ClusterSequence has gone out of scope");
    511511}
    … …  
    521521  // cluster sequence
    522522  if (_jet_def.jet_algorithm() == undefined_jet_algorithm){
    523     const ClusterSequence * cs = dynamic_cast<ClusterSequenceStructure*>(_csi())->validated_cs();
     523    const ClusterSequence * cs = dynamic_cast<ClusterSequenceStructure*>(_csi.get())->validated_cs();
    524524    jet_def = &(cs->jet_def());
    525525  }

  • external/fastjet/tools/Recluster.hh

    rd091310 r1d208a2  
    22#define __FASTJET_TOOLS_RECLUSTER_HH__
    33
    4 // $Id: Recluster.hh 3760 2014-12-19 10:05:10Z soyez $
     4// $Id: Recluster.hh 3753 2014-12-17 15:19:55Z salam $
    55//
    66// Copyright (c) 2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez

  • external/fastjet/tools/Subtractor.cc

    rd091310 r1d208a2  
    11//FJSTARTHEADER
    2 // $Id: Subtractor.cc 3670 2014-09-08 14:17:59Z soyez $
     2// $Id: Subtractor.cc 3970 2015-09-21 10:31:17Z salam $
    33//
    44// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
    … …  
    3939const double Subtractor::_invalid_rho = -numeric_limits<double>::infinity();
    4040
     41LimitedWarning Subtractor::_unused_rho_m_warning;
    4142
    4243//----------------------------------------------------------------------

  • external/fastjet/tools/Subtractor.hh

    rd091310 r1d208a2  
    11//FJSTARTHEADER
    2 // $Id: Subtractor.hh 3670 2014-09-08 14:17:59Z soyez $
     2// $Id: Subtractor.hh 3970 2015-09-21 10:31:17Z salam $
    33//
    44// Copyright (c) 2005-2014, Matteo Cacciari, Gavin P. Salam and Gregory Soyez
    … …  
    203203  static const double _invalid_rho;
    204204
    205   mutable LimitedWarning _unused_rho_m_warning;
     205  static LimitedWarning _unused_rho_m_warning;
    206206};
    207207
Note: See TracChangeset for help on using the changeset viewer.