fjcore.cc File Reference

#include "Core/JetObservables/interface/fjcore.hh"
#include <string>
#include <vector>
#include <iostream>
#include <sstream>
#include <cassert>
#include <cstddef>
#include <memory>
#include <limits>
#include <stack>
#include <iomanip>
#include <algorithm>
#include <fstream>
#include <cmath>
#include <cstdlib>
#include <set>
#include "fastjet/internal/Dnn4piCylinder.hh"
#include "fastjet/internal/Dnn3piCylinder.hh"
#include "fastjet/internal/Dnn2piCylinder.hh"
#include <valarray>
#include <cstdarg>

Include dependency graph for fjcore.cc:

Classes
class	EtaPhi
class	DnnError
class	DynamicNearestNeighbours
class	SearchTree< T >
class	SearchTree< T >::Node
class	SearchTree< T >::circulator
class	SearchTree< T >::const_circulator
class	MinHeap
struct	MinHeap::ValueLoc
class	Coord2D
class	ClosestPair2DBase
class	ClosestPair2D
class	ClosestPair2D::triplet< T >
class	ClosestPair2D::Shuffle
class	ClosestPair2D::Point
class	TiledJet
class	Tile
class	LazyTiling9Alt
class	Tile2Base< NN >
class	LazyTiling9
class	LazyTiling25
class	TilingExtent
class	MirrorInfo
class	SW_Identity
class	SW_Not
class	SW_BinaryOperator
class	SW_And
class	SW_Or
class	SW_Mult
class	QuantityBase
class	QuantitySquareBase
class	SW_QuantityMin< QuantityType >
class	SW_QuantityMax< QuantityType >
class	SW_QuantityRange< QuantityType >
class	QuantityPt2
class	QuantityEt2
class	QuantityE
class	QuantityM2
class	QuantityRap
class	SW_RapMin
class	SW_RapMax
class	SW_RapRange
class	QuantityAbsRap
class	SW_AbsRapMax
class	SW_AbsRapRange
class	QuantityEta
class	QuantityAbsEta
class	SW_PhiRange
class	SW_RapPhiRange
class	SW_NHardest
class	SW_WithReference
class	SW_Circle
class	SW_Doughnut
class	SW_Strip
class	SW_Rectangle
class	SW_PtFractionMin
class	SW_IsZero

Namespaces
	Private

Macros
#define	__FJCORE_VERSION_HH__
#define	__FJCORE_CLUSTERQUENCE_N2_ICC__
#define	__FJCORE_DYNAMICNEARESTNEIGHBOURS_HH__
#define	__FJCORE_SEARCHTREE_HH__
#define	__FJCORE_MINHEAP__HH__
#define	__FJCORE_CLOSESTPAIR2DBASE__HH__
#define	__FJCORE_CLOSESTPAIR2D__HH__
#define	__FJCORE_LAZYTILING9ALT_HH__
#define	__FJCORE_LAZYTILING9_HH__
#define	__FJCORE_LAZYTILING25_HH__
#define	__FJCORE_TILINGEXTENT_HH__
#define	_FJCORE_TILING25_USE_TILING_ANALYSIS_
#define	FJCORE_LAZY25_MIN3TILESY
#define	_FJCORE_TILING2_USE_TILING_ANALYSIS_
#define	FJCORE_LAZY9_MIN2TILESY

Typedefs
typedef Tile2Base< 9 >	Tile2

