SVertex Class Reference

#include <SVertex.hh>

Inheritance diagram for SVertex:

Inheritance graph
[legend]

Collaboration diagram for SVertex:

Collaboration graph
[legend]

List of all members.

Detailed Description

Determine secondary vertices.

Makes use of PVertex projection.

Todo:
Replace function with a functor to improve equality comparisons.
Complex cuts on tracks and vertices to validate them have to be provided by an external function bool f(SVertex&, ParticleVector&, const HepMC::GenVertex&, FourMomentum); which can be embedded in the analysis code. An example can be found in the S6653332 analysis. A pointer to this function has to be given to the constructor of the SVertex projection. Its arguments are as follows:

in: reference to instance of SVertex projection, ParticleVector of vertex to be analyzed, primary (Gen)Vertex out: FourMomentum = visible Momentum of vertex (selected tracks), return bool: cuts passed? 1 : 0

In this way the SVertex projection can be kept as universal/flexible as possible.

The constructor expects also a list of (pre-selected) jets. Associated tracks and vertices to a jet are checked for displacement. A list of tagged jets can be obtained via the getTaggedJets() function

Definition at line 40 of file SVertex.hh.


Public Member Functions

const vector< FourMomentum > & getTaggedJets () const
 Return vector of tagged jets (FourMomentum's).
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.
Standard constructors and destructors.
 SVertex (const ChargedFinalState &chfs, const vector< FourMomentum > &jetaxes, double deltaR, double detEta, double IPres, double DLS, double DLSres=0.0)
virtual const Projection * clone () const
 Clone on the heap.
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)
 Apply the projection to 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

bool _applyVtxTrackCuts (const ParticleVector &, const Vector3 &, FourMomentum)

Private Attributes

const vector< FourMomentum > & _jetaxes
 The jet axes of the jet algorithm projection.
double _deltaR
 Max distance between vis. momentum of vertex and jet to be probed.
double _detEta
 Geometrical acceptance of tracker.
double _IPres
 Impact parameter resolution, (including beam size).
double _DLS
 Decay length significance (cut value).
double _DLSres
 Decay length significance uncertainty.
vector< FourMomentum > _taggedjets
 Jets which have been tagged.

Friends

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

Constructor & Destructor Documentation

SVertex ( const ChargedFinalState &  chfs,
const vector< FourMomentum > &  jetaxes,
double  deltaR,
double  detEta,
double  IPres,
double  DLS,
double  DLSres = 0.0 
) [inline]

The default constructor. Must specify a PVertex projection object which is assumed to live through the run.

Definition at line 47 of file SVertex.hh.

References SVertex::_DLSres, SVertex::_IPres, ProjectionApplier::addProjection(), and Projection::setName().

Referenced by SVertex::clone().

00050       : _jetaxes(jetaxes), _deltaR(deltaR),
00051         _detEta(detEta), _IPres(IPres), _DLS(DLS),
00052         _DLSres(DLSres)
00053     {
00054       setName("SVertex");
00055       addProjection(PVertex(), "PV");
00056       addProjection(chfs, "FS");
00057       if (_DLSres == 0.0) {
00058         _DLSres = _IPres;
00059       }
00060     }

Member Function Documentation

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

Clone on the heap.

Implements Projection.

Definition at line 63 of file SVertex.hh.

References SVertex::SVertex().

00063                                             {
00064       return new SVertex(*this);
00065     }

const vector<FourMomentum>& getTaggedJets (  )  const [inline]

