#include <Alignment/OfflineValidation/plugins/PrimaryVertexValidation.cc>

Inheritance diagram for PrimaryVertexValidation:

Public Member Functions
	PrimaryVertexValidation (const edm::ParameterSet &)

	~PrimaryVertexValidation ()

Public Member Functions inherited from edm::EDAnalyzer
	EDAnalyzer ()

std::string	workerType () const

virtual	~EDAnalyzer ()

Private Member Functions
virtual void	analyze (const edm::Event &, const edm::EventSetup &)

virtual void	beginJob ()

virtual void	endJob ()

bool	hasFirstLayerPixelHits (const reco::TrackRef track)

bool	isHit2D (const TrackingRecHit &hit) const

void	SetVarToZero ()

Private Attributes
int	charge_ [nMaxtracks_]

double	chi2_ [nMaxtracks_]

double	chi2ndof_ [nMaxtracks_]

float	chi2normUnbiasedVertex_ [nMaxtracks_]

float	chi2UnbiasedVertex_ [nMaxtracks_]

bool	debug_

float	DOFUnbiasedVertex_ [nMaxtracks_]

double	dszFromMyVertex_ [nMaxtracks_]

double	dxy_ [nMaxtracks_]

double	dxyFromMyVertex_ [nMaxtracks_]

double	dz_ [nMaxtracks_]

double	dzFromMyVertex_ [nMaxtracks_]

double	eta_ [nMaxtracks_]

std::string	filename_

int	hasRecVertex_ [nMaxtracks_]

int	isGoodTrack_ [nMaxtracks_]

int	Nevt_

int	nhits1D_ [nMaxtracks_]

int	nhits2D_ [nMaxtracks_]

int	nhits_ [nMaxtracks_]

int	nhitsBPIX_ [nMaxtracks_]

int	nhitsFPIX_ [nMaxtracks_]

int	nhitsTEC_ [nMaxtracks_]

int	nhitsTIB_ [nMaxtracks_]

int	nhitsTID_ [nMaxtracks_]

int	nhitsTOB_ [nMaxtracks_]

int	nTracks_

double	p_ [nMaxtracks_]

double	phi_ [nMaxtracks_]

double	pt_ [nMaxtracks_]

double	qoverp_ [nMaxtracks_]

TFile *	rootFile_

TTree *	rootTree_

float	sumOfWeightsUnbiasedVertex_ [nMaxtracks_]

edm::ParameterSet	theConfig

TrackFilterForPVFinding	theTrackFilter_

edm::InputTag	TrackCollectionTag_

int	tracksUsedForVertexing_ [nMaxtracks_]

double	xPCA_ [nMaxtracks_]

double	xUnbiasedVertex_ [nMaxtracks_]

double	yPCA_ [nMaxtracks_]

double	yUnbiasedVertex_ [nMaxtracks_]

double	zPCA_ [nMaxtracks_]

double	zUnbiasedVertex_ [nMaxtracks_]

Static Private Attributes
static const int	nMaxtracks_ = 1000

Additional Inherited Members
Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	ModuleType

typedef WorkerT< EDAnalyzer >	WorkerType

Static Public Member Functions inherited from edm::EDAnalyzer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::EDAnalyzer
CurrentProcessingContext const *	currentContext () const

Detailed Description

Description: Validate alignment constants using unbiased vertex residuals

Implementation: <Notes on="" implementation>="">

Definition at line 75 of file PrimaryVertexValidation.h.

Constructor & Destructor Documentation

PrimaryVertexValidation::PrimaryVertexValidation ( const edm::ParameterSet & iConfig )

explicit

Definition at line 68 of file PrimaryVertexValidation.cc.

References debug_, filename_, edm::ParameterSet::getParameter(), and TrackCollectionTag_.

   : theConfig(iConfig), 
     theTrackFilter_(iConfig.getParameter<edm::ParameterSet>("TkFilterParameters"))
 {
   //now do what ever initialization is needed
   debug_    = iConfig.getParameter<bool>       ("Debug");  
   TrackCollectionTag_      = iConfig.getParameter<edm::InputTag>("TrackCollectionTag");  
   filename_ = iConfig.getParameter<std::string>("OutputFileName"); 
 }

PrimaryVertexValidation::~PrimaryVertexValidation ( )

Definition at line 79 of file PrimaryVertexValidation.cc.

 {
    // do anything here that needs to be done at desctruction time
    // (e.g. close files, deallocate resources etc.)
 }

Member Function Documentation

void PrimaryVertexValidation::analyze	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

privatevirtual

Implements edm::EDAnalyzer.

Definition at line 92 of file PrimaryVertexValidation.cc.

References charge_, chi2_, chi2ndof_, chi2normUnbiasedVertex_, chi2UnbiasedVertex_, gather_cfg::cout, debug_, TransientVertex::degreesOfFreedom(), DOFUnbiasedVertex_, dszFromMyVertex_, dxy_, dxyFromMyVertex_, dz_, dzFromMyVertex_, eta_, edm::EventSetup::get(), edm::Event::getByLabel(), hasFirstLayerPixelHits(), hasRecVertex_, TransientVertex::hasTrackWeight(), i, isGoodTrack_, isHit2D(), TransientVertex::isValid(), j, kBPIX, kFPIX, LogTrace, Nevt_, nhits1D_, nhits2D_, nhits_, nhitsBPIX_, nhitsFPIX_, nhitsTEC_, nhitsTIB_, nhitsTID_, nhitsTOB_, nMaxtracks_, TransientVertex::normalisedChiSquared(), nTracks_, p_, phi_, TransientVertex::position(), pt_, qoverp_, rootTree_, SetVarToZero(), sumOfWeightsUnbiasedVertex_, StripSubdetector::TEC, theTrackFilter_, StripSubdetector::TIB, StripSubdetector::TID, StripSubdetector::TOB, TransientVertex::totalChiSquared(), ExpressReco_HICollisions_FallBack::track, TrackCollectionTag_, tracksUsedForVertexing_, TransientVertex::trackWeight(), VertexFitter< N >::vertex(), cms::Exception::what(), PV3DBase< T, PVType, FrameType >::x(), xPCA_, xUnbiasedVertex_, PV3DBase< T, PVType, FrameType >::y(), yPCA_, yUnbiasedVertex_, PV3DBase< T, PVType, FrameType >::z(), zPCA_, and zUnbiasedVertex_.

 {
 
   Nevt_++;  
 
   //=======================================================
   // Initialize Root-tuple variables
   //=======================================================
 
   SetVarToZero();
  
   //=======================================================
   // Retrieve the Magnetic Field information
   //=======================================================
 
   edm::ESHandle<MagneticField> theMGField;
   iSetup.get<IdealMagneticFieldRecord>().get( theMGField );
 
   //=======================================================
   // Retrieve the Tracking Geometry information
   //=======================================================
 
   edm::ESHandle<GlobalTrackingGeometry> theTrackingGeometry;
   iSetup.get<GlobalTrackingGeometryRecord>().get( theTrackingGeometry );
 
   //=======================================================
   // Retrieve the Track information
   //=======================================================
   
   edm::Handle<reco::TrackCollection>  trackCollectionHandle;
   iEvent.getByLabel(TrackCollectionTag_, trackCollectionHandle);
   
   //=======================================================
   // Retrieve offline vartex information (only for reco)
   //=======================================================
 
   /*
   double OfflineVertexX = 0.;
   double OfflineVertexY = 0.;
   double OfflineVertexZ = 0.;
   edm::Handle<reco::VertexCollection> vertices;
   try {
     iEvent.getByLabel("offlinePrimaryVertices", vertices);
   } catch (...) {
     std::cout << "No offlinePrimaryVertices found!" << std::endl;
   }
   if ( vertices.isValid() ) {
     OfflineVertexX = (*vertices)[0].x();
     OfflineVertexY = (*vertices)[0].y();
     OfflineVertexZ = (*vertices)[0].z();
   }
   */
   
   //=======================================================
   // Retrieve Beamspot information (only for reco)
   //=======================================================
 
   /*
     BeamSpot beamSpot;
     edm::Handle<BeamSpot> beamSpotHandle;
     iEvent.getByLabel("offlineBeamSpot", beamSpotHandle);
     
     if ( beamSpotHandle.isValid() )
     {
     beamSpot = *beamSpotHandle;
     
     } else
     {
     edm::LogInfo("PrimaryVertexValidation")
     << "No beam spot available from EventSetup \n";
     }
     
     double BSx0 = beamSpot.x0();
     double BSy0 = beamSpot.y0();
     double BSz0 = beamSpot.z0();
     
     if(debug_)
     std::cout<<"Beamspot x:"<<BSx0<<" y:"<<BSy0<<" z:"<<BSz0<std::<std::endl; 
     
     //double sigmaz = beamSpot.sigmaZ();
     //double dxdz = beamSpot.dxdz();
     //double BeamWidth = beamSpot.BeamWidth();
     */
   
   //=======================================================
   // Starts here ananlysis
   //=======================================================
   
   if(debug_)
     std::cout<<"PrimaryVertexValidation::analyze() looping over "<<trackCollectionHandle->size()<< "tracks." <<std::endl;       
   
   unsigned int i = 0;   
   for(reco::TrackCollection::const_iterator track = trackCollectionHandle->begin(); track!= trackCollectionHandle->end(); ++track, ++i)
     {
       if ( nTracks_ >= nMaxtracks_ ) {
     std::cout << " PrimaryVertexValidation::analyze() : Warning - Number of tracks: " << nTracks_ << " , greater than " << nMaxtracks_ << std::endl;
     continue;
       }
 
       pt_[nTracks_]       = track->pt();
       p_[nTracks_]        = track->p();
       nhits_[nTracks_]    = track->numberOfValidHits();
       eta_[nTracks_]      = track->eta();
       phi_[nTracks_]      = track->phi();
       chi2_[nTracks_]     = track->chi2();
       chi2ndof_[nTracks_] = track->normalizedChi2();
       charge_[nTracks_]   = track->charge();
       qoverp_[nTracks_]   = track->qoverp();
       dz_[nTracks_]       = track->dz();
       dxy_[nTracks_]      = track->dxy();
       xPCA_[nTracks_]     = track->vertex().x();
       yPCA_[nTracks_]     = track->vertex().y();
       zPCA_[nTracks_]     = track->vertex().z(); 
     
       //=======================================================
       // Retrieve rechit information
       //=======================================================  
 
       int nRecHit1D =0;
       int nRecHit2D =0;
       int nhitinTIB =0; 
       int nhitinTOB =0; 
       int nhitinTID =0; 
       int nhitinTEC =0; 
       int nhitinBPIX=0;
       int nhitinFPIX=0; 
       
       for (trackingRecHit_iterator iHit = track->recHitsBegin(); iHit != track->recHitsEnd(); ++iHit) {
     if((*iHit)->isValid()) {    
       
       if (this->isHit2D(**iHit)) {++nRecHit2D;}
       else {++nRecHit1D; }
    
       int type =(*iHit)->geographicalId().subdetId();
        
       if(type==int(StripSubdetector::TIB)){++nhitinTIB;}
       if(type==int(StripSubdetector::TOB)){++nhitinTOB;}
       if(type==int(StripSubdetector::TID)){++nhitinTID;}
       if(type==int(StripSubdetector::TEC)){++nhitinTEC;}
       if(type==int(                kBPIX)){++nhitinBPIX;}
       if(type==int(                kFPIX)){++nhitinFPIX;}
       
     }
       }      
 
       nhits1D_[nTracks_]     =nRecHit1D;
       nhits2D_[nTracks_]     =nRecHit2D;
       nhitsBPIX_[nTracks_]   =nhitinBPIX;
       nhitsFPIX_[nTracks_]   =nhitinFPIX;
       nhitsTIB_[nTracks_]    =nhitinTIB;
       nhitsTID_[nTracks_]    =nhitinTID;
       nhitsTOB_[nTracks_]    =nhitinTOB;
       nhitsTEC_[nTracks_]    =nhitinTEC;
 
       //=======================================================
       // Good tracks for vertexing selection
       //=======================================================  
 
       reco::TrackRef trackref(trackCollectionHandle,i);
       bool hasTheProbeFirstPixelLayerHit = false;
       hasTheProbeFirstPixelLayerHit = this->hasFirstLayerPixelHits(trackref);
       reco::TransientTrack theTTRef = reco::TransientTrack(trackref, &*theMGField, theTrackingGeometry );
       if (theTrackFilter_(theTTRef)&&hasTheProbeFirstPixelLayerHit){
     isGoodTrack_[nTracks_]=1;
       }
       
       //=======================================================
       // Fit unbiased vertex
       //=======================================================  
       
       std::vector<reco::TransientTrack> transientTracks;
       for(size_t j = 0; j < trackCollectionHandle->size(); j++)
     {
       reco::TrackRef tk(trackCollectionHandle, j);
       if( tk == trackref ) continue;
       bool hasTheTagFirstPixelLayerHit = false;
       hasTheTagFirstPixelLayerHit = this->hasFirstLayerPixelHits(tk);
       reco::TransientTrack theTT = reco::TransientTrack(tk, &*theMGField, theTrackingGeometry );
       if (theTrackFilter_(theTT)&&hasTheTagFirstPixelLayerHit){
         transientTracks.push_back(theTT);
       }
     }
       
       if(transientTracks.size() > 2){
     
     if(debug_)
       std::cout <<"PrimaryVertexValidation::analyze() :Transient Track Collection size: "<<transientTracks.size()<<std::endl;
     
     try{
 
       VertexFitter<5>* fitter = new AdaptiveVertexFitter;
       TransientVertex theFittedVertex = fitter->vertex(transientTracks);
       
       if(theFittedVertex.isValid ()){
         
         if(theFittedVertex.hasTrackWeight()){
           for(size_t rtracks= 0; rtracks < transientTracks.size(); rtracks++){
         sumOfWeightsUnbiasedVertex_[nTracks_] += theFittedVertex.trackWeight(transientTracks[rtracks]);
           }
         }
 
         const math::XYZPoint myVertex(theFittedVertex.position().x(),theFittedVertex.position().y(),theFittedVertex.position().z());
         hasRecVertex_[nTracks_]    = 1;
         xUnbiasedVertex_[nTracks_] = theFittedVertex.position().x();
         yUnbiasedVertex_[nTracks_] = theFittedVertex.position().y();
         zUnbiasedVertex_[nTracks_] = theFittedVertex.position().z();
         chi2normUnbiasedVertex_[nTracks_] = theFittedVertex.normalisedChiSquared();
         chi2UnbiasedVertex_[nTracks_] = theFittedVertex.totalChiSquared();
         DOFUnbiasedVertex_[nTracks_] = theFittedVertex.degreesOfFreedom();   
         tracksUsedForVertexing_[nTracks_] = transientTracks.size();
         dxyFromMyVertex_[nTracks_] = track->dxy(myVertex);
         dzFromMyVertex_[nTracks_]  = track->dz(myVertex);
         dszFromMyVertex_[nTracks_] = track->dsz(myVertex);
         
         if(debug_){
           std::cout<<"PrimaryVertexValidation::analyze() :myVertex.x()= "<<myVertex.x()<<" myVertex.y()= "<<myVertex.y()<<" theFittedVertex.z()= "<<myVertex.z()<<std::endl;      
           std::cout<<"PrimaryVertexValidation::analyze() : track->dz(myVertex)= "<<track->dz(myVertex)<<std::endl;
           std::cout<<"PrimaryVertexValidation::analyze() : zPCA -myVertex.z() = "<<(track->vertex().z() -myVertex.z() )<<std::endl; 
         }// ends if debug_
       } // ends if the fitted vertex is Valid
       
     }  catch ( cms::Exception& er ) {
       LogTrace("PrimaryVertexValidation::analyze RECO")<<"caught std::exception "<<er.what()<<std::endl;
     }
       } //ends if transientTracks.size() > 2
       
       else {
     std::cout << "PrimaryVertexValidation::analyze() :Not enough tracks to make a vertex.  Returns no vertex info" << std::endl;
       }
 
       ++nTracks_;  
     
       if(debug_)
     std::cout<< "Track "<<i<<" : pT = "<<track->pt()<<std::endl;
       
     }// for loop on tracks
   
   rootTree_->Fill();
 } 

void PrimaryVertexValidation::beginJob ( void )

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 382 of file PrimaryVertexValidation.cc.

References charge_, chi2_, chi2ndof_, chi2normUnbiasedVertex_, chi2UnbiasedVertex_, DOFUnbiasedVertex_, dszFromMyVertex_, dxy_, dxyFromMyVertex_, dz_, dzFromMyVertex_, eta_, filename_, hasRecVertex_, isGoodTrack_, Nevt_, nhits1D_, nhits2D_, nhits_, nhitsBPIX_, nhitsFPIX_, nhitsTEC_, nhitsTIB_, nhitsTID_, nhitsTOB_, nTracks_, p_, phi_, pt_, qoverp_, rootFile_, rootTree_, sumOfWeightsUnbiasedVertex_, tracksUsedForVertexing_, xPCA_, xUnbiasedVertex_, yPCA_, yUnbiasedVertex_, zPCA_, and zUnbiasedVertex_.

 {
   edm::LogInfo("beginJob") << "Begin Job" << std::endl;
   // Define TTree for output
 
   Nevt_    = 0;
   
   rootFile_ = new TFile(filename_.c_str(),"recreate");
   rootTree_ = new TTree("tree","PV Validation tree");
   
   // Track Paramters 
   rootTree_->Branch("nTracks",&nTracks_,"nTracks/I");
   rootTree_->Branch("pt",&pt_,"pt[nTracks]/D");
   rootTree_->Branch("p",&p_,"p[nTracks]/D");
   rootTree_->Branch("nhits",&nhits_,"nhits[nTracks]/I");
   rootTree_->Branch("nhits1D",&nhits1D_,"nhits1D[nTracks]/I");
   rootTree_->Branch("nhits2D",&nhits2D_,"nhits2D[nTracks]/I");
   rootTree_->Branch("nhitsBPIX",&nhitsBPIX_,"nhitsBPIX[nTracks]/I");
   rootTree_->Branch("nhitsFPIX",&nhitsFPIX_,"nhitsFPIX[nTracks]/I");
   rootTree_->Branch("nhitsTIB",&nhitsTIB_,"nhitsTIB[nTracks]/I");
   rootTree_->Branch("nhitsTID",&nhitsTID_,"nhitsTID[nTracks]/I");
   rootTree_->Branch("nhitsTOB",&nhitsTOB_,"nhitsTOB[nTracks]/I");
   rootTree_->Branch("nhitsTEC",&nhitsTEC_,"nhitsTEC[nTracks]/I");
   rootTree_->Branch("eta",&eta_,"eta[nTracks]/D");
   rootTree_->Branch("phi",&phi_,"phi[nTracks]/D");
   rootTree_->Branch("chi2",&chi2_,"chi2[nTracks]/D");
   rootTree_->Branch("chi2ndof",&chi2ndof_,"chi2ndof[nTracks]/D");
   rootTree_->Branch("charge",&charge_,"charge[nTracks]/I");
   rootTree_->Branch("qoverp",&qoverp_,"qoverp[nTracks]/D");
   rootTree_->Branch("dz",&dz_,"dz[nTracks]/D");
   rootTree_->Branch("dxy",&dxy_,"dxy[nTracks]/D");
   rootTree_->Branch("xPCA",&xPCA_,"xPCA[nTracks]/D");
   rootTree_->Branch("yPCA",&yPCA_,"yPCA[nTracks]/D");
   rootTree_->Branch("zPCA",&zPCA_,"zPCA[nTracks]/D");
   rootTree_->Branch("xUnbiasedVertex",&xUnbiasedVertex_,"xUnbiasedVertex[nTracks]/D");
   rootTree_->Branch("yUnbiasedVertex",&yUnbiasedVertex_,"yUnbiasedVertex[nTracks]/D");
   rootTree_->Branch("zUnbiasedVertex",&zUnbiasedVertex_,"zUnbiasedVertex[nTracks]/D");
   rootTree_->Branch("chi2normUnbiasedVertex",&chi2normUnbiasedVertex_,"chi2normUnbiasedVertex[nTracks]/F");
   rootTree_->Branch("chi2UnbiasedVertex",&chi2UnbiasedVertex_,"chi2UnbiasedVertex[nTracks]/F");
   rootTree_->Branch("DOFUnbiasedVertex",&DOFUnbiasedVertex_," DOFUnbiasedVertex[nTracks]/F");
   rootTree_->Branch("sumOfWeightsUnbiasedVertex",&sumOfWeightsUnbiasedVertex_,"sumOfWeightsUnbiasedVertex[nTracks]/F");
   rootTree_->Branch("tracksUsedForVertexing",&tracksUsedForVertexing_,"tracksUsedForVertexing[nTracks]/I");
   rootTree_->Branch("dxyFromMyVertex",&dxyFromMyVertex_,"dxyFromMyVertex[nTracks]/D");
   rootTree_->Branch("dzFromMyVertex",&dzFromMyVertex_,"dzFromMyVertex[nTracks]/D");
   rootTree_->Branch("dszFromMyVertex",&dszFromMyVertex_,"dszFromMyVertex[nTracks]/D");
   rootTree_->Branch("hasRecVertex",&hasRecVertex_,"hasRecVertex[nTracks]/I");
   rootTree_->Branch("isGoodTrack",&isGoodTrack_,"isGoodTrack[nTracks]/I");
 }

void PrimaryVertexValidation::endJob ( void )

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 432 of file PrimaryVertexValidation.cc.

References gather_cfg::cout, Nevt_, and rootFile_.

 {
 
   std::cout<<"######################################"<<std::endl;
   std::cout<<"Number of analyzed events: "<<Nevt_<<std::endl;
   std::cout<<"######################################"<<std::endl;
   
    if ( rootFile_ ) {
      rootFile_->Write();
      rootFile_->Close();
    }
 }

bool PrimaryVertexValidation::hasFirstLayerPixelHits ( const reco::TrackRef track )

private

Definition at line 363 of file PrimaryVertexValidation.cc.

References reco::HitPattern::getHitPattern(), reco::HitPattern::getLayer(), i, reco::HitPattern::numberOfHits(), L1TEmulatorMonitor_cff::p, listBenchmarks::pattern, reco::HitPattern::pixelBarrelHitFilter(), reco::HitPattern::pixelEndcapHitFilter(), and reco::HitPattern::validHitFilter().

Referenced by analyze().

 {
   bool accepted = false;
   // hit pattern of the track
   const reco::HitPattern& p = track->hitPattern();      
   for (int i=0; i<p.numberOfHits(); i++) {
     uint32_t pattern = p.getHitPattern(i);   
     if (p.pixelBarrelHitFilter(pattern) || p.pixelEndcapHitFilter(pattern) ) {
       if (p.getLayer(pattern) == 1) {
     if (p.validHitFilter(pattern)) {
       accepted = true;
     }
       }
     }
   }
   return accepted;
 } 

bool PrimaryVertexValidation::isHit2D ( const TrackingRecHit & hit ) const

private

Definition at line 333 of file PrimaryVertexValidation.cc.

References TrackingRecHit::dimension(), TrackingRecHit::geographicalId(), kBPIX, kFPIX, and DetId::Tracker.

Referenced by analyze().

 {
   if (hit.dimension() < 2) {
     return false; // some (muon...) stuff really has RecHit1D
   } else {
     const DetId detId(hit.geographicalId());
     if (detId.det() == DetId::Tracker) {
       if (detId.subdetId() == kBPIX || detId.subdetId() == kFPIX) {
         return true; // pixel is always 2D
       } else { // should be SiStrip now
         if (dynamic_cast<const SiStripRecHit2D*>(&hit)) return false; // normal hit
         else if (dynamic_cast<const SiStripMatchedRecHit2D*>(&hit)) return true; // matched is 2D
         else if (dynamic_cast<const ProjectedSiStripRecHit2D*>(&hit)) return false; // crazy hit...
         else {
           edm::LogError("UnkownType") << "@SUB=AlignmentTrackSelector::isHit2D"
                                       << "Tracker hit not in pixel and neither SiStripRecHit2D nor "
                                       << "SiStripMatchedRecHit2D nor ProjectedSiStripRecHit2D.";
           return false;
         }
       }
     } else { // not tracker??
       edm::LogWarning("DetectorMismatch") << "@SUB=AlignmentTrackSelector::isHit2D"
                                           << "Hit not in tracker with 'official' dimension >=2.";
       return true; // dimension() >= 2 so accept that...
     }
   }
   // never reached...
 }

void PrimaryVertexValidation::SetVarToZero ( )

private

Definition at line 445 of file PrimaryVertexValidation.cc.

References charge_, chi2_, chi2ndof_, chi2normUnbiasedVertex_, chi2UnbiasedVertex_, DOFUnbiasedVertex_, dszFromMyVertex_, dxy_, dxyFromMyVertex_, dz_, dzFromMyVertex_, eta_, hasRecVertex_, i, isGoodTrack_, nhits1D_, nhits2D_, nhits_, nhitsBPIX_, nhitsFPIX_, nhitsTEC_, nhitsTIB_, nhitsTID_, nhitsTOB_, nMaxtracks_, nTracks_, p_, phi_, pt_, qoverp_, sumOfWeightsUnbiasedVertex_, tracksUsedForVertexing_, xPCA_, xUnbiasedVertex_, yPCA_, yUnbiasedVertex_, zPCA_, and zUnbiasedVertex_.

Referenced by analyze().

                                            {
   
   nTracks_ = 0;
   for ( int i=0; i<nMaxtracks_; ++i ) {
     pt_[i]        = 0;
     p_[i]         = 0;
     nhits_[i]     = 0;
     nhits1D_[i]   = 0;
     nhits2D_[i]   = 0;
     nhitsBPIX_[i]  = 0;
     nhitsFPIX_[i]  = 0;
     nhitsTIB_[i]   = 0;
     nhitsTID_[i]   = 0;
     nhitsTOB_[i]   = 0;
     nhitsTEC_[i]   = 0;
     eta_[i]       = 0;
     phi_[i]       = 0;
     chi2_[i]      = 0;
     chi2ndof_[i]  = 0;
     charge_[i]    = 0;
     qoverp_[i]    = 0;
     dz_[i]        = 0;
     dxy_[i]       = 0;
     xPCA_[i]      = 0;
     yPCA_[i]      = 0;
     zPCA_[i]      = 0;
     xUnbiasedVertex_[i] =0;    
     yUnbiasedVertex_[i] =0;
     zUnbiasedVertex_[i] =0;
     chi2normUnbiasedVertex_[i]=0;
     chi2UnbiasedVertex_[i]=0;
     DOFUnbiasedVertex_[i]=0;
     sumOfWeightsUnbiasedVertex_[i]=0;
     tracksUsedForVertexing_[i]=0;
     dxyFromMyVertex_[i]=0;
     dzFromMyVertex_[i]=0;
     dszFromMyVertex_[i]=0;
     hasRecVertex_[i] = 0;
     isGoodTrack_[i]  = 0;
   } 
 }