SISConePlugin.hh

Go to the documentation of this file.

#ifndef __SISCONEPLUGIN_HH__
#define __SISCONEPLUGIN_HH__

#include "fastjet/JetDefinition.hh"
#include "fastjet/ClusterSequence.hh" // needed for the extras we define
#include <vector>
#include <memory>
#include <cmath>

// put a forward declaration to the Csiscone class to avoid having to
// include the siscone headers here
namespace siscone {
  class Csiscone;
}

// questionable whether this should be in fastjet namespace or not...
FASTJET_BEGIN_NAMESPACE      // defined in fastjet/internal/base.hh

// another forward declaration to reduce includes
class PseudoJet;

//----------------------------------------------------------------------
//
//
class SISConePlugin : public JetDefinition::Plugin {
public:

  enum SplitMergeScale {SM_pt,     
                        SM_Et,     

                        SM_mt,     

                        SM_pttilde 

  };


  SISConePlugin (double cone_radius,
                 double overlap_threshold = 0.5,
                 int    n_pass_max = 0,
                 double protojet_ptmin = 0.0, 
                 bool   caching = false,
                 SplitMergeScale  split_merge_scale = SM_pttilde,
                 double split_merge_stopping_scale = 0.0) :
    _cone_radius           (cone_radius       ),
    _overlap_threshold     (overlap_threshold ),
    _n_pass_max            (n_pass_max ), 
    _protojet_ptmin        (protojet_ptmin),
    _caching               (caching),             
    _split_merge_scale     (split_merge_scale),
    _split_merge_stopping_scale (split_merge_stopping_scale),
    _ghost_sep_scale       (0.0) {}

  SISConePlugin (double cone_radius,
                 double overlap_threshold,
                 int    n_pass_max,
                 double protojet_ptmin, 
                 bool   caching ,
                 bool   split_merge_on_transverse_mass) :
    _cone_radius           (cone_radius       ),
    _overlap_threshold     (overlap_threshold ),
    _n_pass_max            (n_pass_max ), 
    _protojet_ptmin        (protojet_ptmin),
    _caching               (caching),             
    _split_merge_scale     (split_merge_on_transverse_mass ? SM_mt : SM_pttilde),
    _ghost_sep_scale       (0.0)  {}
  
  SISConePlugin (double cone_radius,
                 double overlap_threshold,
                 int    n_pass_max,
                 bool   caching ) :
    _cone_radius           (cone_radius       ),
    _overlap_threshold     (overlap_threshold ),
    _n_pass_max            (n_pass_max ), 
    _protojet_ptmin        (0.0),
    _caching               (caching),
    _split_merge_scale     (SM_mt),
    _ghost_sep_scale       (0.0) {}

  SISConePlugin (const SISConePlugin & plugin) {
    *this = plugin;
  }

  double cone_radius        () const {return _cone_radius        ;}

  double overlap_threshold  () const {return _overlap_threshold  ;}

  int n_pass_max  () const {return _n_pass_max  ;}

  double protojet_ptmin  () const {return _protojet_ptmin  ;}

  double protojet_or_ghost_ptmin  () const {return std::max(_protojet_ptmin,
                                                            _ghost_sep_scale);}

  SplitMergeScale split_merge_scale() const {return _split_merge_scale;}
  void set_split_merge_scale(SplitMergeScale sms) {_split_merge_scale = sms;}

  bool split_merge_on_transverse_mass() const {return _split_merge_scale == SM_mt ;}
  void set_split_merge_on_transverse_mass(bool val) {
    _split_merge_scale = val  ? SM_mt : SM_pt;}

  void set_split_merge_stopping_scale(double scale) {
    _split_merge_stopping_scale = scale;}

  double split_merge_stopping_scale() {return _split_merge_stopping_scale;}

  bool caching() const {return _caching ;}

  // the things that are required by base class
  virtual std::string description () const;
  virtual void run_clustering(ClusterSequence &) const;
  virtual double R() const {return cone_radius();}

  virtual bool supports_ghosted_passive_areas() const {return true;}
  
  virtual void set_ghost_separation_scale(double scale) const {
    _ghost_sep_scale = scale;
  }

  virtual double ghost_separation_scale() const {return _ghost_sep_scale;}

private:
  double _cone_radius, _overlap_threshold;
  int    _n_pass_max;
  double _protojet_ptmin;
  bool   _caching;//, _split_merge_on_transverse_mass;
  SplitMergeScale _split_merge_scale;
  double _split_merge_stopping_scale;

  mutable double _ghost_sep_scale;

  // variables for caching the results and the input
  static std::auto_ptr<SISConePlugin          > stored_plugin;
  static std::auto_ptr<std::vector<PseudoJet> > stored_particles;
  static std::auto_ptr<siscone::Csiscone      > stored_siscone;

};


//======================================================================
class SISConeExtras : public ClusterSequence::Extras {
public:
  const std::vector<PseudoJet> & stable_cones() const {return _protocones;}

  const std::vector<PseudoJet> & protocones() const {return _protocones;}


  const SISConePlugin * jet_def_plugin() const {return _jet_def_plugin;}

  std::string description() const;

  inline double most_ambiguous_split() const {return _most_ambiguous_split;}

private:
  std::vector<PseudoJet> _protocones;
  const SISConePlugin * _jet_def_plugin;
  double                _most_ambiguous_split;
  // let us be written to by SISConePlugin
  friend class SISConePlugin;
};


FASTJET_END_NAMESPACE        // defined in fastjet/internal/base.hh

#endif // __SISCONEPLUGIN_HH__

---