Return vector of tagged jets (FourMomentum's).

Definition at line 71 of file SVertex.hh.

References SVertex::_taggedjets.

00071                                                       {
00072       return _taggedjets;
00073     }

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

Apply the projection to the event.

Todo:
Use acceptance from the FinalState instead

Implements Projection.

Definition at line 26 of file SVertex.cc.

References SVertex::_applyVtxTrackCuts(), SVertex::_deltaR, SVertex::_detEta, SVertex::_DLS, SVertex::_DLSres, SVertex::_jetaxes, SVertex::_taggedjets, Rivet::deltaR(), Particle::genParticle(), Rivet::get2dDecayLength(), Particle::momentum(), FinalState::particles(), PVertex::position(), and FourVector::pseudorapidity().

00026                                       {
00027     const PVertex& pvtx = applyProjection<PVertex>(e, "PV");
00028     const Vector3 pvpos = pvtx.position();
00029     const ChargedFinalState& chfs = applyProjection<ChargedFinalState>(e, "FS");
00030  
00031     // Produce vector of vertices, each containing a vector of all charged
00032     // final state particles belonging to this vertex
00033     typedef map<GenVertex*,ParticleVector> VtxPartsMap;
00034     VtxPartsMap vtxparts;
00035     foreach (const Particle& p, chfs.particles()) {
00036       // Consider only charged particles in tracker geometrical acceptance
00037       /// @todo Use acceptance from the FinalState instead
00038       if (fabs(p.momentum().pseudorapidity()) > _detEta) continue;
00039       HepMC::GenVertex* pvtx = p.genParticle().production_vertex();
00040       vtxparts[pvtx].push_back(p);
00041     }
00042 
00043     // Check if jets are tagged, by means of selected vertices fulfilling track criteria
00044     _taggedjets.clear();
00045     for (VtxPartsMap::const_iterator vp = vtxparts.begin(); vp != vtxparts.end(); ++vp) {
00046       FourMomentum vtxVisMom;
00047       if (! _applyVtxTrackCuts(vp->second, pvpos, vtxVisMom) ) break;
00048       for (vector<FourMomentum>::const_iterator jaxis = _jetaxes.begin(); jaxis != _jetaxes.end(); ++jaxis) {
00049         // Delta{R} requirement between jet and visible vector sum of vertex tracks
00050         if (deltaR(*jaxis, vtxVisMom) < _deltaR) {
00051           const double dls = get2dDecayLength(vp->first->position(), pvpos, *jaxis) / _DLSres;
00052           if (dls > _DLS) _taggedjets.push_back(*jaxis);
00053         }
00054       }
00055     }
00056  
00057   }

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

Compare projections.

Implements Projection.

Definition at line 13 of file SVertex.cc.

References SVertex::_detEta, SVertex::_DLS, SVertex::_DLSres, SVertex::_IPres, Rivet::cmp(), Rivet::EQUIVALENT, and Projection::mkNamedPCmp().

00013                                                 {
00014     const PCmp fscmp = mkNamedPCmp(p, "PV");
00015     if (fscmp != EQUIVALENT) return fscmp;
00016     const SVertex& other = pcast<SVertex>(p);
00017     return \
00018       cmp(_detEta, other._detEta) ||
00019       cmp(_IPres, other._IPres) ||
00020       cmp(_DLS, other._DLS) ||
00021       cmp(_DLSres, _DLSres);
00022   }

bool _applyVtxTrackCuts ( const ParticleVector &  vtxparts,
const Vector3 &  pvtxpos,
FourMomentum  vtxVisMom 
) [private]

Analysis dependent cuts to be specified in analysis function

Todo:
Replace with inheritance-based cut method.
Analysis dependent cuts on vertex tracks in SVertex projection Since the analysis specific cuts are very complex, they are not implemented in the projection and are instead passed via a function (object). SVertex member function implementation below in: reference to instance of SVertex projection, ParticleVector of vertex to be analyzed, primary (Gen)Vertex out: FourMomentum = visible Momentum of vertex (selected tracks), return bool: cuts passed? 1 : 0
Todo:
Move this into the projection concrete class.

Definition at line 70 of file SVertex.cc.

References SVertex::_IPres, Particle::genParticle(), Rivet::get2dClosestApproach(), Particle::momentum(), and FourMomentum::pT().

Referenced by SVertex::project().

00073   {
00074     // Check vertex final state charged particles, if fulfilling track criteria
00075     size_t pass1trk1pTdcaSig25(0), pass1trk05pTdcaSig25(0),
00076       pass2trk15pTdcaSig3(0), pass2trk1pTdcaSig3(0);
00077  
00078     foreach (const Particle& vp, vtxparts) {
00079       const double IPsig = get2dClosestApproach(vp.genParticle(), pvtxpos) / _IPres;
00080    
00081       // Update "visible momentum" vector (returned by reference).
00082       if (vp.momentum().pT() > 0.5) {
00083         vtxVisMom += vp.momentum();
00084       }
00085       // 1st pass
00086       if (vtxparts.size() >= 3 && IPsig > 2.5) {
00087         if (vp.momentum().pT() > 1.0) pass1trk1pTdcaSig25++;
00088         else if (vp.momentum().pT() > 0.5) pass1trk05pTdcaSig25++;
00089       }
00090       // 2nd pass
00091       if (vtxparts.size() >= 2 && IPsig > 3.) {
00092         if (vp.momentum().pT() > 1.5) pass2trk15pTdcaSig3++;
00093         else if (vp.momentum().pT() > 1.0) pass2trk1pTdcaSig3++;
00094       }
00095     }
00096 
00097     // Combine info from passes to make yes/no decision about whether this is significant:
00098     if (pass1trk1pTdcaSig25 >= 1 && pass1trk1pTdcaSig25 + pass1trk05pTdcaSig25>=3) return true;
00099     if (pass2trk15pTdcaSig3 >= 1 && pass2trk15pTdcaSig3 + pass2trk1pTdcaSig3>=2) return true;
00100     return false;
00101   }

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

const vector<FourMomentum>& _jetaxes [private]

The jet axes of the jet algorithm projection.

Definition at line 86 of file SVertex.hh.

Referenced by SVertex::project().

double _deltaR [private]

Max distance between vis. momentum of vertex and jet to be probed.

Definition at line 89 of file SVertex.hh.

Referenced by SVertex::project().

double _detEta [private]

Geometrical acceptance of tracker.

Definition at line 97 of file SVertex.hh.

Referenced by SVertex::compare(), and SVertex::project().

double _IPres [private]

Impact parameter resolution, (including beam size).

Definition at line 100 of file SVertex.hh.

Referenced by SVertex::_applyVtxTrackCuts(), SVertex::compare(), and SVertex::SVertex().

double _DLS [private]

Decay length significance (cut value).

Definition at line 103 of file SVertex.hh.

Referenced by SVertex::compare(), and SVertex::project().

double _DLSres [private]

Decay length significance uncertainty.

Definition at line 106 of file SVertex.hh.

Referenced by SVertex::compare(), SVertex::project(), and SVertex::SVertex().

vector<FourMomentum> _taggedjets [private]

Jets which have been tagged.

Definition at line 109 of file SVertex.hh.

Referenced by SVertex::getTaggedJets(), and SVertex::project().

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: