Thrust Class Reference

#include <Thrust.hh>

Inheritance diagram for Thrust:

Inheritance graph
[legend]

Collaboration diagram for Thrust:

Collaboration graph
[legend]

List of all members.

Detailed Description

Obtain the e+ e- thrust event shape, consisting of the thrust basis and the thrust scalar values in each direction (the thrust, thrust major and thrust minor).

Author:
Andy Buckley
The scalar (maximum) thrust is defined as

\[ T = \mathrm{max}_{\vec{n}} \frac{\sum_i \left|\vec{p}_i \cdot \vec{n} \right|}{\sum_i |\vec{p}_i|} \]

, with the direction of the unit vector $ \vec{n} $ which maximises $ T $ being identified as the thrust axis. The unit vector which maximises the thrust scalar in the plane perpendicular to $ \vec{n} $ is the "thrust major" direction, and the vector perpendicular to both the thrust and thrust major directions is the thrust minor. Both the major and minor directions have associated thrust scalars.

Thrust calculations have particularly simple forms for less than 4 particles, and in those cases this projection is computationally minimal. For 4 or more particles, a more general calculation must be carried out, based on the Brandt/Dahmen method from Z. Phys. C1 (1978). While a polynomial improvement on the exponential scaling of the naive method, this algorithm scales asymptotically as $ \mathcal{O}\left( n^3 \right) $. Be aware that the thrust may easily be the most computationally demanding projection in Rivet for large events!

The Rivet implementation of thrust is based heavily on Stefan Gieseke's Herwig++ re-coding of the 'tasso' code from HERWIG.

NB. special case with >= 4 coplanar particles will still fail. NB. Thrust assumes all momenta are in the CoM system: no explicit boost is performed. This can be dealt with by appropriate choice of the supplied FinalState.

Definition at line 46 of file Thrust.hh.


Public Member Functions

 Thrust (const FinalState &fsp)
 Constructor.
virtual const Projection * clone () const
 Clone on the heap.
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.
double thrust () const
double thrustMajor () const
 The thrust major scalar, $ M $, (thrust along thrust major axis).
double thrustMinor () const
 The thrust minor scalar, $ m $, (thrust along thrust minor axis).
double oblateness () const
 The oblateness, $ O = M - m $ .
const Vector3 & thrustAxis () const
const Vector3 & thrustMajorAxis () const
 The thrust major axis (axis of max thrust perpendicular to thrust axis).
const Vector3 & thrustMinorAxis () const
 The thrust minor axis (axis perpendicular to thrust and thrust major).
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.
Direct methods
Ways to do the calculation directly, without engaging the caching system

void calc (const FinalState &fs)
 Manually calculate the thrust, without engaging the caching system.
void calc (const vector< Particle > &fsparticles)
 Manually calculate the thrust, without engaging the caching system.
void calc (const vector< FourMomentum > &fsmomenta)
 Manually calculate the thrust, without engaging the caching system.
void calc (const vector< Vector3 > &threeMomenta)
 Manually calculate the thrust, 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 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 _calcThrust (const vector< Vector3 > &fsmomenta)
 Explicitly calculate the thrust values.

Private Attributes

vector< double > _thrusts
 The thrust scalars.
vector< Vector3 > _thrustAxes
 The thrust axes.
bool _calculatedThrust
 Caching flag to avoid costly recalculations.

Friends

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

Constructor & Destructor Documentation

Thrust ( const FinalState &  fsp  )  [inline]

Constructor.

Definition at line 50 of file Thrust.hh.

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

Referenced by Thrust::clone().

00051       : _calculatedThrust(false)
00052     {
00053       setName("Thrust");
00054       addProjection(fsp, "FS");
00055     }

Member Function Documentation

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

Clone on the heap.

Implements AxesDefinition.

Definition at line 58 of file Thrust.hh.

References Thrust::Thrust().

00058                                             {
00059       return new Thrust(*this);
00060     }

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

Perform the projection on the Event.

Implements Projection.

Definition at line 65 of file Thrust.hh.

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

00065                                  {
00066       const vector<Particle> ps
00067         = applyProjection<FinalState>(e, "FS").particles();
00068       calc(ps);
00069     }

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

Compare projections.

Implements Projection.

Definition at line 72 of file Thrust.hh.

References Projection::mkNamedPCmp().

00072                                            {
00073       return mkNamedPCmp(p, "FS");
00074     }

double thrust (  )  const [inline]

Thrust scalar accessors The thrust scalar, $ T $, (maximum thrust).

