TransientVertex Class Reference

#include <TransientVertex.h>

Public Types
typedef std::map< reco::TransientTrack, float >	TransientTrackToFloatMap

Public Member Functions
float	degreesOfFreedom () const
bool	hasPrior () const
bool	hasRefittedTracks () const
bool	hasTrackWeight () const
bool	isValid () const
float	normalisedChiSquared () const
	operator reco::Vertex () const
	operator reco::VertexCompositePtrCandidate () const
reco::TransientTrack	originalTrack (const reco::TransientTrack &refTrack) const
std::vector< reco::TransientTrack > const &	originalTracks () const
GlobalPoint	position () const
GlobalError	positionError () const
GlobalError	priorError () const
GlobalPoint	priorPosition () const
double	priorTime () const
double	priorTimeError () const
reco::TransientTrack	refittedTrack (const reco::TransientTrack &track) const
std::vector< reco::TransientTrack > const &	refittedTracks () const
void	refittedTracks (const std::vector< reco::TransientTrack > &refittedTracks)
double	time () const
double	timeError () const
AlgebraicMatrix33	tkToTkCovariance (const reco::TransientTrack &t1, const reco::TransientTrack &t2) const
void	tkToTkCovariance (const TTtoTTmap &covMap)
bool	tkToTkCovarianceIsAvailable () const
float	totalChiSquared () const
float	trackWeight (const reco::TransientTrack &track) const
	TransientVertex ()
	TransientVertex (const GlobalPoint &pos, const GlobalError &posError, const std::vector< reco::TransientTrack > &tracks, float chi2)
	TransientVertex (const GlobalPoint &pos, const double time, const GlobalError &posError, const std::vector< reco::TransientTrack > &tracks, float chi2)
	TransientVertex (const GlobalPoint &pos, const GlobalError &posError, const std::vector< reco::TransientTrack > &tracks, float chi2, float ndf)
	TransientVertex (const GlobalPoint &pos, const double time, const GlobalError &posError, const std::vector< reco::TransientTrack > &tracks, float chi2, float ndf)
	TransientVertex (const GlobalPoint &priorPos, const GlobalError &priorErr, const GlobalPoint &pos, const GlobalError &posError, const std::vector< reco::TransientTrack > &tracks, float chi2)
	TransientVertex (const GlobalPoint &priorPos, const double priorTime, const GlobalError &priorErr, const GlobalPoint &pos, const double time, const GlobalError &posError, const std::vector< reco::TransientTrack > &tracks, float chi2)
	TransientVertex (const GlobalPoint &priorPos, const GlobalError &priorErr, const GlobalPoint &pos, const GlobalError &posError, const std::vector< reco::TransientTrack > &tracks, float chi2, float ndf)
	TransientVertex (const GlobalPoint &priorPos, const double priorTime, const GlobalError &priorErr, const GlobalPoint &pos, const double time, const GlobalError &posError, const std::vector< reco::TransientTrack > &tracks, float chi2, float ndf)
	TransientVertex (const GlobalPoint &priorPos, const GlobalError &priorErr, const double priorTime, const double priorTimeErr, const GlobalPoint &pos, const GlobalError &posError, const double time, const double timeErr, const std::vector< reco::TransientTrack > &tracks, float chi2, float ndf)
	TransientVertex (const VertexState &state, const std::vector< reco::TransientTrack > &tracks, float chi2)
	TransientVertex (const VertexState &state, const std::vector< reco::TransientTrack > &tracks, float chi2, float ndf)
	TransientVertex (const VertexState &prior, const VertexState &state, const std::vector< reco::TransientTrack > &tracks, float chi2)
	TransientVertex (const VertexState &prior, const VertexState &state, const std::vector< reco::TransientTrack > &tracks, float chi2, float ndf)
VertexState const &	vertexState () const
TransientTrackToFloatMap	weightMap () const
void	weightMap (const TransientTrackToFloatMap &theMap)

Private Attributes
float	theChi2
TTtoTTmap	theCovMap
bool	theCovMapAvailable
float	theNDF
std::vector< reco::TransientTrack >	theOriginalTracks
VertexState	thePriorVertexState
std::vector< reco::TransientTrack >	theRefittedTracks
VertexState	theVertexState
TransientTrackToFloatMap	theWeightMap
bool	theWeightMapIsAvailable
bool	vertexValid
bool	withPrior
bool	withRefittedTracks

Detailed Description

Definition at line 18 of file TransientVertex.h.

Member Typedef Documentation

typedef std::map<reco::TransientTrack, float> TransientVertex::TransientTrackToFloatMap

Definition at line 22 of file TransientVertex.h.

