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

Inheritance diagram for PrimaryVertexValidation:

Public Member Functions
	PrimaryVertexValidation (const edm::ParameterSet &)
	~PrimaryVertexValidation ()
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

Detailed Description

Description: Validate alignment constants using unbiased vertex residuals

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

Definition at line 74 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(), SetVarToZero(), and TrackCollectionTag_.

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

  SetVarToZero();
}

PrimaryVertexValidation::~PrimaryVertexValidation ( )

Definition at line 84 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
	)		`[private, virtual]`

Implements edm::EDAnalyzer.

Definition at line 97 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(), 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 ) [private, virtual]

Reimplemented from edm::EDAnalyzer.

Definition at line 387 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 ) [private, virtual]

Reimplemented from edm::EDAnalyzer.

Definition at line 437 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 368 of file PrimaryVertexValidation.cc.

References reco::HitPattern::getHitPattern(), reco::HitPattern::getLayer(), i, reco::HitPattern::numberOfHits(), AlCaHLTBitMon_ParallelJobs::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 338 of file PrimaryVertexValidation.cc.

References TrackingRecHit::dimension(), TrackingRecHit::geographicalId(), kBPIX, kFPIX, and align::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 450 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(), and PrimaryVertexValidation().

                                           {
  
  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;
  } 
}