Sphericity Class Reference

#include <Sphericity.hh>

Inheritance diagram for Sphericity:

Inheritance graph
[legend]

Collaboration diagram for Sphericity:

Collaboration graph
[legend]

List of all members.

Detailed Description

Calculate the sphericity event shape.

The sphericity tensor (or quadratic momentum tensor) is defined as

\[ S^{\alpha \beta} = \frac{\sum_i p_i^\alpha p_i^\beta}{\sum_i |\mathbf{p}_i|^2} \]

, where the Greek indices are spatial components and the Latin indices are used for sums over particles. From this, the sphericity, aplanarity and planarity can be calculated by combinations of eigenvalues.

Defining the three eigenvalues $ \lambda_1 \ge \lambda_2 \ge \lambda_3 $, with $ \lambda_1 + \lambda_2 + \lambda_3 = 1 $, the sphericity is

\[ S = \frac{3}{2} (\lambda_2 + \lambda_3) \]

The aplanarity is $ A = \frac{3}{2}\lambda_3 $ and the planarity is $ P = \frac{2}{3}(S-2A) = \lambda_2 - \lambda_3 $. The eigenvectors define a set of spatial axes comparable with the thrust axes, but more sensitive to high momentum particles due to the quadratic sensitivity of the tensor to the particle momenta.

Since the sphericity is quadratic in the particle momenta, it is not an infrared safe observable in perturbative QCD. This can be fixed by adding a regularizing power of $r$ to the definition:

\[ S^{\alpha \beta} = \frac{\sum_i |\mathbf{p}_i|^{r-2} p_i^\alpha p_i^\beta} {\sum_i |\mathbf{p}_i|^r} \]

$r$ is available as a constructor argument on this class and will be taken into account by the Cmp<Projection> operation, so a single analysis can use several sphericity projections with different $r$ values without fear of a clash.

Definition at line 51 of file Sphericity.hh.


Public Member Functions

void clear ()
 Reset the projection.
bool before (const Projection &p) const
virtual const std::set< BeamPair > beamPairs () const
virtual std::string name () const
 Get the name of the projection.
Projection & addBeamPair (const ParticleName &beam1, const ParticleName &beam2)
 Add a colliding beam pair.
Log & getLog () const
 Get a Log object based on the getName() property of the calling projection object.
void setName (const std::string &name)
 Used by derived classes to set their name.
Constructors etc.
 Sphericity (const FinalState &fsp, double rparam=2.0)
 Constructor.
virtual const Projection * clone () const
 Clone on the heap.
Access the event shapes by name
Sphericity

double sphericity () const
double transSphericity () const
 Transverse Sphericity.
double planarity () const
 Planarity.
double aplanarity () const
 Aplanarity.
Access the sphericity basis vectors
Sphericity axis

const Vector3 & sphericityAxis () const
const Vector3 & sphericityMajorAxis () const
 Sphericity major axis.
const Vector3 & sphericityMinorAxis () const
 Sphericity minor axis.
const Vector3 & axis1 () const
 AxesDefinition axis accessors.
const Vector3 & axis2 () const
 The 2nd most significant ("major") axis.
const Vector3 & axis3 () const
 The least significant ("minor") axis.
Access the momentum tensor eigenvalues
double lambda1 () const
double lambda2 () const
double lambda3 () const
Direct methods
Ways to do the calculation directly, without engaging the caching system

void calc (const FinalState &fs)
 Manually calculate the sphericity, without engaging the caching system.
void calc (const vector< Particle > &fsparticles)
 Manually calculate the sphericity, without engaging the caching system.
void calc (const vector< FourMomentum > &fsmomenta)
 Manually calculate the sphericity, without engaging the caching system.
void calc (const vector< Vector3 > &fsmomenta)
 Manually calculate the sphericity, without engaging the caching system.
Projection "getting" functions
std::set< ConstProjectionPtr > getProjections () const
 Get the contained projections, including recursion.
template<typename PROJ>
const PROJ & getProjection (const std::string &name) const
 Get the named projection, specifying return type via a template argument.
const Projection & getProjection (const std::string &name) const
Projection applying functions
template<typename PROJ>
const PROJ & applyProjection (const Event &evt, const PROJ &proj) const
 Apply the supplied projection on event.
template<typename PROJ>
const PROJ & applyProjection (const Event &evt, const Projection &proj) const
 Apply the supplied projection on event.
template<typename PROJ>
const PROJ & applyProjection (const Event &evt, const std::string &name) const
 Apply the named projection on event.

Protected Member Functions