Constructor & Destructor Documentation

TransientVertex::TransientVertex

(

)

Empty constructor, produces invalid vertex

Definition at line 11 of file TransientVertex.cc.

                                 : theVertexState(), theOriginalTracks(),
  theChi2(0), theNDF(0), vertexValid(false), withPrior(false),
  theWeightMapIsAvailable(false), theCovMapAvailable(false), 
  withRefittedTracks(false)
{}

TransientVertex::TransientVertex	(	const GlobalPoint &	pos,
		const GlobalError &	posError,
		const std::vector< reco::TransientTrack > &	tracks,
		float	chi2
	)

Constructor defining the RecVertex by its 3D position and position uncertainty, its associated tracks and its chi-squared. The number of degrees of freedom is equal to 2*nb of tracks - 3.

Definition at line 18 of file TransientVertex.cc.

References theNDF, and theOriginalTracks.

                                                                   :
    theVertexState(pos, posError), theOriginalTracks(tracks),
    theChi2(chi2), theNDF(0), vertexValid(true), withPrior(false),
  theWeightMapIsAvailable(false), theCovMapAvailable(false), 
  withRefittedTracks(false)
{
  theNDF = 2.*theOriginalTracks.size() - 3.;
}

TransientVertex::TransientVertex	(	const GlobalPoint &	pos,
		const double	time,
		const GlobalError &	posError,
		const std::vector< reco::TransientTrack > &	tracks,
		float	chi2
	)

Definition at line 28 of file TransientVertex.cc.

References theNDF, and theOriginalTracks.

                                                                                       :
  theVertexState(pos, time, posTimeError), theOriginalTracks(tracks),
  theChi2(chi2), theNDF(0), vertexValid(true), withPrior(false),
  theWeightMapIsAvailable(false), theCovMapAvailable(false), 
  withRefittedTracks(false)
{
  theNDF = 2.*theOriginalTracks.size() - 3.;
}

TransientVertex::TransientVertex	(	const GlobalPoint &	pos,
		const GlobalError &	posError,
		const std::vector< reco::TransientTrack > &	tracks,
		float	chi2,
		float	ndf
	)

Constructor defining the RecVertex by its 3D position and position uncertainty, its associated tracks, its chi-squared and its number of degrees of freedom. The ndf can be a float.

Definition at line 40 of file TransientVertex.cc.

                                                                                                  :
    theVertexState(pos, posError), theOriginalTracks(tracks),
    theChi2(chi2), theNDF(ndf), vertexValid(true), withPrior(false),
    theWeightMapIsAvailable(false), theCovMapAvailable(false), 
    withRefittedTracks(false)
{
}

TransientVertex::TransientVertex	(	const GlobalPoint &	pos,
		const double	time,
		const GlobalError &	posError,
		const std::vector< reco::TransientTrack > &	tracks,
		float	chi2,
		float	ndf
	)

Definition at line 49 of file TransientVertex.cc.

                                                                                                  :
  theVertexState(pos, time, posTimeError), theOriginalTracks(tracks),
  theChi2(chi2), theNDF(ndf), vertexValid(true), withPrior(false),
  theWeightMapIsAvailable(false), theCovMapAvailable(false), 
  withRefittedTracks(false)
{
}

TransientVertex::TransientVertex	(	const GlobalPoint &	priorPos,
		const GlobalError &	priorErr,
		const GlobalPoint &	pos,
		const GlobalError &	posError,
		const std::vector< reco::TransientTrack > &	tracks,
		float	chi2
	)

Constructor defining the RecVertex by the prior, the vertex 3D position and uncertainty, the associated tracks and the chi-squared. Since the prior brings information on 3 coordinates, the number of degrees of freedom is equal to 2*nb of tracks.

Definition at line 60 of file TransientVertex.cc.

References theNDF, and theOriginalTracks.

                                                                                       :
    thePriorVertexState(priorPos, priorErr), theVertexState(pos, posError),
    theOriginalTracks(tracks), theChi2(chi2), theNDF(0), vertexValid(true),
    withPrior(true), theWeightMapIsAvailable(false), theCovMapAvailable(false),
    withRefittedTracks(false)
{
  theNDF = 2.*theOriginalTracks.size();
}

TransientVertex::TransientVertex	(	const GlobalPoint &	priorPos,
		const double	priorTime,
		const GlobalError &	priorErr,
		const GlobalPoint &	pos,
		const double	time,
		const GlobalError &	posError,
		const std::vector< reco::TransientTrack > &	tracks,
		float	chi2
	)

Definition at line 71 of file TransientVertex.cc.

References theNDF, and theOriginalTracks.

                                                                                       :
  thePriorVertexState(priorPos, priorTime, priorErr), theVertexState(pos, time, posError),
  theOriginalTracks(tracks), theChi2(chi2), theNDF(0), vertexValid(true),
  withPrior(true), theWeightMapIsAvailable(false), theCovMapAvailable(false),
  withRefittedTracks(false)
{
  theNDF = 2.*theOriginalTracks.size();
}

TransientVertex::TransientVertex	(	const GlobalPoint &	priorPos,
		const GlobalError &	priorErr,
		const GlobalPoint &	pos,
		const GlobalError &	posError,
		const std::vector< reco::TransientTrack > &	tracks,
		float	chi2,
		float	ndf
	)

Constructor defining the RecVertex by the prior, the vertex 3D position and uncertainty, the associated tracks, the chi-squared and the number of degrees of freedom. The ndf can be a float.

Definition at line 83 of file TransientVertex.cc.

                                                                                                  :
    thePriorVertexState(priorPos, priorErr), theVertexState(pos, posError),
    theOriginalTracks(tracks), theChi2(chi2), theNDF(ndf), vertexValid(true),
    withPrior(true), theWeightMapIsAvailable(false), theCovMapAvailable(false),
    withRefittedTracks(false)
{
}

TransientVertex::TransientVertex	(	const GlobalPoint &	priorPos,
		const double	priorTime,
		const GlobalError &	priorErr,
		const GlobalPoint &	pos,
		const double	time,
		const GlobalError &	posError,
		const std::vector< reco::TransientTrack > &	tracks,
		float	chi2,
		float	ndf
	)

Definition at line 93 of file TransientVertex.cc.

                                                                                                  :
  thePriorVertexState(priorPos, priorTime, priorErr), theVertexState(pos, time, posError),
  theOriginalTracks(tracks), theChi2(chi2), theNDF(ndf), vertexValid(true),
  withPrior(true), theWeightMapIsAvailable(false), theCovMapAvailable(false),
  withRefittedTracks(false)
{
}

TransientVertex::TransientVertex	(	const GlobalPoint &	priorPos,
		const GlobalError &	priorErr,
		const double	priorTime,
		const double	priorTimeErr,
		const GlobalPoint &	pos,
		const GlobalError &	posError,
		const double	time,
		const double	timeErr,
		const std::vector< reco::TransientTrack > &	tracks,
		float	chi2,
		float	ndf
	)

Constructor defining the RecVertex by the prior, the vertex 3D position and uncertainty, time and uncertainty, the associated tracks, the chi-squared and the number of degrees of freedom. The ndf can be a float.

TransientVertex::TransientVertex	(	const VertexState &	state,
		const std::vector< reco::TransientTrack > &	tracks,
		float	chi2
	)

Constructor defining the RecVertex by its 3D position and position uncertainty, its associated tracks and its chi-squared. The number of degrees of freedom is equal to 2*nb of tracks - 3.

Definition at line 104 of file TransientVertex.cc.

References theNDF, and theOriginalTracks.

                                                                                       : 
  theVertexState(state), theOriginalTracks(tracks),
  theChi2(chi2), theNDF(0), vertexValid(true), withPrior(false),
  theWeightMapIsAvailable(false), theCovMapAvailable(false), 
  withRefittedTracks(false)
{
  theNDF = 2.*theOriginalTracks.size() - 3.;
}

TransientVertex::TransientVertex	(	const VertexState &	state,
		const std::vector< reco::TransientTrack > &	tracks,
		float	chi2,
		float	ndf
	)

Constructor defining the RecVertex by its 3D position and position uncertainty, its associated tracks, its chi-squared and its number of degrees of freedom. The ndf can be a float.

Definition at line 115 of file TransientVertex.cc.

                                                                                                  : 
    theVertexState(state), theOriginalTracks(tracks),
    theChi2(chi2), theNDF(ndf), vertexValid(true), withPrior(false),
    theWeightMapIsAvailable(false), theCovMapAvailable(false), 
    withRefittedTracks(false) 
{
}

TransientVertex::TransientVertex	(	const VertexState &	prior,
		const VertexState &	state,
		const std::vector< reco::TransientTrack > &	tracks,
		float	chi2
	)

Constructor defining the RecVertex by the prior, the vertex 3D position and uncertainty, the associated tracks and the chi-squared. Since the prior brings information on 3 coordinates, the number of degrees of freedom is equal to 2*nb of tracks.

Definition at line 125 of file TransientVertex.cc.

References theNDF, and theOriginalTracks.

                                 :
    thePriorVertexState(prior), theVertexState(state),
    theOriginalTracks(tracks), theChi2(chi2), theNDF(0), vertexValid(true),
    withPrior(true), theWeightMapIsAvailable(false), theCovMapAvailable(false),
    withRefittedTracks(false)
{
  theNDF = 2.*theOriginalTracks.size();
}

TransientVertex::TransientVertex	(	const VertexState &	prior,
		const VertexState &	state,
		const std::vector< reco::TransientTrack > &	tracks,
		float	chi2,
		float	ndf
	)

Constructor defining the RecVertex by the prior, the vertex 3D position and uncertainty, the associated tracks, the chi-squared and the number of degrees of freedom. The ndf can be a float.

Definition at line 138 of file TransientVertex.cc.

                                    :
    thePriorVertexState(prior), theVertexState(state),
    theOriginalTracks(tracks), theChi2(chi2), theNDF(ndf), vertexValid(true),
    withPrior(true), theWeightMapIsAvailable(false),
    theCovMapAvailable(false), withRefittedTracks(false)
{
}

Member Function Documentation

float TransientVertex::degreesOfFreedom ( ) const

inline

Definition at line 155 of file TransientVertex.h.

References theNDF.

Referenced by PrimaryVertexValidation::analyze(), AdaptiveVertexReconstructor::cleanUp(), VertexFitterResult::fill(), normalisedChiSquared(), operator reco::Vertex(), operator reco::VertexCompositePtrCandidate(), TemplatedSecondaryVertexProducer< IPTI, VTX >::SVBuilder::operator()(), Onia2MuMuPAT::produce(), PrimaryVertexProducer::produce(), reco::GhostTrackVertexFinder::vertexFitter(), and PrimaryVertexProducerAlgorithm::vertices().

{ return theNDF; }

bool TransientVertex::hasPrior ( ) const

inline

Definition at line 144 of file TransientVertex.h.

References withPrior.

Referenced by AdaptiveVertexReconstructor::cleanUp().

{ return withPrior; }

bool TransientVertex::hasRefittedTracks ( ) const

inline

Returns true if at for at least one of the original tracks, the refitted track is available

Definition at line 176 of file TransientVertex.h.

References withRefittedTracks.

Referenced by AdaptiveVertexReconstructor::cleanUp(), V0Fitter::fitAll(), PFTauSecondaryVertexProducer::produce(), and HPSPFRecoTauAlgorithm::refitThreeProng().

{ return withRefittedTracks; }

bool TransientVertex::hasTrackWeight ( ) const

inline

Returns true if the track-weights are available.

Definition at line 207 of file TransientVertex.h.

References theWeightMapIsAvailable, and trackWeight().

Referenced by PrimaryVertexValidation::analyze().

{ return theWeightMapIsAvailable; }

bool TransientVertex::isValid ( void  ) const

inline

Returns true if vertex is valid. An invalid RecVertex is created e.g. when vertex fitting fails.

Definition at line 160 of file TransientVertex.h.

References vertexValid.

Referenced by ntupleDataFormat._Object::_checkIsValid(), KineExample::analyze(), PrimaryVertexValidation::analyze(), VertexFitterResult::fill(), CandCommonVertexFitter< Fitter >::fit(), PFCandCommonVertexFitter< Fitter >::fit(), V0Fitter::fitAll(), PFDisplacedVertexFinder::fitVertexFromSeed(), HLTmmkkFilter::hltFilter(), HLTmmkFilter::hltFilter(), operator reco::Vertex(), operator reco::VertexCompositePtrCandidate(), HLTDisplacedmumumuVtxProducer::produce(), HLTDisplacedmumuVtxProducer::produce(), HLTDisplacedtktkVtxProducer::produce(), TemplatedInclusiveVertexFinder< InputContainer, VTX >::produce(), HLTmumutktkVtxProducer::produce(), Onia2MuMuPAT::produce(), HLTmumutkVtxProducer::produce(), PrimaryVertexProducer::produce(), core.AutoHandle.AutoHandle::ReallyLoad(), HPSPFRecoTauAlgorithm::refitThreeProng(), PFRecoTauDiscriminationByFlightPathSignificance::threeProngFlightPathSig(), TrackVertexArbitration< VTX >::trackVertexArbitrator(), and PrimaryVertexProducerAlgorithm::vertices().

                       {
    return vertexValid;
  }

float TransientVertex::normalisedChiSquared ( ) const

inline

Definition at line 152 of file TransientVertex.h.

References degreesOfFreedom(), and totalChiSquared().

Referenced by PrimaryVertexValidation::analyze(), HLTmmkkFilter::hltFilter(), and HLTmmkFilter::hltFilter().

                                     {
    return totalChiSquared() / degreesOfFreedom();
  }

