namespace Rivet

Rivet

Namespaces

Name
Rivet::ALICE
Rivet::ATLAS Common projections for ATLAS trigger conditions and centrality.
Rivet::Cuts Namespace used for ambiguous identifiers.
Rivet::HepMCUtils
Rivet::Kin
Rivet::PID

Classes

	Name
struct	Rivet::AbsDeltaEtaWRT Calculator of (
struct	Rivet::AbsDeltaRapWRT Calculator of (
struct	Rivet::AbsEtaGtr Abs pseudorapidity greater-than functor.
struct	Rivet::AbsEtaInRange Abs pseudorapidity in-range functor.
struct	Rivet::AbsEtaLess Abs pseudorapidity momentum less-than functor.
struct	Rivet::AbsRapGtr Abs rapidity greater-than functor.
struct	Rivet::AbsRapInRange Abs rapidity in-range functor.
struct	Rivet::AbsRapLess Abs rapidity momentum less-than functor.
class	Rivet::Analysis This is the base class of all analysis classes in Rivet.
class	Rivet::AnalysisHandler The key class for coordination of Analysis objects and the event loop.
class	Rivet::AnalysisInfo Holder of analysis metadata.
class	Rivet::AnalysisLoader Internal class which loads and registers analyses from plugin libs.
class	Rivet::AxesDefinition Base class for projections which define a spatial basis.
struct	Rivet::bad_lexical_cast Exception class for throwing from lexical_cast when a parse goes wrong.
class	Rivet::Beam Project out the incoming beams.
class	Rivet::BeamThrust Calculator of the beam-thrust observable.
class	Rivet::BinnedHistogram A set of booked Histo1DPtr, each in a bin of a second variable.
struct	Rivet::BoolJetAND Functor for and-combination of selector logic.
struct	Rivet::BoolJetFunctor Base type for Jet -> bool functors.
struct	Rivet::BoolJetNOT Functor for inverting selector logic.
struct	Rivet::BoolJetOR Functor for or-combination of selector logic.
struct	Rivet::BoolParticleAND Functor for and-combination of selector logic.
struct	Rivet::BoolParticleBaseFunctor Base type for Particle -> bool functors.
struct	Rivet::BoolParticleFunctor Base type for Particle -> bool functors.
struct	Rivet::BoolParticleNOT Functor for inverting selector logic.
struct	Rivet::BoolParticleOR Functor for or-combination of selector logic.
class	Rivet::BRAHMSCentrality BRAHMS Centrality projection.
class	Rivet::CentralEtHCM Summed ( E_\perp ) of central particles in HCM system.
class	Rivet::CentralityBinner
class	Rivet::CentralityEstimator Base class for projections profile observable value vs the collision centrality.
class	Rivet::CentralityProjection Used together with the percentile-based analysis objects Percentile and PercentileXaxis.
class	Rivet::ChargedFinalState Project only charged final state particles.
class	Rivet::ChargedLeptons Get charged final-state leptons.
class	Rivet::ConstLossyFinalState Randomly lose a constant fraction of particles.
class	Rivet::ConstRandomFilter Functor used to implement constant random lossiness.
class	Rivet::Correlators Projection for calculating correlators for flow measurements.
class	Rivet::CumulantAnalysis Tools for flow analyses.
struct	Rivet::Cutflow A tracker of numbers & fractions of events passing sequential cuts.
struct	Rivet::Cutflows A container for several Cutflow objects, with some convenient batch access.
struct	Rivet::DeltaEtaGtr (
struct	Rivet::DeltaEtaInRange ( \Delta \eta ) (with respect to another 4-momentum, vec) in-range functor
struct	Rivet::DeltaEtaLess (
struct	Rivet::DeltaEtaWRT Calculator of ( \Delta \eta ) with respect to a given momentum.
struct	Rivet::DeltaPhiGtr (
struct	Rivet::DeltaPhiInRange ( \Delta \phi ) (with respect to another 4-momentum, vec) in-range functor
struct	Rivet::DeltaPhiLess (
struct	Rivet::DeltaPhiWRT Calculator of ( \Delta \phi ) with respect to a given momentum.
struct	Rivet::DeltaRapGtr (
struct	Rivet::DeltaRapInRange ( \Delta y ) (with respect to another 4-momentum, vec) in-range functor
struct	Rivet::DeltaRapLess (
struct	Rivet::DeltaRapWRT Calculator of ( \Delta y ) with respect to a given momentum.
struct	Rivet::DeltaRGtr ( \Delta R ) (with respect to another 4-momentum, vec) greater-than functor
struct	Rivet::DeltaRInRange ( \Delta R ) (with respect to another 4-momentum, vec) in-range functor
struct	Rivet::DeltaRLess ( \Delta R ) (with respect to another 4-momentum, vec) less-than functor
struct	Rivet::DeltaRWRT Calculator of ( \Delta R ) with respect to a given momentum.
class	Rivet::DISDiffHadron Get the incoming and outgoing hadron in a diffractive ep event.
class	Rivet::DISFinalState Final state particles boosted to the hadronic center of mass system.
class	Rivet::DISKinematics Get the DIS kinematic variables and relevant boosts for an event.
class	Rivet::DISLepton Get the incoming and outgoing leptons in a DIS event.
class	Rivet::DISRapidityGap Get the incoming and outgoing hadron in a diffractive ep event.
struct	Rivet::DoubleParticleBaseFunctor Base type for Particle -> double functors.
class	Rivet::DressedLepton A charged lepton meta-particle created by clustering photons close to the bare lepton.
class	Rivet::DressedLeptons Cluster photons from a given FS to all charged particles (typically leptons)
struct	Rivet::Error Generic runtime Rivet error.
struct	Rivet::EtaGtr Pseudorapidity greater-than functor.
struct	Rivet::EtaInRange Pseudorapidity in-range functor.
struct	Rivet::EtaLess Pseudorapidity less-than functor.
class	Rivet::Event Representation of a HepMC event, and enabler of Projection caching.
class	Rivet::EventMixingBase
class	Rivet::EventMixingCentrality
class	Rivet::EventMixingFinalState
class	Rivet::FastJets Project out jets found using the FastJet package jet algorithms.
class	Rivet::FinalPartons
class	Rivet::FinalState Project out all final-state particles in an event. Probably the most important projection in Rivet!
struct	Rivet::FirstParticleWith Determine whether a particle is the first in a decay chain to meet the cut/function.
struct	Rivet::FirstParticleWithout Determine whether a particle is the first in a decay chain not to meet the cut/function.
class	Rivet::FourMomentum Specialized version of the FourVector with momentum/energy functionality.
class	Rivet::FourVector Specialisation of VectorN to a general (non-momentum) Lorentz 4-vector.
class	Rivet::FParameter Calculator of the ( F )-parameter observable.
class	Rivet::GammaGammaFinalState Final state particles boosted to the hadronic center of mass system.
class	Rivet::GammaGammaKinematics Get the gamma gamma kinematic variables and relevant boosts for an event.
class	Rivet::GammaGammaLeptons Get the incoming and outgoing leptons in a gamma gamma collision event in e+e-.
class	Rivet::GeneratedCentrality
class	Rivet::GeneratedPercentileProjection
class	Rivet::HadronicFinalState Project only hadronic final state particles.
struct	Rivet::HasAbsPID
struct	Rivet::HasBTag B-tagging functor, with a tag selection cut as the stored state.
struct	Rivet::HasCTag C-tagging functor, with a tag selection cut as the stored state.
struct	Rivet::HasNoTag Anti-B/C-tagging functor, with a tag selection cut as the stored state.
struct	Rivet::HasParticleAncestorWith Determine whether a particle has an ancestor which meets the cut/function.
struct	Rivet::HasParticleAncestorWithout Determine whether a particle has an ancestor which doesn’t meet the cut/function.
struct	Rivet::HasParticleChildWith Determine whether a particle has a child which meets the cut/function.
struct	Rivet::HasParticleChildWithout Determine whether a particle has a child which doesn’t meet the cut/function.
struct	Rivet::HasParticleDescendantWith Determine whether a particle has a descendant which meets the cut/function.
struct	Rivet::HasParticleDescendantWithout Determine whether a particle has a descendant which doesn’t meet the cut/function.
struct	Rivet::HasParticleParentWith Determine whether a particle has an parent which meets the cut/function.
struct	Rivet::HasParticleParentWithout Determine whether a particle has an parent which doesn’t meet the cut/function.
struct	Rivet::HasPID PID matching functor.
struct	Rivet::HasTauTag Tau-tagging functor, with a tag selection cut as the stored state.
class	Rivet::HeavyHadrons Project out the last pre-decay b and c hadrons.
class	Rivet::Hemispheres Calculate the hemisphere masses and broadenings.
class	Rivet::HepMCHeavyIon
class	Rivet::IdentifiedFinalState Produce a final state which only contains specified particle IDs.
class	Rivet::ImpactParameterProjection
struct	Rivet::InfoError Error specialisation for failures relating to analysis info.
class	Rivet::InitialQuarks Project out quarks from the hard process in ( e^+ e^- \to Z^0 ) events.
class	Rivet::InvisibleFinalState Final state modifier excluding particles which are experimentally visible.
class	Rivet::InvMassFinalState Identify particles which can be paired to fit within a given invariant mass window.
struct	Rivet::IOError Error for I/O failures.
class	Rivet::Jet Representation of a clustered jet of particles.
struct	Rivet::JET_BTAG_EFFS b-tagging efficiency functor, for more readable b-tag effs and mistag rates
struct	Rivet::JET_EFF_CONST Take a Jet and return a constant efficiency.
struct	Rivet::JetEffFilter A functor to return true if Jetj survives a random efficiency selection.
struct	Rivet::JetEffSmearFn Functor for simultaneous efficiency-filtering and smearing of Jets.
class	Rivet::JetFinder Abstract base class for projections which can return a set of `Jet`s.
class	Rivet::Jets Specialised vector of Jet objects.
class	Rivet::JetShape Calculate transverse jet profiles.
struct	Rivet::LastParticleWith Determine whether a particle is the last in a decay chain to meet the cut/function.
struct	Rivet::LastParticleWithout Determine whether a particle is the last in a decay chain not to meet the cut/function.
class	Rivet::LeadingParticlesFinalState Get the highest-pT occurrences of FS particles with the specified PDG IDs.
class	Rivet::Log Logging system for controlled & formatted writing to stdout.
struct	Rivet::LogicError Error specialisation for places where alg logic has failed.
struct	Rivet::LookupError Error relating to looking up analysis objects in the register.
class	Rivet::LorentzTransform Object implementing Lorentz transform calculations and boosts.
class	Rivet::LossyFinalState Templated FS projection which can lose some of the supplied particles.
class	Rivet::Matrix General ( N )-dimensional mathematical matrix object.
class	Rivet::Matrix3 Specialisation of MatrixN to aid 3 dimensional rotations.
class	Rivet::MC_JetAnalysis Base class providing common functionality for MC jet validation analyses.
class	Rivet::MC_JetSplittings Base class providing common functionality for MC jet validation analyses.
class	Rivet::MC_ParticleAnalysis Base class providing common functionality for MC particle species validation analyses.
class	Rivet::MC_pPbMinBiasTrigger
class	Rivet::MC_SumETFwdPbCentrality
class	Rivet::MendelMin A genetic algorithm functional minimizer.
class	Rivet::MergedFinalState Get final state particles merged from two FinalState projections.
class	Rivet::METFinder Interface for projections that find missing transverse energy/momentum.
class	Rivet::MissingMomentum Calculate missing ( E ), ( E_\perp ) etc. as complements to the total visible momentum.
class	Rivet::NeutralFinalState Project only neutral final state particles.
class	Rivet::NonHadronicFinalState Project only hadronic final state particles.
class	Rivet::NonPromptFinalState Find final state particles NOT directly connected to the hard process.
struct	Rivet::P3_EFF_CONST Take a Vector3 and return a constant number.
struct	Rivet::P4_EFF_CONST Take a FourMomentum and return a constant number.
class	Rivet::ParisiTensor Calculate the Parisi event shape tensor (or linear momentum tensor).
class	Rivet::Particle Particle representation, either from a HepMC::GenEvent or reconstructed.
struct	Rivet::PARTICLE_EFF_CONST Take a Particle and return a constant number.
class	Rivet::ParticleBase Base class for particle-like things like Particle and Jet.
struct	Rivet::ParticleEffFilter A functor to return true if Particlep survives a random efficiency selection.
struct	Rivet::ParticleEffSmearFn Functor for simultaneous efficiency-filtering and smearing of Particles.
class	Rivet::ParticleFinder Base class for projections which return subsets of an event’s particles.
class	Rivet::Particles Specialised vector of Particle objects.
class	Rivet::PartonicTops Convenience finder of partonic top quarks.
class	Rivet::Percentile The Percentile class for centrality binning.
class	Rivet::PercentileBase PercentileBase is the base class of all Percentile classes.
class	Rivet::PercentileProjection class for projections that reports the percentile for a given SingleValueProjection when initialized with a Histo1D of the distribution in the SingleValueProjection.
class	Rivet::PercentileTBase PercentileTBase is the base class of all Percentile classes.
class	Rivet::PercentileXaxis The PercentileXaxis class for centrality binning.
struct	Rivet::PidError Error specialisation for failures relating to particle ID codes.
class	Rivet::PrimaryHadrons Project out the first hadrons from hadronisation.
class	Rivet::PrimaryParticles Project out primary particles according to definition.
class	Rivet::Projection Base class for all Rivet projections.
class	Rivet::ProjectionApplier Common base class for Projection and Analysis, used for internal polymorphism.
class	Rivet::ProjectionHandler The projection handler is a central repository for projections to be used in a Rivet analysis run.
class	Rivet::PromptFinalState Find final state particles directly connected to the hard process.
struct	Rivet::PtGtr Transverse momentum greater-than functor.
struct	Rivet::PtInRange Transverse momentum in-range functor.
struct	Rivet::PtLess Transverse momentum less-than functor.
struct	Rivet::RangeError Error for e.g. use of invalid bin ranges.
struct	Rivet::RapGtr Rapidity greater-than functor.
struct	Rivet::RapInRange Rapidity in-range functor.
struct	Rivet::RapLess Rapidity momentum less-than functor.
struct	Rivet::ReadError Error for read failures.
class	Rivet::Run Interface to handle a run of events read from a HepMC stream or file.
class	Rivet::SingleValueProjection Base class for projections returning a single floating point value.
class	Rivet::SmearedJets Wrapper projection for smearing `Jet`s with detector resolutions and efficiencies.
class	Rivet::SmearedMET Wrapper projection for smearing missing (transverse) energy/momentum with detector resolutions.
class	Rivet::SmearedParticles Wrapper projection for smearing `Jet`s with detector resolutions and efficiencies.
class	Rivet::Sphericity Calculate the sphericity event shape.
class	Rivet::Spherocity Get the transverse spherocity scalars for hadron-colliders.
class	Rivet::STAR_BES_Centrality Common projections for RHIC experiments’ trigger conditions and centrality.
class	Rivet::TauFinder Convenience finder of unstable taus.
class	Rivet::ThreeMomentum Specialized version of the ThreeVector with momentum functionality.
class	Rivet::Thrust Get the e+ e- thrust basis and the thrust, thrust major and thrust minor scalars.
class	Rivet::TriggerCDFRun0Run1 Access to the min bias triggers used by CDF in Run 0 and Run 1.
class	Rivet::TriggerCDFRun2 Access to the min bias triggers used by CDF in Run 0 and Run 1.
class	Rivet::TriggerProjection Base class for projections returning a bool corresponding to a trigger.
class	Rivet::TriggerUA5 Access to the min bias triggers used by UA5.
class	Rivet::UndressBeamLeptons Project out the incoming beams, but subtract any colinear photons from lepton beams within a given cone.
class	Rivet::UnstableParticles Project out all physical-but-decayed particles in an event.
class	Rivet::UserCentEstimate
struct	Rivet::UserError Error specialisation for where the problem is between the chair and the computer.
class	Rivet::Vector A minimal base class for ( N )-dimensional vectors.
class	Rivet::Vector2 Two-dimensional specialisation of Vector.
class	Rivet::Vector3 Three-dimensional specialisation of Vector.
class	Rivet::VetoedFinalState FS modifier to exclude classes of particles from the final state.
class	Rivet::VisibleFinalState Final state modifier excluding particles which are not experimentally visible.
struct	Rivet::WeightError Errors relating to event/bin weights.
class	Rivet::WFinder Convenience finder of leptonically decaying W.
struct	Rivet::WriteError Error for write failures.
class	Rivet::ZFinder Convenience finder of leptonically decaying Zs.

Types

	Name
enum	RangeBoundary { OPEN =0, SOFT =0, CLOSED =1, HARD =1}
typedef std::vector< FourVector >	FourVectors
typedef std::vector< FourMomentum >	FourMomenta
typedef function< Jet(const Jet &)>	JetSmearFn Typedef for Jet smearing functions/functors.
typedef function< double(const Jet &)>	JetEffFn Typedef for Jet efficiency functions/functors.
using JetEffFilter	jetEffFilter
typedef std::function< FourMomentum(const FourMomentum &)>	P4SmearFn Typedef for FourMomentum smearing functions/functors.
typedef std::function< double(const FourMomentum &)>	P4EffFn Typedef for FourMomentum efficiency functions/functors.
typedef function< Particle(const Particle &)>	ParticleSmearFn Typedef for Particle smearing functions/functors.
typedef function< double(const Particle &)>	ParticleEffFn Typedef for Particle efficiency functions/functors.
using ParticleEffFilter	particleEffFilter
typedef vector< std::string >	strings
typedef vector< double >	doubles
typedef vector< float >	floats
typedef vector< int >	ints
enum	Sign { MINUS = -1, ZERO = 0, PLUS = 1} Enum for signs of numbers.
enum	RapScheme { PSEUDORAPIDITY = 0, ETARAP = 0, RAPIDITY = 1, YRAP = 1} Enum for rapidity variable to be used in calculating ( R ), applying rapidity cuts, etc.
enum	PhiMapping { MINUSPI_PLUSPI, ZERO_2PI, ZERO_PI} Enum for range of ( \phi ) to be mapped into.
typedef std::shared_ptr< Analysis >	AnaHandle
typedef Matrix< 4 >	Matrix4
typedef Vector2	TwoVector
typedef Vector2	V2
typedef Vector3	ThreeVector
typedef Vector3	V3
typedef ThreeMomentum	P3
typedef FourVector	Vector4
typedef FourVector	V4
typedef FourMomentum	P4
typedef std::pair< Particle, Particle >	ParticlePair Typedef for a pair of Particle objects.
typedef std::shared_ptr< const Projection >	ProjHandle Typedef for Projection (smart) pointer.
using PromptFinalState	DirectFinalState Alias with a more correct name.
typedef pair< Particles, double >	MixEvent
typedef map< double, std::deque< MixEvent > >	MixMap
using NonPromptFinalState	IndirectFinalState Alias with a more correct name.
using JetFinder	JetAlg
using MissingMomentum	MissingMom A slightly more convenient name, following other Rivet shortening-conventions.
using TauFinder	Taus
using UnstableParticles	UnstableFinalState
using Cmp< Projection >	PCmp Typedef for Cmp
typedef Error	Exception Rivet::Exception is a synonym for Rivet::Error.
using function< bool(const Jet &)>	JetSelector std::function instantiation for functors taking a Jet and returning a bool
using function< bool(const Jet &, const Jet &)>	JetSorter std::function instantiation for functors taking two Jets and returning a bool
using HasBTag	hasBTag
using HasCTag	hasCTag
using HasTauTag	hasTauTag
using HasNoTag	hasNoTag
using function< bool(const ParticleBase &)>	ParticleBaseSelector std::function instantiation for functors taking a ParticleBase and returning a bool
using function< bool(const ParticleBase &, const ParticleBase &)>	ParticleBaseSorter std::function instantiation for functors taking two ParticleBase and returning a bool
using PtGtr	pTGtr
using PtGtr	ptGtr
using PtLess	pTLess
using PtLess	ptLess
using PtInRange	pTInRange
using PtInRange	ptInRange
using EtaGtr	etaGtr
using EtaLess	etaLess
using EtaInRange	etaInRange
using AbsEtaGtr	absEtaGtr
using AbsEtaGtr	absetaGtr
using AbsEtaLess	absEtaLess
using AbsEtaLess	absetaLess
using AbsEtaInRange	absEtaInRange
using AbsEtaInRange	absetaInRange
using RapGtr	rapGtr
using RapLess	rapLess
using RapInRange	rapInRange
using AbsRapGtr	absRapGtr
using AbsRapGtr	absrapGtr
using AbsRapLess	absRapLess
using AbsRapLess	absrapLess
using AbsRapInRange	absRapInRange
using AbsRapInRange	absrapInRange
using DeltaRGtr	deltaRGtr
using DeltaRLess	deltaRLess
using DeltaRInRange	deltaRInRange
using DeltaPhiGtr	deltaPhiGtr
using DeltaPhiLess	deltaPhiLess
using DeltaPhiInRange	deltaPhiInRange
using DeltaEtaGtr	deltaEtaGtr
using DeltaEtaLess	deltaEtaLess
using DeltaEtaInRange	deltaEtaInRange
using DeltaRapGtr	deltaRapGtr
using DeltaRapLess	deltaRapLess
using DeltaRapInRange	deltaRapInRange
using DeltaRWRT	deltaRWRT
using DeltaPhiWRT	deltaPhiWRT
using DeltaEtaWRT	deltaEtaWRT
using AbsDeltaEtaWRT	absDeltaEtaWRT
using DeltaRapWRT	deltaRapWRT
using AbsDeltaRapWRT	absDeltaRapWRT
using HasPID	hasPID
using HasAbsPID	hasAbsPID
using FirstParticleWith	firstParticleWith
using FirstParticleWithout	firstParticleWithout
using LastParticleWith	lastParticleWith
using LastParticleWithout	lastParticleWithout
using HasParticleAncestorWith	hasParticleAncestorWith
using HasParticleAncestorWithout	hasParticleAncestorWithout
using HasParticleParentWith	hasParticleParentWith
using HasParticleParentWithout	hasParticleParentWithout
using HasParticleChildWith	hasParticleChildWith
using HasParticleChildWithout	hasParticleChildWithout
using HasParticleDescendantWith	hasParticleDescendantWith
using HasParticleDescendantWithout	hasParticleDescendantWithout
typedef std::vector< PseudoJet >	PseudoJets
typedef const HepMC::GenParticle *	ConstGenParticlePtr
typedef const HepMC::GenVertex *	ConstGenVertexPtr
typedef const HepMC::HeavyIon *	ConstGenHeavyIonPtr
using HepMC::IO_GenEvent	HepMC_IO_type
using RivetHepMC::PdfInfo	PdfInfo
using std::shared_ptr< const GenEvent >	ConstGenEventPtr
using double	Weight Typedef for weights.
template <class T > using pair< typename T::FillType, Weight >	Fill A single fill is a (FillType, Weight) pair.
template <class T > using multiset< Fill< T > >	Fills
using rivet_shared_ptr< MultiweightAOWrapper >	MultiweightAOPtr
using rivet_shared_ptr< Wrapper< YODA::Histo1D > >	Histo1DPtr
using rivet_shared_ptr< Wrapper< YODA::Histo2D > >	Histo2DPtr
using rivet_shared_ptr< Wrapper< YODA::Profile1D > >	Profile1DPtr
using rivet_shared_ptr< Wrapper< YODA::Profile2D > >	Profile2DPtr
using rivet_shared_ptr< Wrapper< YODA::Counter > >	CounterPtr
using rivet_shared_ptr< Wrapper< YODA::Scatter1D > >	Scatter1DPtr
using rivet_shared_ptr< Wrapper< YODA::Scatter2D > >	Scatter2DPtr
using rivet_shared_ptr< Wrapper< YODA::Scatter3D > >	Scatter3DPtr

Functions

	Name
template <typename N1 ,typename N2 ,typename N3 > std::enable_if< std::is_arithmetic< N1 >::value &&std::is_arithmetic< N2 >::value &&std::is_arithmetic< N3 >::value, bool >::type	inRange(N1 value, N2 low, N3 high, RangeBoundary lowbound =CLOSED, RangeBoundary highbound =OPEN) Determine if value is in the range low to high, for floating point numbers.
template <typename N1 ,typename N2 ,typename N3 > std::enable_if< std::is_arithmetic< N1 >::value &&std::is_arithmetic< N2 >::value &&std::is_arithmetic< N3 >::value, bool >::type	fuzzyInRange(N1 value, N2 low, N3 high, RangeBoundary lowbound =CLOSED, RangeBoundary highbound =OPEN) Determine if value is in the range low to high, for floating point numbers.
template <typename N1 ,typename N2 ,typename N3 > std::enable_if< std::is_arithmetic< N1 >::value &&std::is_arithmetic< N2 >::value &&std::is_arithmetic< N3 >::value, bool >::type	inRange(N1 value, pair< N2, N3 > lowhigh, RangeBoundary lowbound =CLOSED, RangeBoundary highbound =OPEN) Alternative version of inRange which accepts a pair for the range arguments.
template <typename N1 ,typename N2 ,typename N3 > std::enable_if< std::is_arithmetic< N1 >::value &&std::is_arithmetic< N2 >::value &&std::is_arithmetic< N3 >::value, bool >::type	in_range(N1 val, N2 low, N3 high) Boolean function to determine if value is within the given range.
template <typename N1 ,typename N2 ,typename N3 > std::enable_if< std::is_arithmetic< N1 >::value &&std::is_arithmetic< N2 >::value &&std::is_arithmetic< N3 >::value, bool >::type	in_closed_range(N1 val, N2 low, N3 high) Boolean function to determine if value is within the given range.
template <typename N1 ,typename N2 ,typename N3 > std::enable_if< std::is_arithmetic< N1 >::value &&std::is_arithmetic< N2 >::value &&std::is_arithmetic< N3 >::value, bool >::type	in_open_range(N1 val, N2 low, N3 high) Boolean function to determine if value is within the given range.
double	JET_EFF_ZERO(const Jet & p) Take a jet and return a constant 0.
double	JET_EFF_0(const Jet & p) Alias for JET_EFF_ZERO.
double	JET_FN0(const Jet & p) Alias for JET_EFF_ZERO.
double	JET_EFF_ONE(const Jet & p) Take a jet and return a constant 1.
double	JET_EFF_1(const Jet & p) Alias for JET_EFF_ONE.
double	JET_EFF_PERFECT(const Jet & ) Alias for JET_EFF_ONE.
double	JET_FN1(const Jet & ) Alias for JET_EFF_ONE.
double	JET_BTAG_PERFECT(const Jet & j) Return 1 if the given Jet contains a b, otherwise 0.
double	JET_CTAG_PERFECT(const Jet & j) Return 1 if the given Jet contains a c, otherwise 0.
double	JET_TAUTAG_PERFECT(const Jet & j) Return 1 if the given Jet contains a c, otherwise 0.
Jet	JET_SMEAR_IDENTITY(const Jet & j)
Jet	JET_SMEAR_PERFECT(const Jet & j) Alias for JET_SMEAR_IDENTITY.
template <typename FN > bool	efffilt(const Jet & j, FN & feff) Return true if Jet_j_ is chosen to survive a random efficiency selection.
double	P4_EFF_ZERO(const FourMomentum & ) Take a FourMomentum and return 0.
double	P4_FN0(const FourMomentum & )
double	P4_EFF_ONE(const FourMomentum & ) Take a FourMomentum and return 1.
double	P4_FN1(const FourMomentum & )
FourMomentum	P4_SMEAR_IDENTITY(const FourMomentum & p) Take a FourMomentum and return it unmodified.
FourMomentum	P4_SMEAR_PERFECT(const FourMomentum & p) Alias for P4_SMEAR_IDENTITY.
FourMomentum	P4_SMEAR_E_GAUSS(const FourMomentum & p, double resolution)
FourMomentum	P4_SMEAR_PT_GAUSS(const FourMomentum & p, double resolution) Smear a FourMomentum’s transverse momentum using a Gaussian of absolute width resolution.
FourMomentum	P4_SMEAR_MASS_GAUSS(const FourMomentum & p, double resolution) Smear a FourMomentum’s mass using a Gaussian of absolute width resolution.
double	PARTICLE_EFF_ZERO(const Particle & ) Take a Particle and return 0.
double	PARTICLE_EFF_0(const Particle & ) Alias for PARTICLE_EFF_ZERO.
double	PARTICLE_FN0(const Particle & ) Alias for PARTICLE_EFF_ZERO.
double	PARTICLE_EFF_ONE(const Particle & ) Take a Particle and return 1.
double	PARTICLE_EFF_1(const Particle & ) Alias for PARTICLE_EFF_ONE.
double	PARTICLE_EFF_PERFECT(const Particle & ) Alias for PARTICLE_EFF_ONE.
double	PARTICLE_FN1(const Particle & ) Alias for PARTICLE_EFF_ONE.
Particle	PARTICLE_SMEAR_IDENTITY(const Particle & p) Take a Particle and return it unmodified.
Particle	PARTICLE_SMEAR_PERFECT(const Particle & p) Alias for PARTICLE_SMEAR_IDENTITY.
bool	efffilt(const Particle & p, const ParticleEffFn & feff) Return true if Particle_p_ is chosen to survive a random efficiency selection.
std::ostream &	operator«(std::ostream & os, const Jet & j) Allow a Jet to be passed to an ostream.
std::ostream &	operator«(std::ostream & os, const Particle & p) Allow a Particle to be passed to an ostream.
std::ostream &	operator«(std::ostream & os, const ParticlePair & pp) Allow ParticlePair to be passed to an ostream.
template <typename NUM > std::enable_if< std::is_floating_point< NUM >::value, bool >::type	isZero(NUM val, double tolerance =1e-8) Compare a number to zero.
template <typename NUM > std::enable_if< std::is_integral< NUM >::value, bool >::type	isZero(NUM val, double =1e-5) Compare a number to zero.
template <typename NUM > std::enable_if< std::is_floating_point< NUM >::value, bool >::type	isNaN(NUM val) Check if a number is NaN.
template <typename NUM > std::enable_if< std::is_floating_point< NUM >::value, bool >::type	notNaN(NUM val) Check if a number is non-NaN.
template <typename N1 ,typename N2 > std::enable_if< std::is_arithmetic< N1 >::value &&std::is_arithmetic< N2 >::value &&(std::is_floating_point< N1 >::value
template <typename N1 ,typename N2 > std::enable_if< std::is_integral< N1 >::value &&std::is_integral< N2 >::value, bool >::type	fuzzyEquals(N1 a, N2 b, double ) Compare two numbers for equality with a degree of fuzziness.
template <typename N1 ,typename N2 > std::enable_if< std::is_arithmetic< N1 >::value &&std::is_arithmetic< N2 >::value, bool >::type	fuzzyGtrEquals(N1 a, N2 b, double tolerance =1e-5) Compare two numbers for >= with a degree of fuzziness.
template <typename N1 ,typename N2 > std::enable_if< std::is_arithmetic< N1 >::value &&std::is_arithmetic< N2 >::value, bool >::type	fuzzyLessEquals(N1 a, N2 b, double tolerance =1e-5) Compare two floating point numbers for <= with a degree of fuzziness.
template <typename N1 ,typename N2 > std::enable_if< std::is_arithmetic< N1 >::value &&std::is_arithmetic< N2 >::value, typenamestd::common_type< N1, N2 >::type >::type	min(N1 a, N2 b) Get the minimum of two numbers.
template <typename N1 ,typename N2 > std::enable_if< std::is_arithmetic< N1 >::value &&std::is_arithmetic< N2 >::value, typenamestd::common_type< N1, N2 >::type >::type	max(N1 a, N2 b) Get the maximum of two numbers.
template <typename NUM > std::enable_if< std::is_arithmetic< NUM >::value, NUM >::type	sqr(NUM a) Named number-type squaring operation.
template <typename NUM > std::enable_if< std::is_arithmetic< NUM >::value, NUM >::type	add_quad(NUM a, NUM b) Named number-type addition in quadrature operation.
template <typename NUM > std::enable_if< std::is_arithmetic< NUM >::value, NUM >::type	add_quad(NUM a, NUM b, NUM c)
double	safediv(double num, double den, double fail =0.0)
template <typename NUM > std::enable_if< std::is_arithmetic< NUM >::value, NUM >::type	intpow(NUM val, unsigned int exp) A more efficient version of pow for raising numbers to integer powers.
template <typename NUM > std::enable_if< std::is_arithmetic< NUM >::value, int >::type	sign(NUM val) Find the sign of a number.
double	cdfBW(double x, double mu, double gamma) CDF for the Breit-Wigner distribution.
double	invcdfBW(double p, double mu, double gamma) Inverse CDF for the Breit-Wigner distribution.
vector< double >	linspace(size_t nbins, double start, double end, bool include_end =true) Make a list of nbins + 1 values equally spaced between start and end inclusive.
vector< double >	aspace(double step, double start, double end, bool include_end =true, double tol =1e-2) Make a list of values equally spaced by step between start and end inclusive.
vector< double >	logspace(size_t nbins, double start, double end, bool include_end =true) Make a list of nbins + 1 values exponentially spaced between start and end inclusive.
vector< double >	bwspace(size_t nbins, double start, double end, double mu, double gamma) Make a list of nbins + 1 values spaced for equal area Breit-Wigner binning between start and end inclusive. mu and gamma are the Breit-Wigner parameters.
template <typename NUM1 ,typename NUM2 > std::enable_if< std::is_arithmetic< NUM1 >::value &&std::is_arithmetic< NUM2 >::value, int >::type	binIndex(NUM1 val, std::initializer_list< NUM2 > binedges, bool allow_overflow =false) Return the bin index of the given value, val, given a vector of bin edges.
template <typename NUM ,typename CONTAINER > std::enable_if< std::is_arithmetic< NUM >::value &&std::is_arithmetic< typenameCONTAINER::value_type >::value, int >::type	binIndex(NUM val, const CONTAINER & binedges, bool allow_overflow =false) Return the bin index of the given value, val, given a vector of bin edges.
template <typename NUM > std::enable_if< std::is_arithmetic< NUM >::value, NUM >::type	median(const vector< NUM > & sample)
template <typename NUM > std::enable_if< std::is_arithmetic< NUM >::value, double >::type	mean(const vector< NUM > & sample)
template <typename NUM > std::enable_if< std::is_arithmetic< NUM >::value, double >::type	mean_err(const vector< NUM > & sample)
template <typename NUM > std::enable_if< std::is_arithmetic< NUM >::value, double >::type	covariance(const vector< NUM > & sample1, const vector< NUM > & sample2)
template <typename NUM > std::enable_if< std::is_arithmetic< NUM >::value, double >::type	covariance_err(const vector< NUM > & sample1, const vector< NUM > & sample2)
template <typename NUM > std::enable_if< std::is_arithmetic< NUM >::value, double >::type	correlation(const vector< NUM > & sample1, const vector< NUM > & sample2)
template <typename NUM > std::enable_if< std::is_arithmetic< NUM >::value, double >::type	correlation_err(const vector< NUM > & sample1, const vector< NUM > & sample2)
double	mapAngleMPiToPi(double angle) Map an angle into the range (-PI, PI].
double	mapAngle0To2Pi(double angle) Map an angle into the range [0, 2PI).
double	mapAngle0ToPi(double angle) Map an angle into the range [0, PI].
double	mapAngle(double angle, PhiMapping mapping) Map an angle into the enum-specified range.
double	deltaPhi(double phi1, double phi2, bool sign =false) Calculate the difference between two angles in radians.
double	deltaEta(double eta1, double eta2, bool sign =false)
double	deltaRap(double y1, double y2, bool sign =false)
double	deltaR2(double rap1, double phi1, double rap2, double phi2)
double	deltaR(double rap1, double phi1, double rap2, double phi2)
double	rapidity(double E, double pz) Calculate a rapidity value from the supplied energy E and longitudinal momentum pz.
double	mT(double pT1, double pT2, double dphi)
double	deltaR2(const FourVector & a, const FourVector & b, RapScheme scheme =PSEUDORAPIDITY) Calculate the squared 2D rapidity-azimuthal (“eta-phi”) distance between two four-vectors.
double	deltaR(const FourVector & a, const FourVector & b, RapScheme scheme =PSEUDORAPIDITY) Calculate the 2D rapidity-azimuthal (“eta-phi”) distance between two four-vectors.
double	deltaR2(const FourVector & v, double eta2, double phi2, RapScheme scheme =PSEUDORAPIDITY) Calculate the squared 2D rapidity-azimuthal (“eta-phi”) distance between two four-vectors.
double	deltaR(const FourVector & v, double eta2, double phi2, RapScheme scheme =PSEUDORAPIDITY) Calculate the 2D rapidity-azimuthal (“eta-phi”) distance between two four-vectors.
double	deltaR2(double eta1, double phi1, const FourVector & v, RapScheme scheme =PSEUDORAPIDITY) Calculate the squared 2D rapidity-azimuthal (“eta-phi”) distance between two four-vectors.
double	deltaR(double eta1, double phi1, const FourVector & v, RapScheme scheme =PSEUDORAPIDITY) Calculate the 2D rapidity-azimuthal (“eta-phi”) distance between two four-vectors.
double	deltaR2(const FourMomentum & a, const FourMomentum & b, RapScheme scheme =PSEUDORAPIDITY) Calculate the squared 2D rapidity-azimuthal (“eta-phi”) distance between two four-vectors.
double	deltaR(const FourMomentum & a, const FourMomentum & b, RapScheme scheme =PSEUDORAPIDITY) Calculate the 2D rapidity-azimuthal (“eta-phi”) distance between two four-vectors.
double	deltaR2(const FourMomentum & v, double eta2, double phi2, RapScheme scheme =PSEUDORAPIDITY) Calculate the squared 2D rapidity-azimuthal (“eta-phi”) distance between two four-vectors. There is a scheme ambiguity for momentum-type four vectors as to whether the pseudorapidity (a purely geometric concept) or the rapidity (a relativistic energy-momentum quantity) is to be used: this can be chosen via the optional scheme parameter.
double	deltaR(const FourMomentum & v, double eta2, double phi2, RapScheme scheme =PSEUDORAPIDITY) Calculate the 2D rapidity-azimuthal (“eta-phi”) distance between two four-vectors. There is a scheme ambiguity for momentum-type four vectors as to whether the pseudorapidity (a purely geometric concept) or the rapidity (a relativistic energy-momentum quantity) is to be used: this can be chosen via the optional scheme parameter.
double	deltaR2(double eta1, double phi1, const FourMomentum & v, RapScheme scheme =PSEUDORAPIDITY) Calculate the squared 2D rapidity-azimuthal (“eta-phi”) distance between two four-vectors. There is a scheme ambiguity for momentum-type four vectors as to whether the pseudorapidity (a purely geometric concept) or the rapidity (a relativistic energy-momentum quantity) is to be used: this can be chosen via the optional scheme parameter.
double	deltaR(double eta1, double phi1, const FourMomentum & v, RapScheme scheme =PSEUDORAPIDITY) Calculate the 2D rapidity-azimuthal (“eta-phi”) distance between two four-vectors. There is a scheme ambiguity for momentum-type four vectors as to whether the pseudorapidity (a purely geometric concept) or the rapidity (a relativistic energy-momentum quantity) is to be used: this can be chosen via the optional scheme parameter.
double	deltaR2(const FourMomentum & a, const FourVector & b, RapScheme scheme =PSEUDORAPIDITY) Calculate the squared 2D rapidity-azimuthal (“eta-phi”) distance between two four-vectors. There is a scheme ambiguity for momentum-type four vectors as to whether the pseudorapidity (a purely geometric concept) or the rapidity (a relativistic energy-momentum quantity) is to be used: this can be chosen via the optional scheme parameter.
double	deltaR(const FourMomentum & a, const FourVector & b, RapScheme scheme =PSEUDORAPIDITY) Calculate the 2D rapidity-azimuthal (“eta-phi”) distance between two four-vectors. There is a scheme ambiguity for momentum-type four vectors as to whether the pseudorapidity (a purely geometric concept) or the rapidity (a relativistic energy-momentum quantity) is to be used: this can be chosen via the optional scheme parameter.
double	deltaR2(const FourVector & a, const FourMomentum & b, RapScheme scheme =PSEUDORAPIDITY) Calculate the 2D rapidity-azimuthal (“eta-phi”) distance between two four-vectors. There is a scheme ambiguity for momentum-type four vectors as to whether the pseudorapidity (a purely geometric concept) or the rapidity (a relativistic energy-momentum quantity) is to be used: this can be chosen via the optional scheme parameter.
double	deltaR(const FourVector & a, const FourMomentum & b, RapScheme scheme =PSEUDORAPIDITY) Calculate the 2D rapidity-azimuthal (“eta-phi”) distance between two four-vectors. There is a scheme ambiguity for momentum-type four vectors as to whether the pseudorapidity (a purely geometric concept) or the rapidity (a relativistic energy-momentum quantity) is to be used: this can be chosen via the optional scheme parameter.
double	deltaR2(const FourMomentum & a, const Vector3 & b) Calculate the 2D rapidity-azimuthal (“eta-phi”) distance between a three-vector and a four-vector.
double	deltaR(const FourMomentum & a, const Vector3 & b) Calculate the 2D rapidity-azimuthal (“eta-phi”) distance between a three-vector and a four-vector.
double	deltaR2(const Vector3 & a, const FourMomentum & b) Calculate the 2D rapidity-azimuthal (“eta-phi”) distance between a three-vector and a four-vector.
double	deltaR(const Vector3 & a, const FourMomentum & b) Calculate the 2D rapidity-azimuthal (“eta-phi”) distance between a three-vector and a four-vector.
double	deltaR2(const FourVector & a, const Vector3 & b) Calculate the 2D rapidity-azimuthal (“eta-phi”) distance between a three-vector and a four-vector.
double	deltaR(const FourVector & a, const Vector3 & b) Calculate the 2D rapidity-azimuthal (“eta-phi”) distance between a three-vector and a four-vector.
double	deltaR2(const Vector3 & a, const FourVector & b) Calculate the 2D rapidity-azimuthal (“eta-phi”) distance between a three-vector and a four-vector.
double	deltaR(const Vector3 & a, const FourVector & b) Calculate the 2D rapidity-azimuthal (“eta-phi”) distance between a three-vector and a four-vector.
double	deltaPhi(const FourMomentum & a, const FourMomentum & b, bool sign =false) Calculate the difference in azimuthal angle between two vectors.
double	deltaPhi(const FourMomentum & v, double phi2, bool sign =false) Calculate the difference in azimuthal angle between two vectors.
double	deltaPhi(double phi1, const FourMomentum & v, bool sign =false) Calculate the difference in azimuthal angle between two vectors.
double	deltaPhi(const FourVector & a, const FourVector & b, bool sign =false) Calculate the difference in azimuthal angle between two vectors.
double	deltaPhi(const FourVector & v, double phi2, bool sign =false) Calculate the difference in azimuthal angle between two vectors.
double	deltaPhi(double phi1, const FourVector & v, bool sign =false) Calculate the difference in azimuthal angle between two vectors.
double	deltaPhi(const FourVector & a, const FourMomentum & b, bool sign =false) Calculate the difference in azimuthal angle between two vectors.
double	deltaPhi(const FourMomentum & a, const FourVector & b, bool sign =false) Calculate the difference in azimuthal angle between two vectors.
double	deltaPhi(const FourVector & a, const Vector3 & b, bool sign =false) Calculate the difference in azimuthal angle between two vectors.
double	deltaPhi(const Vector3 & a, const FourVector & b, bool sign =false) Calculate the difference in azimuthal angle between two vectors.
double	deltaPhi(const FourMomentum & a, const Vector3 & b, bool sign =false) Calculate the difference in azimuthal angle between two vectors.
double	deltaPhi(const Vector3 & a, const FourMomentum & b, bool sign =false) Calculate the difference in azimuthal angle between two vectors.
double	deltaEta(const FourMomentum & a, const FourMomentum & b, bool sign =false) Calculate the difference in pseudorapidity between two vectors.
double	deltaEta(const FourMomentum & v, double eta2, bool sign =false) Calculate the difference in pseudorapidity between two vectors.
double	deltaEta(double eta1, const FourMomentum & v, bool sign =false) Calculate the difference in pseudorapidity between two vectors.
double	deltaEta(const FourVector & a, const FourVector & b, bool sign =false) Calculate the difference in pseudorapidity between two vectors.
double	deltaEta(const FourVector & v, double eta2, bool sign =false) Calculate the difference in pseudorapidity between two vectors.
double	deltaEta(double eta1, const FourVector & v, bool sign =false) Calculate the difference in pseudorapidity between two vectors.
double	deltaEta(const FourVector & a, const FourMomentum & b, bool sign =false) Calculate the difference in pseudorapidity between two vectors.
double	deltaEta(const FourMomentum & a, const FourVector & b, bool sign =false) Calculate the difference in pseudorapidity between two vectors.
double	deltaEta(const FourVector & a, const Vector3 & b, bool sign =false) Calculate the difference in pseudorapidity between two vectors.
double	deltaEta(const Vector3 & a, const FourVector & b, bool sign =false) Calculate the difference in pseudorapidity between two vectors.
double	deltaEta(const FourMomentum & a, const Vector3 & b, bool sign =false) Calculate the difference in pseudorapidity between two vectors.
double	deltaEta(const Vector3 & a, const FourMomentum & b, bool sign =false) Calculate the difference in pseudorapidity between two vectors.
double	deltaRap(const FourMomentum & a, const FourMomentum & b, bool sign =false) Calculate the difference in rapidity between two 4-momentum vectors.
double	deltaRap(const FourMomentum & v, double y2, bool sign =false) Calculate the difference in rapidity between two 4-momentum vectors.
double	deltaRap(double y1, const FourMomentum & v, bool sign =false) Calculate the difference in rapidity between two 4-momentum vectors.
bool	cmpMomByPt(const FourMomentum & a, const FourMomentum & b) Comparison to give a sorting by decreasing pT.
bool	cmpMomByAscPt(const FourMomentum & a, const FourMomentum & b) Comparison to give a sorting by increasing pT.
bool	cmpMomByP(const FourMomentum & a, const FourMomentum & b) Comparison to give a sorting by decreasing 3-momentum magnitude
bool	cmpMomByAscP(const FourMomentum & a, const FourMomentum & b) Comparison to give a sorting by increasing 3-momentum magnitude
bool	cmpMomByEt(const FourMomentum & a, const FourMomentum & b) Comparison to give a sorting by decreasing transverse energy.
bool	cmpMomByAscEt(const FourMomentum & a, const FourMomentum & b) Comparison to give a sorting by increasing transverse energy.
bool	cmpMomByE(const FourMomentum & a, const FourMomentum & b) Comparison to give a sorting by decreasing energy.
bool	cmpMomByAscE(const FourMomentum & a, const FourMomentum & b) Comparison to give a sorting by increasing energy.
bool	cmpMomByMass(const FourMomentum & a, const FourMomentum & b) Comparison to give a sorting by decreasing mass.
bool	cmpMomByAscMass(const FourMomentum & a, const FourMomentum & b) Comparison to give a sorting by increasing mass.
bool	cmpMomByEta(const FourMomentum & a, const FourMomentum & b) Comparison to give a sorting by increasing eta (pseudorapidity)
bool	cmpMomByDescEta(const FourMomentum & a, const FourMomentum & b) Comparison to give a sorting by decreasing eta (pseudorapidity)
bool	cmpMomByAbsEta(const FourMomentum & a, const FourMomentum & b) Comparison to give a sorting by increasing absolute eta (pseudorapidity)
bool	cmpMomByDescAbsEta(const FourMomentum & a, const FourMomentum & b) Comparison to give a sorting by increasing absolute eta (pseudorapidity)
bool	cmpMomByRap(const FourMomentum & a, const FourMomentum & b) Comparison to give a sorting by increasing rapidity.
bool	cmpMomByDescRap(const FourMomentum & a, const FourMomentum & b) Comparison to give a sorting by decreasing rapidity.
bool	cmpMomByAbsRap(const FourMomentum & a, const FourMomentum & b) Comparison to give a sorting by increasing absolute rapidity.
bool	cmpMomByDescAbsRap(const FourMomentum & a, const FourMomentum & b) Comparison to give a sorting by decreasing absolute rapidity.
template <typename MOMS ,typename CMP > MOMS &	isortBy(MOMS & pbs, const CMP & cmp) Sort a container of momenta by cmp and return by reference for non-const inputs.
template <typename MOMS ,typename CMP > MOMS	sortBy(const MOMS & pbs, const CMP & cmp) Sort a container of momenta by cmp and return by value for const inputs.
template <typename MOMS > MOMS &	isortByPt(MOMS & pbs) Sort a container of momenta by pT (decreasing) and return by reference for non-const inputs.
template <typename MOMS > MOMS	sortByPt(const MOMS & pbs) Sort a container of momenta by pT (decreasing) and return by value for const inputs.
template <typename MOMS > MOMS &	isortByE(MOMS & pbs) Sort a container of momenta by E (decreasing) and return by reference for non-const inputs.
template <typename MOMS > MOMS	sortByE(const MOMS & pbs) Sort a container of momenta by E (decreasing) and return by value for const inputs.
template <typename MOMS > MOMS &	isortByEt(MOMS & pbs) Sort a container of momenta by Et (decreasing) and return by reference for non-const inputs.
template <typename MOMS > MOMS	sortByEt(const MOMS & pbs) Sort a container of momenta by Et (decreasing) and return by value for const inputs.
template <size_t N> const string	toString(const Vector< N > & v) Make string representation.
template <size_t N> std::ostream &	operator«(std::ostream & out, const Vector< N > & v) Stream out string representation.
template <size_t N> bool	fuzzyEquals(const Vector< N > & va, const Vector< N > & vb, double tolerance =1E-5) Compare two vectors by index, allowing for numerical precision.
template <size_t N> bool	isZero(const Vector< N > & v, double tolerance =1E-5) External form of numerically safe nullness check.
double	deltaR(const ParticleBase & p1, const ParticleBase & p2, RapScheme scheme =PSEUDORAPIDITY)
double	deltaR(const ParticleBase & p, const FourMomentum & v, RapScheme scheme =PSEUDORAPIDITY)
double	deltaR(const ParticleBase & p, const FourVector & v, RapScheme scheme =PSEUDORAPIDITY)
double	deltaR(const ParticleBase & p, const Vector3 & v)
double	deltaR(const ParticleBase & p, double eta, double phi)
double	deltaR(const FourMomentum & v, const ParticleBase & p, RapScheme scheme =PSEUDORAPIDITY)
double	deltaR(const FourVector & v, const ParticleBase & p, RapScheme scheme =PSEUDORAPIDITY)
double	deltaR(const Vector3 & v, const ParticleBase & p)
double	deltaR(double eta, double phi, const ParticleBase & p)
double	deltaPhi(const ParticleBase & p1, const ParticleBase & p2, bool sign =false)
double	deltaPhi(const ParticleBase & p, const FourMomentum & v, bool sign =false)
double	deltaPhi(const ParticleBase & p, const FourVector & v, bool sign =false)
double	deltaPhi(const ParticleBase & p, const Vector3 & v, bool sign =false)
double	deltaPhi(const ParticleBase & p, double phi, bool sign =false)
double	deltaPhi(const FourMomentum & v, const ParticleBase & p, bool sign =false)
double	deltaPhi(const FourVector & v, const ParticleBase & p, bool sign =false)
double	deltaPhi(const Vector3 & v, const ParticleBase & p, bool sign =false)
double	deltaPhi(double phi, const ParticleBase & p, bool sign =false)
double	deltaEta(const ParticleBase & p1, const ParticleBase & p2)
double	deltaEta(const ParticleBase & p, const FourMomentum & v)
double	deltaEta(const ParticleBase & p, const FourVector & v)
double	deltaEta(const ParticleBase & p, const Vector3 & v)
double	deltaEta(const ParticleBase & p, double eta)
double	deltaEta(const FourMomentum & v, const ParticleBase & p)
double	deltaEta(const FourVector & v, const ParticleBase & p)
double	deltaEta(const Vector3 & v, const ParticleBase & p)
double	deltaEta(double eta, const ParticleBase & p)
double	deltaRap(const ParticleBase & p1, const ParticleBase & p2)
double	deltaRap(const ParticleBase & p, const FourMomentum & v)
double	deltaRap(const ParticleBase & p, double y)
double	deltaRap(const FourMomentum & v, const ParticleBase & p)
double	deltaRap(double y, const ParticleBase & p)
ParticlePair	beams(const Event & e) Get beam particles from an event.
PdgIdPair	beamIds(const ParticlePair & beams)
PdgIdPair	beamIds(const Event & e)
double	sqrtS(const FourMomentum & pa, const FourMomentum & pb) Get beam centre-of-mass energy from a pair of beam momenta.
double	sqrtS(const ParticlePair & beams) Get beam centre-of-mass energy from a pair of Particles.
double	sqrtS(const Event & e) Get beam centre-of-mass energy from an Event.
double	asqrtS(const FourMomentum & pa, const FourMomentum & pb)
double	asqrtS(const ParticlePair & beams)
double	asqrtS(const Event & e)
FourMomentum	cmsBoostVec(const FourMomentum & pa, const FourMomentum & pb) Get the Lorentz boost to the beam centre-of-mass system (CMS) from a pair of beam momenta.
FourMomentum	cmsBoostVec(const ParticlePair & beams) Get the Lorentz boost to the beam centre-of-mass system (CMS) from a pair of Particles.
FourMomentum	acmsBoostVec(const FourMomentum & pa, const FourMomentum & pb) Get the Lorentz boost to the beam centre-of-mass system (CMS) from a pair of beam momenta.
FourMomentum	acmsBoostVec(const ParticlePair & beams) Get the Lorentz boost to the beam centre-of-mass system (CMS) from a pair of Particles.
Vector3	cmsBetaVec(const FourMomentum & pa, const FourMomentum & pb) Get the Lorentz boost to the beam centre-of-mass system (CMS) from a pair of beam momenta.
Vector3	cmsBetaVec(const ParticlePair & beams) Get the Lorentz boost to the beam centre-of-mass system (CMS) from a pair of Particles.
Vector3	acmsBetaVec(const FourMomentum & pa, const FourMomentum & pb)
Vector3	acmsBetaVec(const ParticlePair & beams)
Vector3	cmsGammaVec(const FourMomentum & pa, const FourMomentum & pb) Get the Lorentz boost to the beam centre-of-mass system (CMS) from a pair of beam momenta.
Vector3	cmsGammaVec(const ParticlePair & beams) Get the Lorentz boost to the beam centre-of-mass system (CMS) from a pair of Particles.
Vector3	acmsGammaVec(const FourMomentum & pa, const FourMomentum & pb)
Vector3	acmsGammaVec(const ParticlePair & beams)
LorentzTransform	cmsTransform(const FourMomentum & pa, const FourMomentum & pb) Get the Lorentz transformation to the beam centre-of-mass system (CMS) from a pair of beam momenta.
LorentzTransform	cmsTransform(const ParticlePair & beams) Get the Lorentz transformation to the beam centre-of-mass system (CMS) from a pair of Particles.
LorentzTransform	acmsTransform(const FourMomentum & pa, const FourMomentum & pb)
LorentzTransform	acmsTransform(const ParticlePair & beams)
Cut	operator,(const Cut & , const Cut & ) =delete
Cut &	operator,(Cut & , Cut & ) =delete
Cut	operator,(Cut , Cut ) =delete
Cut	operator==(Cuts::Quantity , double )
Cut	operator!=(Cuts::Quantity , double )
Cut	operator<(Cuts::Quantity , double )
Cut	operator>(Cuts::Quantity , double )
Cut	operator<=(Cuts::Quantity , double )
Cut	operator>=(Cuts::Quantity , double )
Cut	operator==(Cuts::Quantity qty, int i)
Cut	operator!=(Cuts::Quantity qty, int i)
Cut	operator<(Cuts::Quantity qty, int i)
Cut	operator>(Cuts::Quantity qty, int i)
Cut	operator<=(Cuts::Quantity qty, int i)
Cut	operator>=(Cuts::Quantity qty, int i)
Cut	operator&&(const Cut & aptr, const Cut & bptr)
Cut	**[operator
Cut	operator!(const Cut & cptr) Logical NOT operation on a cut.
Cut	operator&(const Cut & aptr, const Cut & bptr) Logical AND operation on two cuts.
Cut	**[operator
Cut	operator~(const Cut & cptr) Logical NOT operation on a cut.
Cut	operator^(const Cut & aptr, const Cut & bptr) Logical XOR operation on two cuts.
std::ostream &	operator«(std::ostream & os, const Cut & cptr) String representation.
template <typename T > Percentile< typename ReferenceTraits< T >::RefT >	divide(const Percentile< T > numer, const Percentile< T > denom)
template <typename T > Percentile< typename ReferenceTraits< T >::RefT >	divide(const Percentile< T > numer, const Percentile< typename ReferenceTraits< T >::RefT > denom)
template <typename T > Percentile< typename ReferenceTraits< T >::RefT >	divide(const Percentile< typename ReferenceTraits< T >::RefT > numer, const Percentile< T > denom)
template <typename T > Percentile< T >	add(const Percentile< T > pctla, const Percentile< T > pctlb)
template <typename T > Percentile< typename ReferenceTraits< T >::RefT >	add(const Percentile< T > pctla, const Percentile< typename ReferenceTraits< T >::RefT > pctlb)
template <typename T > Percentile< typename ReferenceTraits< T >::RefT >	add(const Percentile< typename ReferenceTraits< T >::RefT > pctla, const Percentile< T > pctlb)
template <typename T > Percentile< T >	subtract(const Percentile< T > pctla, const Percentile< T > pctlb)
template <typename T > Percentile< typename ReferenceTraits< T >::RefT >	subtract(const Percentile< T > pctla, const Percentile< typename ReferenceTraits< T >::RefT > pctlb)
template <typename T > Percentile< typename ReferenceTraits< T >::RefT >	subtract(const Percentile< typename ReferenceTraits< T >::RefT > pctla, const Percentile< T > pctlb)
template <typename T > Percentile< typename ReferenceTraits< T >::RefT >	multiply(const Percentile< T > pctla, const Percentile< typename ReferenceTraits< T >::RefT > pctlb)
template <typename T > Percentile< typename ReferenceTraits< T >::RefT >	multiply(const Percentile< typename ReferenceTraits< T >::RefT > pctla, const Percentile< T > pctlb)
template <typename T > PercentileXaxis< typename ReferenceTraits< T >::RefT >	divide(const PercentileXaxis< T > numer, const PercentileXaxis< T > denom)
template <typename T > PercentileXaxis< typename ReferenceTraits< T >::RefT >	divide(const PercentileXaxis< T > numer, const PercentileXaxis< typename ReferenceTraits< T >::RefT > denom)
template <typename T > PercentileXaxis< typename ReferenceTraits< T >::RefT >	divide(const PercentileXaxis< typename ReferenceTraits< T >::RefT > numer, const PercentileXaxis< T > denom)
template <typename T > PercentileXaxis< T >	add(const PercentileXaxis< T > pctla, const PercentileXaxis< T > pctlb)
template <typename T > PercentileXaxis< typename ReferenceTraits< T >::RefT >	add(const PercentileXaxis< T > pctla, const PercentileXaxis< typename ReferenceTraits< T >::RefT > pctlb)
template <typename T > PercentileXaxis< typename ReferenceTraits< T >::RefT >	add(const PercentileXaxis< typename ReferenceTraits< T >::RefT > pctla, const PercentileXaxis< T > pctlb)
template <typename T > PercentileXaxis< T >	subtract(const PercentileXaxis< T > pctla, const PercentileXaxis< T > pctlb)
template <typename T > PercentileXaxis< typename ReferenceTraits< T >::RefT >	subtract(const PercentileXaxis< T > pctla, const PercentileXaxis< typename ReferenceTraits< T >::RefT > pctlb)
template <typename T > PercentileXaxis< typename ReferenceTraits< T >::RefT >	subtract(const PercentileXaxis< typename ReferenceTraits< T >::RefT > pctla, const PercentileXaxis< T > pctlb)
template <typename T > PercentileXaxis< typename ReferenceTraits< T >::RefT >	multiply(const PercentileXaxis< T > pctla, const PercentileXaxis< typename ReferenceTraits< T >::RefT > pctlb)
template <typename T > PercentileXaxis< typename ReferenceTraits< T >::RefT >	multiply(const PercentileXaxis< typename ReferenceTraits< T >::RefT > pctla, const PercentileXaxis< T > pctlb)
template <typename T > Percentile< T >	operator+(const Percentile< T > pctla, const Percentile< T > pctlb)
template <typename T > Percentile< T >	operator-(const Percentile< T > pctla, const Percentile< T > pctlb)
template <typename T > Percentile< typename ReferenceTraits< T >::RefT >	operator/(const Percentile< T > numer, const Percentile< T > denom)
template <typename T > PercentileXaxis< T >	operator+(const PercentileXaxis< T > pctla, const PercentileXaxis< T > pctlb)
template <typename T > PercentileXaxis< T >	operator-(const PercentileXaxis< T > pctla, const PercentileXaxis< T > pctlb)
template <typename T > PercentileXaxis< typename ReferenceTraits< T >::RefT >	operator/(const PercentileXaxis< T > numer, const PercentileXaxis< T > denom)
std::string	getLibPath() Get library install path.
std::string	getDataPath() Get data install path.
std::string	getRivetDataPath() Get Rivet data install path.
std::vector< std::string >	getAnalysisLibPaths() Get Rivet analysis plugin library search paths.
void	setAnalysisLibPaths(const std::vector< std::string > & paths) Set the Rivet analysis plugin library search paths.
void	addAnalysisLibPath(const std::string & extrapath) Add a Rivet analysis plugin library search path.
std::string	findAnalysisLibFile(const std::string & filename) Find the first file of the given name in the analysis library search dirs.
std::vector< std::string >	getAnalysisDataPaths() Get Rivet analysis reference data search paths.
void	setAnalysisDataPaths(const std::vector< std::string > & paths) Set the Rivet data file search paths.
void	addAnalysisDataPath(const std::string & extrapath) Add a Rivet data file search path.
std::string	findAnalysisDataFile(const std::string & filename, const std::vector< std::string > & pathprepend =std::vector< std::string >(), const std::vector< std::string > & pathappend =std::vector< std::string >()) Find the first file of the given name in the general data file search dirs.
std::vector< std::string >	getAnalysisRefPaths() Get Rivet analysis reference data search paths.
std::string	findAnalysisRefFile(const std::string & filename, const std::vector< std::string > & pathprepend =std::vector< std::string >(), const std::vector< std::string > & pathappend =std::vector< std::string >()) Find the first file of the given name in the ref data file search dirs.
std::vector< std::string >	getAnalysisInfoPaths() Get Rivet analysis info metadata search paths.
std::string	findAnalysisInfoFile(const std::string & filename, const std::vector< std::string > & pathprepend =std::vector< std::string >(), const std::vector< std::string > & pathappend =std::vector< std::string >()) Find the first file of the given name in the analysis info file search dirs.
std::vector< std::string >	getAnalysisPlotPaths() Get Rivet analysis plot style search paths.
std::string	findAnalysisPlotFile(const std::string & filename, const std::vector< std::string > & pathprepend =std::vector< std::string >(), const std::vector< std::string > & pathappend =std::vector< std::string >()) Find the first file of the given name in the analysis plot file search dirs.
template <typename T > std::ostream &	operator«(std::ostream & os, const std::vector< T > & vec) Convenient function for streaming out vectors of any streamable object.
template <typename T > std::ostream &	operator«(std::ostream & os, const std::list< T > & vec) Convenient function for streaming out lists of any streamable object.
bool	contains(const std::string & s, const std::string & sub) Does s contain sub as a substring?
template <typename T > bool	contains(const std::initializer_list< T > & il, const T & x) Does the init list il contain x?
template <typename T > bool	contains(const std::vector< T > & v, const T & x) Does the vector v contain x?
template <typename T > bool	contains(const std::list< T > & l, const T & x) Does the list l contain x?
template <typename T > bool	contains(const std::set< T > & s, const T & x) Does the set s contain x?
template <typename K ,typename T > bool	has_key(const std::map< K, T > & m, const K & key) Does the map m contain the key key?
template <typename K ,typename T > bool	has_value(const std::map< K, T > & m, const T & val) Does the map m contain the value val?
std::string	toString(const AnalysisInfo & ai) String representation.
std::ostream &	operator«(std::ostream & os, const AnalysisInfo & ai) Stream an AnalysisInfo as a text description.
Jets	operator+(const Jets & a, const Jets & b)
LorentzTransform	inverse(const LorentzTransform & lt)
LorentzTransform	combine(const LorentzTransform & a, const LorentzTransform & b)
FourVector	transform(const LorentzTransform & lt, const FourVector & v4)
string	toString(const LorentzTransform & lt)
std::ostream &	operator«(std::ostream & out, const LorentzTransform & lt)
template <size_t N> EigenSystem< N >	diagonalize(const Matrix< N > & m)
template <size_t N> const string	toString(const typename EigenSystem< N >::EigenPair & e)
template <size_t N> ostream &	operator«(std::ostream & out, const typename EigenSystem< N >::EigenPair & e)
template <size_t N> Matrix< N >	multiply(const Matrix< N > & a, const Matrix< N > & b)
template <size_t N> Matrix< N >	divide(const Matrix< N > & m, const double a)
template <size_t N> Matrix< N >	operator*(const Matrix< N > & a, const Matrix< N > & b)
template <size_t N> Matrix< N >	add(const Matrix< N > & a, const Matrix< N > & b)
template <size_t N> Matrix< N >	subtract(const Matrix< N > & a, const Matrix< N > & b)
template <size_t N> Matrix< N >	operator+(const Matrix< N > a, const Matrix< N > & b)
template <size_t N> Matrix< N >	operator-(const Matrix< N > a, const Matrix< N > & b)
template <size_t N> Matrix< N >	multiply(const double a, const Matrix< N > & m)
template <size_t N> Matrix< N >	multiply(const Matrix< N > & m, const double a)
template <size_t N> Matrix< N >	operator*(const double a, const Matrix< N > & m)
template <size_t N> Matrix< N >	operator*(const Matrix< N > & m, const double a)
template <size_t N> Vector< N >	multiply(const Matrix< N > & a, const Vector< N > & b)
template <size_t N> Vector< N >	operator*(const Matrix< N > & a, const Vector< N > & b)
template <size_t N> Matrix< N >	transpose(const Matrix< N > & m)
template <size_t N> Matrix< N >	inverse(const Matrix< N > & m)
template <size_t N> double	det(const Matrix< N > & m)
template <size_t N> double	trace(const Matrix< N > & m)
template <size_t N> string	toString(const Matrix< N > & m) Make string representation.
template <size_t N> std::ostream &	operator«(std::ostream & out, const Matrix< N > & m) Stream out string representation.
template <size_t N> bool	fuzzyEquals(const Matrix< N > & ma, const Matrix< N > & mb, double tolerance =1E-5) Compare two matrices by index, allowing for numerical precision.
template <size_t N> bool	isZero(const Matrix< N > & m, double tolerance =1E-5) External form of numerically safe nullness check.
Vector2	multiply(const double a, const Vector2 & v)
Vector2	multiply(const Vector2 & v, const double a)
Vector2	add(const Vector2 & a, const Vector2 & b)
Vector2	operator*(const double a, const Vector2 & v)
Vector2	operator*(const Vector2 & v, const double a)
Vector2	operator/(const Vector2 & v, const double a)
Vector2	operator+(const Vector2 & a, const Vector2 & b)
Vector2	operator-(const Vector2 & a, const Vector2 & b)
double	dot(const Vector2 & a, const Vector2 & b)
Vector2	subtract(const Vector2 & a, const Vector2 & b)
double	angle(const Vector2 & a, const Vector2 & b) Angle (in radians) between two 2-vectors.
Vector3	multiply(const double a, const Vector3 & v) Unbound scalar-product function.
Vector3	multiply(const Vector3 & v, const double a) Unbound scalar-product function.
Vector3	add(const Vector3 & a, const Vector3 & b) Unbound vector addition function.
Vector3	operator*(const double a, const Vector3 & v) Unbound scalar multiplication operator.
Vector3	operator*(const Vector3 & v, const double a) Unbound scalar multiplication operator.
Vector3	operator/(const Vector3 & v, const double a) Unbound scalar division operator.
Vector3	operator+(const Vector3 & a, const Vector3 & b) Unbound vector addition operator.
Vector3	operator-(const Vector3 & a, const Vector3 & b) Unbound vector subtraction operator.
ThreeMomentum	multiply(const double a, const ThreeMomentum & v)
ThreeMomentum	multiply(const ThreeMomentum & v, const double a)
ThreeMomentum	add(const ThreeMomentum & a, const ThreeMomentum & b)
ThreeMomentum	operator*(const double a, const ThreeMomentum & v)
ThreeMomentum	operator*(const ThreeMomentum & v, const double a)
ThreeMomentum	operator/(const ThreeMomentum & v, const double a)
ThreeMomentum	operator+(const ThreeMomentum & a, const ThreeMomentum & b)
ThreeMomentum	operator-(const ThreeMomentum & a, const ThreeMomentum & b)
double	dot(const Vector3 & a, const Vector3 & b) Unbound dot-product function.
Vector3	cross(const Vector3 & a, const Vector3 & b) Unbound cross-product function.
Vector3	subtract(const Vector3 & a, const Vector3 & b) Unbound vector subtraction function.
double	angle(const Vector3 & a, const Vector3 & b) Angle (in radians) between two 3-vectors.
double	deltaEta(const Vector3 & a, const Vector3 & b, bool sign =false) Calculate the difference in pseudorapidity between two spatial vectors.
double	deltaEta(const Vector3 & v, double eta2, bool sign =false) Calculate the difference in pseudorapidity between two spatial vectors.
double	deltaEta(double eta1, const Vector3 & v, bool sign =false) Calculate the difference in pseudorapidity between two spatial vectors.
double	deltaPhi(const Vector3 & a, const Vector3 & b, bool sign =false) Calculate the difference in azimuthal angle between two spatial vectors.
double	deltaPhi(const Vector3 & v, double phi2, bool sign =false) Calculate the difference in azimuthal angle between two spatial vectors.
double	deltaPhi(double phi1, const Vector3 & v, bool sign =false) Calculate the difference in azimuthal angle between two spatial vectors.
double	deltaR2(const Vector3 & a, const Vector3 & b) Calculate the 2D rapidity-azimuthal (“eta-phi”) distance between two spatial vectors.
double	deltaR(const Vector3 & a, const Vector3 & b) Calculate the 2D rapidity-azimuthal (“eta-phi”) distance between two spatial vectors.
double	deltaR2(const Vector3 & v, double eta2, double phi2) Calculate the 2D rapidity-azimuthal (“eta-phi”) distance between two spatial vectors.
double	deltaR(const Vector3 & v, double eta2, double phi2) Calculate the 2D rapidity-azimuthal (“eta-phi”) distance between two spatial vectors.
double	deltaR2(double eta1, double phi1, const Vector3 & v) Calculate the 2D rapidity-azimuthal (“eta-phi”) distance between two spatial vectors.
double	deltaR(double eta1, double phi1, const Vector3 & v) Calculate the 2D rapidity-azimuthal (“eta-phi”) distance between two spatial vectors.
double	mT(const Vector3 & vis, const Vector3 & invis) Calculate transverse mass of a visible and an invisible 3-vector.
double	contract(const FourVector & a, const FourVector & b) Contract two 4-vectors, with metric signature (+ - - -).
double	dot(const FourVector & a, const FourVector & b) Contract two 4-vectors, with metric signature (+ - - -).
FourVector	multiply(const double a, const FourVector & v)
FourVector	multiply(const FourVector & v, const double a)
FourVector	operator*(const double a, const FourVector & v)
FourVector	operator*(const FourVector & v, const double a)
FourVector	operator/(const FourVector & v, const double a)
FourVector	add(const FourVector & a, const FourVector & b)
FourVector	operator+(const FourVector & a, const FourVector & b)
FourVector	operator-(const FourVector & a, const FourVector & b)
double	invariant(const FourVector & lv)
double	angle(const FourVector & a, const FourVector & b) Angle (in radians) between spatial parts of two Lorentz vectors.
double	angle(const Vector3 & a, const FourVector & b) Angle (in radians) between spatial parts of two Lorentz vectors.
double	angle(const FourVector & a, const Vector3 & b) Angle (in radians) between spatial parts of two Lorentz vectors.
FourMomentum	multiply(const double a, const FourMomentum & v)
FourMomentum	multiply(const FourMomentum & v, const double a)
FourMomentum	operator*(const double a, const FourMomentum & v)
FourMomentum	operator*(const FourMomentum & v, const double a)
FourMomentum	operator/(const FourMomentum & v, const double a)
FourMomentum	add(const FourMomentum & a, const FourMomentum & b)
FourMomentum	operator+(const FourMomentum & a, const FourMomentum & b)
FourMomentum	operator-(const FourMomentum & a, const FourMomentum & b)
double	mT(const FourMomentum & vis, const FourMomentum & invis) Calculate transverse mass of a visible and an invisible 4-vector.
double	mT(const FourMomentum & vis, const Vector3 & invis) Calculate transverse mass of a visible 4-vector and an invisible 3-vector.
double	mT(const Vector3 & vis, const FourMomentum & invis) Calculate transverse mass of a visible 4-vector and an invisible 3-vector.
std::string	toString(const FourVector & lv) Render a 4-vector as a string.
std::ostream &	operator«(std::ostream & out, const FourVector & lv) Write a 4-vector to an ostream.
Particles	operator+(const Particles & a, const Particles & b)
template <class RandomAccessIterator ,class WeightIterator ,class RandomNumberGenerator > void	weighted_shuffle(RandomAccessIterator first, RandomAccessIterator last, WeightIterator fw, WeightIterator lw, RandomNumberGenerator & g)
void	pxcone_(int mode, int ntrak, int itkdm, const double * ptrak, double coner, double epslon, double ovlim, int mxjet, int & njet, double * pjet, int * ipass, int * ijmul, int * ierr)
std::string	version() A function to get the Rivet version string.
bool	compatible(PdgId p, PdgId allowed)
bool	compatible(const PdgIdPair & pair, const PdgIdPair & allowedpair)
bool	compatible(const ParticlePair & ppair, const PdgIdPair & allowedpair) Check particle compatibility of Particle pairs.
bool	compatible(const PdgIdPair & allowedpair, const ParticlePair & ppair) Check particle compatibility of Particle pairs (for symmetric completeness)
bool	compatible(const PdgIdPair & pair, const set< PdgIdPair > & allowedpairs)
set< PdgIdPair >	intersection(const set< PdgIdPair > & a, const set< PdgIdPair > & b) Return the intersection of two sets of {PdgIdPair}s.
template <typename T > Cmp< T >	cmp(const T & t1, const T & t2) Global helper function for easy creation of Cmp objects.
Cmp< Projection >	pcmp(const Projection & p1, const Projection & p2) Global helper function for easy creation of Cmp objects.
Cmp< Projection >	pcmp(const Projection & parent1, const Projection & parent2, const string & pname)
Cmp< Projection >	pcmp(const Projection * parent1, const Projection & parent2, const string & pname)
Cmp< Projection >	pcmp(const Projection & parent1, const Projection * parent2, const string & pname)
Cmp< Projection >	pcmp(const Projection * parent1, const Projection * parent2, const string & pname)
std::ostream &	operator«(std::ostream & os, const Cutflow & cf) Print a Cutflow to a stream.
std::ostream &	operator«(std::ostream & os, const Cutflows & cfs) Print a Cutflows to a stream.
bool	operator==(const Cut & a, const Cut & b) Compare two cuts for equality, forwards to the cut-specific implementation.
double	ELECTRON_RECOEFF_ATLAS_RUN1(const Particle & e)
double	ELECTRON_RECOEFF_ATLAS_RUN2(const Particle & e)
double	ELECTRON_EFF_ATLAS_RUN2_LOOSE(const Particle & e) ATLASRun 2 ’loose’ electron reco+identification efficiency.
double	ELECTRON_EFF_ATLAS_RUN1_MEDIUM(const Particle & e) ATLASRun 1 ‘medium’ electron reco+identification efficiency.
double	ELECTRON_EFF_ATLAS_RUN2_MEDIUM(const Particle & e) ATLASRun 2 ‘medium’ electron reco+identification efficiency.
double	ELECTRON_EFF_ATLAS_RUN1_TIGHT(const Particle & e) ATLASRun 1 ’tight’ electron reco+identification efficiency.
double	ELECTRON_EFF_ATLAS_RUN2_TIGHT(const Particle & e) ATLASRun 2 ’tight’ electron reco+identification efficiency.
Particle	ELECTRON_SMEAR_ATLAS_RUN1(const Particle & e) ATLASRun 1 electron reco smearing.
Particle	ELECTRON_SMEAR_ATLAS_RUN2(const Particle & e)
double	ELECTRON_EFF_CMS_RUN1(const Particle & e) CMS Run 1 electron reconstruction efficiency.
double	ELECTRON_EFF_CMS_RUN2(const Particle & e)
Particle	ELECTRON_SMEAR_CMS_RUN1(const Particle & e) CMS electron energy smearing, preserving direction.
Particle	ELECTRON_SMEAR_CMS_RUN2(const Particle & e)
double	PHOTON_EFF_ATLAS_RUN1(const Particle & y) ATLASRun 2 photon reco efficiency.
double	PHOTON_EFF_ATLAS_RUN2(const Particle & y) ATLASRun 2 photon reco efficiency.
double	PHOTON_EFF_CMS_RUN1(const Particle & y)
double	PHOTON_EFF_CMS_RUN2(const Particle & y)
Particle	PHOTON_SMEAR_ATLAS_RUN1(const Particle & y)
Particle	PHOTON_SMEAR_ATLAS_RUN2(const Particle & y)
Particle	PHOTON_SMEAR_CMS_RUN1(const Particle & y)
Particle	PHOTON_SMEAR_CMS_RUN2(const Particle & y)
double	MUON_EFF_ATLAS_RUN1(const Particle & m) ATLASRun 1 muon reco efficiency.
double	MUON_RECOEFF_ATLAS_RUN2(const Particle & m)
double	MUON_EFF_ATLAS_RUN2(const Particle & m) ATLASRun 2 muon reco+ID efficiency.
Particle	MUON_SMEAR_ATLAS_RUN1(const Particle & m) ATLASRun 1 muon reco smearing.
Particle	MUON_SMEAR_ATLAS_RUN2(const Particle & m)
double	MUON_EFF_CMS_RUN1(const Particle & m) CMS Run 1 muon reco efficiency.
double	MUON_EFF_CMS_RUN2(const Particle & m)
Particle	MUON_SMEAR_CMS_RUN1(const Particle & m) CMS Run 1 muon reco smearing.
Particle	MUON_SMEAR_CMS_RUN2(const Particle & m)
double	TAU_EFF_ATLAS_RUN1(const Particle & t) ATLASRun 1 8 TeV tau efficiencies (medium working point)
double	TAUJET_EFF_ATLAS_RUN1(const Jet & j) ATLASRun 1 8 TeV tau misID rates (medium working point)
double	TAU_EFF_ATLAS_RUN2(const Particle & t) ATLASRun 2 13 TeV tau efficiencies (medium working point)
double	TAUJET_EFF_ATLAS_RUN2(const Jet & j) ATLASRun 2 13 TeV tau misID rate (medium working point)
Particle	TAU_SMEAR_ATLAS_RUN1(const Particle & t)
Particle	TAU_SMEAR_ATLAS_RUN2(const Particle & t)
double	TAU_EFF_CMS_RUN1(const Particle & t)
double	TAU_EFF_CMS_RUN2(const Particle & t)
Particle	TAU_SMEAR_CMS_RUN1(const Particle & t)
Particle	TAU_SMEAR_CMS_RUN2(const Particle & t)
double	JET_BTAG_ATLAS_RUN1(const Jet & j) Return the ATLASRun 1 jet flavour tagging efficiency for the given Jet, from Delphes.
double	JET_BTAG_ATLAS_RUN2_MV2C20(const Jet & j) Return the ATLASRun 2 MC2c20 77% WP jet flavour tagging efficiency for the given Jet.
double	JET_BTAG_ATLAS_RUN2_MV2C10(const Jet & j) Return the ATLASRun 2 MC2c10 77% WP jet flavour tagging efficiency for the given Jet.
Jet	JET_SMEAR_ATLAS_RUN1(const Jet & j) ATLASRun 1 jet smearing.
Jet	JET_SMEAR_ATLAS_RUN2(const Jet & j)
Jet	JET_SMEAR_CMS_RUN1(const Jet & j)
Jet	JET_SMEAR_CMS_RUN2(const Jet & j)
Vector3	MET_SMEAR_IDENTITY(const Vector3 & met, double )
Vector3	MET_SMEAR_ATLAS_RUN1(const Vector3 & met, double set) ATLASRun 1 ETmiss smearing.
Vector3	MET_SMEAR_ATLAS_RUN2(const Vector3 & met, double set)
Vector3	MET_SMEAR_CMS_RUN1(const Vector3 & met, double set)
Vector3	MET_SMEAR_CMS_RUN2(const Vector3 & met, double set)
double	TRK_EFF_ATLAS_RUN1(const Particle & p) ATLASRun 1 tracking efficiency.
double	TRK_EFF_ATLAS_RUN2(const Particle & p)
double	TRK_EFF_CMS_RUN1(const Particle & p) CMS Run 1 tracking efficiency.
double	TRK_EFF_CMS_RUN2(const Particle & p)
PseudoJets	mkPseudoJets(const Particles & ps)
PseudoJets	mkPseudoJets(const Jets & js)
Jets	mkJets(const PseudoJets & pjs)
BoolJetAND	operator&&(const JetSelector & a, const JetSelector & b) Operator syntactic sugar for AND construction.
BoolJetOR	**[operator
BoolJetNOT	operator!(const JetSelector & a) Operator syntactic sugar for NOT construction.
Jets &	ifilter_select(Jets & jets, const Cut & c) Filter a jet collection in-place to the subset that passes the supplied Cut.
Jets &	ifilterBy(Jets & jets, const Cut & c)
Jets &	iselect(Jets & jets, const Cut & c) New alias for ifilter_select.
Jets	filter_select(const Jets & jets, const Cut & c) Filter a jet collection in-place to the subset that passes the supplied Cut.
Jets	filterBy(const Jets & jets, const Cut & c)
Jets	select(const Jets & jets, const Cut & c) New alias for filter_select.
Jets	filter_select(const Jets & jets, const Cut & c, Jets & out) Filter a jet collection in-place to the subset that passes the supplied Cut.
Jets	filterBy(const Jets & jets, const Cut & c, Jets & out)
Jets	select(const Jets & jets, const Cut & c, Jets & out) New alias for filter_select.
Jets &	ifilter_discard(Jets & jets, const Cut & c) Filter a jet collection in-place to the subset that fails the supplied Cut.
Jets &	idiscard(Jets & jets, const Cut & c) New alias for ifilter_discard.
Jets	filter_discard(const Jets & jets, const Cut & c) Filter a jet collection in-place to the subset that fails the supplied Cut.
Jets	discard(const Jets & jets, const Cut & c) New alias for filter_discard.
Jets	filter_discard(const Jets & jets, const Cut & c, Jets & out) Filter a jet collection in-place to the subset that fails the supplied Cut.
Jets	discard(const Jets & jets, const Cut & c, Jets & out) New alias for filter_discard.
std::ostream &	operator«(Log & log, int level) Streaming output to a logger must have a Log::Level/int as its first argument.
double	P3_EFF_ZERO(const Vector3 & p) Take a Vector3 and return 0.
double	P3_FN0(const Vector3 & p)
double	P3_EFF_ONE(const Vector3 & p) Take a Vector3 and return 1.
double	P3_FN1(const Vector3 & p)
Vector3	P3_SMEAR_IDENTITY(const Vector3 & p) Take a Vector3 and return it unmodified.
Vector3	P3_SMEAR_PERFECT(const Vector3 & p) Alias for P3_SMEAR_IDENTITY.
Vector3	P3_SMEAR_LEN_GAUSS(const Vector3 & p, double resolution) Smear a Vector3’s length using a Gaussian of absolute width resolution.
template <typename PBCONTAINER1 ,typename PBCONTAINER2 > void	idiscardIfAny(PBCONTAINER1 & tofilter, const PBCONTAINER2 & tocompare, typename std::function< bool(const typename PBCONTAINER1::value_type &, const typename PBCONTAINER2::value_type &)> fn)
template <typename PBCONTAINER1 ,typename PBCONTAINER2 > PBCONTAINER1	discardIfAny(const PBCONTAINER1 & tofilter, const PBCONTAINER2 & tocompare, typename std::function< bool(const typename PBCONTAINER1::value_type &, const typename PBCONTAINER2::value_type &)> fn)
template <typename PBCONTAINER1 ,typename PBCONTAINER2 > PBCONTAINER1	selectIfAny(const PBCONTAINER1 & tofilter, const PBCONTAINER2 & tocompare, typename std::function< bool(const typename PBCONTAINER1::value_type &, const typename PBCONTAINER2::value_type &)> fn)
template <typename PBCONTAINER1 ,typename PBCONTAINER2 > void	iselectIfAny(PBCONTAINER1 & tofilter, const PBCONTAINER2 & tocompare, typename std::function< bool(const typename PBCONTAINER1::value_type &, const typename PBCONTAINER2::value_type &)> fn)
template <typename PBCONTAINER1 ,typename PBCONTAINER2 > PBCONTAINER1	discardIfAll(const PBCONTAINER1 & tofilter, const PBCONTAINER2 & tocompare, typename std::function< bool(const typename PBCONTAINER1::value_type &, const typename PBCONTAINER2::value_type &)> fn)
template <typename PBCONTAINER1 ,typename PBCONTAINER2 > void	idiscardIfAll(PBCONTAINER1 & tofilter, const PBCONTAINER2 & tocompare, typename std::function< bool(const typename PBCONTAINER1::value_type &, const typename PBCONTAINER2::value_type &)> fn)
template <typename PBCONTAINER1 ,typename PBCONTAINER2 > PBCONTAINER1	selectIfAll(const PBCONTAINER1 & tofilter, const PBCONTAINER2 & tocompare, typename std::function< bool(const typename PBCONTAINER1::value_type &, const typename PBCONTAINER2::value_type &)> fn)
template <typename PBCONTAINER1 ,typename PBCONTAINER2 > void	iselectIfAll(PBCONTAINER1 & tofilter, const PBCONTAINER2 & tocompare, typename std::function< bool(const typename PBCONTAINER1::value_type &, const typename PBCONTAINER2::value_type &)> fn)
template <typename PBCONTAINER1 ,typename PBCONTAINER2 > void	idiscardIfAnyDeltaRLess(PBCONTAINER1 & tofilter, const PBCONTAINER2 & tocompare, double dR)
template <typename PBCONTAINER1 ,typename PBCONTAINER2 > PBCONTAINER1	discardIfAnyDeltaRLess(const PBCONTAINER1 & tofilter, const PBCONTAINER2 & tocompare, double dR)
template <typename PBCONTAINER1 ,typename PBCONTAINER2 > void	idiscardIfAnyDeltaPhiLess(PBCONTAINER1 & tofilter, const PBCONTAINER2 & tocompare, double dphi)
template <typename PBCONTAINER1 ,typename PBCONTAINER2 > PBCONTAINER1	discardIfAnyDeltaPhiLess(const PBCONTAINER1 & tofilter, const PBCONTAINER2 & tocompare, double dphi)
template <typename PBCONTAINER1 ,typename PBCONTAINER2 > PBCONTAINER1	selectIfAnyDeltaRLess(const PBCONTAINER1 & tofilter, const PBCONTAINER2 & tocompare, double dR)
template <typename PBCONTAINER1 ,typename PBCONTAINER2 > void	iselectIfAnyDeltaRLess(PBCONTAINER1 & tofilter, const PBCONTAINER2 & tocompare, double dR)
template <typename PBCONTAINER1 ,typename PBCONTAINER2 > PBCONTAINER1	selectIfAnyDeltaPhiLess(const PBCONTAINER1 & tofilter, const PBCONTAINER2 & tocompare, double dphi)
template <typename PBCONTAINER1 ,typename PBCONTAINER2 > void	iselectIfAnyDeltaPhiLess(PBCONTAINER1 & tofilter, const PBCONTAINER2 & tocompare, double dphi)
int	pid(const Particle & p) Unbound function access to PID code.
int	abspid(const Particle & p) Unbound function access to abs PID code.
bool	isSameSign(const Particle & a, const Particle & b)
bool	isOppSign(const Particle & a, const Particle & b)
bool	isSameFlav(const Particle & a, const Particle & b)
bool	isOppFlav(const Particle & a, const Particle & b)
bool	isOSSF(const Particle & a, const Particle & b)
bool	isSSSF(const Particle & a, const Particle & b)
bool	isOSOF(const Particle & a, const Particle & b)
bool	isSSOF(const Particle & a, const Particle & b)
bool	oppSign(const Particle & a, const Particle & b) Return true if Particles_a_ and b have the opposite charge sign.
bool	sameSign(const Particle & a, const Particle & b)
bool	oppCharge(const Particle & a, const Particle & b)
bool	sameCharge(const Particle & a, const Particle & b)
bool	diffCharge(const Particle & a, const Particle & b) Return true if Particles_a_ and b have a different (not necessarily opposite) charge.
bool	isFirstWith(const Particle & p, const ParticleSelector & f) Determine whether a particle is the first in a decay chain to meet the function requirement.
bool	isFirstWithout(const Particle & p, const ParticleSelector & f) Determine whether a particle is the first in a decay chain not to meet the function requirement.
bool	isLastWith(const Particle & p, const ParticleSelector & f) Determine whether a particle is the last in a decay chain to meet the function requirement.
bool	isLastWithout(const Particle & p, const ParticleSelector & f) Determine whether a particle is the last in a decay chain not to meet the function requirement.
bool	hasAncestorWith(const Particle & p, const ParticleSelector & f, bool only_physical =true) Determine whether a particle has an ancestor which meets the function requirement.
bool	hasAncestorWithout(const Particle & p, const ParticleSelector & f, bool only_physical =true) Determine whether a particle has an ancestor which doesn’t meet the function requirement.
bool	hasParentWith(const Particle & p, const ParticleSelector & f) Determine whether a particle has a parent which meets the function requirement.
bool	hasParentWithout(const Particle & p, const ParticleSelector & f) Determine whether a particle has a parent which doesn’t meet the function requirement.
bool	hasChildWith(const Particle & p, const ParticleSelector & f) Determine whether a particle has a child which meets the function requirement.
bool	hasChildWithout(const Particle & p, const ParticleSelector & f) Determine whether a particle has a child which doesn’t meet the function requirement.
bool	hasDescendantWith(const Particle & p, const ParticleSelector & f, bool remove_duplicates =true) Determine whether a particle has a descendant which meets the function requirement.
bool	hasDescendantWithout(const Particle & p, const ParticleSelector & f, bool remove_duplicates =true) Determine whether a particle has a descendant which doesn’t meet the function requirement.
bool	hasStableDescendantWith(const Particle & p, const ParticleSelector & f) Determine whether a particle has a stable descendant which meets the function requirement.
bool	hasStableDescendantWithout(const Particle & p, const ParticleSelector & f) Determine whether a particle has a stable descendant which doesn’t meet the function requirement.
bool	isVisible(const Particle & p) Is this particle potentially visible in a detector?
bool	isDirect(const Particle & p, bool allow_from_direct_tau =false, bool allow_from_direct_mu =false) Decide if a given particle is direct, via Particle::isDirect()
bool	isPrompt(const Particle & p, bool allow_from_prompt_tau =false, bool allow_from_prompt_mu =false) Decide if a given particle is prompt, via Particle::isPrompt()
bool	isStable(const Particle & p) Decide if a given particle is stable, via Particle::isStable()
bool	hasHadronicDecay(const Particle & p) Decide if a given particle decays hadronically.
bool	hasLeptonicDecay(const Particle & p) Decide if a given particle decays leptonically (decays, and no hadrons)
bool	hasAncestor(const Particle & p, PdgId pid)
bool	fromBottom(const Particle & p) Determine whether the particle is from a b-hadron decay.
bool	fromCharm(const Particle & p) Determine whether the particle is from a c-hadron decay.
bool	fromHadron(const Particle & p) Determine whether the particle is from a hadron decay.
bool	fromTau(const Particle & p, bool prompt_taus_only =false) Determine whether the particle is from a tau decay.
bool	fromPromptTau(const Particle & p) Determine whether the particle is from a prompt tau decay.
BoolParticleAND	operator&&(const ParticleSelector & a, const ParticleSelector & b) Operator syntactic sugar for AND construction.
BoolParticleOR	**[operator
BoolParticleNOT	operator!(const ParticleSelector & a) Operator syntactic sugar for NOT construction.
Particles &	ifilter_select(Particles & particles, const Cut & c) Filter a particle collection in-place to the subset that passes the supplied Cut.
Particles &	ifilterBy(Particles & particles, const Cut & c)
Particles &	iselect(Particles & particles, const Cut & c) New alias for ifilter_select.
Particles	filter_select(const Particles & particles, const Cut & c) Filter a particle collection in-place to the subset that passes the supplied Cut.
Particles	filterBy(const Particles & particles, const Cut & c)
Particles	select(const Particles & particles, const Cut & c) New alias for ifilter_select.
Particles	filter_select(const Particles & particles, const Cut & c, Particles & out) Filter a particle collection in-place to the subset that passes the supplied Cut.
Particles	filterBy(const Particles & particles, const Cut & c, Particles & out)
Particles	select(const Particles & particles, const Cut & c, Particles & out) New alias for ifilter_select.
Particles &	ifilter_discard(Particles & particles, const Cut & c) Filter a particle collection in-place to the subset that fails the supplied Cut.
Particles &	idiscard(Particles & particles, const Cut & c) New alias for ifilter_discard.
Particles	filter_discard(const Particles & particles, const Cut & c) Filter a particle collection in-place to the subset that fails the supplied Cut.
Particles	discard(const Particles & particles, const Cut & c) New alias for filter_discard.
Particles	filter_discard(const Particles & particles, const Cut & c, Particles & out) Filter a particle collection in-place to the subset that fails the supplied Cut.
Particles	discard(const Particles & particles, const Cut & c, Particles & out) New alias for filter_discard.
PdgIdPair	pids(const ParticlePair & pp)
bool	isSame(const Particle & a, const Particle & b) Check Particle equivalence.
std::mt19937 &	rng() Return a thread-safe random number generator (mainly for internal use)
double	rand01() Return a uniformly sampled random number between 0 and 1.
double	randnorm(double loc, double scale) Return a random number sampled from a Gaussian/normal distribution.
double	randlognorm(double loc, double scale) Return a random number sampled from a log-normal distribution.
double	randcrystalball(double alpha, double n, double mu, double sigma) Return a random number sampled from a Crystal Ball distribution.
double	pNorm(double x, double mu, double sigma) Probability density of a Gaussian/normal distribution at x.
double	pCrystalBall(double x, double alpha, double n, double mu, double sigma) Probability density of a Crystal Ball distribution at x.
Vector3	momentum3(const fastjet::PseudoJet & pj) Make a 3-momentum vector from a FastJet pseudojet.
FourMomentum	momentum(const fastjet::PseudoJet & pj) Make a 4-momentum vector from a FastJet pseudojet.
double	mT2Sq(const FourMomentum & a, const FourMomentum & b, const Vector3 & ptmiss, double invisiblesMass, double invisiblesMass2 =-1) Compute asymm mT2**2 using the bisection method.
double	mT2Sq(const FourMomentum & a, const FourMomentum & b, const FourMomentum & ptmiss, double invisiblesMass, double invisiblesMass2 =-1) Override for mT2Sq with FourMomentum ptmiss.
double	mT2(const FourMomentum & a, const FourMomentum & b, const Vector3 & ptmiss, double invisiblesMass, double invisiblesMass2 =-1) Compute asymm mT2 using the bisection method.
double	mT2(const FourMomentum & a, const FourMomentum & b, const FourMomentum & ptmiss, double invisiblesMass, double invisiblesMass2 =-1) Override for mT2 with FourMomentum ptmiss.
bool	fileexists(const std::string & path) Convenience function for determining if a filesystem path exists.
map< string, YODA::AnalysisObjectPtr >	getRefData(const string & papername)
string	getDatafilePath(const string & papername) Get the file system path to the reference file for this paper.
template <typename T > bool	aocopy(YODA::AnalysisObjectPtr src, YODA::AnalysisObjectPtr dst)
template <typename T > bool	aocopy(YODA::AnalysisObjectPtr src, YODA::AnalysisObjectPtr dst, double scale)
template <typename T > bool	aoadd(YODA::AnalysisObjectPtr dst, YODA::AnalysisObjectPtr src, double scale)
bool	copyao(YODA::AnalysisObjectPtr src, YODA::AnalysisObjectPtr dst, double scale =1.0)
bool	addaos(YODA::AnalysisObjectPtr dst, YODA::AnalysisObjectPtr src, double scale)
template <typename TPtr > bool	bookingCompatible(TPtr a, TPtr b)
bool	bookingCompatible(CounterPtr a, CounterPtr b)
bool	bookingCompatible(YODA::CounterPtr a, YODA::CounterPtr b)
template <typename T ,typename U > T	lexical_cast(const U & in) Convert between any types via stringstream.
template <typename T > string	to_str(const T & x) Convert any object to a string.
template <typename T > string	toString(const T & x) Convert any object to a string.
string &	replace_first(string & str, const string & patt, const string & repl) Replace the first instance of patt with repl.
string &	replace_all(string & str, const string & patt, const string & repl) Replace all instances of patt with repl.
int	nocase_cmp(const string & s1, const string & s2) Case-insensitive string comparison function.
bool	nocase_equals(const string & s1, const string & s2) Case-insensitive string equality function.
string	toLower(const string & s) Convert a string to lower-case.
string	toUpper(const string & s) Convert a string to upper-case.
bool	startsWith(const string & s, const string & start) Check whether a string start is found at the start of s.
bool	endsWith(const string & s, const string & end) Check whether a string end is found at the end of s.
string	strcat()
template <typename T ,typename… Ts> string	strcat(T value, Ts… fargs) Make a string containing the concatenated string representations of each item in the variadic list.
template <typename T > string	join(const vector< T > & v, const string & sep =" “) Make a string containing the string representations of each item in v, separated by sep.
string	join(const vector< string > & v, const string & sep) Make a string containing the string representations of each item in v, separated by sep.
template <typename T > string	join(const set< T > & s, const string & sep =” “) Make a string containing the string representations of each item in s, separated by sep.
string	join(const set< string > & s, const string & sep) Make a string containing the string representations of each item in s, separated by sep.
vector< string >	split(const string & s, const string & sep) Split a string on a specified separator string.
string	lpad(const string & s, size_t width, const string & padchar =” “) Left-pad the given string s to width width.
string	rpad(const string & s, size_t width, const string & padchar =” “) Right-pad the given string s to width width.
vector< string >	pathsplit(const string & path) Split a path string with colon delimiters.
string	pathjoin(const vector< string > & paths) Join several filesystem paths together with the standard ‘:’ delimiter.
string	operator/(const string & a, const string & b) Operator for joining strings a and b with filesystem separators.
string	basename(const string & p) Get the basename (i.e. terminal file name) from a path p.
string	dirname(const string & p) Get the dirname (i.e. path to the penultimate directory) from a path p.
string	file_stem(const string & f) Get the stem (i.e. part without a file extension) from a filename f.
string	file_extn(const string & f) Get the file extension from a filename f.
template <typename CONTAINER > unsigned int	count(const CONTAINER & c) Return number of true elements in the container c .
template <typename CONTAINER ,typename FN > unsigned int	count(const CONTAINER & c, const FN & f) Return number of elements in the container c for which `f(x)` is true.
template <typename CONTAINER > bool	any(const CONTAINER & c) Return true if x is true for any x in container c, otherwise false.
template <typename CONTAINER ,typename FN > bool	any(const CONTAINER & c, const FN & f) Return true if f(x) is true for any x in container c, otherwise false.
template <typename CONTAINER > bool	all(const CONTAINER & c) Return true if x is true for all `x` in container c, otherwise false.
template <typename CONTAINER ,typename FN > bool	all(const CONTAINER & c, const FN & f) Return true if f(x) is true for all `x` in container c, otherwise false.
template <typename CONTAINER > bool	none(const CONTAINER & c) Return true if x is false for all `x` in container c, otherwise false.
template <typename CONTAINER ,typename FN > bool	none(const CONTAINER & c, const FN & f) Return true if f(x) is false for all `x` in container c, otherwise false.
template <typename CONTAINER1 ,typename CONTAINER2 ,typename FN > const CONTAINER2 &	transform(const CONTAINER1 & in, CONTAINER2 & out, const FN & f) A single-container-arg version of std::transform, aka `map`.
template <typename CONTAINER1 ,typename T2 > std::vector< T2 >	transform(const CONTAINER1 & in, const std::function< T2(typename CONTAINER1::value_type)> & f)
template <typename CONTAINER1 ,typename T ,typename FN > T	accumulate(const CONTAINER1 & in, const T & init, const FN & f) A single-container-arg version of std::accumulate, aka `reduce`.
template <typename CONTAINER > CONTAINER::value_type	sum(const CONTAINER & c) Generic sum function, adding `x` for all `x` in container c.
template <typename CONTAINER ,typename T > T	sum(const CONTAINER & c, const T & start)
template <typename CONTAINER ,typename FN ,typename T > T	sum(const CONTAINER & c, const FN & f, const T & start =T()) Generic sum function, adding fn(`x`) for all `x` in container c, starting with start.
template <typename CONTAINER ,typename T > T &	isum(const CONTAINER & c, T & out)
template <typename CONTAINER ,typename FN ,typename T > T &	isum(const CONTAINER & c, const FN & f, T & out)
template <typename CONTAINER ,typename FN > CONTAINER &	ifilter_discard(CONTAINER & c, const FN & f)
template <typename CONTAINER ,typename FN > CONTAINER &	idiscard(CONTAINER & c, const FN & f) Alias.
template <typename CONTAINER ,typename FN > CONTAINER	filter_discard(const CONTAINER & c, const FN & f)
template <typename CONTAINER ,typename FN > CONTAINER &	discard(CONTAINER & c, const FN & f) Alias.
template <typename CONTAINER ,typename FN > CONTAINER &	filter_discard(const CONTAINER & c, const FN & f, CONTAINER & out)
template <typename CONTAINER ,typename FN > CONTAINER &	discard(CONTAINER & c, const FN & f, CONTAINER & out) Alias.
template <typename CONTAINER ,typename FN > CONTAINER &	ifilter_select(CONTAINER & c, const FN & f)
template <typename CONTAINER ,typename FN > CONTAINER &	iselect(CONTAINER & c, const FN & f) Alias.
template <typename CONTAINER ,typename FN > CONTAINER	filter_select(const CONTAINER & c, const FN & f)
template <typename CONTAINER ,typename FN > CONTAINER	select(const CONTAINER & c, const FN & f) Alias.
template <typename CONTAINER ,typename FN > CONTAINER &	filter_select(const CONTAINER & c, const FN & f, CONTAINER & out)
template <typename CONTAINER ,typename FN > CONTAINER &	select(CONTAINER & c, const FN & f, CONTAINER & out) Alias.
template <typename CONTAINER > CONTAINER	slice(const CONTAINER & c, int i, int j) Slice of the container elements cf. Python’s [i:j] syntax.
template <typename CONTAINER > CONTAINER	slice(const CONTAINER & c, int i) Tail slice of the container elements cf. Python’s [i:] syntax.
template <typename CONTAINER > CONTAINER	head(const CONTAINER & c, int n) Head slice of the n first container elements.
template <typename CONTAINER > CONTAINER	tail(const CONTAINER & c, int n) Tail slice of the n last container elements.
double	min(const vector< double > & in, double errval =DBL_NAN) Find the minimum value in the vector.
double	max(const vector< double > & in, double errval =DBL_NAN) Find the maximum value in the vector.
pair< double, double >	minmax(const vector< double > & in, double errval =DBL_NAN) Find the minimum and maximum values in the vector.
int	min(const vector< int > & in, int errval =-1) Find the minimum value in the vector.
int	max(const vector< int > & in, int errval =-1) Find the maximum value in the vector.
pair< int, int >	minmax(const vector< int > & in, int errval =-1) Find the minimum and maximum values in the vector.
template <typename T > T	getEnvParam(const std::string name, const T & fallback) Get a parameter from a named environment variable, with automatic type conversion.

Attributes

	Name
constexpr double	pi
constexpr double	twopi
constexpr double	halfpi
constexpr double	pi2
constexpr double	c_light
constexpr double	degree
const double	PI
const double	TWOPI A pre-defined value of ( 2\pi ).
const double	HALFPI A pre-defined value of ( \pi/2 ).
const double	SQRT2 A pre-defined value of ( \sqrt{2} ).
const double	SQRTPI A pre-defined value of ( \sqrt{\pi} ).
const double	INFF Pre-defined values of ( \infty ).
const double	INF
const double	INFL
constexpr double	millimeter
constexpr double	millimeter2
constexpr double	millimeter3
constexpr double	centimeter
constexpr double	centimeter2
constexpr double	centimeter3
constexpr double	meter
constexpr double	meter2
constexpr double	meter3
constexpr double	micrometer
constexpr double	nanometer
constexpr double	angstrom
constexpr double	picometer
constexpr double	femtometer
constexpr double	attometer
constexpr double	fermi
constexpr double	mm
constexpr double	mm2
constexpr double	mm3
constexpr double	cm
constexpr double	cm2
constexpr double	cm3
constexpr double	m
constexpr double	m2
constexpr double	m3
constexpr double	picobarn
constexpr double	barn
constexpr double	millibarn
constexpr double	microbarn
constexpr double	nanobarn
constexpr double	femtobarn
constexpr double	attobarn
constexpr double	nanosecond
constexpr double	second
constexpr double	millisecond
constexpr double	microsecond
constexpr double	picosecond
constexpr double	ns
constexpr double	s
constexpr double	ms
constexpr double	eplus
constexpr double	e_SI
constexpr double	gigaelectronvolt
constexpr double	electronvolt
constexpr double	kiloelectronvolt
constexpr double	megaelectronvolt
constexpr double	teraelectronvolt
constexpr double	petaelectronvolt
constexpr double	eV
constexpr double	keV
constexpr double	MeV
constexpr double	GeV
constexpr double	TeV
constexpr double	PeV
constexpr double	eV2
constexpr double	keV2
constexpr double	MeV2
constexpr double	GeV2
constexpr double	TeV2
constexpr double	PeV2
constexpr double	DBL_NAN Convenient const for getting the double NaN value.

Detailed Description

Todo: BinnedHistogram needs to have a list of interbnal members first which then get booked by the analysis. Booking a temporary, and then adding into BinnedHisto is not possible

Types Documentation

enum RangeBoundary

Enumerator	Value	Description
OPEN	=0
SOFT	=0
CLOSED	=1
HARD	=1

Represents whether an interval is open (non-inclusive) or closed (inclusive).

For example, the interval ( [0, \pi) ) is closed (an inclusive boundary) at 0, and open (a non-inclusive boundary) at ( \pi ).

typedef FourVectors

typedef std::vector<FourVector> Rivet::FourVectors;

Typedefs for lists of vector types

typedef FourMomenta

typedef std::vector<FourMomentum> Rivet::FourMomenta;

typedef JetSmearFn

typedef function<Jet(const Jet&)> Rivet::JetSmearFn;

Typedef for Jet smearing functions/functors.

typedef JetEffFn

typedef function<double(const Jet&)> Rivet::JetEffFn;

Typedef for Jet efficiency functions/functors.

using jetEffFilter

using Rivet::jetEffFilter = typedef JetEffFilter;

typedef P4SmearFn

typedef std::function<FourMomentum(const FourMomentum&)> Rivet::P4SmearFn;

Typedef for FourMomentum smearing functions/functors.

typedef P4EffFn

typedef std::function<double(const FourMomentum&)> Rivet::P4EffFn;

Typedef for FourMomentum efficiency functions/functors.

typedef ParticleSmearFn

typedef function<Particle(const Particle&)> Rivet::ParticleSmearFn;

Typedef for Particle smearing functions/functors.

typedef ParticleEffFn

typedef function<double(const Particle&)> Rivet::ParticleEffFn;

Typedef for Particle efficiency functions/functors.

using particleEffFilter

using Rivet::particleEffFilter = typedef ParticleEffFilter;

typedef strings

typedef vector<std::string> Rivet::strings;

typedef doubles

typedef vector<double> Rivet::doubles;

typedef floats

typedef vector<float> Rivet::floats;

typedef ints

typedef vector<int> Rivet::ints;

enum Sign

Enumerator	Value	Description
MINUS	-1
ZERO	0
PLUS	1

Enum for signs of numbers.

enum RapScheme

Enumerator	Value	Description
PSEUDORAPIDITY	0
ETARAP	0
RAPIDITY	1
YRAP	1

Enum for rapidity variable to be used in calculating ( R ), applying rapidity cuts, etc.

enum PhiMapping

Enumerator	Value	Description
MINUSPI_PLUSPI
ZERO_2PI
ZERO_PI

Enum for range of ( \phi ) to be mapped into.

typedef AnaHandle

typedef std::shared_ptr<Analysis> Rivet::AnaHandle;

typedef Matrix4

typedef Matrix<4> Rivet::Matrix4;

typedef TwoVector

typedef Vector2 Rivet::TwoVector;

typedef V2

typedef Vector2 Rivet::V2;

typedef ThreeVector

typedef Vector3 Rivet::ThreeVector;

typedef V3

typedef Vector3 Rivet::V3;

typedef P3

typedef ThreeMomentum Rivet::P3;

typedef Vector4

typedef FourVector Rivet::Vector4;

typedef V4

typedef FourVector Rivet::V4;

typedef P4

typedef FourMomentum Rivet::P4;

typedef ParticlePair

typedef std::pair<Particle, Particle> Rivet::ParticlePair;

Typedef for a pair of Particle objects.

typedef ProjHandle

typedef std::shared_ptr<const Projection> Rivet::ProjHandle;

Typedef for Projection (smart) pointer.

using DirectFinalState

using Rivet::DirectFinalState = typedef PromptFinalState;

Alias with a more correct name.

typedef MixEvent

typedef pair<Particles, double> Rivet::MixEvent;

typedef MixMap

typedef map<double, std::deque<MixEvent> > Rivet::MixMap;

using IndirectFinalState

using Rivet::IndirectFinalState = typedef NonPromptFinalState;

Alias with a more correct name.

using JetAlg

using Rivet::JetAlg = typedef JetFinder;

Deprecated:

Use the JetFinder name; JetAlg will be removed and used as a jet-measure enum in future

Backward-compatibility typedef

using MissingMom

using Rivet::MissingMom = typedef MissingMomentum;

A slightly more convenient name, following other Rivet shortening-conventions.

using Taus

using Rivet::Taus = typedef TauFinder;

Todo: Make this the canonical name in future

using UnstableFinalState

using Rivet::UnstableFinalState = typedef UnstableParticles;

using PCmp

using Rivet::PCmp = typedef Cmp<Projection>;

Typedef for Cmp

typedef Exception

typedef Error Rivet::Exception;

Rivet::Exception is a synonym for Rivet::Error.

using JetSelector

using Rivet::JetSelector = typedef function<bool(const Jet&)>;

std::function instantiation for functors taking a Jet and returning a bool

using JetSorter

using Rivet::JetSorter = typedef function<bool(const Jet&, const Jet&)>;

std::function instantiation for functors taking two Jets and returning a bool

using hasBTag

using Rivet::hasBTag = typedef HasBTag;

using hasCTag

using Rivet::hasCTag = typedef HasCTag;

using hasTauTag

using Rivet::hasTauTag = typedef HasTauTag;

using hasNoTag

using Rivet::hasNoTag = typedef HasNoTag;

using ParticleBaseSelector

using Rivet::ParticleBaseSelector = typedef function<bool(const ParticleBase&)>;

std::function instantiation for functors taking a ParticleBase and returning a bool

using ParticleBaseSorter

using Rivet::ParticleBaseSorter = typedef function<bool(const ParticleBase&, const ParticleBase&)>;

std::function instantiation for functors taking two ParticleBase and returning a bool

using pTGtr

using Rivet::pTGtr = typedef PtGtr;

using ptGtr

using Rivet::ptGtr = typedef PtGtr;

using pTLess

using Rivet::pTLess = typedef PtLess;

using ptLess

using Rivet::ptLess = typedef PtLess;

using pTInRange

using Rivet::pTInRange = typedef PtInRange;

using ptInRange

using Rivet::ptInRange = typedef PtInRange;

using etaGtr

using Rivet::etaGtr = typedef EtaGtr;

using etaLess

using Rivet::etaLess = typedef EtaLess;

using etaInRange

using Rivet::etaInRange = typedef EtaInRange;

using absEtaGtr

using Rivet::absEtaGtr = typedef AbsEtaGtr;

using absetaGtr

using Rivet::absetaGtr = typedef AbsEtaGtr;

using absEtaLess

using Rivet::absEtaLess = typedef AbsEtaLess;

using absetaLess

using Rivet::absetaLess = typedef AbsEtaLess;

using absEtaInRange

using Rivet::absEtaInRange = typedef AbsEtaInRange;

using absetaInRange

using Rivet::absetaInRange = typedef AbsEtaInRange;

using rapGtr

using Rivet::rapGtr = typedef RapGtr;

using rapLess

using Rivet::rapLess = typedef RapLess;

using rapInRange

using Rivet::rapInRange = typedef RapInRange;

using absRapGtr

using Rivet::absRapGtr = typedef AbsRapGtr;

using absrapGtr

using Rivet::absrapGtr = typedef AbsRapGtr;

using absRapLess

using Rivet::absRapLess = typedef AbsRapLess;

using absrapLess

using Rivet::absrapLess = typedef AbsRapLess;

using absRapInRange

using Rivet::absRapInRange = typedef AbsRapInRange;

using absrapInRange

using Rivet::absrapInRange = typedef AbsRapInRange;

using deltaRGtr

using Rivet::deltaRGtr = typedef DeltaRGtr;

using deltaRLess

using Rivet::deltaRLess = typedef DeltaRLess;

using deltaRInRange

using Rivet::deltaRInRange = typedef DeltaRInRange;

using deltaPhiGtr

using Rivet::deltaPhiGtr = typedef DeltaPhiGtr;

using deltaPhiLess

using Rivet::deltaPhiLess = typedef DeltaPhiLess;

using deltaPhiInRange

using Rivet::deltaPhiInRange = typedef DeltaPhiInRange;

using deltaEtaGtr

using Rivet::deltaEtaGtr = typedef DeltaEtaGtr;

using deltaEtaLess

using Rivet::deltaEtaLess = typedef DeltaEtaLess;

using deltaEtaInRange

using Rivet::deltaEtaInRange = typedef DeltaEtaInRange;

using deltaRapGtr

using Rivet::deltaRapGtr = typedef DeltaRapGtr;

using deltaRapLess

using Rivet::deltaRapLess = typedef DeltaRapLess;

using deltaRapInRange

using Rivet::deltaRapInRange = typedef DeltaRapInRange;

using deltaRWRT

using Rivet::deltaRWRT = typedef DeltaRWRT;

using deltaPhiWRT

using Rivet::deltaPhiWRT = typedef DeltaPhiWRT;

using deltaEtaWRT

using Rivet::deltaEtaWRT = typedef DeltaEtaWRT;

using absDeltaEtaWRT

using Rivet::absDeltaEtaWRT = typedef AbsDeltaEtaWRT;

using deltaRapWRT

using Rivet::deltaRapWRT = typedef DeltaRapWRT;

using absDeltaRapWRT

using Rivet::absDeltaRapWRT = typedef AbsDeltaRapWRT;

using hasPID

using Rivet::hasPID = typedef HasPID;

using hasAbsPID

using Rivet::hasAbsPID = typedef HasAbsPID;

using firstParticleWith

using Rivet::firstParticleWith = typedef FirstParticleWith;

using firstParticleWithout

using Rivet::firstParticleWithout = typedef FirstParticleWithout;

using lastParticleWith

using Rivet::lastParticleWith = typedef LastParticleWith;

using lastParticleWithout

using Rivet::lastParticleWithout = typedef LastParticleWithout;

using hasParticleAncestorWith

using Rivet::hasParticleAncestorWith = typedef HasParticleAncestorWith;

using hasParticleAncestorWithout

using Rivet::hasParticleAncestorWithout = typedef HasParticleAncestorWithout;

using hasParticleParentWith

using Rivet::hasParticleParentWith = typedef HasParticleParentWith;

using hasParticleParentWithout

using Rivet::hasParticleParentWithout = typedef HasParticleParentWithout;

using hasParticleChildWith

using Rivet::hasParticleChildWith = typedef HasParticleChildWith;

using hasParticleChildWithout

using Rivet::hasParticleChildWithout = typedef HasParticleChildWithout;

using hasParticleDescendantWith

using Rivet::hasParticleDescendantWith = typedef HasParticleDescendantWith;

using hasParticleDescendantWithout

using Rivet::hasParticleDescendantWithout = typedef HasParticleDescendantWithout;

typedef PseudoJets

typedef std::vector<PseudoJet> Rivet::PseudoJets;

Todo: Make into an explicit container with conversion to Jets and FourMomenta?

Typedef for a collection of PseudoJet objects.

typedef ConstGenParticlePtr

typedef const HepMC::GenParticle* Rivet::ConstGenParticlePtr;

typedef ConstGenVertexPtr

typedef const HepMC::GenVertex* Rivet::ConstGenVertexPtr;

typedef ConstGenHeavyIonPtr

typedef const HepMC::HeavyIon* Rivet::ConstGenHeavyIonPtr;

using HepMC_IO_type

using Rivet::HepMC_IO_type = typedef HepMC::IO_GenEvent;

using PdfInfo

using Rivet::PdfInfo = typedef RivetHepMC::PdfInfo;

using ConstGenEventPtr

using Rivet::ConstGenEventPtr = typedef std::shared_ptr<const GenEvent>;

using Weight

using Rivet::Weight = typedef double;

Typedef for weights.

using Fill

template <class T >
using Rivet::Fill = typedef pair<typename T::FillType, Weight>;

A single fill is a (FillType, Weight) pair.

using Fills

template <class T >
using Rivet::Fills = typedef multiset<Fill<T> >;

Todo: Why a set rather than a vector? Efficiency???

A set of several fill objects.

using MultiweightAOPtr

using Rivet::MultiweightAOPtr = typedef rivet_shared_ptr<MultiweightAOWrapper>;

using Histo1DPtr

using Rivet::Histo1DPtr = typedef rivet_shared_ptr<Wrapper<YODA::Histo1D> >;

using Histo2DPtr

using Rivet::Histo2DPtr = typedef rivet_shared_ptr<Wrapper<YODA::Histo2D> >;

using Profile1DPtr

using Rivet::Profile1DPtr = typedef rivet_shared_ptr<Wrapper<YODA::Profile1D> >;

using Profile2DPtr

using Rivet::Profile2DPtr = typedef rivet_shared_ptr<Wrapper<YODA::Profile2D> >;

using CounterPtr

using Rivet::CounterPtr = typedef rivet_shared_ptr<Wrapper<YODA::Counter> >;

using Scatter1DPtr

using Rivet::Scatter1DPtr = typedef rivet_shared_ptr<Wrapper<YODA::Scatter1D> >;

using Scatter2DPtr

using Rivet::Scatter2DPtr = typedef rivet_shared_ptr<Wrapper<YODA::Scatter2D> >;

using Scatter3DPtr

using Rivet::Scatter3DPtr = typedef rivet_shared_ptr<Wrapper<YODA::Scatter3D> >;

Functions Documentation

function inRange

template <typename N1 ,
typename N2 ,
typename N3 >
inline std::enable_if< std::is_arithmetic< N1 >::value &&std::is_arithmetic< N2 >::value &&std::is_arithmetic< N3 >::value, bool >::type inRange(
    N1 value,
    N2 low,
    N3 high,
    RangeBoundary lowbound =CLOSED,
    RangeBoundary highbound =OPEN
)

Determine if value is in the range low to high, for floating point numbers.

Interval boundary types are defined by lowbound and highbound.

function fuzzyInRange

template <typename N1 ,
typename N2 ,
typename N3 >
inline std::enable_if< std::is_arithmetic< N1 >::value &&std::is_arithmetic< N2 >::value &&std::is_arithmetic< N3 >::value, bool >::type fuzzyInRange(
    N1 value,
    N2 low,
    N3 high,
    RangeBoundary lowbound =CLOSED,
    RangeBoundary highbound =OPEN
)

Determine if value is in the range low to high, for floating point numbers.

Interval boundary types are defined by lowbound and highbound. Closed intervals are compared fuzzily.

function inRange

template <typename N1 ,
typename N2 ,
typename N3 >
inline std::enable_if< std::is_arithmetic< N1 >::value &&std::is_arithmetic< N2 >::value &&std::is_arithmetic< N3 >::value, bool >::type inRange(
    N1 value,
    pair< N2, N3 > lowhigh,
    RangeBoundary lowbound =CLOSED,
    RangeBoundary highbound =OPEN
)

Alternative version of inRange which accepts a pair for the range arguments.

function in_range

template <typename N1 ,
typename N2 ,
typename N3 >
inline std::enable_if< std::is_arithmetic< N1 >::value &&std::is_arithmetic< N2 >::value &&std::is_arithmetic< N3 >::value, bool >::type in_range(
    N1 val,
    N2 low,
    N3 high
)

Boolean function to determine if value is within the given range.

Note: The interval is closed (inclusive) at the low end, and open (exclusive) at the high end.

function in_closed_range

template <typename N1 ,
typename N2 ,
typename N3 >
inline std::enable_if< std::is_arithmetic< N1 >::value &&std::is_arithmetic< N2 >::value &&std::is_arithmetic< N3 >::value, bool >::type in_closed_range(
    N1 val,
    N2 low,
    N3 high
)

Boolean function to determine if value is within the given range.

Note: The interval is closed at both ends.

function in_open_range

template <typename N1 ,
typename N2 ,
typename N3 >
inline std::enable_if< std::is_arithmetic< N1 >::value &&std::is_arithmetic< N2 >::value &&std::is_arithmetic< N3 >::value, bool >::type in_open_range(
    N1 val,
    N2 low,
    N3 high
)

Boolean function to determine if value is within the given range.

Note: The interval is open at both ends.

function JET_EFF_ZERO

inline double JET_EFF_ZERO(
    const Jet & p
)

Take a jet and return a constant 0.

function JET_EFF_0

inline double JET_EFF_0(
    const Jet & p
)

Alias for JET_EFF_ZERO.

function JET_FN0

inline double JET_FN0(
    const Jet & p
)

Alias for JET_EFF_ZERO.

function JET_EFF_ONE

inline double JET_EFF_ONE(
    const Jet & p
)

Take a jet and return a constant 1.

function JET_EFF_1

inline double JET_EFF_1(
    const Jet & p
)

Alias for JET_EFF_ONE.

function JET_EFF_PERFECT

inline double JET_EFF_PERFECT(
    const Jet & 
)

Alias for JET_EFF_ONE.

function JET_FN1

inline double JET_FN1(
    const Jet & 
)

Alias for JET_EFF_ONE.

function JET_BTAG_PERFECT

inline double JET_BTAG_PERFECT(
    const Jet & j
)

Return 1 if the given Jet contains a b, otherwise 0.

Todo: Need to be able to pass a tag pT threshold? -> functor struct

function JET_CTAG_PERFECT

inline double JET_CTAG_PERFECT(
    const Jet & j
)

Return 1 if the given Jet contains a c, otherwise 0.

Todo: Need to be able to pass a tag pT threshold? -> functor struct

function JET_TAUTAG_PERFECT

inline double JET_TAUTAG_PERFECT(
    const Jet & j
)

Return 1 if the given Jet contains a c, otherwise 0.

Todo: Need to be able to pass a tag pT threshold? -> functor struct

function JET_SMEAR_IDENTITY

inline Jet JET_SMEAR_IDENTITY(
    const Jet & j
)

Todo: Modify constituent particle vectors for consistency

Set a null PseudoJet if the Jet is smeared?

Take a jet and return an unmodified copy

function JET_SMEAR_PERFECT

inline Jet JET_SMEAR_PERFECT(
    const Jet & j
)

Alias for JET_SMEAR_IDENTITY.

function efffilt

template <typename FN >
inline bool efffilt(
    const Jet & j,
    FN & feff
)

Return true if Jet_j_ is chosen to survive a random efficiency selection.

function P4_EFF_ZERO

inline double P4_EFF_ZERO(
    const FourMomentum & 
)

Take a FourMomentum and return 0.

function P4_FN0

inline double P4_FN0(
    const FourMomentum & 
)

Deprecated:

Alias for P4_EFF_ZERO

function P4_EFF_ONE

inline double P4_EFF_ONE(
    const FourMomentum & 
)

Take a FourMomentum and return 1.

function P4_FN1

inline double P4_FN1(
    const FourMomentum & 
)

Deprecated:

Alias for P4_EFF_ONE

function P4_SMEAR_IDENTITY

inline FourMomentum P4_SMEAR_IDENTITY(
    const FourMomentum & p
)

Take a FourMomentum and return it unmodified.

function P4_SMEAR_PERFECT

inline FourMomentum P4_SMEAR_PERFECT(
    const FourMomentum & p
)

Alias for P4_SMEAR_IDENTITY.

function P4_SMEAR_E_GAUSS

inline FourMomentum P4_SMEAR_E_GAUSS(
    const FourMomentum & p,
    double resolution
)

Todo: Also make jet versions that update/smear constituents?

Smear a FourMomentum’s energy using a Gaussian of absolute width resolution

function P4_SMEAR_PT_GAUSS

inline FourMomentum P4_SMEAR_PT_GAUSS(
    const FourMomentum & p,
    double resolution
)

Smear a FourMomentum’s transverse momentum using a Gaussian of absolute width resolution.

function P4_SMEAR_MASS_GAUSS

inline FourMomentum P4_SMEAR_MASS_GAUSS(
    const FourMomentum & p,
    double resolution
)

Smear a FourMomentum’s mass using a Gaussian of absolute width resolution.

function PARTICLE_EFF_ZERO

inline double PARTICLE_EFF_ZERO(
    const Particle & 
)

Take a Particle and return 0.

function PARTICLE_EFF_0

inline double PARTICLE_EFF_0(
    const Particle & 
)

Alias for PARTICLE_EFF_ZERO.

function PARTICLE_FN0

inline double PARTICLE_FN0(
    const Particle & 
)

Alias for PARTICLE_EFF_ZERO.

function PARTICLE_EFF_ONE

inline double PARTICLE_EFF_ONE(
    const Particle & 
)

Take a Particle and return 1.

function PARTICLE_EFF_1

inline double PARTICLE_EFF_1(
    const Particle & 
)

Alias for PARTICLE_EFF_ONE.

function PARTICLE_EFF_PERFECT

inline double PARTICLE_EFF_PERFECT(
    const Particle & 
)

Alias for PARTICLE_EFF_ONE.

function PARTICLE_FN1

inline double PARTICLE_FN1(
    const Particle & 
)

Alias for PARTICLE_EFF_ONE.

function PARTICLE_SMEAR_IDENTITY

inline Particle PARTICLE_SMEAR_IDENTITY(
    const Particle & p
)

Take a Particle and return it unmodified.

function PARTICLE_SMEAR_PERFECT

inline Particle PARTICLE_SMEAR_PERFECT(
    const Particle & p
)

Alias for PARTICLE_SMEAR_IDENTITY.

function efffilt

inline bool efffilt(
    const Particle & p,
    const ParticleEffFn & feff
)

Return true if Particle_p_ is chosen to survive a random efficiency selection.

function operator«

std::ostream & operator<<(
    std::ostream & os,
    const Jet & j
)

Allow a Jet to be passed to an ostream.

function operator«

std::ostream & operator<<(
    std::ostream & os,
    const Particle & p
)

Allow a Particle to be passed to an ostream.

function operator«

std::ostream & operator<<(
    std::ostream & os,
    const ParticlePair & pp
)

Allow ParticlePair to be passed to an ostream.

function isZero

template <typename NUM >
inline std::enable_if< std::is_floating_point< NUM >::value, bool >::type isZero(
    NUM val,
    double tolerance =1e-8
)

Compare a number to zero.

This version for floating point types has a degree of fuzziness expressed by the absolute tolerance parameter, for floating point safety.

function isZero

template <typename NUM >
inline std::enable_if< std::is_integral< NUM >::value, bool >::type isZero(
    NUM val,
    double  =1e-5
)

Compare a number to zero.

SFINAE template specialisation for integers, since there is no FP precision issue.

function isNaN

template <typename NUM >
inline std::enable_if< std::is_floating_point< NUM >::value, bool >::type isNaN(
    NUM val
)

Check if a number is NaN.

function notNaN

template <typename NUM >
inline std::enable_if< std::is_floating_point< NUM >::value, bool >::type notNaN(
    NUM val
)

Check if a number is non-NaN.

function fuzzyEquals

template <typename N1 ,
typename N2 >
inline std::enable_if< std::is_arithmetic< N1 >::value &&std::is_arithmetic< N2 >::value &&(std::is_floating_point< N1 >::value||std::is_floating_point< N2 >::value), bool >::type fuzzyEquals(
    N1 a,
    N2 b,
    double tolerance =1e-5
)

Compare two numbers for equality with a degree of fuzziness.

This version for floating point types (if any argument is FP) has a degree of fuzziness expressed by the fractional tolerance parameter, for floating point safety.

function fuzzyEquals

template <typename N1 ,
typename N2 >
inline std::enable_if< std::is_integral< N1 >::value &&std::is_integral< N2 >::value, bool >::type fuzzyEquals(
    N1 a,
    N2 b,
    double 
)

Compare two numbers for equality with a degree of fuzziness.

Simpler SFINAE template specialisation for integers, since there is no FP precision issue.

function fuzzyGtrEquals

template <typename N1 ,
typename N2 >
inline std::enable_if< std::is_arithmetic< N1 >::value &&std::is_arithmetic< N2 >::value, bool >::type fuzzyGtrEquals(
    N1 a,
    N2 b,
    double tolerance =1e-5
)

Compare two numbers for >= with a degree of fuzziness.

The tolerance parameter on the equality test is as for fuzzyEquals.

function fuzzyLessEquals

template <typename N1 ,
typename N2 >
inline std::enable_if< std::is_arithmetic< N1 >::value &&std::is_arithmetic< N2 >::value, bool >::type fuzzyLessEquals(
    N1 a,
    N2 b,
    double tolerance =1e-5
)

Compare two floating point numbers for <= with a degree of fuzziness.

The tolerance parameter on the equality test is as for fuzzyEquals.

function min

template <typename N1 ,
typename N2 >
inline std::enable_if< std::is_arithmetic< N1 >::value &&std::is_arithmetic< N2 >::value, typenamestd::common_type< N1, N2 >::type >::type min(
    N1 a,
    N2 b
)

Get the minimum of two numbers.

function max

template <typename N1 ,
typename N2 >
inline std::enable_if< std::is_arithmetic< N1 >::value &&std::is_arithmetic< N2 >::value, typenamestd::common_type< N1, N2 >::type >::type max(
    N1 a,
    N2 b
)

Get the maximum of two numbers.

function sqr

template <typename NUM >
inline std::enable_if< std::is_arithmetic< NUM >::value, NUM >::type sqr(
    NUM a
)

Named number-type squaring operation.

function add_quad

template <typename NUM >
inline std::enable_if< std::is_arithmetic< NUM >::value, NUM >::type add_quad(
    NUM a,
    NUM b
)

Named number-type addition in quadrature operation.

Note: Result has the sqrt operation applied.

Todo: When std::common_type can be used, generalise to multiple numeric types with appropriate return type.

function add_quad

template <typename NUM >
inline std::enable_if< std::is_arithmetic< NUM >::value, NUM >::type add_quad(
    NUM a,
    NUM b,
    NUM c
)

Note: Result has the sqrt operation applied.

Todo: When std::common_type can be used, generalise to multiple numeric types with appropriate return type.

Named number-type addition in quadrature operation.

function safediv

inline double safediv(
    double num,
    double den,
    double fail =0.0
)

Todo: When std::common_type can be used, generalise to multiple numeric types with appropriate return type.

Return a/b, or fail if b = 0

function intpow

template <typename NUM >
inline std::enable_if< std::is_arithmetic< NUM >::value, NUM >::type intpow(
    NUM val,
    unsigned int exp
)

A more efficient version of pow for raising numbers to integer powers.

function sign

template <typename NUM >
inline std::enable_if< std::is_arithmetic< NUM >::value, int >::type sign(
    NUM val
)

Find the sign of a number.

function cdfBW

inline double cdfBW(
    double x,
    double mu,
    double gamma
)

CDF for the Breit-Wigner distribution.

function invcdfBW

inline double invcdfBW(
    double p,
    double mu,
    double gamma
)

Inverse CDF for the Breit-Wigner distribution.

function linspace

inline vector< double > linspace(
    size_t nbins,
    double start,
    double end,
    bool include_end =true
)

Make a list of nbins + 1 values equally spaced between start and end inclusive.

Note: The arg ordering and the meaning of the nbins variable is “histogram-like”, as opposed to the Numpy/Matlab version.

Todo: Import the YODA version rather than maintain this parallel version?

function aspace

inline vector< double > aspace(
    double step,
    double start,
    double end,
    bool include_end =true,
    double tol =1e-2
)

Make a list of values equally spaced by step between start and end inclusive.

Note: The arg ordering is “Rivet-like”, cf. linspace() and logspace(), as opposed to the Numpy/Matlab arange() function (whose name inspired this, but we preferred to keep the “space” nomenclature for consistence.)

The values will start at start and be equally spaced up to the highest increment less than or equal to end. If include_end is given, the end value will be appended if distinct by tol times step.

function logspace

inline vector< double > logspace(
    size_t nbins,
    double start,
    double end,
    bool include_end =true
)

Make a list of nbins + 1 values exponentially spaced between start and end inclusive.

Note: The arg ordering and the meaning of the nbins variable is “histogram-like”, as opposed to the Numpy/Matlab version, and the start and end arguments are expressed in “normal” space, rather than as the logarithms of the start/end values as in Numpy/Matlab.

Todo: Import the YODA version rather than maintain this parallel version?

function bwspace

inline vector< double > bwspace(
    size_t nbins,
    double start,
    double end,
    double mu,
    double gamma
)

Make a list of nbins + 1 values spaced for equal area Breit-Wigner binning between start and end inclusive. mu and gamma are the Breit-Wigner parameters.

Note: The arg ordering and the meaning of the nbins variable is “histogram-like”, as opposed to the Numpy/Matlab version, and the start and end arguments are expressed in “normal” space.

Todo: pdfspace()… from YODA?

function binIndex

template <typename NUM1 ,
typename NUM2 >
inline std::enable_if< std::is_arithmetic< NUM1 >::value &&std::is_arithmetic< NUM2 >::value, int >::type binIndex(
    NUM1 val,
    std::initializer_list< NUM2 > binedges,
    bool allow_overflow =false
)

Return the bin index of the given value, val, given a vector of bin edges.

Note: The binedges vector must be sorted

Todo: Use std::common_type<NUM1, NUM2>::type x = val; ?

An underflow always returns -1. If allow_overflow is false (default) an overflow also returns -1, otherwise it returns the Nedge-1, the index of an inclusive bin starting at the last edge.

function binIndex

template <typename NUM ,
typename CONTAINER >
inline std::enable_if< std::is_arithmetic< NUM >::value &&std::is_arithmetic< typenameCONTAINER::value_type >::value, int >::type binIndex(
    NUM val,
    const CONTAINER & binedges,
    bool allow_overflow =false
)

Return the bin index of the given value, val, given a vector of bin edges.

Note: The binedges vector must be sorted

Todo: Use std::common_type<NUM1, NUM2>::type x = val; ?

An underflow always returns -1. If allow_overflow is false (default) an overflow also returns -1, otherwise it returns the Nedge-1, the index of an inclusive bin starting at the last edge.

function median

template <typename NUM >
inline std::enable_if< std::is_arithmetic< NUM >::value, NUM >::type median(
    const vector< NUM > & sample
)

Todo: Support multiple container types via SFINAE

Calculate the median of a sample

function mean

template <typename NUM >
inline std::enable_if< std::is_arithmetic< NUM >::value, double >::type mean(
    const vector< NUM > & sample
)

Todo: Support multiple container types via SFINAE

Calculate the mean of a sample

function mean_err

template <typename NUM >
inline std::enable_if< std::is_arithmetic< NUM >::value, double >::type mean_err(
    const vector< NUM > & sample
)

Todo: Support multiple container types via SFINAE

function covariance

template <typename NUM >
inline std::enable_if< std::is_arithmetic< NUM >::value, double >::type covariance(
    const vector< NUM > & sample1,
    const vector< NUM > & sample2
)

Todo: Support multiple container types via SFINAE

Calculate the covariance (variance) between two samples

function covariance_err

template <typename NUM >
inline std::enable_if< std::is_arithmetic< NUM >::value, double >::type covariance_err(
    const vector< NUM > & sample1,
    const vector< NUM > & sample2
)

Todo: Support multiple container types via SFINAE

Calculate the error on the covariance (variance) of two samples, assuming poissonian errors

function correlation

template <typename NUM >
inline std::enable_if< std::is_arithmetic< NUM >::value, double >::type correlation(
    const vector< NUM > & sample1,
    const vector< NUM > & sample2
)

Todo: Support multiple container types via SFINAE

Calculate the correlation strength between two samples

function correlation_err

template <typename NUM >
inline std::enable_if< std::is_arithmetic< NUM >::value, double >::type correlation_err(
    const vector< NUM > & sample1,
    const vector< NUM > & sample2
)

Todo: Support multiple container types via SFINAE

Calculate the error of the correlation strength between two samples assuming Poissonian errors

function mapAngleMPiToPi

inline double mapAngleMPiToPi(
    double angle
)

Map an angle into the range (-PI, PI].

function mapAngle0To2Pi

inline double mapAngle0To2Pi(
    double angle
)

Map an angle into the range [0, 2PI).

function mapAngle0ToPi

inline double mapAngle0ToPi(
    double angle
)

Map an angle into the range [0, PI].

function mapAngle

inline double mapAngle(
    double angle,
    PhiMapping mapping
)

Map an angle into the enum-specified range.

function deltaPhi

inline double deltaPhi(
    double phi1,
    double phi2,
    bool sign =false
)

Calculate the difference between two angles in radians.

Returns in the range [0, PI].

function deltaEta

inline double deltaEta(
    double eta1,
    double eta2,
    bool sign =false
)

Note: Just a cosmetic name for analysis code clarity.

Calculate the abs difference between two pseudorapidities

function deltaRap

inline double deltaRap(
    double y1,
    double y2,
    bool sign =false
)

Note: Just a cosmetic name for analysis code clarity.

Calculate the abs difference between two rapidities

function deltaR2

inline double deltaR2(
    double rap1,
    double phi1,
    double rap2,
    double phi2
)

Calculate the squared distance between two points in 2D rapidity-azimuthal ("\f$ \eta-\phi \f$”) space. The phi values are given in radians.

function deltaR

inline double deltaR(
    double rap1,
    double phi1,
    double rap2,
    double phi2
)

Calculate the distance between two points in 2D rapidity-azimuthal ("\f$ \eta-\phi \f$") space. The phi values are given in radians.

function rapidity

inline double rapidity(
    double E,
    double pz
)

Calculate a rapidity value from the supplied energy E and longitudinal momentum pz.

function mT

inline double mT(
    double pT1,
    double pT2,
    double dphi
)

Note: Several versions taking two vectors are found in Vector4.hh

Calculate transverse mass of two vectors from provided pT and deltaPhi

function deltaR2

inline double deltaR2(
    const FourVector & a,
    const FourVector & b,
    RapScheme scheme =PSEUDORAPIDITY
)

Calculate the squared 2D rapidity-azimuthal (“eta-phi”) distance between two four-vectors.

There is a scheme ambiguity for momentum-type four vectors as to whether the pseudorapidity (a purely geometric concept) or the rapidity (a relativistic energy-momentum quantity) is to be used: this can be chosen via the optional scheme parameter. Use of this scheme option is discouraged in this case since RAPIDITY is only a valid option for vectors whose type is really the FourMomentum derived class.

function deltaR

inline double deltaR(
    const FourVector & a,
    const FourVector & b,
    RapScheme scheme =PSEUDORAPIDITY
)

Calculate the 2D rapidity-azimuthal (“eta-phi”) distance between two four-vectors.

function deltaR2

inline double deltaR2(
    const FourVector & v,
    double eta2,
    double phi2,
    RapScheme scheme =PSEUDORAPIDITY
)

Calculate the squared 2D rapidity-azimuthal (“eta-phi”) distance between two four-vectors.

function deltaR

inline double deltaR(
    const FourVector & v,
    double eta2,
    double phi2,
    RapScheme scheme =PSEUDORAPIDITY
)

Calculate the 2D rapidity-azimuthal (“eta-phi”) distance between two four-vectors.

function deltaR2

inline double deltaR2(
    double eta1,
    double phi1,
    const FourVector & v,
    RapScheme scheme =PSEUDORAPIDITY
)

Calculate the squared 2D rapidity-azimuthal (“eta-phi”) distance between two four-vectors.

function deltaR

inline double deltaR(
    double eta1,
    double phi1,
    const FourVector & v,
    RapScheme scheme =PSEUDORAPIDITY
)

Calculate the 2D rapidity-azimuthal (“eta-phi”) distance between two four-vectors.

function deltaR2

inline double deltaR2(
    const FourMomentum & a,
    const FourMomentum & b,
    RapScheme scheme =PSEUDORAPIDITY
)

Calculate the squared 2D rapidity-azimuthal (“eta-phi”) distance between two four-vectors.

function deltaR

inline double deltaR(
    const FourMomentum & a,
    const FourMomentum & b,
    RapScheme scheme =PSEUDORAPIDITY
)

Calculate the 2D rapidity-azimuthal (“eta-phi”) distance between two four-vectors.

function deltaR2

inline double deltaR2(
    const FourMomentum & v,
    double eta2,
    double phi2,
    RapScheme scheme =PSEUDORAPIDITY
)

Calculate the squared 2D rapidity-azimuthal (“eta-phi”) distance between two four-vectors. There is a scheme ambiguity for momentum-type four vectors as to whether the pseudorapidity (a purely geometric concept) or the rapidity (a relativistic energy-momentum quantity) is to be used: this can be chosen via the optional scheme parameter.

function deltaR

inline double deltaR(
    const FourMomentum & v,
    double eta2,
    double phi2,
    RapScheme scheme =PSEUDORAPIDITY
)

Calculate the 2D rapidity-azimuthal (“eta-phi”) distance between two four-vectors. There is a scheme ambiguity for momentum-type four vectors as to whether the pseudorapidity (a purely geometric concept) or the rapidity (a relativistic energy-momentum quantity) is to be used: this can be chosen via the optional scheme parameter.

function deltaR2

inline double deltaR2(
    double eta1,
    double phi1,
    const FourMomentum & v,
    RapScheme scheme =PSEUDORAPIDITY
)

function deltaR

inline double deltaR(
    double eta1,
    double phi1,
    const FourMomentum & v,
    RapScheme scheme =PSEUDORAPIDITY
)

function deltaR2

inline double deltaR2(
    const FourMomentum & a,
    const FourVector & b,
    RapScheme scheme =PSEUDORAPIDITY
)

function deltaR

inline double deltaR(
    const FourMomentum & a,
    const FourVector & b,
    RapScheme scheme =PSEUDORAPIDITY
)

function deltaR2

inline double deltaR2(
    const FourVector & a,
    const FourMomentum & b,
    RapScheme scheme =PSEUDORAPIDITY
)

function deltaR

inline double deltaR(
    const FourVector & a,
    const FourMomentum & b,
    RapScheme scheme =PSEUDORAPIDITY
)

function deltaR2

inline double deltaR2(
    const FourMomentum & a,
    const Vector3 & b
)

Calculate the 2D rapidity-azimuthal (“eta-phi”) distance between a three-vector and a four-vector.

function deltaR

inline double deltaR(
    const FourMomentum & a,
    const Vector3 & b
)

Calculate the 2D rapidity-azimuthal (“eta-phi”) distance between a three-vector and a four-vector.

function deltaR2

inline double deltaR2(
    const Vector3 & a,
    const FourMomentum & b
)

Calculate the 2D rapidity-azimuthal (“eta-phi”) distance between a three-vector and a four-vector.

function deltaR

inline double deltaR(
    const Vector3 & a,
    const FourMomentum & b
)

Calculate the 2D rapidity-azimuthal (“eta-phi”) distance between a three-vector and a four-vector.

function deltaR2

inline double deltaR2(
    const FourVector & a,
    const Vector3 & b
)

Calculate the 2D rapidity-azimuthal (“eta-phi”) distance between a three-vector and a four-vector.

function deltaR

inline double deltaR(
    const FourVector & a,
    const Vector3 & b
)

Calculate the 2D rapidity-azimuthal (“eta-phi”) distance between a three-vector and a four-vector.

function deltaR2

inline double deltaR2(
    const Vector3 & a,
    const FourVector & b
)

Calculate the 2D rapidity-azimuthal (“eta-phi”) distance between a three-vector and a four-vector.

function deltaR

inline double deltaR(
    const Vector3 & a,
    const FourVector & b
)

Calculate the 2D rapidity-azimuthal (“eta-phi”) distance between a three-vector and a four-vector.

function deltaPhi

inline double deltaPhi(
    const FourMomentum & a,
    const FourMomentum & b,
    bool sign =false
)

Calculate the difference in azimuthal angle between two vectors.

function deltaPhi

inline double deltaPhi(
    const FourMomentum & v,
    double phi2,
    bool sign =false
)

Calculate the difference in azimuthal angle between two vectors.

function deltaPhi

inline double deltaPhi(
    double phi1,
    const FourMomentum & v,
    bool sign =false
)

Calculate the difference in azimuthal angle between two vectors.

function deltaPhi

inline double deltaPhi(
    const FourVector & a,
    const FourVector & b,
    bool sign =false
)

Calculate the difference in azimuthal angle between two vectors.

function deltaPhi

inline double deltaPhi(
    const FourVector & v,
    double phi2,
    bool sign =false
)

Calculate the difference in azimuthal angle between two vectors.

function deltaPhi

inline double deltaPhi(
    double phi1,
    const FourVector & v,
    bool sign =false
)

Calculate the difference in azimuthal angle between two vectors.

function deltaPhi

inline double deltaPhi(
    const FourVector & a,
    const FourMomentum & b,
    bool sign =false
)

Calculate the difference in azimuthal angle between two vectors.

function deltaPhi

inline double deltaPhi(
    const FourMomentum & a,
    const FourVector & b,
    bool sign =false
)

Calculate the difference in azimuthal angle between two vectors.

function deltaPhi

inline double deltaPhi(
    const FourVector & a,
    const Vector3 & b,
    bool sign =false
)

Calculate the difference in azimuthal angle between two vectors.

function deltaPhi

inline double deltaPhi(
    const Vector3 & a,
    const FourVector & b,
    bool sign =false
)

Calculate the difference in azimuthal angle between two vectors.

function deltaPhi

inline double deltaPhi(
    const FourMomentum & a,
    const Vector3 & b,
    bool sign =false
)

Calculate the difference in azimuthal angle between two vectors.

function deltaPhi

inline double deltaPhi(
    const Vector3 & a,
    const FourMomentum & b,
    bool sign =false
)

Calculate the difference in azimuthal angle between two vectors.