NewV0Fitter Class Reference

Improved V0 fitter class. More...

#include <NewV0Fitter.h>

Classes
struct	FittedTrack
	Structure to save track data of the last successful iteration. More...

Public Member Functions
	NewV0Fitter (const std::string &trackFitResultsName="", const std::string &v0sName="", const std::string &v0ValidationVerticesName="", const std::string &recoTracksName="", const std::string &copiedRecoTracksName="CopiedRecoTracks", bool enableValidation=false)
	Constructor.
void	initializeCuts (double vertexDistanceCut, double vertexChi2Cut, const std::tuple< double, double > &invMassRangeKshort, const std::tuple< double, double > &invMassRangeLambda, const std::tuple< double, double > &invMassRangePhoton)
	Initialization of cuts applied during the fit and store process.
void	setFitterMode (int fitterMode)
	Setter for the fitter mode.
void	setVertexFitter (std::unique_ptr< V0VertexFitter > vertexFitter)
	Setter for the vertex fitter, replacing the default one.
bool	fitAndStore (const Track *trackPlus, const Track *trackMinus, const Const::ParticleType &v0Hypothesis, bool &isForceStored, bool &isHitRemoved)
	Fit V0 with given hypothesis and store results if fit is successful.

Static Public Member Functions
static std::pair< Const::ParticleType, Const::ParticleType >	getTrackHypotheses (const Const::ParticleType &v0Hypothesis)
	Returns daughter particle types for a given V0 hypothesis.

Private Types
enum	ErrorStatus {   c_NoTrackRepresentation = -4 ,   c_VertexFitFailed = -3 ,   c_ExtrapolationFailed = -2 ,   c_NotSelected = -1 }
	Error status codes returned by the vertexFit method. More...
enum	EInnerHitBits {   c_BitTrackPlus = 0x1 ,   c_BitTrackMinus = 0x2 }
	Bits used to signal that track has hits inside the V0 vertex. More...

Private Member Functions
int	vertexFit (const RecoTrack *recoTrackPlus, const RecoTrack *recoTrackMinus, int pdgTrackPlus, int pdgTrackMinus, const Const::ParticleType &v0Hypothesis)
	Performs a vertex fit.
RecoTrack *	copyRecoTrack (const RecoTrack *origRecoTrack, const genfit::MeasuredStateOnPlane &state)
	Make a copy of reco track.
const RecoTrack *	removeHitsAndRefit (const RecoTrack *origRecoTrack, const RecoTrack *lastRecoTrack, const Const::ParticleType &ptype)
	Remove track inner hits and refit the track.
int	isInnermostClusterShared (const RecoTrack *recoTrackPlus, const RecoTrack *recoTrackMinus)
	Returns bit flags indicating that the innermost cluster is shared between both tracks.
const TrackFitResult *	saveTrackFitResult (const FittedTrack &trk, int sharedInnermostCluster)
	Append track fit result to the collection.

Static Private Member Functions
static const genfit::AbsTrackRep *	getTrackRepresentation (const RecoTrack *recoTrack, int pdgCode)
	Returns track representation for a given PDG code.
static bool	setCardinalRep (genfit::Track &gfTrack, int pdgCode)
	Sets cardinal representation of a given genfit track and PDG code.
static int	extrapolateToVertex (genfit::MeasuredStateOnPlane &statePlus, genfit::MeasuredStateOnPlane &stateMinus, const genfit::GFRaveVertex &vertex)
	Extrapolation of both tracks to the vertex.

Private Attributes
std::string	m_recoTracksName
	name of the RecoTracks collection
StoreArray< RecoTrack >	m_recoTracks
	RecoTracks collection.
StoreArray< TrackFitResult >	m_trackFitResults
	TrackFitResults collection.
StoreArray< V0 >	m_v0s
	V0s collection.
StoreArray< V0ValidationVertex >	m_validationV0s
	V0ValidationVertex collection (optional)
StoreArray< RecoTrack >	m_copiedRecoTracks
	copied RecoTracks collection
double	m_vertexDistanceCut = 0
	cut on the transverse radius
double	m_vertexChi2Cut = 0
	Chi2 cut.
std::map< int, std::pair< double, double > >	m_invMassCuts
	invariant mass cuts, key = abs(PDG)
std::unique_ptr< V0VertexFitter >	m_vertexFitter
	vertex fitter used to fit the V0 vertex
int	m_fitterMode = 1
	fitter mode
bool	m_validation = false
	validation flag
