V0Fitter Class Reference

#include <RecoVertex/V0Producer/interface/V0Fitter.h>

Public Member Functions
void	fitAll (const edm::Event &iEvent, const edm::EventSetup &iSetup, reco::VertexCompositeCandidateCollection &k, reco::VertexCompositeCandidateCollection &l)
	V0Fitter (const edm::ParameterSet &theParams, edm::ConsumesCollector &&iC)

Private Attributes
double	cosThetaXYCut_
double	cosThetaXYZCut_
bool	doKShorts_
bool	doLambdas_
double	innerHitPosCut_
double	kShortMassCut_
double	lambdaMassCut_
double	mPiPiCut_
double	tkChi2Cut_
double	tkDCACut_
double	tkIPSigXYCut_
double	tkIPSigZCut_
int	tkNHitsCut_
double	tkPtCut_
edm::EDGetTokenT< reco::BeamSpot >	token_beamSpot
edm::EDGetTokenT< reco::TrackCollection >	token_tracks
edm::EDGetTokenT< std::vector< reco::Vertex > >	token_vertices
bool	useRefTracks_
bool	useVertex_
bool	vertexFitter_
double	vtxChi2Cut_
double	vtxDecaySigXYCut_
double	vtxDecaySigXYZCut_

Detailed Description

Description: <one line="" class="" summary>="">

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

Definition at line 40 of file V0Fitter.h.

Constructor & Destructor Documentation

V0Fitter()

V0Fitter::V0Fitter	(	const edm::ParameterSet &	theParams,
		edm::ConsumesCollector &&	iC
	)

Definition at line 49 of file V0Fitter.cc.

                                                                                  {
  token_beamSpot = iC.consumes<reco::BeamSpot>(theParameters.getParameter<edm::InputTag>("beamSpot"));
  useVertex_ = theParameters.getParameter<bool>("useVertex");
  token_vertices = iC.consumes<std::vector<reco::Vertex>>(theParameters.getParameter<edm::InputTag>("vertices"));
 
  token_tracks = iC.consumes<reco::TrackCollection>(theParameters.getParameter<edm::InputTag>("trackRecoAlgorithm"));
  vertexFitter_ = theParameters.getParameter<bool>("vertexFitter");
  useRefTracks_ = theParameters.getParameter<bool>("useRefTracks");
 
  // whether to reconstruct KShorts
  doKShorts_ = theParameters.getParameter<bool>("doKShorts");
  // whether to reconstruct Lambdas
  doLambdas_ = theParameters.getParameter<bool>("doLambdas");
 
  // cuts on initial track selection
  tkChi2Cut_ = theParameters.getParameter<double>("tkChi2Cut");
  tkNHitsCut_ = theParameters.getParameter<int>("tkNHitsCut");
  tkPtCut_ = theParameters.getParameter<double>("tkPtCut");
  tkIPSigXYCut_ = theParameters.getParameter<double>("tkIPSigXYCut");
  tkIPSigZCut_ = theParameters.getParameter<double>("tkIPSigZCut");
 
  // cuts on vertex
  vtxChi2Cut_ = theParameters.getParameter<double>("vtxChi2Cut");
  vtxDecaySigXYZCut_ = theParameters.getParameter<double>("vtxDecaySigXYZCut");
  vtxDecaySigXYCut_ = theParameters.getParameter<double>("vtxDecaySigXYCut");
  // miscellaneous cuts
  tkDCACut_ = theParameters.getParameter<double>("tkDCACut");
  mPiPiCut_ = theParameters.getParameter<double>("mPiPiCut");
  innerHitPosCut_ = theParameters.getParameter<double>("innerHitPosCut");
  cosThetaXYCut_ = theParameters.getParameter<double>("cosThetaXYCut");
  cosThetaXYZCut_ = theParameters.getParameter<double>("cosThetaXYZCut");
  // cuts on the V0 candidate mass
  kShortMassCut_ = theParameters.getParameter<double>("kShortMassCut");
  lambdaMassCut_ = theParameters.getParameter<double>("lambdaMassCut");
}