Definition at line 81 of file Thrust.hh.

References Thrust::_thrusts.

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

00081 { return _thrusts[0]; }

double thrustMajor (  )  const [inline]

The thrust major scalar, $ M $, (thrust along thrust major axis).

Definition at line 83 of file Thrust.hh.

References Thrust::_thrusts.

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

00083 { return _thrusts[1]; }

double thrustMinor (  )  const [inline]

The thrust minor scalar, $ m $, (thrust along thrust minor axis).

Definition at line 85 of file Thrust.hh.

References Thrust::_thrusts.

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

00085 { return _thrusts[2]; }

double oblateness (  )  const [inline]

The oblateness, $ O = M - m $ .

Definition at line 87 of file Thrust.hh.

References Thrust::_thrusts.

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

00087 { return _thrusts[1] - _thrusts[2]; }

const Vector3& thrustAxis (  )  const [inline]

Thrust axis accessors The thrust axis.

Definition at line 92 of file Thrust.hh.

References Thrust::_thrustAxes.

Referenced by ALEPH_1996_S3486095::analyze(), ALEPH_1996_S3196992::analyze(), and Thrust::axis1().

00092 { return _thrustAxes[0]; }

const Vector3& thrustMajorAxis (  )  const [inline]

The thrust major axis (axis of max thrust perpendicular to thrust axis).

Definition at line 94 of file Thrust.hh.

References Thrust::_thrustAxes.

Referenced by Thrust::axis2().

00094 { return _thrustAxes[1]; }

const Vector3& thrustMinorAxis (  )  const [inline]

The thrust minor axis (axis perpendicular to thrust and thrust major).

Definition at line 96 of file Thrust.hh.

References Thrust::_thrustAxes.

Referenced by Thrust::axis3().

00096 { return _thrustAxes[2]; }

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

AxesDefinition axis accessors.

Implements AxesDefinition.

Definition at line 100 of file Thrust.hh.

References Thrust::thrustAxis().

00100 { return thrustAxis(); }

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

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

Implements AxesDefinition.

Definition at line 101 of file Thrust.hh.

References Thrust::thrustMajorAxis().

00101 { return thrustMajorAxis(); }

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

The least significant ("minor") axis.

Implements AxesDefinition.

Definition at line 102 of file Thrust.hh.

References Thrust::thrustMinorAxis().

00102 { return thrustMinorAxis(); }

void calc ( const FinalState &  fs  ) 

Manually calculate the thrust, without engaging the caching system.

Definition at line 10 of file Thrust.cc.

References FinalState::particles().

Referenced by Thrust::project().

00010                                         {
00011     calc(fs.particles());
00012   }

void calc ( const vector< Particle > &  fsparticles  ) 

Manually calculate the thrust, without engaging the caching system.

Definition at line 14 of file Thrust.cc.

References Thrust::_calcThrust(), Particle::momentum(), and FourVector::vector3().

00014                                                        {
00015     vector<Vector3> threeMomenta;
00016     threeMomenta.reserve(fsparticles.size());
00017     foreach (const Particle& p, fsparticles) {
00018       const Vector3 p3 = p.momentum().vector3();
00019       threeMomenta.push_back(p3);
00020     }
00021     _calcThrust(threeMomenta);
00022   }

void calc ( const vector< FourMomentum > &  fsmomenta  ) 

Manually calculate the thrust, without engaging the caching system.

Definition at line 24 of file Thrust.cc.

References Thrust::_calcThrust(), and FourVector::vector3().

00024                                                          {
00025     vector<Vector3> threeMomenta;
00026     threeMomenta.reserve(fsmomenta.size());
00027     foreach (const FourMomentum& v, fsmomenta) {
00028       threeMomenta.push_back(v.vector3());
00029     }
00030     _calcThrust(threeMomenta);
00031   }

void calc ( const vector< Vector3 > &  threeMomenta  ) 

Manually calculate the thrust, without engaging the caching system.

Definition at line 33 of file Thrust.cc.

References Thrust::_calcThrust().

00033                                                     {
00034     _calcThrust(fsmomenta);
00035   }

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

Explicitly calculate the thrust values.

Todo:
Improve this --- special directions bad... (a,b,c) _|_ 1/(a^2+b^2) (b,-a,0) etc., but which combination minimises error?

Definition at line 103 of file Thrust.cc.

References Rivet::_calcT(), Thrust::_thrustAxes, Thrust::_thrusts, Rivet::cross(), Vector3::cross(), Log::DEBUG, Rivet::dot(), Projection::getLog(), Rivet::mod(), Vector3::unit(), Vector3::x(), and Vector3::z().