TransientVertex::operator reco::Vertex

(

)

const

Definition at line 241 of file TransientVertex.cc.

References reco::Vertex::add(), degreesOfFreedom(), VertexState::error4D(), mps_fire::i, isValid(), GlobalErrorBase< T, ErrorWeightType >::matrix4D(), VertexState::position(), refittedTrack(), theOriginalTracks, theVertexState, VertexState::time(), totalChiSquared(), reco::TransientTrack::track(), trackWeight(), and withRefittedTracks.

{
   //If the vertex is invalid, return an invalid TV !
  if (!isValid()) return Vertex();

  Vertex vertex(Vertex::Point(theVertexState.position()),
                //  RecoVertex::convertError(theVertexState.error()), 
                theVertexState.error4D().matrix4D(),
                theVertexState.time(),
                totalChiSquared(), degreesOfFreedom(), theOriginalTracks.size() );
  for (std::vector<TransientTrack>::const_iterator i = theOriginalTracks.begin();
       i != theOriginalTracks.end(); ++i) {
//     const TrackTransientTrack* ttt = dynamic_cast<const TrackTransientTrack*>((*i).basicTransientTrack());
//     if ((ttt!=0) && (ttt->persistentTrackRef().isNonnull()))
//     {
//       TrackRef tr = ttt->persistentTrackRef();
//       TrackBaseRef tbr(tr);
      if (withRefittedTracks) {
        
    vertex.add((*i).trackBaseRef(), refittedTrack(*i).track(), trackWeight ( *i ) );
      } else { 
    vertex.add((*i).trackBaseRef(), trackWeight ( *i ) );
      }
    //}
  }
  return vertex;
}

TransientVertex::operator reco::VertexCompositePtrCandidate

(

)

const

Definition at line 269 of file TransientVertex.cc.

References reco::CompositePtrCandidate::addDaughter(), reco::CandidatePtrTransientTrack::candidate(), degreesOfFreedom(), relativeConstraints::error, isValid(), makeMuonMisalignmentScenario::matrix, reco::Candidate::p4(), p4, position(), reco::VertexCompositePtrCandidate::setChi2AndNdof(), reco::VertexCompositePtrCandidate::setCovariance(), reco::LeafCandidate::setP4(), reco::LeafCandidate::setVertex(), theOriginalTracks, totalChiSquared(), trackWeight(), groupFilesInBlocks::tt, vertexState(), x, y, and z.

{
using namespace reco;
    if (!isValid())  return VertexCompositePtrCandidate();

    VertexCompositePtrCandidate vtxCompPtrCand;

    vtxCompPtrCand.setCovariance(vertexState().error().matrix());
    vtxCompPtrCand.setChi2AndNdof(totalChiSquared(), degreesOfFreedom());
    vtxCompPtrCand.setVertex(Candidate::Point(position().x(),position().y(),position().z()));

    Candidate::LorentzVector p4;
    for(std::vector<reco::TransientTrack>::const_iterator tt = theOriginalTracks.begin(); tt != theOriginalTracks.end(); ++tt)
    {
        if (trackWeight(*tt) < 0.5)
            continue;

        const CandidatePtrTransientTrack* cptt = dynamic_cast<const CandidatePtrTransientTrack*>(tt->basicTransientTrack());
        if ( cptt==0 )
            edm::LogError("DynamicCastingFailed") << "Casting of TransientTrack to CandidatePtrTransientTrack failed!";
        else
        {
            p4 += cptt->candidate()->p4();
            vtxCompPtrCand.addDaughter(cptt->candidate());
        }
    }

    //TODO: if has refitted tracks we should scale the candidate p4 to the refitted one
    vtxCompPtrCand.setP4(p4);
    return vtxCompPtrCand;
}

TransientTrack TransientVertex::originalTrack

(

const reco::TransientTrack &

refTrack

)

const

Returns the original track which corresponds to a particular refitted Track Throws an exception if now refitted tracks are stored ot the track is not found in the list

Definition at line 217 of file TransientVertex.cc.

References spr::find(), theOriginalTracks, and theRefittedTracks.

Referenced by refittedTracks().

{
  if (theRefittedTracks.empty())
    throw VertexException("No refitted tracks stored in vertex");
  std::vector<TransientTrack>::const_iterator it =
    find(theRefittedTracks.begin(), theRefittedTracks.end(), refTrack);
  if (it==theRefittedTracks.end())
    throw VertexException("Refitted track not found in list");
  size_t pos = it - theRefittedTracks.begin();
  return theOriginalTracks[pos];
}

std::vector<reco::TransientTrack> const& TransientVertex::originalTracks ( ) const

inline

Access to the original tracks used to make the vertex. Returns track container by value.

Definition at line 167 of file TransientVertex.h.

References theOriginalTracks.

Referenced by AdaptiveVertexReconstructor::cleanUp(), AdaptiveVertexReconstructor::erase(), VertexFitterResult::fill(), VertexHigherPtSquared::operator()(), TemplatedSecondaryVertexProducer< IPTI, VTX >::SVBuilder::operator()(), PrimaryVertexProducer::produce(), TrimmedVertexFitter::vertex(), reco::GhostTrackVertexFinder::vertexFitter(), and MultiVertexFitter::vertices().

                                                               {
    return theOriginalTracks;
  }

GlobalPoint TransientVertex::position ( ) const

inline

Definition at line 136 of file TransientVertex.h.

References VertexState::position(), and theVertexState.

Referenced by KVFTest::analyze(), KineExample::analyze(), PFCheckHitPattern::analyze(), PrimaryVertexValidation::analyze(), VertexFitterResult::fill(), PFDisplacedVertexFinder::fitVertexFromSeed(), HLTmmkkFilter::hltFilter(), HLTmmkFilter::hltFilter(), operator reco::VertexCompositePtrCandidate(), TemplatedSecondaryVertexProducer< IPTI, VTX >::SVBuilder::operator()(), Onia2MuMuPAT::produce(), PrimaryVertexProducer::produce(), reco::GhostTrackVertexFinder::reassignTracks(), HPSPFRecoTauAlgorithm::refitThreeProng(), TrimmedVertexFitter::vertex(), reco::GhostTrackVertexFinder::vertexFitter(), and PrimaryVertexProducerAlgorithm::vertices().

{ return theVertexState.position(); }

GlobalError TransientVertex::positionError ( ) const

inline

Definition at line 137 of file TransientVertex.h.

References VertexState::error(), VertexState::error4D(), VertexState::is4D(), and theVertexState.

Referenced by PrimaryVertexValidation::analyze(), VertexFitterResult::fill(), HLTmmkkFilter::hltFilter(), HLTmmkFilter::hltFilter(), PrimaryVertexProducer::produce(), TrimmedVertexFitter::vertex(), and reco::GhostTrackVertexFinder::vertexFitter().

{ return theVertexState.is4D() ? theVertexState.error4D() : theVertexState.error(); }

GlobalError TransientVertex::priorError ( ) const

inline

Definition at line 139 of file TransientVertex.h.

References VertexState::error(), VertexState::error4D(), VertexState::is4D(), and thePriorVertexState.

Referenced by AdaptiveVertexReconstructor::cleanUp().

{ return thePriorVertexState.is4D() ? thePriorVertexState.error4D() : thePriorVertexState.error(); }

GlobalPoint TransientVertex::priorPosition ( ) const

inline

Definition at line 138 of file TransientVertex.h.

References VertexState::position(), and thePriorVertexState.

Referenced by AdaptiveVertexReconstructor::cleanUp().

{ return thePriorVertexState.position(); }

double TransientVertex::priorTime ( ) const

inline

Definition at line 142 of file TransientVertex.h.

References thePriorVertexState, and VertexState::time().

{ return thePriorVertexState.time(); }

double TransientVertex::priorTimeError ( ) const

inline

Definition at line 143 of file TransientVertex.h.

References thePriorVertexState, and VertexState::timeError().

{ return thePriorVertexState.timeError(); }

TransientTrack TransientVertex::refittedTrack

(

const reco::TransientTrack &

track

)

const

Returns the refitted track which corresponds to a particular original Track Throws an exception if now refitted tracks are stored ot the track is not found in the list

Definition at line 229 of file TransientVertex.cc.

References spr::find(), theOriginalTracks, theRefittedTracks, and HiIsolationCommonParameters_cff::track.

Referenced by PFDisplacedVertexFinder::fitVertexFromSeed(), operator reco::Vertex(), and refittedTracks().

{
  if (theRefittedTracks.empty())
    throw VertexException("No refitted tracks stored in vertex");
  std::vector<TransientTrack>::const_iterator it =
    find(theOriginalTracks.begin(), theOriginalTracks.end(), track);
  if (it==theOriginalTracks.end())
    throw VertexException("Track not found in list");
  size_t pos = it - theOriginalTracks.begin();
  return theRefittedTracks[pos];
}

std::vector<reco::TransientTrack> const& TransientVertex::refittedTracks ( ) const

inline

Access to the refitted tracks used to make the vertex. Returns track container by value.

Definition at line 182 of file TransientVertex.h.

References originalTrack(), refittedTrack(), theRefittedTracks, and HiIsolationCommonParameters_cff::track.

Referenced by AdaptiveVertexReconstructor::cleanUp(), V0Fitter::fitAll(), CachingVertex< N >::operator TransientVertex(), PFTauSecondaryVertexProducer::produce(), refittedTracks(), HPSPFRecoTauAlgorithm::refitThreeProng(), CandCommonVertexFitterBase::set(), and PFCandCommonVertexFitterBase::set().

                                                                {
    return theRefittedTracks;
  }

void TransientVertex::refittedTracks

(

const std::vector< reco::TransientTrack > &

refittedTracks

)

Method to set the refitted tracks used to make the vertex.

Definition at line 155 of file TransientVertex.cc.

References refittedTracks(), theRefittedTracks, and withRefittedTracks.

{
  if (refittedTracks.empty())
    throw VertexException("TransientVertex::refittedTracks: No refitted tracks stored in input container");
  theRefittedTracks = refittedTracks;
  withRefittedTracks = true;
}

double TransientVertex::time ( ) const

inline

Definition at line 140 of file TransientVertex.h.

References theVertexState, and VertexState::time().

Referenced by PrimaryVertexProducer::produce().

{ return theVertexState.time(); } 

double TransientVertex::timeError ( ) const

inline

Definition at line 141 of file TransientVertex.h.

References theVertexState, and VertexState::timeError().

{ return theVertexState.timeError(); }

AlgebraicMatrix33 TransientVertex::tkToTkCovariance	(	const reco::TransientTrack &	t1,
		const reco::TransientTrack &	t2
	)		const

Returns the Track-to-track covariance matrix for two specified tracks. In case these do not exist, or one of the tracks does not belong to the vertex, an exception is thrown.

Definition at line 186 of file TransientVertex.cc.

References reco::t2, theCovMap, and theCovMapAvailable.

Referenced by CachingVertex< N >::operator TransientVertex(), and tkToTkCovarianceIsAvailable().

{
  if (!theCovMapAvailable) {
   throw VertexException("TransientVertex::Track-to-track covariance matrices not available");
  }
  const TransientTrack* tr1;
  const TransientTrack* tr2;
  if (t1<t2) {
    tr1 = &t1;
    tr2 = &t2;
  } else {
    tr1 = &t2;
    tr2 = &t1;
  }
  TTtoTTmap::const_iterator it = theCovMap.find(*tr1);
  if (it !=  theCovMap.end()) {
    const TTmap & tm = it->second;
    TTmap::const_iterator nit = tm.find(*tr2);
    if (nit != tm.end()) {
      return( nit->second);
    }
    else {
      throw VertexException("TransientVertex::requested Track-to-track covariance matrix does not exist");
    }
  }
  else {
    throw VertexException("TransientVertex::requested Track-to-track covariance matrix does not exist");
  }
}

void TransientVertex::tkToTkCovariance

(

const TTtoTTmap &

covMap

)

Definition at line 165 of file TransientVertex.cc.

References theCovMap, and theCovMapAvailable.

{
  theCovMap = covMap;
  theCovMapAvailable = true;
}

bool TransientVertex::tkToTkCovarianceIsAvailable ( ) const

inline

Returns true if the Track-to-track covariance matrices have been calculated.

Definition at line 226 of file TransientVertex.h.

References reco::t2, theCovMapAvailable, and tkToTkCovariance().

{ return theCovMapAvailable; }

float TransientVertex::totalChiSquared ( ) const

inline

Implements method of abstract Vertex. Returns track pointer container by value

Definition at line 151 of file TransientVertex.h.

References theChi2.

Referenced by PrimaryVertexValidation::analyze(), AdaptiveVertexReconstructor::cleanUp(), VertexFitterResult::fill(), PFDisplacedVertexFinder::fitVertexFromSeed(), normalisedChiSquared(), operator reco::Vertex(), operator reco::VertexCompositePtrCandidate(), TemplatedSecondaryVertexProducer< IPTI, VTX >::SVBuilder::operator()(), Onia2MuMuPAT::produce(), PrimaryVertexProducer::produce(), TrimmedVertexFitter::vertex(), and reco::GhostTrackVertexFinder::vertexFitter().

{ return theChi2; }

float TransientVertex::trackWeight

(

const reco::TransientTrack &

track

)

const

Returns the weight with which a track has been used in the fit. If the track is not present in the list, it is obviously not used, and this method returns a weight of 0. If this information has not been provided at construction, a weight of 1.0 is assumed for all tracks used and present in the originalTracks() std::vector.