Functions
bool	floor_ln2_less (unsigned x, unsigned y)
string	fastjet_version_string ()
bool	make_mirror (Coord2D &point, double Dlim)
PseudoJet	join (const vector< PseudoJet > &pieces, const JetDefinition::Recombiner &recombiner)
PseudoJet	join (const PseudoJet &j1, const JetDefinition::Recombiner &recombiner)
PseudoJet	join (const PseudoJet &j1, const PseudoJet &j2, const JetDefinition::Recombiner &recombiner)
PseudoJet	join (const PseudoJet &j1, const PseudoJet &j2, const PseudoJet &j3, const JetDefinition::Recombiner &recombiner)
PseudoJet	join (const PseudoJet &j1, const PseudoJet &j2, const PseudoJet &j3, const PseudoJet &j4, const JetDefinition::Recombiner &recombiner)
PseudoJet	operator+ (const PseudoJet &jet1, const PseudoJet &jet2)
PseudoJet	operator- (const PseudoJet &jet1, const PseudoJet &jet2)
PseudoJet	operator* (double coeff, const PseudoJet &jet)
PseudoJet	operator* (const PseudoJet &jet, double coeff)
PseudoJet	operator/ (const PseudoJet &jet, double coeff)
bool	operator== (const PseudoJet &a, const PseudoJet &b)
bool	operator== (const PseudoJet &jet, const double val)
bool	have_same_momentum (const PseudoJet &jeta, const PseudoJet &jetb)
PseudoJet	PtYPhiM (double pt, double y, double phi, double m)
void	sort_indices (vector< int > &indices, const vector< double > &values)
vector< PseudoJet >	sorted_by_pt (const vector< PseudoJet > &jets)
vector< PseudoJet >	sorted_by_rapidity (const vector< PseudoJet > &jets)
vector< PseudoJet >	sorted_by_E (const vector< PseudoJet > &jets)
vector< PseudoJet >	sorted_by_pz (const vector< PseudoJet > &jets)
PseudoJet	join (const vector< PseudoJet > &pieces)
PseudoJet	join (const PseudoJet &j1)
PseudoJet	join (const PseudoJet &j1, const PseudoJet &j2)
PseudoJet	join (const PseudoJet &j1, const PseudoJet &j2, const PseudoJet &j3)
PseudoJet	join (const PseudoJet &j1, const PseudoJet &j2, const PseudoJet &j3, const PseudoJet &j4)
Selector	SelectorIdentity ()
Selector	operator! (const Selector &s)
Selector	operator&& (const Selector &s1, const Selector &s2)
Selector	operator|| (const Selector &s1, const Selector &s2)
Selector	operator* (const Selector &s1, const Selector &s2)
Selector	SelectorPtMin (double ptmin)
Selector	SelectorPtMax (double ptmax)
Selector	SelectorPtRange (double ptmin, double ptmax)
Selector	SelectorEtMin (double Etmin)
Selector	SelectorEtMax (double Etmax)
Selector	SelectorEtRange (double Etmin, double Etmax)
Selector	SelectorEMin (double Emin)
Selector	SelectorEMax (double Emax)
Selector	SelectorERange (double Emin, double Emax)
Selector	SelectorMassMin (double mmin)
Selector	SelectorMassMax (double mmax)
Selector	SelectorMassRange (double mmin, double mmax)
Selector	SelectorRapMin (double rapmin)
Selector	SelectorRapMax (double rapmax)
Selector	SelectorRapRange (double rapmin, double rapmax)
Selector	SelectorAbsRapMin (double absrapmin)
Selector	SelectorAbsRapMax (double absrapmax)
Selector	SelectorAbsRapRange (double rapmin, double rapmax)
Selector	SelectorEtaMin (double etamin)
Selector	SelectorEtaMax (double etamax)
Selector	SelectorEtaRange (double etamin, double etamax)
Selector	SelectorAbsEtaMin (double absetamin)
Selector	SelectorAbsEtaMax (double absetamax)
Selector	SelectorAbsEtaRange (double absetamin, double absetamax)
Selector	SelectorPhiRange (double phimin, double phimax)
Selector	SelectorRapPhiRange (double rapmin, double rapmax, double phimin, double phimax)
Selector	SelectorNHardest (unsigned int n)
Selector	SelectorCircle (const double radius)
Selector	SelectorDoughnut (const double radius_in, const double radius_out)
Selector	SelectorStrip (const double half_width)
Selector	SelectorRectangle (const double half_rap_width, const double half_phi_width)
Selector	SelectorPtFractionMin (double fraction)
Selector	SelectorIsZero ()
ostream &	operator<< (ostream &ostr, const TiledJet &jet)

