SISConeBasePlugin.hh

#ifndef __SISCONEBASEPLUGIN_HH__
#define __SISCONEBASEPLUGIN_HH__

#include "fastjet/JetDefinition.hh"
#include "fastjet/ClusterSequence.hh"
#include <vector>
#include <memory>
#include <cmath>

#include <sstream>

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

//----------------------------------------------------------------------
//
//
class SISConeBasePlugin : public JetDefinition::Plugin {
public:
  SISConeBasePlugin (){
    _use_jet_def_recombiner = false;
  }

  SISConeBasePlugin (const SISConeBasePlugin & 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  ;}

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

  double split_merge_stopping_scale() {return _split_merge_stopping_scale;}

  void set_use_jet_def_recombiner(bool choice) {_use_jet_def_recombiner = choice;}

  bool use_jet_def_recombiner() const {return _use_jet_def_recombiner;}

  bool caching() const {return _caching ;}

  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;
  }

  // the things that one MUST overload required by base class
  //---------------------------------------------------------

  virtual std::string description () const =0;

  virtual void run_clustering(ClusterSequence &) const = 0;

protected:
  double _cone_radius, _overlap_threshold;
  int    _n_pass_max;
  bool   _caching;//, _split_merge_on_transverse_mass;
  double _split_merge_stopping_scale;
  bool   _use_jet_def_recombiner;

  mutable double _ghost_sep_scale;

  // the part that HAS to be overloaded
  virtual void reset_stored_plugin() const =0;

};


//======================================================================
class SISConeBaseExtras : public ClusterSequence::Extras {
public:

  //  it just initialises the pass information 
  SISConeBaseExtras(int nparticles) : _pass(nparticles*2,-1) {}

  inline virtual ~SISConeBaseExtras()=0;

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

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

  int pass(const PseudoJet & jet) const {return _pass[jet.cluster_hist_index()];}

  std::string description() const{
    std::ostringstream ostr;
    ostr << "This SISCone clustering found " << protocones().size()
         << " stable protocones";
    return ostr.str();
  };

  inline double most_ambiguous_split() const {return _most_ambiguous_split;}

protected:
  std::vector<PseudoJet> _protocones;
  std::vector<int>       _pass;
  double                _most_ambiguous_split;
  const SISConeBasePlugin * _jet_def_plugin;
};

inline SISConeBaseExtras::~SISConeBaseExtras(){}


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

#endif // __SISCONEBASEPLUGIN_HH__