void project (const Event &e)
 Perform the projection on the Event.
int compare (const Projection &p) const
 Compare with other projections.
Cmp< Projection > mkNamedPCmp (const Projection &otherparent, const std::string &pname) const
Cmp< Projection > mkPCmp (const Projection &otherparent, const std::string &pname) const
ProjectionHandler & getProjHandler () const
 Get a reference to the ProjectionHandler for this thread.
Projection registration functions
template<typename PROJ>
const PROJ & addProjection (const PROJ &proj, const std::string &name)
const Projection & _addProjection (const Projection &proj, const std::string &name)
 Untemplated function to do the work...

Protected Attributes

bool _allowProjReg
 Flag to forbid projection registration in analyses until the init phase.

Private Member Functions

void _calcSphericity (const vector< Vector3 > &fsmomenta)
 Actually do the calculation.

Private Attributes

vector< double > _lambdas
 Eigenvalues.
vector< Vector3 > _sphAxes
 Sphericity axes.
const double _regparam
 Regularizing parameter, used to force infra-red safety.

Friends

class Event
 Event is a friend.
class Cmp< Projection >
 The Cmp specialization for Projection is a friend.
class Projectionhandler

Constructor & Destructor Documentation

Sphericity ( const FinalState &  fsp,
double  rparam = 2.0 
)

Constructor.

Definition at line 10 of file Sphericity.cc.

References ProjectionApplier::addProjection(), Sphericity::clear(), and Projection::setName().

Referenced by Sphericity::clone().

00011     : _regparam(rparam)
00012   {
00013     setName("Sphericity");
00014     addProjection(fsp, "FS");
00015     clear();
00016   }

Member Function Documentation

virtual const Projection* clone (  )  const [inline, virtual]

Clone on the heap.

Implements AxesDefinition.

Definition at line 62 of file Sphericity.hh.

References Sphericity::Sphericity().

00062                                             {
00063       return new Sphericity(*this);
00064     }

void project ( const Event &  e  )  [protected, virtual]

Perform the projection on the Event.

Implements Projection.

Definition at line 34 of file Sphericity.cc.

References Sphericity::calc(), and Rivet::particles().

00034                                          {
00035     const ParticleVector prts = applyProjection<FinalState>(e, "FS").particles();
00036     calc(prts);
00037   }

int compare ( const Projection &  p  )  const [protected, virtual]

Compare with other projections.

Implements Projection.

Definition at line 25 of file Sphericity.cc.

References Sphericity::_regparam, Rivet::cmp(), Rivet::EQUIVALENT, Rivet::fuzzyEquals(), and Projection::mkNamedPCmp().

00025                                                    {
00026     PCmp fscmp = mkNamedPCmp(p, "FS");
00027     if (fscmp != EQUIVALENT) return fscmp;
00028     const Sphericity& other = dynamic_cast<const Sphericity&>(p);
00029     if (fuzzyEquals(_regparam, other._regparam)) return 0;
00030     return cmp(_regparam, other._regparam);
00031   }

void clear (  ) 

Reset the projection.

Definition at line 19 of file Sphericity.cc.

References Sphericity::_lambdas, and Sphericity::_sphAxes.

Referenced by Sphericity::_calcSphericity(), and Sphericity::Sphericity().

00019                          {
00020     _lambdas = vector<double>(3, 0);
00021     _sphAxes = vector<Vector3>(3, Vector3());
00022   }

double sphericity (  )  const [inline]

Definition at line 85 of file Sphericity.hh.

References Sphericity::lambda2(), and Sphericity::lambda3().

Referenced by OPAL_2004_S6132243::analyze(), ExampleAnalysis::analyze(), ALEPH_2004_S5765862::analyze(), ALEPH_1996_S3486095::analyze(), and Sphericity::planarity().

00085 { return 3.0 / 2.0 * (lambda2() + lambda3()); }

double transSphericity (  )  const [inline]

Transverse Sphericity.

Definition at line 87 of file Sphericity.hh.

References Sphericity::lambda1(), and Sphericity::lambda2().

00087 { return 2.0 * lambda2() / ( lambda1() + lambda2() ); }

double planarity (  )  const [inline]

Planarity.

Definition at line 89 of file Sphericity.hh.

References Sphericity::aplanarity(), and Sphericity::sphericity().

00089 { return 2 * (sphericity() - 2 * aplanarity()) / 3.0; }

double aplanarity (  )  const [inline]

Aplanarity.

Definition at line 91 of file Sphericity.hh.

References Sphericity::lambda3().

