JetDefinition

#include <fjcore.hh>

Collaboration diagram for JetDefinition:

Classes
class	DefaultRecombiner
class	Plugin
class	Recombiner

Public Member Functions
	JetDefinition (JetAlgorithm jet_algorithm_in, double R_in, RecombinationScheme recomb_scheme_in=E_scheme, Strategy strategy_in=Best)
	JetDefinition (JetAlgorithm jet_algorithm_in, RecombinationScheme recomb_scheme_in=E_scheme, Strategy strategy_in=Best)
	JetDefinition (JetAlgorithm jet_algorithm_in, double R_in, double xtra_param_in, RecombinationScheme recomb_scheme_in=E_scheme, Strategy strategy_in=Best)
	JetDefinition (JetAlgorithm jet_algorithm_in, double R_in, const Recombiner *recombiner_in, Strategy strategy_in=Best)
	JetDefinition (JetAlgorithm jet_algorithm_in, const Recombiner *recombiner_in, Strategy strategy_in=Best)
	JetDefinition (JetAlgorithm jet_algorithm_in, double R_in, double xtra_param_in, const Recombiner *recombiner_in, Strategy strategy_in=Best)
	JetDefinition ()
	JetDefinition (const Plugin *plugin_in)
	JetDefinition (JetAlgorithm jet_algorithm_in, double R_in, RecombinationScheme recomb_scheme_in, Strategy strategy_in, int nparameters_in)
	JetDefinition (JetAlgorithm jet_algorithm_in, double R_in, Strategy strategy_in, RecombinationScheme recomb_scheme_in=E_scheme, int nparameters_in=1)
template<class L >
std::vector< PseudoJet >	operator() (const std::vector< L > &particles) const
void	set_recombination_scheme (RecombinationScheme)
void	set_recombiner (const Recombiner *recomb)
void	set_recombiner (const JetDefinition &other_jet_def)
void	delete_recombiner_when_unused ()
const Plugin *	plugin () const
void	delete_plugin_when_unused ()
JetAlgorithm	jet_algorithm () const
JetAlgorithm	jet_finder () const
double	R () const
double	extra_param () const
Strategy	strategy () const
RecombinationScheme	recombination_scheme () const
void	set_jet_algorithm (JetAlgorithm njf)
void	set_jet_finder (JetAlgorithm njf)
void	set_extra_param (double xtra_param)
const Recombiner *	recombiner () const
bool	has_same_recombiner (const JetDefinition &other_jd) const
bool	is_spherical () const
std::string	description () const
std::string	description_no_recombiner () const

Static Public Member Functions
static std::string	algorithm_description (const JetAlgorithm jet_alg)
static unsigned int	n_parameters_for_algorithm (const JetAlgorithm jet_alg)

Static Public Attributes
static const double	max_allowable_R = 1000.0

Private Attributes
JetAlgorithm	_jet_algorithm
double	_Rparam
double	_extra_param
Strategy	_strategy
const Plugin *	_plugin
SharedPtr< const Plugin >	_plugin_shared
DefaultRecombiner	_default_recombiner
const Recombiner *	_recombiner
SharedPtr< const Recombiner >	_shared_recombiner

Constructor & Destructor Documentation

JetDefinition() [1/10]

JetDefinition ( JetAlgorithm  jet_algorithm_in, double  R_in, RecombinationScheme  recomb_scheme_in = E_scheme, Strategy  strategy_in = Best  )

inline

                                             {
    *this = JetDefinition(jet_algorithm_in, R_in, recomb_scheme_in, strategy_in, 1);
  }

JetDefinition() [2/10]

JetDefinition ( JetAlgorithm  jet_algorithm_in, RecombinationScheme  recomb_scheme_in = E_scheme, Strategy  strategy_in = Best  )

inline

                                             {
    double dummyR = 0.0;
    *this = JetDefinition(jet_algorithm_in, dummyR, recomb_scheme_in, strategy_in, 0);
  }

JetDefinition() [3/10]

JetDefinition ( JetAlgorithm  jet_algorithm_in, double  R_in, double  xtra_param_in, RecombinationScheme  recomb_scheme_in = E_scheme, Strategy  strategy_in = Best  )

inline

                                             {
    *this = JetDefinition(jet_algorithm_in, R_in, recomb_scheme_in, strategy_in, 2);
    set_extra_param(xtra_param_in);
  }

JetDefinition() [4/10]

JetDefinition ( JetAlgorithm  jet_algorithm_in, double  R_in, const Recombiner *  recombiner_in, Strategy  strategy_in = Best  )

inline

                                             {
    *this = JetDefinition(jet_algorithm_in, R_in, external_scheme, strategy_in);
    _recombiner = recombiner_in;
  }

JetDefinition() [5/10]

JetDefinition ( JetAlgorithm  jet_algorithm_in, const Recombiner *  recombiner_in, Strategy  strategy_in = Best  )

inline

                                             {
    *this = JetDefinition(jet_algorithm_in, external_scheme, strategy_in);
    _recombiner = recombiner_in;
  }

JetDefinition() [6/10]

JetDefinition ( JetAlgorithm  jet_algorithm_in, double  R_in, double  xtra_param_in, const Recombiner *  recombiner_in, Strategy  strategy_in = Best  )

inline

                                             {
    *this = JetDefinition(jet_algorithm_in, R_in, xtra_param_in, external_scheme, strategy_in);
    _recombiner = recombiner_in;
  }

JetDefinition() [7/10]

JetDefinition ( )

inline

                   {
    *this = JetDefinition(undefined_jet_algorithm, 1.0);
  }

JetDefinition() [8/10]

JetDefinition ( const Plugin *  plugin_in )

inline

                                          {
    _plugin = plugin_in;
    _strategy = plugin_strategy;
    _Rparam = _plugin->R();
    _extra_param = 0.0; // a dummy value to keep static code checkers happy
    _jet_algorithm = plugin_algorithm;
    set_recombination_scheme(E_scheme);
  }

JetDefinition() [9/10]

JetDefinition	(	JetAlgorithm	jet_algorithm_in,
		double	R_in,
		RecombinationScheme	recomb_scheme_in,
		Strategy	strategy_in,
		int	nparameters_in
	)

                                              :
  _jet_algorithm(jet_algorithm_in), _Rparam(R_in), _strategy(strategy_in) {
  if (_jet_algorithm == ee_kt_algorithm) {
    _Rparam = 4.0; // introduce a fictional R that ensures that
  } else {
    if (R_in > max_allowable_R) {
      ostringstream oss;
      oss << "Requested R = " << R_in << " for jet definition is larger than max_allowable_R = " << max_allowable_R;
      throw Error(oss.str());
    }
  }
  unsigned int nparameters_expected = n_parameters_for_algorithm(jet_algorithm_in);
  if (nparameters != (int) nparameters_expected){
    ostringstream oss;
    oss << "The jet algorithm you requested ("
        << jet_algorithm_in << ") should be constructed with " << nparameters_expected
        << " parameter(s) but was called with " << nparameters << " parameter(s)\n";
    throw Error(oss.str());
  }
  assert (_strategy  != plugin_strategy);
  _plugin = NULL;
  set_recombination_scheme(recomb_scheme_in);
  set_extra_param(0.0); // make sure it's defined
}

JetDefinition() [10/10]

JetDefinition ( JetAlgorithm  jet_algorithm_in, double  R_in, Strategy  strategy_in, RecombinationScheme  recomb_scheme_in = E_scheme, int  nparameters_in = 1  )

inline

                                       {
    (*this) = JetDefinition(jet_algorithm_in,R_in,recomb_scheme_in,strategy_in,nparameters_in);
  }

Member Function Documentation

algorithm_description()

string algorithm_description ( const JetAlgorithm  jet_alg )

static

                                                                     {
  ostringstream name;
  switch (jet_alg){
  case plugin_algorithm:                return "plugin algorithm";
  case kt_algorithm:                    return "Longitudinally invariant kt algorithm";
  case cambridge_algorithm:             return "Longitudinally invariant Cambridge/Aachen algorithm";
  case antikt_algorithm:                return "Longitudinally invariant anti-kt algorithm";
  case genkt_algorithm:                 return "Longitudinally invariant generalised kt algorithm";
  case cambridge_for_passive_algorithm: return "Longitudinally invariant Cambridge/Aachen algorithm";
  case ee_kt_algorithm:                 return "e+e- kt (Durham) algorithm (NB: no R)";
  case ee_genkt_algorithm:              return "e+e- generalised kt algorithm";
  case undefined_jet_algorithm:         return "undefined jet algorithm";
  default:
    throw Error("JetDefinition::algorithm_description(): unrecognized jet_algorithm");
  };
}

delete_plugin_when_unused()

void delete_plugin_when_unused

(

)

                                             {
  if (_plugin == 0){
    throw Error("tried to call JetDefinition::delete_plugin_when_unused() for a JetDefinition without a plugin");
  }
  _plugin_shared.reset(_plugin);
}

delete_recombiner_when_unused()

void delete_recombiner_when_unused

(

)

                                                 {
  if (_recombiner == 0){
    throw Error("tried to call JetDefinition::delete_recombiner_when_unused() for a JetDefinition without a user-defined recombination scheme");
  } else if (_shared_recombiner.get()) {
    throw Error("Error in JetDefinition::delete_recombiner_when_unused: the recombiner is already scheduled for deletion when unused (or was already set as shared)");
  }
  _shared_recombiner.reset(_recombiner);
}

description()

string description

(

)

const

                                        {
  ostringstream name;
  name << description_no_recombiner();
  if ((jet_algorithm() == plugin_algorithm) || (jet_algorithm() == undefined_jet_algorithm)){
    return name.str();
  }
  if (n_parameters_for_algorithm(jet_algorithm()) == 0)
    name << " with ";
  else
    name << " and ";
  name << recombiner()->description();
  return name.str();
}

description_no_recombiner()

string description_no_recombiner

(

)

const

                                                      {
  ostringstream name;
  if (jet_algorithm() == plugin_algorithm) {
    return plugin()->description();
  } else if (jet_algorithm() == undefined_jet_algorithm) {
    return "uninitialised JetDefinition (jet_algorithm=undefined_jet_algorithm)" ;
  }
  name << algorithm_description(jet_algorithm());
  switch (n_parameters_for_algorithm(jet_algorithm())){
  case 0: name << " (NB: no R)"; break;
  case 1: name << " with R = " << R(); break; // the parameter is always R
  case 2:
    name << " with R = " << R();
    if (jet_algorithm() == cambridge_for_passive_algorithm){
      name << "and a special hack whereby particles with kt < "
           << extra_param() << "are treated as passive ghosts";
    } else {
      name << ", p = " << extra_param();
    }
  };
  return name.str();
}

extra_param()

double extra_param ( ) const

inline

{return _extra_param ;}

has_same_recombiner()

bool has_same_recombiner

(

const JetDefinition &

other_jd

)

const

                                                                          {
  const RecombinationScheme & scheme = recombination_scheme();
  if (other_jd.recombination_scheme() != scheme) return false;
  return (scheme != external_scheme)
    || (recombiner() == other_jd.recombiner());
}

is_spherical()

bool is_spherical

(

)

const

                                       {
  if (jet_algorithm() == plugin_algorithm) {
    return plugin()->is_spherical();
  } else {
    return (jet_algorithm() == ee_kt_algorithm ||  // as of 2013-02-14, the two
            jet_algorithm() == ee_genkt_algorithm  // native spherical algorithms
            );
  }
}

jet_algorithm()

JetAlgorithm jet_algorithm ( ) const

inline

{return _jet_algorithm  ;}

jet_finder()

JetAlgorithm jet_finder ( ) const

inline

{return _jet_algorithm  ;}

n_parameters_for_algorithm()

unsigned int n_parameters_for_algorithm ( const JetAlgorithm  jet_alg )

static

                                                                                {
  switch (jet_alg) {
  case ee_kt_algorithm:    return 0;
  case genkt_algorithm:
  case ee_genkt_algorithm: return 2;
  default:                 return 1;
  };
}

operator()()

std::vector< PseudoJet > operator()

(

const std::vector< L > &

particles

)

const

                                                                                   {
  ClusterSequence * cs = new ClusterSequence(particles, *this);
  std::vector<PseudoJet> jets;
  if (is_spherical()) {
    jets = sorted_by_E(cs->inclusive_jets());
  } else {
    jets = sorted_by_pt(cs->inclusive_jets());
  }
  if (jets.size() != 0) {
    cs->delete_self_when_unused();
  } else {
    delete cs;
  }
  return jets;
}

plugin()

const Plugin* plugin ( ) const

inline

{return _plugin;};

R()

double R ( ) const

inline

{return _Rparam      ;}

recombination_scheme()

RecombinationScheme recombination_scheme ( ) const

inline

                                                   {
    return _default_recombiner.scheme();}

recombiner()

const Recombiner* recombiner ( ) const

inline

                                        {
    return _recombiner == 0 ? & _default_recombiner : _recombiner;}

set_extra_param()

void set_extra_param ( double  xtra_param )

inline

{_extra_param = xtra_param;}

set_jet_algorithm()

void set_jet_algorithm ( JetAlgorithm  njf )

inline

{_jet_algorithm = njf;}

set_jet_finder()

void set_jet_finder ( JetAlgorithm  njf )

inline

{_jet_algorithm = njf;}

set_recombination_scheme()

void set_recombination_scheme

(

RecombinationScheme

recomb_scheme

)

                                                                  {
  _default_recombiner = JetDefinition::DefaultRecombiner(recomb_scheme);
  if (_shared_recombiner) _shared_recombiner.reset();
  _recombiner = 0;
}

set_recombiner() [1/2]

void set_recombiner

(

const JetDefinition &

other_jet_def

)

                                                                    {
  assert(other_jet_def._recombiner ||
         other_jet_def.recombination_scheme() != external_scheme);
  if (other_jet_def._recombiner == 0){
    set_recombination_scheme(other_jet_def.recombination_scheme());
    return;
  }
  _recombiner = other_jet_def._recombiner;
  _default_recombiner = DefaultRecombiner(external_scheme);
  _shared_recombiner.reset(other_jet_def._shared_recombiner);
}

set_recombiner() [2/2]

void set_recombiner ( const Recombiner *  recomb )

inline

                                                 {
    if (_shared_recombiner) _shared_recombiner.reset(recomb);
    _recombiner = recomb;
    _default_recombiner = DefaultRecombiner(external_scheme);
  }

strategy()

Strategy strategy ( ) const

inline

{return _strategy    ;}

Member Data Documentation

_default_recombiner

DefaultRecombiner _default_recombiner

private

_extra_param

double _extra_param

private

parameter whose meaning varies according to context

_jet_algorithm

JetAlgorithm _jet_algorithm

private

_plugin

const Plugin* _plugin

private

_plugin_shared

SharedPtr<const Plugin> _plugin_shared

private

_recombiner

const Recombiner* _recombiner

private

_Rparam

double _Rparam

private

_shared_recombiner

SharedPtr<const Recombiner> _shared_recombiner

private

_strategy

Strategy _strategy

private

max_allowable_R

const double max_allowable_R = 1000.0

static

---

The documentation for this class was generated from the following files:

• /builds/cms-analysis/general/DasAnalysisSystem/Core/Installer/Core/JetObservables/interface/fjcore.hh
• /builds/cms-analysis/general/DasAnalysisSystem/Core/Installer/Core/JetObservables/src/fjcore.cc