Definition at line 171 of file TransientVertex.cc.

References spr::find(), theOriginalTracks, theWeightMap, theWeightMapIsAvailable, and HiIsolationCommonParameters_cff::track.

Referenced by PrimaryVertexValidation::analyze(), AdaptiveVertexReconstructor::cleanUp(), AdaptiveVertexReconstructor::erase(), PFDisplacedVertexFinder::fitVertexFromSeed(), hasTrackWeight(), operator reco::Vertex(), operator reco::VertexCompositePtrCandidate(), and TemplatedSecondaryVertexProducer< IPTI, VTX >::SVBuilder::operator()().

                                                                     {
  if (!theWeightMapIsAvailable) {
    std::vector<TransientTrack>::const_iterator foundTrack = find(theOriginalTracks.begin(), 
            theOriginalTracks.end(), track);
    return ((foundTrack != theOriginalTracks.end()) ? 1. : 0.);
  }
  TransientTrackToFloatMap::const_iterator it = theWeightMap.find(track);
  if (it !=  theWeightMap.end()) {
    return(it->second);
  }
  return 0.;

}

VertexState const& TransientVertex::vertexState ( ) const

inline

Constructor defining the RecVertex by its 3D position and position uncertainty, its associated tracks, its chi-squared and its number of degrees of freedom, and the track weights. The ndf can be a float.Access methods

Definition at line 135 of file TransientVertex.h.

References theVertexState.

Referenced by AdaptiveVertexReconstructor::cleanUp(), operator reco::VertexCompositePtrCandidate(), and TemplatedSecondaryVertexProducer< IPTI, VTX >::SVBuilder::operator()().

{ return theVertexState; }

TransientTrackToFloatMap TransientVertex::weightMap ( ) const

inline

Definition at line 219 of file TransientVertex.h.

References theWeightMap.

Referenced by AdaptiveVertexReconstructor::cleanUp(), and CachingVertex< N >::operator TransientVertex().

{ return theWeightMap; }

void TransientVertex::weightMap

(

const TransientTrackToFloatMap &

theMap

)

Definition at line 149 of file TransientVertex.cc.

References theWeightMap, and theWeightMapIsAvailable.

{
  theWeightMap = theMap;
  theWeightMapIsAvailable = true;
}

Member Data Documentation

float TransientVertex::theChi2

private

Definition at line 252 of file TransientVertex.h.

Referenced by totalChiSquared().

TTtoTTmap TransientVertex::theCovMap

private

Definition at line 257 of file TransientVertex.h.

Referenced by tkToTkCovariance().

bool TransientVertex::theCovMapAvailable

private

Definition at line 255 of file TransientVertex.h.

Referenced by tkToTkCovariance(), and tkToTkCovarianceIsAvailable().

float TransientVertex::theNDF

private

Definition at line 253 of file TransientVertex.h.

Referenced by degreesOfFreedom(), and TransientVertex().

std::vector<reco::TransientTrack> TransientVertex::theOriginalTracks

private

Definition at line 248 of file TransientVertex.h.

Referenced by operator reco::Vertex(), operator reco::VertexCompositePtrCandidate(), originalTrack(), originalTracks(), refittedTrack(), trackWeight(), and TransientVertex().

VertexState TransientVertex::thePriorVertexState

mutableprivate

Definition at line 243 of file TransientVertex.h.

Referenced by priorError(), priorPosition(), priorTime(), and priorTimeError().

std::vector<reco::TransientTrack> TransientVertex::theRefittedTracks

private

Definition at line 249 of file TransientVertex.h.

Referenced by originalTrack(), refittedTrack(), and refittedTracks().

VertexState TransientVertex::theVertexState

mutableprivate

Definition at line 244 of file TransientVertex.h.

Referenced by operator reco::Vertex(), position(), positionError(), time(), timeError(), and vertexState().

TransientTrackToFloatMap TransientVertex::theWeightMap

private

Definition at line 258 of file TransientVertex.h.

Referenced by trackWeight(), and weightMap().

bool TransientVertex::theWeightMapIsAvailable

private

Definition at line 255 of file TransientVertex.h.

Referenced by hasTrackWeight(), trackWeight(), and weightMap().

bool TransientVertex::vertexValid

private

Definition at line 254 of file TransientVertex.h.

Referenced by isValid().

bool TransientVertex::withPrior

private

Definition at line 255 of file TransientVertex.h.

Referenced by hasPrior().

bool TransientVertex::withRefittedTracks

private

Definition at line 256 of file TransientVertex.h.

Referenced by hasRefittedTracks(), operator reco::Vertex(), and refittedTracks().