Referenced by OPAL_2004_S6132243::analyze(), ExampleAnalysis::analyze(), ALEPH_2004_S5765862::analyze(), ALEPH_1996_S3486095::analyze(), and Sphericity::planarity().

00091 { return 3 / 2.0 * lambda3(); }

const Vector3& sphericityAxis (  )  const [inline]

Definition at line 97 of file Sphericity.hh.

References Sphericity::_sphAxes.

Referenced by Sphericity::_calcSphericity(), and Sphericity::axis1().

00097 { return _sphAxes[0]; }

const Vector3& sphericityMajorAxis (  )  const [inline]

Sphericity major axis.

Definition at line 99 of file Sphericity.hh.

References Sphericity::_sphAxes.

Referenced by Sphericity::_calcSphericity(), ALEPH_1996_S3486095::analyze(), and Sphericity::axis2().

00099 { return _sphAxes[1]; }

const Vector3& sphericityMinorAxis (  )  const [inline]

Sphericity minor axis.

Definition at line 101 of file Sphericity.hh.

References Sphericity::_sphAxes.

Referenced by Sphericity::_calcSphericity(), ALEPH_1996_S3486095::analyze(), and Sphericity::axis3().

00101 { return _sphAxes[2]; }

const Vector3& axis1 (  )  const [inline, virtual]

AxesDefinition axis accessors.

Implements AxesDefinition.

Definition at line 105 of file Sphericity.hh.

References Sphericity::sphericityAxis().

00105 { return sphericityAxis(); }

const Vector3& axis2 (  )  const [inline, virtual]

The 2nd most significant ("major") axis.

Implements AxesDefinition.

Definition at line 106 of file Sphericity.hh.

References Sphericity::sphericityMajorAxis().

00106 { return sphericityMajorAxis(); }

const Vector3& axis3 (  )  const [inline, virtual]

The least significant ("minor") axis.

Implements AxesDefinition.

Definition at line 107 of file Sphericity.hh.

References Sphericity::sphericityMinorAxis().

00107 { return sphericityMinorAxis(); }

double lambda1 (  )  const [inline]

Definition at line 113 of file Sphericity.hh.

References Sphericity::_lambdas.

Referenced by Sphericity::_calcSphericity(), ParisiTensor::project(), and Sphericity::transSphericity().

00113 { return _lambdas[0]; }

double lambda2 (  )  const [inline]

Definition at line 114 of file Sphericity.hh.

References Sphericity::_lambdas.

Referenced by Sphericity::_calcSphericity(), ParisiTensor::project(), Sphericity::sphericity(), and Sphericity::transSphericity().

00114 { return _lambdas[1]; }

double lambda3 (  )  const [inline]

Definition at line 115 of file Sphericity.hh.

References Sphericity::_lambdas.

Referenced by Sphericity::_calcSphericity(), Sphericity::aplanarity(), ParisiTensor::project(), and Sphericity::sphericity().

00115 { return _lambdas[2]; }

void calc ( const FinalState &  fs  ) 

Manually calculate the sphericity, without engaging the caching system.

Definition at line 40 of file Sphericity.cc.

References FinalState::particles().

Referenced by Sphericity::project().

00040                                             {
00041     calc(fs.particles());
00042   }

void calc ( const vector< Particle > &  fsparticles  ) 

Manually calculate the sphericity, without engaging the caching system.

Definition at line 44 of file Sphericity.cc.

References Sphericity::_calcSphericity(), Particle::momentum(), and FourVector::vector3().

00044                                                            {
00045     vector<Vector3> threeMomenta;
00046     threeMomenta.reserve(fsparticles.size());
00047     foreach (const Particle& p, fsparticles) {
00048       const Vector3 p3 = p.momentum().vector3();
00049       threeMomenta.push_back(p3);
00050     }
00051     _calcSphericity(threeMomenta);
00052   }

void calc ( const vector< FourMomentum > &  fsmomenta  ) 

Manually calculate the sphericity, without engaging the caching system.

Definition at line 54 of file Sphericity.cc.

References Sphericity::_calcSphericity(), and FourVector::vector3().

00054                                                              {
00055     vector<Vector3> threeMomenta;
00056     threeMomenta.reserve(fsmomenta.size());
00057     foreach (const FourMomentum& v, fsmomenta) {
00058       threeMomenta.push_back(v.vector3());
00059     }
00060     _calcSphericity(threeMomenta);
00061   }

void calc ( const vector< Vector3 > &  fsmomenta  ) 

Manually calculate the sphericity, without engaging the caching system.

Definition at line 63 of file Sphericity.cc.

References Sphericity::_calcSphericity().

00063                                                         {
00064     _calcSphericity(fsmomenta);
00065   }

void _calcSphericity ( const vector< Vector3 > &  fsmomenta  )  [private]

Actually do the calculation.

Definition at line 69 of file Sphericity.cc.

References Sphericity::_lambdas, Sphericity::_regparam, Sphericity::_sphAxes, Sphericity::clear(), Log::DEBUG, Rivet::diagonalize(), Log::ERROR, Rivet::fuzzyEquals(), Matrix::get(), EigenSystem::getDiagMatrix(), EigenSystem::getEigenPairs(), Projection::getLog(), Matrix::isSymm(), Sphericity::lambda1(), Sphericity::lambda2(), Sphericity::lambda3(), Vector::mod(), Rivet::second, Matrix::set(), Sphericity::sphericityAxis(), Sphericity::sphericityMajorAxis(), Sphericity::sphericityMinorAxis(), and Log::TRACE.

Referenced by Sphericity::calc().

00069                                                                    {
00070     getLog() << Log::DEBUG << "Calculating sphericity with r = " << _regparam << endl;
00071 
00072     // Return (with "safe nonsense" sphericity params) if there are no final state particles.
00073     if (fsmomenta.empty()) {
00074       getLog() << Log::DEBUG << "No particles in final state..." << endl;
00075       clear();
00076       return;
00077     }
00078 
00079     // Iterate over all the final state particles.
00080     Matrix3 mMom;
00081     double totalMomentum = 0.0;
00082     getLog() << Log::DEBUG << "Number of particles = " << fsmomenta.size() << endl;
00083     foreach (const Vector3& p3, fsmomenta) {
00084       // Build the (regulated) normalising factor.
00085       totalMomentum += pow(p3.mod(), _regparam);
00086 
00087       // Build (regulated) quadratic momentum components.
00088       const double regfactor = pow(p3.mod(), _regparam-2);
00089       if (!fuzzyEquals(regfactor, 1.0)) {
00090         getLog() << Log::TRACE << "Regfactor (r=" << _regparam << ") = " << regfactor << endl;
00091       }
00092 
00093       Matrix3 mMomPart;
00094       for (size_t i = 0; i < 3; ++i) {
00095         for (size_t j = 0; j < 3; ++j) {
00096           mMomPart.set(i,j, p3[i]*p3[j]);
00097         }
00098       }
00099       mMom += regfactor * mMomPart;
00100     }
00101 
00102     // Normalise to total (regulated) momentum.
00103     mMom /= totalMomentum;
00104     getLog() << Log::DEBUG << "Momentum tensor = " << endl << mMom << endl;
00105 
00106     // Check that the matrix is symmetric.
00107     const bool isSymm = mMom.isSymm();
00108     if (!isSymm) {
00109       getLog() << Log::ERROR << "Error: momentum tensor not symmetric (r=" << _regparam << ")" << endl;
00110       getLog() << Log::ERROR << "[0,1] vs. [1,0]: " << mMom.get(0,1) << ", " << mMom.get(1,0) << endl;
00111       getLog() << Log::ERROR << "[0,2] vs. [2,0]: " << mMom.get(0,2) << ", " << mMom.get(2,0) << endl;
00112       getLog() << Log::ERROR << "[1,2] vs. [2,1]: " << mMom.get(1,2) << ", " << mMom.get(2,1) << endl;
00113     }
00114     // If not symmetric, something's wrong (we made sure the error msg appeared first).
00115     assert(isSymm);
00116 
00117     // Diagonalize momentum matrix.
00118     const EigenSystem<3> eigen3 = diagonalize(mMom);
00119     getLog() << Log::DEBUG << "Diag momentum tensor = " << endl << eigen3.getDiagMatrix() << endl;
00120  
00121     // Reset and set eigenvalue/vector parameters.
00122     _lambdas.clear();
00123     _sphAxes.clear();
00124     const EigenSystem<3>::EigenPairs epairs = eigen3.getEigenPairs();
00125     assert(epairs.size() == 3);
00126     for (size_t i = 0; i < 3; ++i) {
00127       _lambdas.push_back(epairs[i].first);
00128       _sphAxes.push_back(Vector3(epairs[i].second));
00129     }
00130 
00131     // Debug output.
00132     getLog() << Log::DEBUG << "Lambdas = ("
00133              << lambda1() << ", " << lambda2() << ", " << lambda3() << ")" << endl;
00134     getLog() << Log::DEBUG << "Sum of lambdas = " << lambda1() + lambda2() + lambda3() << endl;
00135     getLog() << Log::DEBUG << "Vectors = "
00136              << sphericityAxis() << ", "
00137              << sphericityMajorAxis() << ", "
00138              << sphericityMinorAxis() << ")" << endl;
00139   }

bool before ( const Projection &  p  )  const [inherited]

Determine whether this object should be ordered before the object p given as argument. If p is of a different class than this, the before() function of the corresponding type_info objects is used. Otherwise, if the objects are of the same class, the virtual compare(const Projection &) will be returned.

Definition at line 28 of file Projection.cc.

References Projection::compare().

Referenced by less< const Rivet::Projection * >::operator()().

00028                                                    {
00029     const std::type_info& thisid = typeid(*this);
00030     const std::type_info& otherid = typeid(p);
00031     if (thisid == otherid) {
00032       return compare(p) < 0;
00033     } else {
00034       return thisid.before(otherid);
00035     }
00036   }

const set< BeamPair > beamPairs (  )  const [virtual, inherited]

Return the BeamConstraints for this projection, not including recursion. Derived classes should ensure that all contained projections are registered in the _projections set for the beam constraint chaining to work.

Definition at line 39 of file Projection.cc.

References Projection::_beamPairs, Projection::beamPairs(), Projection::getLog(), ProjectionApplier::getProjections(), Rivet::intersection(), and Log::TRACE.

Referenced by Projection::beamPairs().

00039                                                   {
00040     set<BeamPair> ret = _beamPairs;
00041     set<ConstProjectionPtr> projs = getProjections();
00042     for (set<ConstProjectionPtr>::const_iterator ip = projs.begin(); ip != projs.end(); ++ip) {
00043       ConstProjectionPtr p = *ip;
00044       getLog() << Log::TRACE << "Proj addr = " << p << endl;
00045       if (p) ret = intersection(ret, p->beamPairs());
00046     }
00047     return ret;
00048   }

virtual std::string name (  )  const [inline, virtual, inherited]

Get the name of the projection.

Implements ProjectionApplier.

Definition at line 99 of file Projection.hh.

References Projection::_name.

Referenced by ProjectionApplier::_addProjection(), ProjectionHandler::_checkDuplicate(), ProjectionHandler::_getEquiv(), VetoedFinalState::addVetoOnThisFinalState(), Projection::getLog(), ZFinder::project(), ClusteredPhotons::project(), Projection::Projection(), ProjectionHandler::registerProjection(), and Projection::~Projection().

00099                                    {
00100       return _name;
00101     }

Projection& addBeamPair ( const ParticleName &  beam1,
const ParticleName &  beam2 
) [inline, inherited]

Add a colliding beam pair.

Definition at line 105 of file Projection.hh.

References Projection::_beamPairs.

Referenced by Projection::Projection().

00105                                                                                   {
00106       _beamPairs.insert(BeamPair(beam1, beam2));
00107       return *this;
00108     }

Log& getLog (  )  const [inline, inherited]

Get a Log object based on the getName() property of the calling projection object.

Reimplemented from ProjectionApplier.

Definition at line 112 of file Projection.hh.

References Log::getLog(), and Projection::name().

Referenced by Sphericity::_calcSphericity(), Thrust::_calcThrust(), Projection::beamPairs(), FastJets::calc(), FastJets::FastJets(), FinalState::FinalState(), JetAlg::JetAlg(), ZFinder::project(), WFinder::project(), VetoedFinalState::project(), UnstableFinalState::project(), TriggerUA5::project(), TriggerCDFRun0Run1::project(), PVertex::project(), NeutralFinalState::project(), MergedFinalState::project(), LossyFinalState::project(), LeadingParticlesFinalState::project(), IsolationProjection::project(), InvMassFinalState::project(), InitialQuarks::project(), Hemispheres::project(), HadronicFinalState::project(), FoxWolframMoments::project(), FinalState::project(), ClusteredPhotons::project(), ChargedFinalState::project(), Beam::project(), Projection::Projection(), FastJets::splitJet(), Beam::sqrtS(), and Projection::~Projection().

00112                         {
00113       string logname = "Rivet.Projection." + name();
00114       return Log::getLog(logname);
00115     }

void setName ( const std::string &  name  )  [inline, inherited]

Used by derived classes to set their name.

Definition at line 118 of file Projection.hh.

References Projection::_name.

Referenced by ZFinder::_init(), WFinder::_init(), Beam::Beam(), CentralEtHCM::CentralEtHCM(), ChargedFinalState::ChargedFinalState(), ChargedLeptons::ChargedLeptons(), ClusteredPhotons::ClusteredPhotons(), DISKinematics::DISKinematics(), DISLepton::DISLepton(), FastJets::FastJets(), FinalState::FinalState(), FinalStateHCM::FinalStateHCM(), FoxWolframMoments::FoxWolframMoments(), HadronicFinalState::HadronicFinalState(), Hemispheres::Hemispheres(), IdentifiedFinalState::IdentifiedFinalState(), InitialQuarks::InitialQuarks(), IsolationProjection::IsolationProjection(), JetAlg::JetAlg(), JetShape::JetShape(), KtJets::KtJets(), LeadingParticlesFinalState::LeadingParticlesFinalState(), LossyFinalState::LossyFinalState(), MergedFinalState::MergedFinalState(), Multiplicity::Multiplicity(), NeutralFinalState::NeutralFinalState(), ParisiTensor::ParisiTensor(), PVertex::PVertex(), Sphericity::Sphericity(), SVertex::SVertex(), Thrust::Thrust(), TotalVisibleMomentum::TotalVisibleMomentum(), TriggerCDFRun0Run1::TriggerCDFRun0Run1(), TriggerUA5::TriggerUA5(), UnstableFinalState::UnstableFinalState(), and VetoedFinalState::VetoedFinalState().

00118                                         {
00119       _name = name;
00120     }

Cmp<Projection> mkNamedPCmp ( const Projection &  otherparent,
const std::string &  pname 
) const [protected, inherited]

Shortcut to make a named Cmp<Projection> comparison with the *this object automatically passed as one of the parent projections.

Referenced by ZFinder::compare(), WFinder::compare(), VetoedFinalState::compare(), TotalVisibleMomentum::compare(), Thrust::compare(), SVertex::compare(), Sphericity::compare(), ParisiTensor::compare(), NeutralFinalState::compare(), Multiplicity::compare(), MergedFinalState::compare(), LossyFinalState::compare(), LeadingParticlesFinalState::compare(), KtJets::compare(), JetShape::compare(), IsolationProjection::compare(), InvMassFinalState::compare(), IdentifiedFinalState::compare(), Hemispheres::compare(), FoxWolframMoments::compare(), FinalStateHCM::compare(), FastJets::compare(), DISLepton::compare(), DISKinematics::compare(), ClusteredPhotons::compare(), ChargedLeptons::compare(), ChargedFinalState::compare(), and CentralEtHCM::compare().

Cmp<Projection> mkPCmp ( const Projection &  otherparent,
const std::string &  pname 
) const [protected, inherited]

Shortcut to make a named Cmp<Projection> comparison with the *this object automatically passed as one of the parent projections.

std::set<ConstProjectionPtr> getProjections (  )  const [inline, inherited]

Get the contained projections, including recursion.

Definition at line 43 of file ProjectionApplier.hh.

References ProjectionHandler::DEEP, ProjectionHandler::getChildProjections(), and ProjectionApplier::getProjHandler().

Referenced by Projection::beamPairs().

00043                                                       {
00044       return getProjHandler().getChildProjections(*this, ProjectionHandler::DEEP);
00045     }

const PROJ& getProjection ( const std::string &  name  )  const [inline, inherited]

Get the named projection, specifying return type via a template argument.

Definition at line 50 of file ProjectionApplier.hh.

References ProjectionHandler::getProjection(), and ProjectionApplier::getProjHandler().

Referenced by VetoedFinalState::compare(), Rivet::pcmp(), and Hemispheres::project().

00050                                                            {
00051       const Projection& p = getProjHandler().getProjection(*this, name);
00052       return pcast<PROJ>(p);
00053     }

const Projection& getProjection ( const std::string &  name  )  const [inline, inherited]

Get the named projection (non-templated, so returns as a reference to a Projection base class).

Definition at line 58 of file ProjectionApplier.hh.

References ProjectionHandler::getProjection(), and ProjectionApplier::getProjHandler().

00058                                                                  {
00059       return getProjHandler().getProjection(*this, name);
00060     }

const PROJ& applyProjection ( const Event &  evt,
const PROJ &  proj 
) const [inline, inherited]

Apply the supplied projection on event.

Definition at line 68 of file ProjectionApplier.hh.

References ProjectionApplier::_applyProjection().

Referenced by HadronicFinalState::project(), and FinalStateHCM::project().

00068                                                                           {
00069       return pcast<PROJ>(_applyProjection(evt, proj));
00070     }

const PROJ& applyProjection ( const Event &  evt,
const Projection &  proj 
) const [inline, inherited]

Apply the supplied projection on event.

Definition at line 75 of file ProjectionApplier.hh.

References ProjectionApplier::_applyProjection().

00075                                                                                 {
00076       return pcast<PROJ>(_applyProjection(evt, proj));
00077     }

const PROJ& applyProjection ( const Event &  evt,
const std::string &  name 
) const [inline, inherited]

Apply the named projection on event.

Definition at line 82 of file ProjectionApplier.hh.

References ProjectionApplier::_applyProjection().

00082                                                                                {
00083       return pcast<PROJ>(_applyProjection(evt, name));
00084     }

ProjectionHandler& getProjHandler (  )  const [inline, protected, inherited]

Get a reference to the ProjectionHandler for this thread.

Definition at line 95 of file ProjectionApplier.hh.

References ProjectionApplier::_projhandler.

Referenced by ProjectionApplier::_addProjection(), ProjectionApplier::getProjection(), ProjectionApplier::getProjections(), and ProjectionApplier::~ProjectionApplier().

00095                                               {
00096       assert(_projhandler);
00097       return *_projhandler;
00098     }

const PROJ& addProjection ( const PROJ &  proj,
const std::string &  name 
) [inline, protected, inherited]

Register a contained projection. The type of the argument is used to instantiate a new projection internally: this new object is applied to events rather than the argument object. Hence you are advised to only use locally-scoped Projection objects in your Projection and Analysis constructors, and to avoid polymorphism (e.g. handling ConcreteProjection via a pointer or reference to type Projection) since this will screw up the internal type management.

Definition at line 115 of file ProjectionApplier.hh.

References ProjectionApplier::_addProjection().

Referenced by ZFinder::_init(), WFinder::_init(), VetoedFinalState::addVetoOnThisFinalState(), CDF_2009_S8057893::CDF_2009_S8057893::init(), CentralEtHCM::CentralEtHCM(), ChargedFinalState::ChargedFinalState(), ChargedLeptons::ChargedLeptons(), ClusteredPhotons::ClusteredPhotons(), DISKinematics::DISKinematics(), DISLepton::DISLepton(), FinalState::FinalState(), FinalStateHCM::FinalStateHCM(), FoxWolframMoments::FoxWolframMoments(), HadronicFinalState::HadronicFinalState(), Hemispheres::Hemispheres(), IdentifiedFinalState::IdentifiedFinalState(), ZEUS_2001_S4815815::init(), UA5_1989_S1926373::init(), UA5_1988_S1867512::init(), UA5_1986_S1583476::init(), UA5_1982_S875503::init(), UA1_1990_S2044935::init(), STAR_2009_UE_HELEN::init(), STAR_2008_S7993412::init(), STAR_2006_S6870392::init(), STAR_2006_S6860818::init(), STAR_2006_S6500200::init(), SFM_1984_S1178091::init(), PDG_HADRON_MULTIPLICITIES_RATIOS::init(), PDG_HADRON_MULTIPLICITIES::init(), OPAL_2004_S6132243::init(), OPAL_1998_S3780481::init(), MC_ZJETS::init(), MC_WJETS::init(), MC_TTBAR::init(), MC_SUSY::init(), MC_PHOTONJETUE::init(), MC_PHOTONJETS::init(), MC_LEADINGJETS::init(), MC_JETS::init(), MC_DIPHOTON::init(), MC_DIJET::init(), JADE_OPAL_2000_S4300807::init(), H1_2000_S4129130::init(), H1_1995_S3167097::init(), H1_1994_S2919893::init(), ExampleAnalysis::init(), E735_1998_S3905616::init(), DELPHI_2002_069_CONF_603::init(), DELPHI_1995_S3137023::init(), D0_2010_S8570965::init(), D0_2010_S8566488::init(), D0_2009_S8349509::init(), D0_2009_S8320160::init(), D0_2009_S8202443::init(), D0_2008_S7863608::init(), D0_2008_S7837160::init(), D0_2008_S7719523::init(), D0_2008_S7662670::init(), D0_2008_S7554427::init(), D0_2008_S6879055::init(), D0_2007_S7075677::init(), D0_2006_S6438750::init(), D0_2004_S5992206::init(), D0_2001_S4674421::init(), D0_1998_S3711838::init(), D0_1996_S3324664::init(), D0_1996_S3214044::init(), CDF_2009_S8436959::init(), CDF_2009_S8383952::init(), CDF_2009_S8233977::init(), CDF_2008_S8095620::init(), CDF_2008_S8093652::init(), CDF_2008_S7828950::init(), CDF_2008_S7782535::init(), CDF_2008_S7541902::init(), CDF_2008_S7540469::init(), CDF_2008_NOTE_9351::init(), CDF_2008_LEADINGJETS::init(), CDF_2007_S7057202::init(), CDF_2006_S6653332::init(), CDF_2006_S6450792::init(), CDF_2005_S6217184::init(), CDF_2005_S6080774::init(), CDF_2004_S5839831::init(), CDF_2002_S4796047::init(), CDF_2001_S4751469::init(), CDF_2001_S4563131::init(), CDF_2001_S4517016::init(), CDF_2000_S4266730::init(), CDF_2000_S4155203::init(), CDF_1998_S3618439::init(), CDF_1997_S3541940::init(), CDF_1996_S3418421::init(), CDF_1996_S3349578::init(), CDF_1996_S3108457::init(), CDF_1994_S2952106::init(), CDF_1991_S2313472::init(), CDF_1990_S2089246::init(), CDF_1988_S1865951::init(), BELLE_2006_S6265367::init(), ATLAS_2010_S8591806::init(), ALEPH_2004_S5765862::init(), ALEPH_1996_S3486095::init(), ALEPH_1996_S3196992::init(), ALEPH_1991_S2435284::init(), IsolationProjection::IsolationProjection(), JetAlg::JetAlg(), JetShape::JetShape(), KtJets::KtJets(), LeadingParticlesFinalState::LeadingParticlesFinalState(), LossyFinalState::LossyFinalState(), MergedFinalState::MergedFinalState(), Multiplicity::Multiplicity(), NeutralFinalState::NeutralFinalState(), ParisiTensor::ParisiTensor(), Sphericity::Sphericity(), SVertex::SVertex(), Thrust::Thrust(), TotalVisibleMomentum::TotalVisibleMomentum(), TriggerCDFRun0Run1::TriggerCDFRun0Run1(), TriggerUA5::TriggerUA5(), and VetoedFinalState::VetoedFinalState().

00115                                                                        {
00116       const Projection& reg = _addProjection(proj, name);
00117       return dynamic_cast<const PROJ&>(reg);
00118     }

const Projection & _addProjection ( const Projection &  proj,
const std::string &  name 
) [protected, inherited]

Untemplated function to do the work...

Definition at line 33 of file ProjectionApplier.cc.

References ProjectionApplier::_allowProjReg, Log::ERROR, ProjectionApplier::getLog(), ProjectionApplier::getProjHandler(), ProjectionApplier::name(), Projection::name(), and ProjectionHandler::registerProjection().

Referenced by ProjectionApplier::addProjection().

00034                                                                              {
00035     if (!_allowProjReg) {
00036       getLog() << Log::ERROR << "Trying to register projection '"
00037                << proj.name() << "' before init phase in '" << this->name() << "'." << endl;
00038       exit(2);
00039     }
00040     const Projection& reg = getProjHandler().registerProjection(*this, proj, name);
00041     return reg;
00042   }

Friends And Related Function Documentation

friend class Event [friend, inherited]

Event is a friend.

Definition at line 31 of file Projection.hh.

friend class Cmp< Projection > [friend, inherited]

The Cmp specialization for Projection is a friend.

Definition at line 34 of file Projection.hh.

friend class Projectionhandler [friend, inherited]

Definition at line 23 of file ProjectionApplier.hh.

Member Data Documentation

vector<double> _lambdas [private]

Eigenvalues.

Definition at line 141 of file Sphericity.hh.

Referenced by Sphericity::_calcSphericity(), Sphericity::clear(), Sphericity::lambda1(), Sphericity::lambda2(), and Sphericity::lambda3().

vector<Vector3> _sphAxes [private]

Sphericity axes.

Definition at line 144 of file Sphericity.hh.

Referenced by Sphericity::_calcSphericity(), Sphericity::clear(), Sphericity::sphericityAxis(), Sphericity::sphericityMajorAxis(), and Sphericity::sphericityMinorAxis().

const double _regparam [private]

Regularizing parameter, used to force infra-red safety.

Definition at line 147 of file Sphericity.hh.

Referenced by Sphericity::_calcSphericity(), and Sphericity::compare().

bool _allowProjReg [protected, inherited]

Flag to forbid projection registration in analyses until the init phase.

Definition at line 141 of file ProjectionApplier.hh.

Referenced by ProjectionApplier::_addProjection(), and AnalysisHandler::init().

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