genfit::GFRaveVertex	m_fittedVertex
	last successfully fitted vertex
double	m_momentum = 0
	momentum of last successfully fitted vertex
double	m_invMass = 0
	invariant mass of last successfully fitted vertex
FittedTrack	m_trkPlus
	positively charged track data of last successfully fitted vertex
FittedTrack	m_trkMinus
	negatively charged track data of last successfully fitted vertex

Detailed Description

Improved V0 fitter class.

Definition at line 33 of file NewV0Fitter.h.

Member Enumeration Documentation

EInnerHitBits

enum EInnerHitBits

private

Bits used to signal that track has hits inside the V0 vertex.

Enumerator
c_BitTrackPlus	positive track has inner hits
c_BitTrackMinus	negative track has inner hits

Definition at line 149 of file NewV0Fitter.h.

                       {
      c_BitTrackPlus = 0x1, 
      c_BitTrackMinus = 0x2 
    };

ErrorStatus

enum ErrorStatus

private

Error status codes returned by the vertexFit method.

Enumerator
c_NoTrackRepresentation	no track representation for given PDG code
c_VertexFitFailed	vertex fit failed
c_ExtrapolationFailed	track extrapolation failed
c_NotSelected	fitted vertex not passing the cuts

Definition at line 138 of file NewV0Fitter.h.

                     {
      c_NoTrackRepresentation = -4, 
      c_VertexFitFailed = -3,       
      c_ExtrapolationFailed = -2,   
      c_NotSelected = -1            
    };

Constructor & Destructor Documentation

NewV0Fitter()

NewV0Fitter ( const std::string & trackFitResultsName = "", const std::string & v0sName = "", const std::string & v0ValidationVerticesName = "", const std::string & recoTracksName = "", const std::string & copiedRecoTracksName = "CopiedRecoTracks", bool enableValidation = false )

explicit

Constructor.

Parameters

trackFitResultsName	name of the StoreArray TrackFitResults
v0sName	name of the StoreArray V0s
v0ValidationVerticesName	name of the StoreArray V0ValidationVertex
recoTracksName	name of the StoreArray RecoTracks
copiedRecoTracksName	name of the StoreArray of copied RecoTracks
enableValidation	on true store additional data for validation

Definition at line 24 of file NewV0Fitter.cc.

  : m_recoTracksName(recoTracksName), m_vertexFitter(V0VertexFitterFactory::create("Rave")),
    m_validation(enableValidation)
{
  B2ASSERT("V0Fitter: material effects not set up.  Please use SetupGenfitExtrapolationModule.",
           genfit::MaterialEffects::getInstance()->isInitialized());
  B2ASSERT("V0Fitter: magnetic field not set up.  Please use SetupGenfitExtrapolationModule.",
           genfit::FieldManager::getInstance()->isInitialized());
 
  m_recoTracks.isRequired(m_recoTracksName);
  m_trackFitResults.isRequired(trackFitResultsName);
 
  m_v0s.registerInDataStore(v0sName, DataStore::c_WriteOut | DataStore::c_ErrorIfAlreadyRegistered);
  m_copiedRecoTracks.registerInDataStore(copiedRecoTracksName, DataStore::c_ErrorIfAlreadyRegistered);
  RecoTrack::registerRequiredRelations(m_copiedRecoTracks);
  m_copiedRecoTracks.registerRelationTo(m_recoTracks);
 
  if (m_validation) {
    m_validationV0s.registerInDataStore(v0ValidationVerticesName, DataStore::c_ErrorIfAlreadyRegistered);
    m_v0s.registerRelationTo(m_validationV0s);
  }
 
}

Member Function Documentation

copyRecoTrack()

RecoTrack * copyRecoTrack ( const RecoTrack * origRecoTrack, const genfit::MeasuredStateOnPlane & state )

private

Make a copy of reco track.

Parameters

origRecoTrack	source
state	measured state for the track fit seeding

Returns

a copy of source

Definition at line 361 of file NewV0Fitter.cc.

{
  RecoTrack* newRecoTrack = origRecoTrack->copyToStoreArrayUsing(m_copiedRecoTracks,
                            ROOT::Math::XYZVector(state.getPos()),
                            ROOT::Math::XYZVector(state.getMom()),
                            state.getCharge(),
                            state.get6DCov(), state.getTime());
  newRecoTrack->addHitsFromRecoTrack(origRecoTrack);
  newRecoTrack->addRelationTo(origRecoTrack);
  return newRecoTrack;
}

extrapolateToVertex()

int extrapolateToVertex ( genfit::MeasuredStateOnPlane & statePlus, genfit::MeasuredStateOnPlane & stateMinus, const genfit::GFRaveVertex & vertex )

staticprivate

Extrapolation of both tracks to the vertex.

On success the return value indicates if tracks have inner hits (see EInnerHitBits).

Parameters

statePlus	measured state of positively charged track from which the extrapolation is performed [in/out]
stateMinus	measured state of negatively charged track from which the extrapolation is performed [in/out]
vertex	vertex

Returns

value >= 0 on success, value < 0 on failure

extrapolate the first (innermost) hit to the V0 vertex position the value will be positive (negative) if the direction of the extrapolation is (counter)momentum-wise

plus track has hits inside the V0 vertex.

minus track has hits inside the V0 vertex.

This shouldn't ever happen, but I can see the extrapolation code trying several windings before giving up, so this happens occasionally. Something more stable would perhaps be desirable.

Definition at line 251 of file NewV0Fitter.cc.

{
  try {
    double extralengthPlus  =  statePlus.extrapolateToPoint(vertex.getPos());
    double extralengthMinus =  stateMinus.extrapolateToPoint(vertex.getPos());
    unsigned status = 0;
    if (extralengthPlus  > 0) status |= c_BitTrackPlus; 
    if (extralengthMinus > 0) status |= c_BitTrackMinus; 
    return status;
  } catch (...) {
    B2DEBUG(22, "Could not extrapolate track to vertex.");
    return c_ExtrapolationFailed;
  }
}

fitAndStore()

bool fitAndStore	(	const Track *	trackPlus,
		const Track *	trackMinus,
		const Const::ParticleType &	v0Hypothesis,
		bool &	isForceStored,
		bool &	isHitRemoved )

Fit V0 with given hypothesis and store results if fit is successful.

Parameters

trackPlus	positively charged track
trackMinus	negatively charged track
v0Hypothesis	V0 hypothesis
isForceStored	true if V0 is forced to store when hit removal failed [out]
isHitRemoved	true if inner hits have been removed (or at least tried to be removed) [out]

Returns

true on success

Initialize status flags and result storage

Get related recoTracks

PDG codes actually used in track fitting

initial vertex fit

try to refit tracks by removing inner hits and refit the vertex

Usually this procedure converges in up to 3 iterations (mostly in a single iteration), but for a small fraction of track pairs it does not converge at all, so we set the limit at 5.

save the results

Definition at line 81 of file NewV0Fitter.cc.

{
  isForceStored = false;
  isHitRemoved = false;
  m_trkPlus.recoTrack = nullptr;
  m_trkMinus.recoTrack = nullptr;

  const RecoTrack* recoTrackPlus  =  trackPlus->getRelated<RecoTrack>(m_recoTracksName);
  if (not recoTrackPlus) return false;
  const RecoTrack* recoTrackMinus = trackMinus->getRelated<RecoTrack>(m_recoTracksName);
  if (not recoTrackMinus) return false;

  auto trackHypotheses = getTrackHypotheses(v0Hypothesis);
  auto ptypeTrackPlus  = trackPlus->getTrackFitResultWithClosestMass(trackHypotheses.first)->getParticleType();
  auto ptypeTrackMinus = trackMinus->getTrackFitResultWithClosestMass(trackHypotheses.second)->getParticleType();
  int pdgTrackPlus  = std::abs(ptypeTrackPlus.getPDGCode());
  int pdgTrackMinus = std::abs(ptypeTrackMinus.getPDGCode());

  int status = vertexFit(recoTrackPlus, recoTrackMinus, pdgTrackPlus, pdgTrackMinus, v0Hypothesis);
  if (status < 0) return false;
 
  if (m_fitterMode > 0) {
    const RecoTrack* origRecoTrackPlus = recoTrackPlus;
    const RecoTrack* origRecoTrackMinus = recoTrackMinus;
    int counter = 0;
    while (status != 0 and counter < 5) {
      counter++;
      const RecoTrack* trkPlus = recoTrackPlus;
      if (status & c_BitTrackPlus) {
        trkPlus = removeHitsAndRefit(origRecoTrackPlus, recoTrackPlus, ptypeTrackPlus);
        if (not trkPlus) return false;
        isHitRemoved = true;
      }
      const RecoTrack* trkMinus = recoTrackMinus;
      if (status & c_BitTrackMinus) {
        trkMinus = removeHitsAndRefit(origRecoTrackMinus, recoTrackMinus, ptypeTrackMinus);
        if (not trkMinus) return false;
        isHitRemoved = true;
      }
      if (trkPlus == recoTrackPlus and trkMinus == recoTrackMinus) break; // vertex fit already done, so exit the loop
      status = vertexFit(trkPlus, trkMinus, pdgTrackPlus, pdgTrackMinus, v0Hypothesis);
      if (status < 0) break; // save the results of the last successful iteration
      recoTrackPlus = trkPlus;
      recoTrackMinus = trkMinus;
    }
 
    isForceStored = (status != 0);
  }

  int sharedCluster = isInnermostClusterShared(recoTrackPlus, recoTrackMinus);
  const auto* fitPlus = saveTrackFitResult(m_trkPlus, sharedCluster);
  if (not fitPlus) return false;
  const auto* fitMinus = saveTrackFitResult(m_trkMinus, sharedCluster);
  if (not fitMinus) return false;
 
  const auto* v0 = m_v0s.appendNew(std::make_pair(trackPlus, fitPlus),
                                   std::make_pair(trackMinus, fitMinus),
                                   m_fittedVertex.getPos().X(), m_fittedVertex.getPos().Y(), m_fittedVertex.getPos().Z());
 
  if (m_validation) {
    const auto* validationV0 = m_validationV0s.appendNew(std::make_pair(trackPlus, fitPlus),
                                                         std::make_pair(trackMinus, fitMinus),
                                                         ROOT::Math::XYZVector(m_fittedVertex.getPos()),
                                                         m_fittedVertex.getCov(),
                                                         m_momentum, m_invMass,
                                                         m_fittedVertex.getChi2());
    v0->addRelationTo(validationV0);
  }
 
  return true;
}

