JetDefinition.hh

Go to the documentation of this file.

//STARTHEADER
// $Id: JetDefinition.hh 483 2007-02-28 17:52:19Z salam $
//
// Copyright (c) 2005-2006, Matteo Cacciari and Gavin Salam
//
//----------------------------------------------------------------------
// This file is part of FastJet.
//
//  FastJet is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  The algorithms that underlie FastJet have required considerable
//  development and are described in hep-ph/0512210. If you use
//  FastJet as part of work towards a scientific publication, please
//  include a citation to the FastJet paper.
//
//  FastJet is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with FastJet; if not, write to the Free Software
//  Foundation, Inc.:
//      59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//----------------------------------------------------------------------
//ENDHEADER

#ifndef __FASTJET_JETDEFINITION_HH__
#define __FASTJET_JETDEFINITION_HH__

#include<cassert>
#include "fastjet/internal/numconsts.hh"
#include "fastjet/PseudoJet.hh"
#include<string>
#include<memory>

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

//======================================================================
enum Strategy {
  N2MinHeapTiled   = -4, 
  N2Tiled     = -3, 
  N2PoorTiled = -2, 
  N2Plain     = -1, 
  N3Dumb      =  0, 
  Best        =  1, 
  NlnN        =  2, 
  NlnN3pi     =  3, 
  NlnN4pi     =  4,
  NlnNCam4pi   = 14,
  NlnNCam2pi2R = 13,
  NlnNCam      = 12, // 2piMultD
  plugin_strategy = 999
};


//======================================================================
enum JetFinder {
  kt_algorithm=0,
  cambridge_algorithm=1,
  plugin_algorithm = 99
};


//======================================================================
enum RecombinationScheme {
  E_scheme=0,
  pt_scheme=1,
  pt2_scheme=2,
  Et_scheme=3,
  Et2_scheme=4,
  BIpt_scheme=5,
  BIpt2_scheme=6,
  external_scheme = 99
};





//======================================================================
class JetDefinition {
  
public:

  class Plugin;

  // forward declaration of a class that will provide the
  // recombination scheme facilities and/or allow a user to
  // extend these facilities
  class Recombiner;

  JetDefinition(JetFinder jet_finder, 
                double R, 
                Strategy strategy,
                RecombinationScheme recomb_scheme = E_scheme) :
    _jet_finder(jet_finder), _Rparam(R), _strategy(strategy) {
    // the largest sensible value for R
    assert(_Rparam <= 0.5*pi);
    assert(_jet_finder != plugin_algorithm &&
           _strategy   != plugin_strategy);
    _plugin = 0;
    set_recombination_scheme(recomb_scheme);
  };
  

  JetDefinition(JetFinder jet_finder = kt_algorithm, 
                double R = 1.0, 
                RecombinationScheme recomb_scheme = E_scheme,
                Strategy strategy = Best) {
    *this = JetDefinition(jet_finder, R, strategy, recomb_scheme);
  };


  JetDefinition(JetFinder jet_finder, 
                double R, 
                const Recombiner * recombiner,
                Strategy strategy = Best) {
    *this = JetDefinition(jet_finder, R, strategy, external_scheme);
    _recombiner = recombiner;
  };

  JetDefinition(const Plugin * plugin) {
    _plugin = plugin;
    _strategy = plugin_strategy;
    _Rparam = -1.0;
    _jet_finder = plugin_algorithm;
    set_recombination_scheme(E_scheme);
  };

  void set_recombination_scheme(RecombinationScheme);

  void set_recombiner(const Recombiner * recomb) {
    _recombiner = recomb;
    _default_recombiner = DefaultRecombiner(external_scheme);
  };

  const Plugin * plugin() const {return _plugin;};

  // return information about the definition...
  JetFinder jet_finder  () const {return _jet_finder  ;}; 
  double    R           () const {return _Rparam      ;};
  Strategy  strategy    () const {return _strategy    ;};
  RecombinationScheme recombination_scheme() const {
    return _default_recombiner.scheme();};

  const Recombiner * recombiner() const {
    return _recombiner == 0 ? & _default_recombiner : _recombiner;};

  std::string description() const;


public:
  //======================================================================
  class Recombiner {
  public:
    virtual std::string description() const = 0;
    
    virtual void recombine(const PseudoJet & pa, const PseudoJet & pb, 
                           PseudoJet & pab) const = 0;

    virtual void preprocess(PseudoJet & p) const {};
    
    virtual ~Recombiner() {};

    inline void plus_equal(PseudoJet & pa, const PseudoJet & pb) const {
      // put result in a temporary location in case the recombiner
      // does something funny (ours doesn't, but who knows about the
      // user's)
      PseudoJet pres; 
      recombine(pa,pb,pres);
      pa = pres;
    }

  };
  
  
  //======================================================================
  class DefaultRecombiner : public Recombiner {
  public:
    DefaultRecombiner(RecombinationScheme recomb_scheme = E_scheme) : 
      _recomb_scheme(recomb_scheme) {};
    
    virtual std::string description() const;
    
    virtual void recombine(const PseudoJet & pa, const PseudoJet & pb, 
                           PseudoJet & pab) const;

    virtual void preprocess(PseudoJet & p) const;

    RecombinationScheme scheme() const {return _recomb_scheme;};
    
  private:
    RecombinationScheme _recomb_scheme;
  };


private:


  JetFinder _jet_finder;
  double      _Rparam    ;
  Strategy  _strategy  ;

  const Plugin * _plugin;

  // when we use our own recombiner it's useful to point to it here
  // so that we don't have to worry about deleting it etc...
  DefaultRecombiner _default_recombiner;
  const Recombiner * _recombiner;

};


// forward declaration, needed in order to specify interface for the
// plugin.
class ClusterSequence;


//======================================================================
class JetDefinition::Plugin{
public:
  virtual std::string description() const = 0;

  virtual void run_clustering(ClusterSequence &) const = 0;

  virtual ~Plugin() {};
};






FASTJET_END_NAMESPACE

#endif // __FASTJET_JETDEFINITION_HH__

---