#include <CandKinematicVertexFitter.h>

Public Types
typedef reco::Vertex::CovarianceMatrix	CovarianceMatrix

Public Member Functions
	CandKinematicVertexFitter (const edm::ParameterSet &cfg)

	CandKinematicVertexFitter (const CandKinematicVertexFitter &o)

RefCountedKinematicParticle	currentParticle () const

bool	fit (const std::vector< RefCountedKinematicParticle > &tracks) const

void	set (const MagneticField *bField)

void	set (const ParticleDataTable *pdt)

void	set (reco::VertexCompositeCandidate &) const

Private Member Functions
void	fill (std::vector< RefCountedKinematicParticle > &, std::vector< reco::Candidate * > &, std::vector< reco::RecoCandidate::TrackType > &, reco::Candidate &) const

Private Attributes
const MagneticField *	bField_

double	chi2_
	chi-sqared More...

CovarianceMatrix	cov_
	covariance matrix (3x3) More...

KinematicParticleFactoryFromTransientTrack	factory_
	particle factor More...

KinematicParticleVertexFitter	fitter_
	fitter More...

boost::shared_ptr< std::vector< CandKinematicVertexFitter > >	fitters_
	fitters used for recursive calls More...

double	ndof_
	number of degrees of freedom More...

const ParticleDataTable *	pdt_

RefCountedKinematicTree	tree_
	fit tree More...

Detailed Description

Definition at line 23 of file CandKinematicVertexFitter.h.

Member Typedef Documentation

typedef reco::Vertex::CovarianceMatrix CandKinematicVertexFitter::CovarianceMatrix

Definition at line 25 of file CandKinematicVertexFitter.h.

Constructor & Destructor Documentation

CandKinematicVertexFitter::CandKinematicVertexFitter ( const edm::ParameterSet & cfg )

inline

Definition at line 26 of file CandKinematicVertexFitter.h.

                                                          :  
     bField_(nullptr), pdt_(nullptr), fitter_(), fitters_(new std::vector<CandKinematicVertexFitter>) { 
   }

CandKinematicVertexFitter::CandKinematicVertexFitter ( const CandKinematicVertexFitter & o )

inline

Definition at line 29 of file CandKinematicVertexFitter.h.

                                                                 :
     bField_(o.bField_), pdt_(o.pdt_), fitter_(), fitters_(new std::vector<CandKinematicVertexFitter>) {
   }

Member Function Documentation

RefCountedKinematicParticle CandKinematicVertexFitter::currentParticle ( ) const

inline

Definition at line 36 of file CandKinematicVertexFitter.h.

                                                       {
     tree_->movePointerToTheTop();
     return tree_->currentParticle();
   }

void CandKinematicVertexFitter::fill	(	std::vector< RefCountedKinematicParticle > &	particles,
		std::vector< reco::Candidate * > &	daughters,
		std::vector< reco::RecoCandidate::TrackType > &	trackTypes,
		reco::Candidate &	c
	)		const

private

Definition at line 98 of file CandKinematicVertexFitter.cc.

References MessageLogger_cfi::cerr, vertices_cff::chi2, edmIntegrityCheck::d, data, reco::Candidate::daughter(), Exception, lumiContext::fill, KinematicParticleFitter::fit(), reco::Candidate::get(), edm::errors::InvalidReference, edm::Ref< C, T, F >::isNull(), ResonanceBuilder::mass, reco::Candidate::mass(), reco::LeafCandidate::massConstraint(), ndof, reco::RecoCandidate::noTrackType, reco::Candidate::numberOfDaughters(), reco::Candidate::pdgId(), reco::LeafCandidate::pdgId(), and reco::VertexCompositeCandidate::vertexChi2().

                                           {
   size_t nDau = c.numberOfDaughters();
   // loop through CompositeCandidate daughters
   for(unsigned int j = 0; j < nDau ; ++j) {
     Candidate * d = c.daughter(j);
     if(d == nullptr) {
       ostringstream message;
       message << "Can't access in write mode candidate daughters. "
           << "pdgId = " << c.pdgId() << ".\n";
       const Candidate * d1 = c.daughter(j);
       if(d1 == nullptr)
     message << "Null daughter also found in read-only mode\n";
       else
     message << "Daughter found in read-only mode with id: " << d1->pdgId() << "\n";
       throw edm::Exception(edm::errors::InvalidReference) << message.str();
     }
     //check for a daughter which itself is a composite
     if(d->numberOfDaughters() > 0) {
       //try to cast to VertexCompositeCandiate
       VertexCompositeCandidate * vtxDau = dynamic_cast<VertexCompositeCandidate*>(d);
       if( vtxDau!=nullptr && vtxDau->vertexChi2()>0 ) {
     // if VertexCompositeCandidate refit vtxDau via the set method
     (*this).set(*vtxDau);
     // if mass constraint is desired, do it here
     if ( vtxDau->massConstraint() ) {
       KinematicParticleFitter csFitter;
       //get particle mass from pdg table via pdgid number
       const ParticleData *data = pdt_->particle(vtxDau->pdgId());
       ParticleMass mass = data->mass();
       float mass_sigma = mass*0.000001; //needs a sigma for the fit
       // create a KinematicConstraint and refit the tree with it
       //KinematicConstraint * mass_c = new MassKinematicConstraint(mass,mass_sigma);
       MassKinematicConstraint mkc(mass,mass_sigma);
       KinematicConstraint * mass_c(&mkc);
       tree_ = csFitter.fit(mass_c,tree_);
       //CHECK THIS! the following works, but might not be safe
       //tree_ = csFitter.fit(&(MassKinematicConstraint(mass,mass_sigma)),tree_);
     }
     // add the kinematic particle from the fit to particles
     RefCountedKinematicParticle current = (*this).currentParticle();
     particles.push_back(current);
     daughters.push_back(d);
     trackTypes.push_back(RecoCandidate::noTrackType);   
       } else {
     fill(particles, daughters, trackTypes, *d);
       }
     } else {
       //get track, make KinematicParticle and add to particles so it can be fit
       TrackRef trk = d->get<TrackRef>();
       RecoCandidate::TrackType type = d->get<RecoCandidate::TrackType>();
       if (!trk.isNull()){
     TransientTrack trTrk(trk, bField_);
     float chi2 = 0, ndof = 0;
     ParticleMass mass = d->mass();
     float sigma = mass *1.e-6;
     particles.push_back(factory_.particle(trTrk, mass, chi2, ndof, sigma));
     daughters.push_back(d);
     trackTypes.push_back(type);
       } else {
     cerr << ">>> warning: candidate of type " << d->pdgId() 
          << " has no track reference." << endl;
       }
     }
   }
 }

bool CandKinematicVertexFitter::fit ( const std::vector< RefCountedKinematicParticle > & tracks ) const

Definition at line 15 of file CandKinematicVertexFitter.cc.

References MessageLogger_cfi::cerr, and cppFunctionSkipper::exception.

Referenced by trackingPlots.Iteration::modules().

                                                                                                {
   try {
     tree_ = fitter_.fit(particles);
   } catch (std::exception & err) {
     std::cerr << ">>> exception thrown by KinematicParticleVertexFitter:\n"
           << err.what() << "\n"
           << ">>> candidate not fitted to common vertex" << std::endl;
     return false;
   }
   //check tree_ is valid here!
   if (tree_->isValid())
     return true;
   else return false;
 }

void CandKinematicVertexFitter::set ( const MagneticField * bField )

inline

Definition at line 32 of file CandKinematicVertexFitter.h.

References ecalTB2006H4_GenSimDigiReco_cfg::bField.

Referenced by reco::modules::CandKinematicVertexFitterEventSetupInit::init().

32 { bField_ = bField; }

ecalTB2006H4_GenSimDigiReco_cfg.bField

bField

Definition: ecalTB2006H4_GenSimDigiReco_cfg.py:235

CandKinematicVertexFitter::bField_

const MagneticField * bField_

Definition: CandKinematicVertexFitter.h:41

void CandKinematicVertexFitter::set ( const ParticleDataTable * pdt )

inline

Definition at line 33 of file CandKinematicVertexFitter.h.

References trackingPlots::fit, and l1t::tracks.

33 { pdt_ = pdt; }

CandKinematicVertexFitter::pdt_

const ParticleDataTable * pdt_

Definition: CandKinematicVertexFitter.h:42

void CandKinematicVertexFitter::set ( reco::VertexCompositeCandidate & c ) const

Definition at line 31 of file CandKinematicVertexFitter.cc.

References GlobalErrorBase< T, ErrorWeightType >::cxx(), GlobalErrorBase< T, ErrorWeightType >::cyx(), GlobalErrorBase< T, ErrorWeightType >::cyy(), GlobalErrorBase< T, ErrorWeightType >::czx(), GlobalErrorBase< T, ErrorWeightType >::czy(), GlobalErrorBase< T, ErrorWeightType >::czz(), BPhysicsValidation_cfi::daughters, reco::Candidate::energy(), Exception, lumiContext::fill, trackingPlots::fit, reco::RecoCandidate::gsfTrackType, edm::errors::InvalidReference, reco::Candidate::longLived(), PV3DBase< T, PVType, FrameType >::mag(), ResonanceBuilder::mass, AlCaHLTBitMon_ParallelJobs::p, p3, HadronAndPartonSelector_cfi::particles, Scenarios_cff::scale, reco::VertexCompositeCandidate::setChi2AndNdof(), reco::VertexCompositeCandidate::setCovariance(), reco::Candidate::setP4(), reco::LeafCandidate::setP4(), reco::Candidate::setVertex(), reco::LeafCandidate::setVertex(), mathSSE::sqrt(), badGlobalMuonTaggersAOD_cff::vtx, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

                                                                       {
   if(bField_ == nullptr)
     throw edm::Exception(edm::errors::InvalidReference)
       << "B-Field was not set up CandKinematicVertexFitter.\n"
       << "the following method must be called before fitting a candidate:\n"
       << " CandKinematicVertexFitter:.set( const MagneticField * )" << endl;
   vector<RefCountedKinematicParticle> particles;
   vector<Candidate *> daughters;
   vector<RecoCandidate::TrackType> trackTypes;
   // fill particles with KinematicParticles and daughters with Candidates of the daughters of c
   fill(particles, daughters, trackTypes, c);
   assert(particles.size() == daughters.size());
 
   // attempt to fit the KinematicParticles, particles  
   if(fit(particles)) {
     // after the fit, tree_ contains the KinematicTree from the fit
     tree_->movePointerToTheTop();
     // set the kinematic properties of the daughters from the fit
     RefCountedKinematicVertex vertex = tree_->currentDecayVertex();
     if(vertex->vertexIsValid()) {
       Candidate::Point vtx(vertex->position());
       c.setVertex(vtx);
       vector<RefCountedKinematicParticle> treeParticles = tree_->daughterParticles();
       vector<RefCountedKinematicParticle>::const_iterator particleIt = treeParticles.begin();
       vector<Candidate *>::const_iterator daughterIt = daughters.begin(), daughtersEnd = daughters.end();
       vector<RecoCandidate::TrackType>::const_iterator trackTypeIt = trackTypes.begin();
       Candidate::LorentzVector mp4(0, 0, 0, 0);
       for(; daughterIt != daughtersEnd; ++ particleIt, ++ daughterIt, ++trackTypeIt) {
     Candidate & daughter = * * daughterIt;
     GlobalVector p3 = (*particleIt)->currentState().globalMomentum();
     double px = p3.x(), py = p3.y(), pz = p3.z(), p = p3.mag();
     double energy;
 
     if(!daughter.longLived()) daughter.setVertex(vtx);
     double scale;
     switch(*trackTypeIt) {
     case RecoCandidate::gsfTrackType :
       //gsf used for electron tracks
       energy = daughter.energy();
       scale = energy / p;
       px *= scale; py *= scale; pz *= scale; 
     default:
       double mass = (*particleIt)->currentState().mass();
       energy = sqrt(p*p + mass*mass);
     };
     Candidate::LorentzVector dp4(px, py, pz, energy);
     daughter.setP4(dp4);
     mp4 += dp4;
       }
       c.setP4(mp4);
       c.setChi2AndNdof(chi2_ = vertex->chiSquared(), ndof_ = vertex->degreesOfFreedom());
       GlobalError err = vertex->error();
       cov_(0,0) = err.cxx();
       cov_(0,1) = err.cyx();
       cov_(0,2) = err.czx();
       cov_(1,2) = err.czy();
       cov_(1,1) = err.cyy();
       cov_(2,2) = err.czz();
       c.setCovariance(cov_);
     }
   } else {
     c.setChi2AndNdof(chi2_ = -1, ndof_ = 0);
     c.setCovariance(cov_ = CovarianceMatrix(ROOT::Math::SMatrixIdentity())); 
   }
 }