getTrackHypotheses()

std::pair< Const::ParticleType, Const::ParticleType > getTrackHypotheses ( const Const::ParticleType & v0Hypothesis )

static

Returns daughter particle types for a given V0 hypothesis.

Parameters

v0Hypothesis

V0 hypothesis

Returns

a pair of daughter particle types

Definition at line 65 of file NewV0Fitter.cc.

{
  if (v0Hypothesis == Const::Kshort) {
    return std::make_pair(Const::pion, Const::pion);
  } else if (v0Hypothesis == Const::photon) {
    return std::make_pair(Const::electron, Const::electron);
  } else if (v0Hypothesis == Const::Lambda) {
    return std::make_pair(Const::proton, Const::pion);
  } else if (v0Hypothesis == Const::antiLambda) {
    return std::make_pair(Const::pion, Const::proton);
  }
  B2FATAL("V0Fitter: given V0 hypothesis not available.");
  return std::make_pair(Const::invalidParticle, Const::invalidParticle); // return something to avoid triggering cppcheck
}

getTrackRepresentation()

const genfit::AbsTrackRep * getTrackRepresentation ( const RecoTrack * recoTrack, int pdgCode )

staticprivate

Returns track representation for a given PDG code.

Parameters

recoTrack	track
pdgCode	PDG code

Returns

track representation on success or nullptr on failure

Definition at line 227 of file NewV0Fitter.cc.

{
  const auto* rep = recoTrack->getTrackRepresentationForPDG(pdgCode);
  if (rep and recoTrack->wasFitSuccessful(rep)) return rep;
 
  B2ERROR("V0Fitter: track hypothesis with closest mass not available. Should never happen!");
  return nullptr;
}

initializeCuts()

void initializeCuts	(	double	vertexDistanceCut,
		double	vertexChi2Cut,
		const std::tuple< double, double > &	invMassRangeKshort,
		const std::tuple< double, double > &	invMassRangeLambda,
		const std::tuple< double, double > &	invMassRangePhoton )

Initialization of cuts applied during the fit and store process.

Parameters

vertexDistanceCut	cut on the transverse radius to cut-off vertices within the beam pipe
vertexChi2Cut	cut on the vertex chi^2
invMassRangeKshort	selection mass window for Ks
invMassRangeLambda	selection mass window for Lambda
invMassRangePhoton	selection mass window for converted gamma

Definition at line 51 of file NewV0Fitter.cc.

{
  m_vertexDistanceCut = vertexDistanceCut;
  m_vertexChi2Cut = vertexChi2Cut;
  m_invMassCuts[22] = std::make_pair(std::get<0>(invMassRangePhoton), std::get<1>(invMassRangePhoton));
  m_invMassCuts[310] = std::make_pair(std::get<0>(invMassRangeKshort), std::get<1>(invMassRangeKshort));
  m_invMassCuts[3122] = std::make_pair(std::get<0>(invMassRangeLambda), std::get<1>(invMassRangeLambda));
}

isInnermostClusterShared()

int isInnermostClusterShared ( const RecoTrack * recoTrackPlus, const RecoTrack * recoTrackMinus )

private

Returns bit flags indicating that the innermost cluster is shared between both tracks.

Bit 0 is set if U cluster is shared, bit 1 is set if V cluster is shared, and both if shared cluster is PXD.

Parameters

recoTrackPlus	positively charged track
recoTrackMinus	negatively charged track

Returns

bit flags

Definition at line 374 of file NewV0Fitter.cc.

{
  const auto& recoHitInformationsPlus = recoTrackPlus->getRecoHitInformations(true); // true to get sorted hits info
  std::vector<RecoHitInformation*> innerHitsPlus;
  for (const auto& hitInfo : recoHitInformationsPlus) {
    if (hitInfo->useInFit()) innerHitsPlus.push_back(hitInfo);
    if (innerHitsPlus.size() == 2) break;
  }
  if (innerHitsPlus.empty()) return 0;
 
  const auto& recoHitInformationsMinus = recoTrackMinus->getRecoHitInformations(true); // true to get sorted hits info
  std::vector<RecoHitInformation*> innerHitsMinus;
  for (const auto& hitInfo : recoHitInformationsMinus) {
    if (hitInfo->useInFit()) innerHitsMinus.push_back(hitInfo);
    if (innerHitsMinus.size() == 2) break;
  }
  if (innerHitsMinus.empty()) return 0;
 
  if (innerHitsPlus.front()->getTrackingDetector() != innerHitsMinus.front()->getTrackingDetector()) return 0;
 
  if (innerHitsPlus.front()->getTrackingDetector() == RecoHitInformation::c_PXD) {
    const auto* clusterPlus = innerHitsPlus.front()->getRelatedTo<PXDCluster>();
    const auto* clusterMinus = innerHitsMinus.front()->getRelatedTo<PXDCluster>();
    if (clusterPlus and clusterPlus == clusterMinus) return 0x03; // PXD cluster the same: set both bits
    return 0;
  }
 
  int flag = 0;
  VxdID sensorID = 0;
  if (innerHitsPlus.front()->getTrackingDetector() == RecoHitInformation::c_SVD) {
    const auto* clusterPlus = innerHitsPlus.front()->getRelatedTo<SVDCluster>();
    const auto* clusterMinus = innerHitsMinus.front()->getRelatedTo<SVDCluster>();
    if (clusterPlus and clusterPlus == clusterMinus) {
      sensorID = clusterPlus->getSensorID();
      if (clusterPlus->isUCluster()) flag = 0x01; // SVD U-cluster the same: set first bit
      else flag = 0x02;  // SVD V-cluster the same: set second bit
    }
  }
 
  if (innerHitsPlus.size() != 2 or innerHitsMinus.size() != 2) return flag;
 
  if (innerHitsPlus.back()->getTrackingDetector() == RecoHitInformation::c_SVD) {
    const auto* clusterPlus = innerHitsPlus.back()->getRelatedTo<SVDCluster>();
    const auto* clusterMinus = innerHitsMinus.back()->getRelatedTo<SVDCluster>();
    if (clusterPlus and clusterPlus == clusterMinus and clusterPlus->getSensorID() == sensorID) {
      if (clusterPlus->isUCluster()) flag |= 0x01; // SVD U-cluster the same: set first bit
      else flag |= 0x02; // SVD V-cluster the same: set second bit
    }
  }
 
  return flag;
}

removeHitsAndRefit()

const RecoTrack * removeHitsAndRefit ( const RecoTrack * origRecoTrack, const RecoTrack * lastRecoTrack, const Const::ParticleType & ptype )

private

Remove track inner hits and refit the track.

On success return the refitted one, otherwise return the track of last iteration (or the original one if no hits need to be removed).

Parameters

origRecoTrack	original track
lastRecoTrack	track at last hit-removal iteration
ptype	particle type for refit

Returns

refitted track on success, lastRecoTrack on failure, origRecoTrack if no hits removed

This shouldn't ever happen, but I can see the extrapolation code trying several windings before giving up, so this happens occasionally. Something more stable would perhaps be desirable.

Definition at line 273 of file NewV0Fitter.cc.

{
  // make a copy of useInFit flags
  std::vector<bool> useInFit;
  const auto& recoHitInformations = origRecoTrack->getRecoHitInformations(true); // true to get sorted hits info
  useInFit.reserve(recoHitInformations.size());
  for (const auto* hitInfo : recoHitInformations) useInFit.push_back(hitInfo->useInFit());
 
  // get track representation for a given particle
  const auto* rep = getTrackRepresentation(origRecoTrack, abs(ptype.getPDGCode()));
  if (not rep) return lastRecoTrack;
 
  // remove inner hits by setting useInFit flags to false
  int removedHits = 0;
  unsigned firstHit = 0;
  for (unsigned i = 0; i < recoHitInformations.size(); i++) {
    const auto* hitInfo = recoHitInformations[i];
    if (not hitInfo->useInFit()) continue;
    try {
      auto state = origRecoTrack->getMeasuredStateOnPlaneFromRecoHit(hitInfo, rep); // a copy of
      double extraLength = state.extrapolateToPoint(m_fittedVertex.getPos());
      if (extraLength > 0) {
        useInFit[i] = false;
        removedHits++;
      } else {
        firstHit = i;
        break;
      }
    } catch (NoTrackFitResult()) {
      B2WARNING("V0Fitter exception: no FitterInfo assigned for TrackPoint created from this RecoHit.");
      useInFit[i] = false;
      removedHits++;
      continue;
    } catch (...) {
      B2DEBUG(22, "Could not extrapolate track to vertex when removing inner hits.");
      return lastRecoTrack;
    }
  }
 
  if (m_fitterMode == 2) {
    // remove SVD hits if there is only one or two left just after the vertex
    std::vector<unsigned> svdIndex;
    for (unsigned i = 0; i < useInFit.size(); i++) {
      if (not useInFit[i]) continue;
      const auto* hitInfo = recoHitInformations[i];
      if (hitInfo->getTrackingDetector() == RecoHitInformation::c_SVD) svdIndex.push_back(i);
      else break;
    }
    if (not svdIndex.empty() and svdIndex.size() < 3) {
      for (unsigned i : svdIndex) {
        useInFit[i] = false;
        removedHits++;
      }
    }
  }
 
  if (removedHits == 0) return origRecoTrack;  // in this case track doesn't need to be refitted
 
  // count remaining hits and return if there is no hope for the fit to succeed
  int nHits = 0;
  for (auto x : useInFit) if (x) nHits++;
  if (nHits < 5) return lastRecoTrack;
 
  // make a copy of recoTrack
  const auto& state = origRecoTrack->getMeasuredStateOnPlaneFromRecoHit(recoHitInformations[firstHit], rep);
  auto* recoTrack_copy = copyRecoTrack(origRecoTrack, state);
 
  // set useInFit flags in a copy of recoTrack
  const auto& recoHitInfos = recoTrack_copy->getRecoHitInformations(true); // true to get sorted hits info
  if (recoHitInfos.size() != useInFit.size()) {
    B2ERROR("V0Fitter: copied recoTrack has different number of hits than the original one");
    return lastRecoTrack;
  }
  for (unsigned i = 0; i < recoHitInfos.size(); i++) recoHitInfos[i]->setUseInFit(useInFit[i]);
 
  // fit a copy of recoTrack
  TrackFitter fitter;
  bool ok = fitter.fit(*recoTrack_copy, ptype);
  if (not ok) return lastRecoTrack;
 
  return recoTrack_copy;
}

saveTrackFitResult()

const TrackFitResult * saveTrackFitResult ( const FittedTrack & trk, int sharedInnermostCluster )

private

Append track fit result to the collection.

Parameters

trk	track data
sharedInnermostCluster	bit flags of shared innermost clusters

Returns

track fit result

Definition at line 428 of file NewV0Fitter.cc.

{
 
  const auto* recoTrack = trk.recoTrack;
  if (not recoTrack) {
    B2ERROR("V0Fitter: bug in saving track fit result, recoTrack is nullptr");
    return nullptr;
  }
 
  auto hitPatternCDC = TrackBuilder::getHitPatternCDCInitializer(*recoTrack);
  auto hitPatternVXD = TrackBuilder::getHitPatternVXDInitializer(*recoTrack);
  if (sharedInnermostCluster > 0) {
    auto pattern = HitPatternVXD(hitPatternVXD);
    pattern.setInnermostHitShareStatus(sharedInnermostCluster);
    hitPatternVXD = pattern.getInteger();
  }
  double Bz = BFieldManager::getFieldInTesla({0, 0, 0}).Z();
  const auto& state = trk.state;
 
  auto* fit = m_trackFitResults.appendNew(ROOT::Math::XYZVector(state.getPos()), ROOT::Math::XYZVector(state.getMom()),
                                          state.get6DCov(), state.getCharge(), trk.ptype, trk.pValue,
                                          Bz, hitPatternCDC, hitPatternVXD, trk.Ndf);
  return fit;
}

setCardinalRep()

bool setCardinalRep ( genfit::Track & gfTrack, int pdgCode )

staticprivate

Sets cardinal representation of a given genfit track and PDG code.

Parameters

gfTrack	genfit track [in/out]
pdgCode	PDG code

Returns

true on success

Definition at line 237 of file NewV0Fitter.cc.

{
  const auto& reps = gfTrack.getTrackReps();
  for (unsigned id = 0; id < reps.size(); id++) {
    if (abs(reps[id]->getPDG()) == pdgCode) {
      gfTrack.setCardinalRep(id);
      return true;
    }
  }
 
  B2ERROR("V0Fitter: cannot set cardinal representation for PDG = " << pdgCode);
  return false;
}

setFitterMode()

void setFitterMode ( int fitterMode )

inline

Setter for the fitter mode.

0: store V0 at the first vertex fit, regardless of inner hits 1: remove hits inside the V0 vertex position (default) 2: mode 1 + don't use SVD hits if there is only one available SVD hit-pair

Parameters

fitterMode

fitter mode

Definition at line 104 of file NewV0Fitter.h.

{m_fitterMode = fitterMode;}

setVertexFitter()

void setVertexFitter ( std::unique_ptr< V0VertexFitter > vertexFitter )

inline

Setter for the vertex fitter, replacing the default one.

The instances are created by the V0VertexFitterFactory.

Parameters

vertexFitter

vertex fitter to be used

Definition at line 111 of file NewV0Fitter.h.

{m_vertexFitter = std::move(vertexFitter);}

vertexFit()

int vertexFit ( const RecoTrack * recoTrackPlus, const RecoTrack * recoTrackMinus, int pdgTrackPlus, int pdgTrackMinus, const Const::ParticleType & v0Hypothesis )

private

Performs a vertex fit.

On success the return value indicates if tracks have inner hits or not (see EInnerHitBits). On failure it returns ErrorStatus code.

Parameters

recoTrackPlus	positively charged track
recoTrackMinus	negatively charged track
pdgTrackPlus	PDG code used in the fit of positively charged track (closest mass to V0 daughter)
pdgTrackMinus	PDG code used in the fit of negatively charged track (closest mass to V0 daughter)
v0Hypothesis	V0 hypothesis

Returns

value >= 0 on success, value < 0 on failure

Definition at line 163 of file NewV0Fitter.cc.

{
 
  // get track representations for given PDG codes and check their existence
 
  const auto* plusRepresentation = getTrackRepresentation(recoTrackPlus, pdgTrackPlus);
  if (not plusRepresentation) return c_NoTrackRepresentation;
 
  const auto* minusRepresentation = getTrackRepresentation(recoTrackMinus, pdgTrackMinus);
  if (not minusRepresentation) return c_NoTrackRepresentation;
 
  // make copies of genfit tracks which will be passed to vertex fit and set the cardinal representations
 
  auto gfTrackPlus = recoTrackPlus->getGenfitTrack();   // a copy of
  if (not setCardinalRep(gfTrackPlus, pdgTrackPlus)) return c_NoTrackRepresentation;
 
  auto gfTrackMinus = recoTrackMinus->getGenfitTrack(); // a copy of
  if (not setCardinalRep(gfTrackMinus, pdgTrackMinus)) return c_NoTrackRepresentation;
 
  // fit vertex
 
  genfit::GFRaveVertex vert;
  if (not m_vertexFitter->fit(gfTrackPlus, gfTrackMinus, pdgTrackPlus, pdgTrackMinus, vert)) return c_VertexFitFailed;
  auto vertexPos = ROOT::Math::XYZVector(vert.getPos());
 
  // apply cuts on the vertex
 
  if (vertexPos.Rho() < m_vertexDistanceCut) return c_NotSelected;
  if (vert.getChi2() > m_vertexChi2Cut) return c_NotSelected;
 
  // apply cut on the invariant mass
 
  const auto& p1 = vert.getParameters(0)->getMom();
  const auto& p2 = vert.getParameters(1)->getMom();
  auto trackHypotheses = getTrackHypotheses(v0Hypothesis);
  double mass1 = trackHypotheses.first.getMass();
  double mass2 = trackHypotheses.second.getMass();
  ROOT::Math::PxPyPzMVector fourVec1(p1.X(), p1.Y(), p1.Z(), mass1);
  ROOT::Math::PxPyPzMVector fourVec2(p2.X(), p2.Y(), p2.Z(), mass2);
  double invMass = (fourVec1 + fourVec2).M();
  int pdgCode = abs(v0Hypothesis.getPDGCode());
  const auto& cuts = m_invMassCuts[pdgCode];
  if (invMass < cuts.first or invMass > cuts.second) return c_NotSelected;
 
  // extrapolate tracks to fitted vertex; the return status, if positive, indicates whether there are inner hits
 
  auto statePlus = recoTrackPlus->getMeasuredStateOnPlaneFromFirstHit(plusRepresentation); // a copy of
  auto stateMinus = recoTrackMinus->getMeasuredStateOnPlaneFromFirstHit(minusRepresentation); // a copy of
  int status = extrapolateToVertex(statePlus, stateMinus, vert);
  if (status < 0) return c_ExtrapolationFailed;
 
  // save fitted vertex and tracks
 
  m_fittedVertex = vert;
  m_momentum = (fourVec1 + fourVec2).P();
  m_invMass = invMass;
  m_trkPlus.set(recoTrackPlus, trackHypotheses.first, statePlus, plusRepresentation);
  m_trkMinus.set(recoTrackMinus, trackHypotheses.second, stateMinus, minusRepresentation);
 
  return status;
}

Member Data Documentation

m_copiedRecoTracks

StoreArray<RecoTrack> m_copiedRecoTracks

private

copied RecoTracks collection

Definition at line 237 of file NewV0Fitter.h.

m_fittedVertex

genfit::GFRaveVertex m_fittedVertex

private

last successfully fitted vertex

Definition at line 249 of file NewV0Fitter.h.

m_fitterMode

int m_fitterMode = 1

private

fitter mode

Definition at line 244 of file NewV0Fitter.h.

m_invMass

double m_invMass = 0

private

invariant mass of last successfully fitted vertex

Definition at line 251 of file NewV0Fitter.h.

m_invMassCuts

std::map<int, std::pair<double, double> > m_invMassCuts

private

invariant mass cuts, key = abs(PDG)

Definition at line 241 of file NewV0Fitter.h.

m_momentum

double m_momentum = 0

private

momentum of last successfully fitted vertex

Definition at line 250 of file NewV0Fitter.h.

m_recoTracks

StoreArray<RecoTrack> m_recoTracks

private

RecoTracks collection.

Definition at line 233 of file NewV0Fitter.h.

m_recoTracksName

std::string m_recoTracksName

private

name of the RecoTracks collection

Definition at line 232 of file NewV0Fitter.h.

m_trackFitResults

StoreArray<TrackFitResult> m_trackFitResults

private

TrackFitResults collection.

Definition at line 234 of file NewV0Fitter.h.

m_trkMinus

FittedTrack m_trkMinus

private

negatively charged track data of last successfully fitted vertex

Definition at line 253 of file NewV0Fitter.h.

m_trkPlus

FittedTrack m_trkPlus

private

positively charged track data of last successfully fitted vertex

Definition at line 252 of file NewV0Fitter.h.

m_v0s

StoreArray<V0> m_v0s

private

V0s collection.

Definition at line 235 of file NewV0Fitter.h.

m_validation

bool m_validation = false

private

validation flag

Definition at line 245 of file NewV0Fitter.h.

m_validationV0s

StoreArray<V0ValidationVertex> m_validationV0s

private

V0ValidationVertex collection (optional)

Definition at line 236 of file NewV0Fitter.h.

m_vertexChi2Cut

double m_vertexChi2Cut = 0

private

Chi2 cut.

Definition at line 240 of file NewV0Fitter.h.

m_vertexDistanceCut

double m_vertexDistanceCut = 0

private

cut on the transverse radius

Definition at line 239 of file NewV0Fitter.h.

m_vertexFitter

std::unique_ptr<V0VertexFitter> m_vertexFitter

private

vertex fitter used to fit the V0 vertex

Definition at line 243 of file NewV0Fitter.h.

---

The documentation for this class was generated from the following files:

• tracking/v0Finding/fitter/include/NewV0Fitter.h
• tracking/v0Finding/fitter/src/NewV0Fitter.cc