References cosThetaXYCut_, cosThetaXYZCut_, doKShorts_, doLambdas_, edm::ParameterSet::getParameter(), innerHitPosCut_, kShortMassCut_, lambdaMassCut_, mPiPiCut_, tkChi2Cut_, tkDCACut_, tkIPSigXYCut_, tkIPSigZCut_, tkNHitsCut_, tkPtCut_, token_beamSpot, token_tracks, token_vertices, useRefTracks_, useVertex_, vertexFitter_, vtxChi2Cut_, vtxDecaySigXYCut_, and vtxDecaySigXYZCut_.

Member Function Documentation

fitAll()

void V0Fitter::fitAll	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup,
		reco::VertexCompositeCandidateCollection &	k,
		reco::VertexCompositeCandidateCollection &	l
	)

Definition at line 86 of file V0Fitter.cc.

                                                                          {
  using std::vector;
 
  edm::Handle<reco::TrackCollection> theTrackHandle;
  iEvent.getByToken(token_tracks, theTrackHandle);
  if (theTrackHandle->empty())
    return;
  const reco::TrackCollection* theTrackCollection = theTrackHandle.product();
 
  edm::Handle<reco::BeamSpot> theBeamSpotHandle;
  iEvent.getByToken(token_beamSpot, theBeamSpotHandle);
  const reco::BeamSpot* theBeamSpot = theBeamSpotHandle.product();
  math::XYZPoint referencePos(theBeamSpot->position());
 
  reco::Vertex referenceVtx;
  if (useVertex_) {
    edm::Handle<std::vector<reco::Vertex>> vertices;
    iEvent.getByToken(token_vertices, vertices);
    referenceVtx = vertices->at(0);
    referencePos = referenceVtx.position();
  }
 
  edm::ESHandle<MagneticField> theMagneticFieldHandle;
  iSetup.get<IdealMagneticFieldRecord>().get(theMagneticFieldHandle);
  const MagneticField* theMagneticField = theMagneticFieldHandle.product();
 
  std::vector<reco::TrackRef> theTrackRefs;
  std::vector<reco::TransientTrack> theTransTracks;
 
  // fill vectors of TransientTracks and TrackRefs after applying preselection cuts
  for (reco::TrackCollection::const_iterator iTk = theTrackCollection->begin(); iTk != theTrackCollection->end();
       ++iTk) {
    const reco::Track* tmpTrack = &(*iTk);
    double ipsigXY = std::abs(tmpTrack->dxy(*theBeamSpot) / tmpTrack->dxyError());
    if (useVertex_)
      ipsigXY = std::abs(tmpTrack->dxy(referencePos) / tmpTrack->dxyError());
    double ipsigZ = std::abs(tmpTrack->dz(referencePos) / tmpTrack->dzError());
    if (tmpTrack->normalizedChi2() < tkChi2Cut_ && tmpTrack->numberOfValidHits() >= tkNHitsCut_ &&
        tmpTrack->pt() > tkPtCut_ && ipsigXY > tkIPSigXYCut_ && ipsigZ > tkIPSigZCut_) {
      reco::TrackRef tmpRef(theTrackHandle, std::distance(theTrackCollection->begin(), iTk));
      theTrackRefs.push_back(std::move(tmpRef));
      reco::TransientTrack tmpTransient(*tmpRef, theMagneticField);
      theTransTracks.push_back(std::move(tmpTransient));
    }
  }
  // good tracks have now been selected for vertexing
 
  // loop over tracks and vertex good charged track pairs
  for (unsigned int trdx1 = 0; trdx1 < theTrackRefs.size(); ++trdx1) {
    for (unsigned int trdx2 = trdx1 + 1; trdx2 < theTrackRefs.size(); ++trdx2) {
      reco::TrackRef positiveTrackRef;
      reco::TrackRef negativeTrackRef;
      reco::TransientTrack* posTransTkPtr = nullptr;
      reco::TransientTrack* negTransTkPtr = nullptr;
 
      if (theTrackRefs[trdx1]->charge() < 0. && theTrackRefs[trdx2]->charge() > 0.) {
        negativeTrackRef = theTrackRefs[trdx1];
        positiveTrackRef = theTrackRefs[trdx2];
        negTransTkPtr = &theTransTracks[trdx1];
        posTransTkPtr = &theTransTracks[trdx2];
      } else if (theTrackRefs[trdx1]->charge() > 0. && theTrackRefs[trdx2]->charge() < 0.) {
        negativeTrackRef = theTrackRefs[trdx2];
        positiveTrackRef = theTrackRefs[trdx1];
        negTransTkPtr = &theTransTracks[trdx2];
        posTransTkPtr = &theTransTracks[trdx1];
      } else {
        continue;
      }
 
      // measure distance between tracks at their closest approach
 
      //these two variables are needed to 'pin' the temporary value returned to the stack
      // in order to keep posState and negState from pointing to destructed objects
      auto const& posImpact = posTransTkPtr->impactPointTSCP();
      auto const& negImpact = negTransTkPtr->impactPointTSCP();
      if (!posImpact.isValid() || !negImpact.isValid())
        continue;
      FreeTrajectoryState const& posState = posImpact.theState();
      FreeTrajectoryState const& negState = negImpact.theState();
      ClosestApproachInRPhi cApp;
      cApp.calculate(posState, negState);
      if (!cApp.status())
        continue;
      float dca = std::abs(cApp.distance());
      if (dca > tkDCACut_)
        continue;
 
      // the POCA should at least be in the sensitive volume
      GlobalPoint cxPt = cApp.crossingPoint();
      if ((cxPt.x() * cxPt.x() + cxPt.y() * cxPt.y()) > 120. * 120. || std::abs(cxPt.z()) > 300.)
        continue;
 
      // the tracks should at least point in the same quadrant
      TrajectoryStateClosestToPoint const& posTSCP = posTransTkPtr->trajectoryStateClosestToPoint(cxPt);
      TrajectoryStateClosestToPoint const& negTSCP = negTransTkPtr->trajectoryStateClosestToPoint(cxPt);
      if (!posTSCP.isValid() || !negTSCP.isValid())
        continue;
      if (posTSCP.momentum().dot(negTSCP.momentum()) < 0)
        continue;
 
      // calculate mPiPi
      double totalE = sqrt(posTSCP.momentum().mag2() + piMassSquared) + sqrt(negTSCP.momentum().mag2() + piMassSquared);
      double totalESq = totalE * totalE;
      double totalPSq = (posTSCP.momentum() + negTSCP.momentum()).mag2();
      double massSquared = totalESq - totalPSq;
      if (massSquared > mPiPiCut_ * mPiPiCut_)
        continue;
 
      // Fill the vector of TransientTracks to send to KVF
      std::vector<reco::TransientTrack> transTracks;
      transTracks.reserve(2);
      transTracks.push_back(*posTransTkPtr);
      transTracks.push_back(*negTransTkPtr);
 
      // create the vertex fitter object and vertex the tracks
      TransientVertex theRecoVertex;
      if (vertexFitter_) {
        KalmanVertexFitter theKalmanFitter(useRefTracks_ == 0 ? false : true);
        theRecoVertex = theKalmanFitter.vertex(transTracks);
      } else if (!vertexFitter_) {
        useRefTracks_ = false;
        AdaptiveVertexFitter theAdaptiveFitter;
        theRecoVertex = theAdaptiveFitter.vertex(transTracks);
      }
      if (!theRecoVertex.isValid())
        continue;
 
      reco::Vertex theVtx = theRecoVertex;
      if (theVtx.normalizedChi2() > vtxChi2Cut_)
        continue;
      GlobalPoint vtxPos(theVtx.x(), theVtx.y(), theVtx.z());
 
      // 2D decay significance
      SMatrixSym3D totalCov = theBeamSpot->rotatedCovariance3D() + theVtx.covariance();
      if (useVertex_)
        totalCov = referenceVtx.covariance() + theVtx.covariance();
      SVector3 distVecXY(vtxPos.x() - referencePos.x(), vtxPos.y() - referencePos.y(), 0.);
      double distMagXY = ROOT::Math::Mag(distVecXY);
      double sigmaDistMagXY = sqrt(ROOT::Math::Similarity(totalCov, distVecXY)) / distMagXY;
      if (distMagXY / sigmaDistMagXY < vtxDecaySigXYCut_)
        continue;
 
      // 3D decay significance
      if (vtxDecaySigXYZCut_ > 0.) {
        SVector3 distVecXYZ(
            vtxPos.x() - referencePos.x(), vtxPos.y() - referencePos.y(), vtxPos.z() - referencePos.z());
        double distMagXYZ = ROOT::Math::Mag(distVecXYZ);
        double sigmaDistMagXYZ = sqrt(ROOT::Math::Similarity(totalCov, distVecXYZ)) / distMagXYZ;
        if (distMagXYZ / sigmaDistMagXYZ < vtxDecaySigXYZCut_)
          continue;
      }
 
      // make sure the vertex radius is within the inner track hit radius
      double tkHitPosLimitSquared =
          (distMagXY - sigmaDistMagXY * innerHitPosCut_) * (distMagXY - sigmaDistMagXY * innerHitPosCut_);
      if (innerHitPosCut_ > 0. && positiveTrackRef->innerOk()) {
        reco::Vertex::Point posTkHitPos = positiveTrackRef->innerPosition();
        double posTkHitPosD2 = (posTkHitPos.x() - referencePos.x()) * (posTkHitPos.x() - referencePos.x()) +
                               (posTkHitPos.y() - referencePos.y()) * (posTkHitPos.y() - referencePos.y());
        if (posTkHitPosD2 < tkHitPosLimitSquared)
          continue;
      }
      if (innerHitPosCut_ > 0. && negativeTrackRef->innerOk()) {
        reco::Vertex::Point negTkHitPos = negativeTrackRef->innerPosition();
        double negTkHitPosD2 = (negTkHitPos.x() - referencePos.x()) * (negTkHitPos.x() - referencePos.x()) +
                               (negTkHitPos.y() - referencePos.y()) * (negTkHitPos.y() - referencePos.y());
        if (negTkHitPosD2 < tkHitPosLimitSquared)
          continue;
      }
 
      std::unique_ptr<TrajectoryStateClosestToPoint> trajPlus;
      std::unique_ptr<TrajectoryStateClosestToPoint> trajMins;
      std::vector<reco::TransientTrack> theRefTracks;
      if (theRecoVertex.hasRefittedTracks()) {
        theRefTracks = theRecoVertex.refittedTracks();
      }
 
      if (useRefTracks_ && theRefTracks.size() > 1) {
        reco::TransientTrack* thePositiveRefTrack = nullptr;
        reco::TransientTrack* theNegativeRefTrack = nullptr;
        for (std::vector<reco::TransientTrack>::iterator iTrack = theRefTracks.begin(); iTrack != theRefTracks.end();
             ++iTrack) {
          if (iTrack->track().charge() > 0.) {
            thePositiveRefTrack = &*iTrack;
          } else if (iTrack->track().charge() < 0.) {
            theNegativeRefTrack = &*iTrack;
          }
        }
        if (thePositiveRefTrack == nullptr || theNegativeRefTrack == nullptr)
          continue;
        trajPlus =
            std::make_unique<TrajectoryStateClosestToPoint>(thePositiveRefTrack->trajectoryStateClosestToPoint(vtxPos));
        trajMins =
            std::make_unique<TrajectoryStateClosestToPoint>(theNegativeRefTrack->trajectoryStateClosestToPoint(vtxPos));
      } else {
        trajPlus =
            std::make_unique<TrajectoryStateClosestToPoint>(posTransTkPtr->trajectoryStateClosestToPoint(vtxPos));
        trajMins =
            std::make_unique<TrajectoryStateClosestToPoint>(negTransTkPtr->trajectoryStateClosestToPoint(vtxPos));
      }
 
      if (trajPlus.get() == nullptr || trajMins.get() == nullptr || !trajPlus->isValid() || !trajMins->isValid())
        continue;
 
      GlobalVector positiveP(trajPlus->momentum());
      GlobalVector negativeP(trajMins->momentum());
      GlobalVector totalP(positiveP + negativeP);
 
      // 2D pointing angle
      double dx = theVtx.x() - referencePos.x();
      double dy = theVtx.y() - referencePos.y();
      double px = totalP.x();
      double py = totalP.y();
      double angleXY = (dx * px + dy * py) / (sqrt(dx * dx + dy * dy) * sqrt(px * px + py * py));
      if (angleXY < cosThetaXYCut_)
        continue;
 
      // 3D pointing angle
      if (cosThetaXYZCut_ > -1.) {
        double dz = theVtx.z() - referencePos.z();
        double pz = totalP.z();
        double angleXYZ =
            (dx * px + dy * py + dz * pz) / (sqrt(dx * dx + dy * dy + dz * dz) * sqrt(px * px + py * py + pz * pz));
        if (angleXYZ < cosThetaXYZCut_)
          continue;
      }
 
      // calculate total energy of V0 3 ways: assume it's a kShort, a Lambda, or a LambdaBar.
      double piPlusE = sqrt(positiveP.mag2() + piMassSquared);
      double piMinusE = sqrt(negativeP.mag2() + piMassSquared);
      double protonE = sqrt(positiveP.mag2() + protonMassSquared);
      double antiProtonE = sqrt(negativeP.mag2() + protonMassSquared);
      double kShortETot = piPlusE + piMinusE;
      double lambdaEtot = protonE + piMinusE;
      double lambdaBarEtot = antiProtonE + piPlusE;
 
      // Create momentum 4-vectors for the 3 candidate types
      const reco::Particle::LorentzVector kShortP4(totalP.x(), totalP.y(), totalP.z(), kShortETot);
      const reco::Particle::LorentzVector lambdaP4(totalP.x(), totalP.y(), totalP.z(), lambdaEtot);
      const reco::Particle::LorentzVector lambdaBarP4(totalP.x(), totalP.y(), totalP.z(), lambdaBarEtot);
 
      reco::Particle::Point vtx(theVtx.x(), theVtx.y(), theVtx.z());
      const reco::Vertex::CovarianceMatrix vtxCov(theVtx.covariance());
      double vtxChi2(theVtx.chi2());
      double vtxNdof(theVtx.ndof());
 
      // Create the VertexCompositeCandidate object that will be stored in the Event
      reco::VertexCompositeCandidate* theKshort = nullptr;
      reco::VertexCompositeCandidate* theLambda = nullptr;
      reco::VertexCompositeCandidate* theLambdaBar = nullptr;
 
      if (doKShorts_) {
        theKshort = new reco::VertexCompositeCandidate(0, kShortP4, vtx, vtxCov, vtxChi2, vtxNdof);
      }
      if (doLambdas_) {
        if (positiveP.mag2() > negativeP.mag2()) {
          theLambda = new reco::VertexCompositeCandidate(0, lambdaP4, vtx, vtxCov, vtxChi2, vtxNdof);
        } else {
          theLambdaBar = new reco::VertexCompositeCandidate(0, lambdaBarP4, vtx, vtxCov, vtxChi2, vtxNdof);
        }
      }
 
      // Create daughter candidates for the VertexCompositeCandidates
      reco::RecoChargedCandidate thePiPlusCand(
          1, reco::Particle::LorentzVector(positiveP.x(), positiveP.y(), positiveP.z(), piPlusE), vtx);
      thePiPlusCand.setTrack(positiveTrackRef);
 
      reco::RecoChargedCandidate thePiMinusCand(
          -1, reco::Particle::LorentzVector(negativeP.x(), negativeP.y(), negativeP.z(), piMinusE), vtx);
      thePiMinusCand.setTrack(negativeTrackRef);
 
      reco::RecoChargedCandidate theProtonCand(
          1, reco::Particle::LorentzVector(positiveP.x(), positiveP.y(), positiveP.z(), protonE), vtx);
      theProtonCand.setTrack(positiveTrackRef);
 
      reco::RecoChargedCandidate theAntiProtonCand(
          -1, reco::Particle::LorentzVector(negativeP.x(), negativeP.y(), negativeP.z(), antiProtonE), vtx);
      theAntiProtonCand.setTrack(negativeTrackRef);
 
      AddFourMomenta addp4;
      // Store the daughter Candidates in the VertexCompositeCandidates if they pass mass cuts
      if (doKShorts_) {
        theKshort->addDaughter(thePiPlusCand);
        theKshort->addDaughter(thePiMinusCand);
        theKshort->setPdgId(310);
        addp4.set(*theKshort);
        if (theKshort->mass() < kShortMass + kShortMassCut_ && theKshort->mass() > kShortMass - kShortMassCut_) {
          theKshorts.push_back(std::move(*theKshort));
        }
      }
      if (doLambdas_ && theLambda) {
        theLambda->addDaughter(theProtonCand);
        theLambda->addDaughter(thePiMinusCand);
        theLambda->setPdgId(3122);
        addp4.set(*theLambda);
        if (theLambda->mass() < lambdaMass + lambdaMassCut_ && theLambda->mass() > lambdaMass - lambdaMassCut_) {
          theLambdas.push_back(std::move(*theLambda));
        }
      } else if (doLambdas_ && theLambdaBar) {
        theLambdaBar->addDaughter(theAntiProtonCand);
        theLambdaBar->addDaughter(thePiPlusCand);
        theLambdaBar->setPdgId(-3122);
        addp4.set(*theLambdaBar);
        if (theLambdaBar->mass() < lambdaMass + lambdaMassCut_ && theLambdaBar->mass() > lambdaMass - lambdaMassCut_) {
          theLambdas.push_back(std::move(*theLambdaBar));
        }
      }
 
      delete theKshort;
      delete theLambda;
      delete theLambdaBar;
      theKshort = theLambda = theLambdaBar = nullptr;
    }
  }
}

References funct::abs(), reco::CompositeCandidate::addDaughter(), ClosestApproachInRPhi::calculate(), ALCARECOTkAlJpsiMuMu_cff::charge, reco::Vertex::chi2(), cosThetaXYCut_, cosThetaXYZCut_, reco::Vertex::covariance(), ClosestApproachInRPhi::crossingPoint(), ClosestApproachInRPhi::distance(), HLT_FULL_cff::distance, doKShorts_, doLambdas_, Vector3DBase< T, FrameTag >::dot(), PVValHelper::dx, reco::TrackBase::dxy(), reco::TrackBase::dxyError(), PVValHelper::dy, PVValHelper::dz, reco::TrackBase::dz(), reco::TrackBase::dzError(), edm::EventSetup::get(), get, TransientVertex::hasRefittedTracks(), iEvent, reco::TransientTrack::impactPointTSCP(), innerHitPosCut_, TrajectoryStateClosestToPoint::isValid(), TransientVertex::isValid(), kShortMassCut_, lambdaMassCut_, PV3DBase< T, PVType, FrameType >::mag2(), mag2(), reco::LeafCandidate::mass(), TrajectoryStateClosestToPoint::momentum(), eostools::move(), mPiPiCut_, reco::Vertex::ndof(), reco::Vertex::normalizedChi2(), reco::TrackBase::normalizedChi2(), reco::TrackBase::numberOfValidHits(), reco::BeamSpot::position(), edm::Handle< T >::product(), edm::ESHandle< T >::product(), reco::TrackBase::pt(), multPhiCorr_741_25nsDY_cfi::px, multPhiCorr_741_25nsDY_cfi::py, TransientVertex::refittedTracks(), reco::BeamSpot::rotatedCovariance3D(), AddFourMomenta::set(), reco::LeafCandidate::setPdgId(), reco::RecoChargedCandidate::setTrack(), mathSSE::sqrt(), ClosestApproachInRPhi::status(), tkChi2Cut_, tkDCACut_, tkIPSigXYCut_, tkIPSigZCut_, tkNHitsCut_, tkPtCut_, token_beamSpot, token_tracks, token_vertices, reco::TransientTrack::trajectoryStateClosestToPoint(), useRefTracks_, useVertex_, trackerHitRTTI::vector, KalmanVertexFitter::vertex(), AdaptiveVertexFitter::vertex(), vertexFitter_, pwdgSkimBPark_cfi::vertices, extraflags_cff::vtx, allConversions_cfi::vtxChi2, vtxChi2Cut_, vtxDecaySigXYCut_, vtxDecaySigXYZCut_, PV3DBase< T, PVType, FrameType >::x(), reco::Vertex::x(), PV3DBase< T, PVType, FrameType >::y(), reco::Vertex::y(), PV3DBase< T, PVType, FrameType >::z(), and reco::Vertex::z().

Referenced by V0Producer::produce().

Member Data Documentation

cosThetaXYCut_

double V0Fitter::cosThetaXYCut_

private

Definition at line 68 of file V0Fitter.h.

Referenced by fitAll(), and V0Fitter().

cosThetaXYZCut_

double V0Fitter::cosThetaXYZCut_

private

Definition at line 69 of file V0Fitter.h.

Referenced by fitAll(), and V0Fitter().

doKShorts_

bool V0Fitter::doKShorts_

private

Definition at line 51 of file V0Fitter.h.

Referenced by fitAll(), and V0Fitter().

doLambdas_

bool V0Fitter::doLambdas_

private

Definition at line 52 of file V0Fitter.h.

Referenced by fitAll(), and V0Fitter().

innerHitPosCut_

double V0Fitter::innerHitPosCut_

private

Definition at line 67 of file V0Fitter.h.

Referenced by fitAll(), and V0Fitter().

kShortMassCut_

double V0Fitter::kShortMassCut_

private

Definition at line 71 of file V0Fitter.h.

Referenced by fitAll(), and V0Fitter().

lambdaMassCut_

double V0Fitter::lambdaMassCut_

private

Definition at line 72 of file V0Fitter.h.

Referenced by fitAll(), and V0Fitter().

mPiPiCut_

double V0Fitter::mPiPiCut_

private

Definition at line 66 of file V0Fitter.h.

Referenced by fitAll(), and V0Fitter().

tkChi2Cut_

double V0Fitter::tkChi2Cut_

private

Definition at line 55 of file V0Fitter.h.

Referenced by fitAll(), and V0Fitter().

tkDCACut_

double V0Fitter::tkDCACut_

private

Definition at line 65 of file V0Fitter.h.

Referenced by fitAll(), and V0Fitter().

tkIPSigXYCut_

double V0Fitter::tkIPSigXYCut_

private

Definition at line 58 of file V0Fitter.h.

Referenced by fitAll(), and V0Fitter().

tkIPSigZCut_

double V0Fitter::tkIPSigZCut_

private

Definition at line 59 of file V0Fitter.h.

Referenced by fitAll(), and V0Fitter().

tkNHitsCut_

int V0Fitter::tkNHitsCut_

private

Definition at line 56 of file V0Fitter.h.

Referenced by fitAll(), and V0Fitter().

tkPtCut_

double V0Fitter::tkPtCut_

private

Definition at line 57 of file V0Fitter.h.

Referenced by fitAll(), and V0Fitter().

token_beamSpot

edm::EDGetTokenT<reco::BeamSpot> V0Fitter::token_beamSpot

private

Definition at line 75 of file V0Fitter.h.

Referenced by fitAll(), and V0Fitter().

token_tracks

edm::EDGetTokenT<reco::TrackCollection> V0Fitter::token_tracks

private

Definition at line 74 of file V0Fitter.h.

Referenced by fitAll(), and V0Fitter().

token_vertices

edm::EDGetTokenT<std::vector<reco::Vertex> > V0Fitter::token_vertices

private

Definition at line 77 of file V0Fitter.h.

Referenced by fitAll(), and V0Fitter().

useRefTracks_

bool V0Fitter::useRefTracks_

private

Definition at line 50 of file V0Fitter.h.

Referenced by fitAll(), and V0Fitter().

useVertex_

bool V0Fitter::useVertex_

private

Definition at line 76 of file V0Fitter.h.

Referenced by fitAll(), and V0Fitter().

vertexFitter_

bool V0Fitter::vertexFitter_

private

Definition at line 49 of file V0Fitter.h.

Referenced by fitAll(), and V0Fitter().

vtxChi2Cut_

double V0Fitter::vtxChi2Cut_

private

Definition at line 61 of file V0Fitter.h.

Referenced by fitAll(), and V0Fitter().

vtxDecaySigXYCut_

double V0Fitter::vtxDecaySigXYCut_

private

Definition at line 62 of file V0Fitter.h.

Referenced by fitAll(), and V0Fitter().

vtxDecaySigXYZCut_

double V0Fitter::vtxDecaySigXYZCut_

private

Definition at line 63 of file V0Fitter.h.

Referenced by fitAll(), and V0Fitter().