Variables
FJCORE_BEGIN_NAMESPACE typedef Tile2Base< 25 >	Tile25
FJCORE_BEGIN_NAMESPACE const char *	fastjet_version = FJCORE_PACKAGE_VERSION
FJCORE_BEGIN_NAMESPACE const double	tile_edge_security_margin =1.0e-7
const int	n_tile_neighbours = 9
FJCORE_END_NAMESPACE FJCORE_BEGIN_NAMESPACE const unsigned int	twopow31 = 2147483648U

Macro Definition Documentation

__FJCORE_CLOSESTPAIR2D__HH__

#define __FJCORE_CLOSESTPAIR2D__HH__

__FJCORE_CLOSESTPAIR2DBASE__HH__

#define __FJCORE_CLOSESTPAIR2DBASE__HH__

__FJCORE_CLUSTERQUENCE_N2_ICC__

#define __FJCORE_CLUSTERQUENCE_N2_ICC__

__FJCORE_DYNAMICNEARESTNEIGHBOURS_HH__

#define __FJCORE_DYNAMICNEARESTNEIGHBOURS_HH__

__FJCORE_LAZYTILING25_HH__

#define __FJCORE_LAZYTILING25_HH__

__FJCORE_LAZYTILING9_HH__

#define __FJCORE_LAZYTILING9_HH__

__FJCORE_LAZYTILING9ALT_HH__

#define __FJCORE_LAZYTILING9ALT_HH__

__FJCORE_MINHEAP__HH__

#define __FJCORE_MINHEAP__HH__

__FJCORE_SEARCHTREE_HH__

#define __FJCORE_SEARCHTREE_HH__

__FJCORE_TILINGEXTENT_HH__

#define __FJCORE_TILINGEXTENT_HH__

__FJCORE_VERSION_HH__

#define __FJCORE_VERSION_HH__

_FJCORE_TILING25_USE_TILING_ANALYSIS_

#define _FJCORE_TILING25_USE_TILING_ANALYSIS_

_FJCORE_TILING2_USE_TILING_ANALYSIS_

#define _FJCORE_TILING2_USE_TILING_ANALYSIS_

FJCORE_LAZY25_MIN3TILESY

#define FJCORE_LAZY25_MIN3TILESY

FJCORE_LAZY9_MIN2TILESY

#define FJCORE_LAZY9_MIN2TILESY

Typedef Documentation

Tile2

typedef Tile2Base<9> Tile2

Function Documentation

fastjet_version_string()

string fastjet_version_string

(

)

                                {
  return "FastJet version "+string(fastjet_version)+" [fjcore]";
}

floor_ln2_less()

bool floor_ln2_less ( unsigned  x, unsigned  y  )

inline

                                                   {
  if (x>y) return false;
  return (x < (x^y)); // beware of operator precedence...
}

have_same_momentum()

bool have_same_momentum	(	const PseudoJet &	jeta,
		const PseudoJet &	jetb
	)

                                                                        {
  return jeta.px() == jetb.px()
    &&   jeta.py() == jetb.py()
    &&   jeta.pz() == jetb.pz()
    &&   jeta.E()  == jetb.E();
}

join() [1/10]

PseudoJet join

(

const PseudoJet &

j1

)

                                    {
  return join(vector<PseudoJet>(1,j1));
}

join() [2/10]

PseudoJet join	(	const PseudoJet &	j1,
		const JetDefinition::Recombiner &	recombiner
	)

                                                      {
  return join(vector<PseudoJet>(1,j1), recombiner);
}

join() [3/10]

PseudoJet join	(	const PseudoJet &	j1,
		const PseudoJet &	j2
	)

                                                          {
  vector<PseudoJet> pieces;
  pieces.reserve(2);
  pieces.push_back(j1);
  pieces.push_back(j2);
  return join(pieces);
}

join() [4/10]

PseudoJet join	(	const PseudoJet &	j1,
		const PseudoJet &	j2,
		const JetDefinition::Recombiner &	recombiner
	)

                                                      {
  vector<PseudoJet> pieces;
  pieces.push_back(j1);
  pieces.push_back(j2);
  return join(pieces, recombiner);
}

join() [5/10]

PseudoJet join	(	const PseudoJet &	j1,
		const PseudoJet &	j2,
		const PseudoJet &	j3
	)

                                                                                {
  vector<PseudoJet> pieces;
  pieces.reserve(3);
  pieces.push_back(j1);
  pieces.push_back(j2);
  pieces.push_back(j3);
  return join(pieces);
}

join() [6/10]

PseudoJet join	(	const PseudoJet &	j1,
		const PseudoJet &	j2,
		const PseudoJet &	j3,
		const JetDefinition::Recombiner &	recombiner
	)

                                                      {
  vector<PseudoJet> pieces;
  pieces.push_back(j1);
  pieces.push_back(j2);
  pieces.push_back(j3);
  return join(pieces, recombiner);
}

join() [7/10]

PseudoJet join	(	const PseudoJet &	j1,
		const PseudoJet &	j2,
		const PseudoJet &	j3,
		const PseudoJet &	j4
	)

                                                                                                      {
  vector<PseudoJet> pieces;
  pieces.reserve(4);
  pieces.push_back(j1);
  pieces.push_back(j2);
  pieces.push_back(j3);
  pieces.push_back(j4);
  return join(pieces);
}

join() [8/10]

PseudoJet join	(	const PseudoJet &	j1,
		const PseudoJet &	j2,
		const PseudoJet &	j3,
		const PseudoJet &	j4,
		const JetDefinition::Recombiner &	recombiner
	)

                                                      {
  vector<PseudoJet> pieces;
  pieces.push_back(j1);
  pieces.push_back(j2);
  pieces.push_back(j3);
  pieces.push_back(j4);
  return join(pieces, recombiner);
}

join() [9/10]

PseudoJet join

(

const vector< PseudoJet > &

pieces

)

                                                {
  PseudoJet result;  // automatically initialised to 0
  for (unsigned int i=0; i<pieces.size(); i++)
    result += pieces[i];
  CompositeJetStructure *cj_struct = new CompositeJetStructure(pieces);
  result.set_structure_shared_ptr(SharedPtr<PseudoJetStructureBase>(cj_struct));
  return result;
}

join() [10/10]

PseudoJet join	(	const vector< PseudoJet > &	pieces,
		const JetDefinition::Recombiner &	recombiner
	)

                                                                                            {
  PseudoJet result;  // automatically initialised to 0
  if (pieces.size()>0){
    result = pieces[0];
    for (unsigned int i=1; i<pieces.size(); i++)
      recombiner.plus_equal(result, pieces[i]);
  }
  CompositeJetStructure *cj_struct = new CompositeJetStructure(pieces, &recombiner);
  result.set_structure_shared_ptr(SharedPtr<PseudoJetStructureBase>(cj_struct));
  return result;
}

operator!()

Selector operator!

(

const Selector &

s

)

                                       {
  return Selector(new SW_Not(s));
}

operator&&()

Selector operator&&	(	const Selector &	s1,
		const Selector &	s2
	)

                                                              {
  return Selector(new SW_And(s1,s2));
}

operator*() [1/3]

PseudoJet operator*	(	const PseudoJet &	jet,
		double	coeff
	)

                                                          {
  return coeff*jet;
}

operator*() [2/3]

Selector operator*	(	const Selector &	s1,
		const Selector &	s2
	)

                                                             {
  return Selector(new SW_Mult(s1,s2));
}

operator*() [3/3]

PseudoJet operator*	(	double	coeff,
		const PseudoJet &	jet
	)

                                                          {
  jet._ensure_valid_rap_phi();
  PseudoJet coeff_times_jet(jet);
  coeff_times_jet *= coeff;
  return coeff_times_jet;
}

operator+()

PseudoJet operator+	(	const PseudoJet &	jet1,
		const PseudoJet &	jet2
	)

                                                                     {
  return PseudoJet(jet1.px()+jet2.px(),
           jet1.py()+jet2.py(),
           jet1.pz()+jet2.pz(),
           jet1.E() +jet2.E()  );
}

operator-()

PseudoJet operator-	(	const PseudoJet &	jet1,
		const PseudoJet &	jet2
	)

                                                                     {
  return PseudoJet(jet1.px()-jet2.px(),
           jet1.py()-jet2.py(),
           jet1.pz()-jet2.pz(),
           jet1.E() -jet2.E()  );
}

operator/()

PseudoJet operator/	(	const PseudoJet &	jet,
		double	coeff
	)

                                                          {
  return (1.0/coeff)*jet;
}

operator<<()

ostream& operator<<	(	ostream &	ostr,
		const TiledJet &	jet
	)

                                                           {
  ostr << "j" << setw(3) << jet._jets_index << ":pt2,rap,phi=" ; ostr.flush();
  ostr     << jet.kt2 << ","; ostr.flush();
  ostr     << jet.eta << ","; ostr.flush();
  ostr     << jet.phi; ostr.flush();
  ostr     << ", tile=" << jet.tile_index; ostr.flush();
  return ostr;
}

operator==() [1/2]

bool operator==	(	const PseudoJet &	a,
		const PseudoJet &	b
	)

                                                          {
  if (a.px() != b.px()) return false;
  if (a.py() != b.py()) return false;
  if (a.pz() != b.pz()) return false;
  if (a.E () != b.E ()) return false;
  if (a.user_index()    != b.user_index()) return false;
  if (a.cluster_hist_index() != b.cluster_hist_index()) return false;
  if (a.user_info_ptr() != b.user_info_ptr()) return false;
  if (a.structure_ptr() != b.structure_ptr()) return false;
  return true;
}

operator==() [2/2]

bool operator==	(	const PseudoJet &	jet,
		const double	val
	)

                                                         {
  if (val != 0)
    throw Error("comparing a PseudoJet with a non-zero constant (double) is not allowed.");
  return (jet.px() == 0 && jet.py() == 0 &&
      jet.pz() == 0 && jet.E() == 0);
}

operator||()

Selector operator||	(	const Selector &	s1,
		const Selector &	s2
	)

                                                               {
  return Selector(new SW_Or(s1,s2));
}

PtYPhiM()

PseudoJet PtYPhiM	(	double	pt,
		double	y,
		double	phi,
		double	m
	)

                                                             {
  assert(phi < 2*twopi && phi > -twopi);
  double ptm = (m == 0) ? pt : sqrt(pt*pt+m*m);
  double exprap = exp(y);
  double pminus = ptm/exprap;
  double pplus  = ptm*exprap;
  double px = pt*cos(phi);
  double py = pt*sin(phi);
  PseudoJet mom(px,py,0.5*(pplus-pminus),0.5*(pplus+pminus));
  mom.set_cached_rap_phi(y,phi);
  return mom;
}

SelectorAbsEtaMax()

Selector SelectorAbsEtaMax

(

double

absetamax

)

select objects with |eta| <= absetamax

                                             {
  return Selector(new SW_QuantityMax<QuantityAbsEta>(absetamax));
}

SelectorAbsEtaMin()

Selector SelectorAbsEtaMin

(

double

absetamin

)

select objects with |eta| >= absetamin

                                             {
  return Selector(new SW_QuantityMin<QuantityAbsEta>(absetamin));
}

SelectorAbsEtaRange()

Selector SelectorAbsEtaRange	(	double	absetamin,
		double	absetamax
	)

select objects with absetamin <= |eta| <= absetamax

                                                                 {
  return Selector(new SW_QuantityRange<QuantityAbsEta>(absetamin, absetamax));
}

SelectorAbsRapMax()

Selector SelectorAbsRapMax

(

double

absrapmax

)

select objects with |rap| <= absrapmax

                                             {
  return Selector(new SW_AbsRapMax(absrapmax));
}

SelectorAbsRapMin()

Selector SelectorAbsRapMin

(

double

absrapmin

)

select objects with |rap| >= absrapmin

                                             {
  return Selector(new SW_QuantityMin<QuantityAbsRap>(absrapmin));
}

SelectorAbsRapRange()

Selector SelectorAbsRapRange	(	double	rapmin,
		double	rapmax
	)

select objects with absrapmin <= |rap| <= absrapmax

                                                           {
  return Selector(new SW_AbsRapRange(rapmin, rapmax));
}

SelectorCircle()

Selector SelectorCircle

(

const double

radius

)

                                             {
  return Selector(new SW_Circle(radius));
}

SelectorDoughnut()

Selector SelectorDoughnut	(	const double	radius_in,
		const double	radius_out
	)

                                                                           {
  return Selector(new SW_Doughnut(radius_in, radius_out));
}

SelectorEMax()

Selector SelectorEMax

(

double

Emax

)

select objects with E <= Emax

                                   {
  return Selector(new SW_QuantityMax<QuantityE>(Emax));
}

SelectorEMin()

Selector SelectorEMin

(

double

Emin

)

select objects with E >= Emin

                                   {
  return Selector(new SW_QuantityMin<QuantityE>(Emin));
}

SelectorERange()

Selector SelectorERange	(	double	Emin,
		double	Emax
	)

select objects with Emin <= E <= Emax

                                                  {
  return Selector(new SW_QuantityRange<QuantityE>(Emin, Emax));
}

SelectorEtaMax()

Selector SelectorEtaMax

(

double

etamax

)

select objects with eta <= etamax

                                       {
  return Selector(new SW_QuantityMax<QuantityEta>(etamax));
}

SelectorEtaMin()

Selector SelectorEtaMin

(

double

etamin

)

select objects with eta >= etamin

                                       {
  return Selector(new SW_QuantityMin<QuantityEta>(etamin));
}

SelectorEtaRange()

Selector SelectorEtaRange	(	double	etamin,
		double	etamax
	)

select objects with etamin <= eta <= etamax

                                                        {
  return Selector(new SW_QuantityRange<QuantityEta>(etamin, etamax));
}

SelectorEtMax()

Selector SelectorEtMax

(

double

Etmax

)

select objects with Et <= Etmax

                                     {
  return Selector(new SW_QuantityMax<QuantityEt2>(Etmax));
}

SelectorEtMin()

Selector SelectorEtMin

(

double

Etmin

)

select objects with Et >= Etmin

                                     {
  return Selector(new SW_QuantityMin<QuantityEt2>(Etmin));
}

SelectorEtRange()

Selector SelectorEtRange	(	double	Etmin,
		double	Etmax
	)

select objects with Etmin <= Et <= Etmax

                                                     {
  return Selector(new SW_QuantityRange<QuantityEt2>(Etmin, Etmax));
}

SelectorIdentity()

Selector SelectorIdentity

(

)

                            {
  return Selector(new SW_Identity);
}

SelectorIsZero()

Selector SelectorIsZero

(

)

                         {
  return Selector(new SW_IsZero());
}

SelectorMassMax()

Selector SelectorMassMax

(

double

mmax

)

select objects with Mass <= Mmax

                                      {
  return Selector(new SW_QuantityMax<QuantityM2>(mmax));
}

SelectorMassMin()

Selector SelectorMassMin

(

double

mmin

)

select objects with Mass >= Mmin

                                      {
  return Selector(new SW_QuantityMin<QuantityM2>(mmin));
}

SelectorMassRange()

Selector SelectorMassRange	(	double	mmin,
		double	mmax
	)

select objects with Mmin <= Mass <= Mmax

                                                     {
  return Selector(new SW_QuantityRange<QuantityM2>(mmin, mmax));
}

SelectorNHardest()

Selector SelectorNHardest

(

unsigned int

n

)

                                          {
  return Selector(new SW_NHardest(n));
}

SelectorPhiRange()

Selector SelectorPhiRange	(	double	phimin,
		double	phimax
	)

select objects with phimin <= phi <= phimax

                                                        {
  return Selector(new SW_PhiRange(phimin, phimax));
}

SelectorPtFractionMin()

Selector SelectorPtFractionMin

(

double

fraction

)

                                               {
  return Selector(new SW_PtFractionMin(fraction));
}

SelectorPtMax()

Selector SelectorPtMax

(

double

ptmax

)