Referenced by Thrust::calc().

00103                                                            {
00104     // Make a vector of the three-momenta in the final state
00105     double momentumSum(0.0);
00106     foreach (const Vector3& p3, fsmomenta) {
00107       momentumSum += mod(p3);
00108     }
00109     getLog() << Log::DEBUG << "Number of particles = " << fsmomenta.size() << endl;
00110 
00111 
00112     // Clear the caches
00113     _thrusts.clear();
00114     _thrustAxes.clear();
00115 
00116 
00117     // If there are fewer than 2 visible particles, we can't do much
00118     if (fsmomenta.size() < 2) {
00119       for (int i = 0; i < 3; ++i) {
00120         _thrusts.push_back(-1);
00121         _thrustAxes.push_back(Vector3(0,0,0));
00122       }
00123       return;
00124     }
00125 
00126 
00127     // Handle special case of thrust = 1 if there are only 2 particles
00128     if (fsmomenta.size() == 2) {
00129       Vector3 axis(0,0,0);
00130       _thrusts.push_back(1.0);
00131       _thrusts.push_back(0.0);
00132       _thrusts.push_back(0.0);
00133       axis = fsmomenta[0].unit();
00134       if (axis.z() < 0) axis = -axis;
00135       _thrustAxes.push_back(axis);
00136       /// @todo Improve this --- special directions bad...
00137       /// (a,b,c) _|_ 1/(a^2+b^2) (b,-a,0) etc., but which combination minimises error?
00138       if (axis.z() < 0.75)
00139         _thrustAxes.push_back( (axis.cross(Vector3(0,0,1))).unit() );
00140       else
00141         _thrustAxes.push_back( (axis.cross(Vector3(0,1,0))).unit() );
00142       _thrustAxes.push_back( _thrustAxes[0].cross(_thrustAxes[1]) );
00143       return;
00144     }
00145 
00146 
00147 
00148     // Temporary variables for calcs
00149     Vector3 axis(0,0,0);
00150     double val = 0.;
00151 
00152     // Get thrust
00153     _calcT(fsmomenta, val, axis);
00154     getLog() << Log::DEBUG << "Mom sum = " << momentumSum << endl;
00155     _thrusts.push_back(val / momentumSum);
00156     // Make sure that thrust always points along the +ve z-axis.
00157     if (axis.z() < 0) axis = -axis;
00158     axis = axis.unit();
00159     getLog() << Log::DEBUG << "Axis = " << axis << endl;
00160     _thrustAxes.push_back(axis);
00161 
00162     // Get thrust major
00163     vector<Vector3> threeMomenta;
00164     foreach (const Vector3& v, fsmomenta) {
00165       // Get the part of each 3-momentum which is perpendicular to the thrust axis
00166       const Vector3 vpar = dot(v, axis.unit()) * axis.unit();
00167       threeMomenta.push_back(v - vpar);
00168     }
00169     _calcT(threeMomenta, val, axis);
00170     _thrusts.push_back(val / momentumSum);
00171     if (axis.x() < 0) axis = -axis;
00172     axis = axis.unit();
00173     _thrustAxes.push_back(axis);
00174 
00175     // Get thrust minor
00176     if (_thrustAxes[0].dot(_thrustAxes[1]) < 1e-10) {
00177       axis = _thrustAxes[0].cross(_thrustAxes[1]);
00178       _thrustAxes.push_back(axis);
00179       val = 0.0;
00180       foreach (const Vector3& v, fsmomenta) {
00181         val += fabs(dot(axis, v));
00182       }
00183       _thrusts.push_back(val / momentumSum);
00184     } else {
00185       _thrusts.push_back(-1.0);
00186       _thrustAxes.push_back(Vector3(0,0,0));
00187     }
00188 
00189   }

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> _thrusts [private]

The thrust scalars.

Definition at line 130 of file Thrust.hh.

Referenced by Thrust::_calcThrust(), Thrust::oblateness(), Thrust::thrust(), Thrust::thrustMajor(), and Thrust::thrustMinor().

vector<Vector3> _thrustAxes [private]

The thrust axes.

Definition at line 133 of file Thrust.hh.

Referenced by Thrust::_calcThrust(), Thrust::thrustAxis(), Thrust::thrustMajorAxis(), and Thrust::thrustMinorAxis().

bool _calculatedThrust [private]

Caching flag to avoid costly recalculations.

Definition at line 136 of file Thrust.hh.

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: