#include <TrackVertexArbitration.h>

Public Member Functions
	TrackVertexArbitration (const edm::ParameterSet &params)

std::vector< VTX >	trackVertexArbitrator (edm::Handle< reco::BeamSpot > &beamSpot, const reco::Vertex &pv, std::vector< reco::TransientTrack > &selectedTracks, std::vector< VTX > &secondaryVertices)

Private Member Functions
bool	trackFilterArbitrator (const reco::TransientTrack &track) const

Private Attributes
edm::InputTag	beamSpotCollection

double	distCut

double	dLenFraction

double	dRCut

double	fitterRatio

double	fitterSigmacut

double	fitterTini

double	maxTimeSignificance

edm::InputTag	primaryVertexCollection

edm::InputTag	secondaryVertexCollection

double	sigCut

double	sign

edm::InputTag	trackCollection

int	trackMinLayers

int	trackMinPixels

double	trackMinPt

Detailed Description

template<class VTX>
class TrackVertexArbitration< VTX >

Definition at line 58 of file TrackVertexArbitration.h.

Constructor & Destructor Documentation

template<class VTX >

TrackVertexArbitration< VTX >::TrackVertexArbitration ( const edm::ParameterSet & params )

Definition at line 94 of file TrackVertexArbitration.h.

References TrackVertexArbitration< VTX >::dRCut, and TrackVertexArbitration< VTX >::sign.

                                                                                  :
     primaryVertexCollection   (params.getParameter<edm::InputTag>("primaryVertices")),
     secondaryVertexCollection (params.getParameter<edm::InputTag>("secondaryVertices")),
     trackCollection           (params.getParameter<edm::InputTag>("tracks")),
         beamSpotCollection        (params.getParameter<edm::InputTag>("beamSpot")),
     dRCut                     (params.getParameter<double>("dRCut")),
     distCut                   (params.getParameter<double>("distCut")),
     sigCut                    (params.getParameter<double>("sigCut")),
     dLenFraction              (params.getParameter<double>("dLenFraction")),
     fitterSigmacut            (params.getParameter<double>("fitterSigmacut")),
     fitterTini                (params.getParameter<double>("fitterTini")),
     fitterRatio               (params.getParameter<double>("fitterRatio")),
     trackMinLayers            (params.getParameter<int32_t>("trackMinLayers")),
     trackMinPt                (params.getParameter<double>("trackMinPt")),
     trackMinPixels            (params.getParameter<int32_t>("trackMinPixels")),
     maxTimeSignificance       (params.getParameter<double>("maxTimeSignificance"))
 {
         sign = 1.0;
         if(dRCut < 0){sign = -1.0;}
         dRCut*=dRCut;
 }

Member Function Documentation

template<class VTX >

bool TrackVertexArbitration< VTX >::trackFilterArbitrator ( const reco::TransientTrack & track ) const

private

Definition at line 116 of file TrackVertexArbitration.h.

References reco::TrackBase::hitPattern(), reco::TransientTrack::isValid(), reco::HitPattern::numberOfValidPixelHits(), reco::TrackBase::pt(), reco::TransientTrack::track(), reco::HitPattern::trackerLayersWithMeasurement(), TrackVertexArbitration< VTX >::trackMinLayers, TrackVertexArbitration< VTX >::trackMinPixels, and TrackVertexArbitration< VTX >::trackMinPt.

Referenced by TrackVertexArbitration< VTX >::trackVertexArbitrator().

 {
     if(!track.isValid()) 
         return false;
         if (track.track().hitPattern().trackerLayersWithMeasurement() < trackMinLayers)
                 return false;
         if (track.track().pt() < trackMinPt)
                 return false;
         if (track.track().hitPattern().numberOfValidPixelHits() < trackMinPixels)
                 return false;
 
         return true;
 }

template<class VTX >

std::vector< VTX > TrackVertexArbitration< VTX >::trackVertexArbitrator	(	edm::Handle< reco::BeamSpot > &	beamSpot,
		const reco::Vertex &	pv,
		std::vector< reco::TransientTrack > &	selectedTracks,
		std::vector< VTX > &	secondaryVertices
	)

Definition at line 153 of file TrackVertexArbitration.h.

 {
     using namespace reco;
 
     //std::cout << "PV: " << pv.position() << std::endl;
         VertexDistance3D dist;
     AdaptiveVertexFitter theAdaptiveFitter(
                                             GeometricAnnealing(fitterSigmacut, fitterTini, fitterRatio),
                                             DefaultLinearizationPointFinder(),
                                             KalmanVertexUpdator<5>(),
                                             KalmanVertexTrackCompatibilityEstimator<5>(),
                                             KalmanVertexSmoother() );
 
 
 
     std::vector<VTX> recoVertices;
         VertexDistance3D vdist;
         GlobalPoint ppv(pv.position().x(),pv.position().y(),pv.position().z());
 
         std::unordered_map<unsigned int, Measurement1D> cachedIP;  
         for(typename std::vector<VTX>::const_iterator sv = secondaryVertices.begin();
         sv != secondaryVertices.end(); ++sv) {
 
       const double svTime(sv->t()), svTimeCov(svhelper::cov33(*sv));
           const bool svHasTime = svTimeCov > 0.;
         
         GlobalPoint ssv(sv->position().x(),sv->position().y(),sv->position().z());
             GlobalVector flightDir = ssv-ppv;
 //            std::cout << "Vertex : " << sv-secondaryVertices->begin() << " " << sv->position() << std::endl;
             Measurement1D dlen= vdist.distance(pv,VertexState(RecoVertex::convertPos(sv->position()),RecoVertex::convertError(sv->error())));
             std::vector<reco::TransientTrack>  selTracks;
         for(unsigned int itrack = 0; itrack < selectedTracks.size(); itrack++){
             TransientTrack & tt = (selectedTracks)[itrack];
             if (!trackFilterArbitrator(tt))                         continue;
                 tt.setBeamSpot(*beamSpot);
             float w = trackWeight(*sv,tt);
             Measurement1D ipv;
         if( cachedIP.count(itrack) ) {
           ipv=cachedIP[itrack];
         } else {
           std::pair<bool,Measurement1D> ipvp = IPTools::absoluteImpactParameter3D(tt,pv);
           cachedIP[itrack]=ipvp.second;
           ipv=ipvp.second;
         }
         
         AnalyticalImpactPointExtrapolator extrapolator(tt.field());
         TrajectoryStateOnSurface tsos = extrapolator.extrapolate(tt.impactPointState(), RecoVertex::convertPos(sv->position()));
         if(! tsos.isValid()) continue;
         GlobalPoint refPoint          = tsos.globalPosition();
         GlobalError refPointErr       = tsos.cartesianError().position();
         Measurement1D isv = dist.distance(VertexState(RecoVertex::convertPos(sv->position()),RecoVertex::convertError(sv->error())),VertexState(refPoint, refPointErr));       
 
         float dR = Geom::deltaR2(( (sign > 0) ? flightDir : -flightDir),tt.track()); //.eta(), flightDir.phi(), tt.track().eta(), tt.track().phi());
         
         double timeSig = 0.;
         if( svHasTime && edm::isFinite(tt.timeExt()) ) {
           double tError = std::sqrt( std::pow( tt.dtErrorExt(), 2 ) + svTimeCov );
           timeSig = std::abs(tt.timeExt() - svTime)/tError;
         }
 
                 if( w > 0 || ( isv.significance() < sigCut && isv.value() < distCut && isv.value() < dlen.value()*dLenFraction && timeSig < maxTimeSignificance) )
                 {
 
                   if(( isv.value() < ipv.value()  ) && isv.value() < distCut && isv.value() < dlen.value()*dLenFraction 
                   && dR < dRCut && timeSig < maxTimeSignificance ) 
                   {
 #ifdef VTXDEBUG
                      if(w > 0.5) std::cout << " = ";
                     else std::cout << " + ";
 #endif 
                      selTracks.push_back(tt);
                   } else
                   {
 #ifdef VTXDEBUG
                      if(w > 0.5 && isv.value() > ipv.value() ) std::cout << " - ";
                   else std::cout << "   ";
 #endif
                      //add also the tracks used in previous fitting that are still closer to Sv than Pv 
                      if(w > 0.5 && isv.value() <= ipv.value() && dR < dRCut && timeSig < maxTimeSignificance) {  
                        selTracks.push_back(tt);
 #ifdef VTXDEBUG
                        std::cout << " = ";
 #endif
                      }
                      if(w > 0.5 && isv.value() <= ipv.value() && dR >= dRCut) {
 #ifdef VTXDEBUG
                        std::cout << " - ";
 #endif
 
                      }
 
                     
                   }
 #ifdef VTXDEBUG
 
                   std::cout << "t : " << itrack << " ref " << ref.key() << " w: " << w 
                   << " svip: " << isv.significance() << " " << isv.value()  
                   << " pvip: " << ipv.significance() << " " << ipv.value()  << " res " << tt.track().residualX(0)   << "," << tt.track().residualY(0) 
 //                  << " tpvip: " << itpv.second.significance() << " " << itpv.second.value()  << " dr: "   << dR << std::endl;
 #endif
  
                 }
                else
                  {
 #ifdef VTXDEBUG
 
                   std::cout << " . t : " << itrack << " ref " << ref.key()<<  " w: " << w 
                   << " svip: " << isv.second.significance() << " " << isv.second.value()  
                   << " pvip: " << ipv.significance() << " " << ipv.value()  << " dr: "   << dR << std::endl;
 #endif
 
                  }
            }      
 
            if(selTracks.size() >= 2)
               { 
                  TransientVertex singleFitVertex;
                  singleFitVertex = theAdaptiveFitter.vertex(selTracks,ssv);
          
                 if(singleFitVertex.isValid())  { 
           if( pv.covariance(3,3) > 0. ) svhelper::updateVertexTime(singleFitVertex);
           recoVertices.push_back(VTX(singleFitVertex));
           
 
 #ifdef VTXDEBUG
                 const VTX & extVertex = recoVertices.back();
                       GlobalVector vtxDir = GlobalVector(extVertex.p4().X(),extVertex.p4().Y(),extVertex.p4().Z());
 
 
         std::cout << " pointing : " << Geom::deltaR(extVertex.position() - pv.position(), vtxDir) << std::endl;
 #endif
         }
               } 
     }
     return recoVertices;
 }