select objects with pt <= ptmax

                                     {
  return Selector(new SW_QuantityMax<QuantityPt2>(ptmax));
}

SelectorPtMin()

Selector SelectorPtMin

(

double

ptmin

)

select objects with pt >= ptmin

                                     {
  return Selector(new SW_QuantityMin<QuantityPt2>(ptmin));
}

SelectorPtRange()

Selector SelectorPtRange	(	double	ptmin,
		double	ptmax
	)

select objects with ptmin <= pt <= ptmax

                                                     {
  return Selector(new SW_QuantityRange<QuantityPt2>(ptmin, ptmax));
}

SelectorRapMax()

Selector SelectorRapMax

(

double

rapmax

)

select objects with rap <= rapmax

                                       {
  return Selector(new SW_RapMax(rapmax));
}

SelectorRapMin()

Selector SelectorRapMin

(

double

rapmin

)

select objects with rap >= rapmin

                                       {
  return Selector(new SW_RapMin(rapmin));
}

SelectorRapPhiRange()

Selector SelectorRapPhiRange	(	double	rapmin,
		double	rapmax,
		double	phimin,
		double	phimax
	)

                                                                                         {
  return Selector(new SW_RapPhiRange(rapmin, rapmax, phimin, phimax));
}

SelectorRapRange()

Selector SelectorRapRange	(	double	rapmin,
		double	rapmax
	)

select objects with rapmin <= rap <= rapmax

                                                        {
  return Selector(new SW_RapRange(rapmin, rapmax));
}

SelectorRectangle()

Selector SelectorRectangle	(	const double	half_rap_width,
		const double	half_phi_width
	)

                                                                                     {
  return Selector(new SW_Rectangle(half_rap_width, half_phi_width));
}

SelectorStrip()

Selector SelectorStrip

(

const double

half_width

)

                                                {
  return Selector(new SW_Strip(half_width));
}

sort_indices()

void sort_indices	(	vector< int > &	indices,
		const vector< double > &	values
	)

                                            {
  IndexedSortHelper index_sort_helper(&values);
  sort(indices.begin(), indices.end(), index_sort_helper);
}

sorted_by_E()

vector<PseudoJet> sorted_by_E

(

const vector< PseudoJet > &

jets

)

                                                              {
  vector<double> energies(jets.size());
  for (size_t i = 0; i < jets.size(); i++) {energies[i] = -jets[i].E();}
  return objects_sorted_by_values(jets, energies);
}

sorted_by_pt()

vector<PseudoJet> sorted_by_pt

(

const vector< PseudoJet > &

jets

)

                                                               {
  vector<double> minus_kt2(jets.size());
  for (size_t i = 0; i < jets.size(); i++) {minus_kt2[i] = -jets[i].kt2();}
  return objects_sorted_by_values(jets, minus_kt2);
}

sorted_by_pz()

vector<PseudoJet> sorted_by_pz

(

const vector< PseudoJet > &

jets

)

                                                               {
  vector<double> pz(jets.size());
  for (size_t i = 0; i < jets.size(); i++) {pz[i] = jets[i].pz();}
  return objects_sorted_by_values(jets, pz);
}

sorted_by_rapidity()

vector<PseudoJet> sorted_by_rapidity

(

const vector< PseudoJet > &

jets

)

                                                                     {
  vector<double> rapidities(jets.size());
  for (size_t i = 0; i < jets.size(); i++) {rapidities[i] = jets[i].rap();}
  return objects_sorted_by_values(jets, rapidities);
}

Variable Documentation

fastjet_version

FJCORE_BEGIN_NAMESPACE const char* fastjet_version = FJCORE_PACKAGE_VERSION

n_tile_neighbours

const int n_tile_neighbours = 9

Tile25

FJCORE_BEGIN_NAMESPACE typedef Tile2Base<25> Tile25

tile_edge_security_margin

FJCORE_BEGIN_NAMESPACE const double tile_edge_security_margin =1.0e-7

twopow31

FJCORE_END_NAMESPACE FJCORE_BEGIN_NAMESPACE const unsigned int twopow31 = 2147483648U