V0Fitter Class Reference

V0Fitter class to create V0 mdst's from reconstructed tracks. More...

#include <V0Fitter.h>

Public Member Functions
	V0Fitter (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 for the V0Fitter.
void	initializeCuts (double beamPipeRadius, double vertexChi2CutOutside, std::tuple< double, double > invMassRangeKshort, std::tuple< double, double > invMassRangeLambda, std::tuple< double, double > invMassRangePhoton)
	Initialize the cuts which will be applied during the fit and store process.
void	setVertexFitter (std::unique_ptr< V0VertexFitter > vertexFitter)
	Set the vertex fitter to be used, replacing the default one.
void	setFitterMode (int fitterMode)
	set V0 fitter mode.
bool	fitAndStore (const Track *trackPlus, const Track *trackMinus, const Const::ParticleType &v0Hypothesis, bool &isForceStored, bool &isHitRemoved)
	Fit V0 with given hypothesis and store if fit was successful.

Static Public Member Functions
static std::pair< Const::ParticleType, Const::ParticleType >	getTrackHypotheses (const Const::ParticleType &v0Hypothesis)
	Get track hypotheses for a given v0 hypothesis.

Private Member Functions
bool	vertexFitWithRecoTracks (const Track *trackPlus, const Track *trackMinus, RecoTrack *recoTrackPlus, RecoTrack *recoTrackMinus, const Const::ParticleType &v0Hypothesis, unsigned int &hasInnerHitStatus, ROOT::Math::XYZVector &vertexPos, const bool forceStore)
	fit V0 vertex using RecoTrack's as inputs.
RecoTrack *	copyRecoTrack (const RecoTrack *origRecoTrack)
	Create a copy of RecoTrack.
RecoTrack *	copyRecoTrackAndFit (const RecoTrack *origRecoTrack, const int trackPDG)
	Create a copy of RecoTrack and fit the Track.
bool	removeInnerHits (RecoTrack *prevRecoTrack, RecoTrack *recoTrack, const int trackPDG, const ROOT::Math::XYZVector &vertexPosition)
	Remove inner hits from RecoTrack at once.
int	checkSharedInnermostCluster (const RecoTrack *recoTrackPlus, const RecoTrack *recoTrackMinus)
	Compare innermost hits of daughter pairs to check if they are the same (shared) or not.
bool	extrapolateToVertex (genfit::MeasuredStateOnPlane &stPlus, genfit::MeasuredStateOnPlane &stMinus, const ROOT::Math::XYZVector &vertexPosition)
	Extrapolate the fit results to the perigee to the vertex.
TrackFitResult *	buildTrackFitResult (const genfit::Track &track, const RecoTrack *recoTrack, const genfit::MeasuredStateOnPlane &msop, const double Bz, const Const::ParticleType &trackHypothesis, const int sharedInnermostCluster)
	Build TrackFitResult of V0 Track and set relation to genfit Track.

Static Private Member Functions
static bool	extrapolateToVertex (genfit::MeasuredStateOnPlane &stPlus, genfit::MeasuredStateOnPlane &stMinus, const ROOT::Math::XYZVector &vertexPosition, unsigned int &hasInnerHitStatus)
	Extrapolate the fit results to the perigee to the vertex.

Private Attributes
bool	m_validation
	Validation flag.
std::string	m_recoTracksName
	RecoTrackColName (input).
StoreArray< RecoTrack >	m_recoTracks
	RecoTrack (input)
StoreArray< TrackFitResult >	m_trackFitResults
	TrackFitResult (output).
StoreArray< V0 >	m_v0s
	V0 (output).
StoreArray< V0ValidationVertex >	m_validationV0s
	V0ValidationVertex (output, optional).
StoreArray< RecoTrack >	m_copiedRecoTracks
	RecoTrack used to refit tracks (output)
double	m_beamPipeRadius
	Radius where inside/outside beampipe is defined.
double	m_vertexChi2CutOutside
	Chi2 cut outside beampipe.
std::tuple< double, double >	m_invMassRangeKshort
	invariant mass cut for Kshort.
std::tuple< double, double >	m_invMassRangeLambda
	invariant mass cut for Lambda.
std::tuple< double, double >	m_invMassRangePhoton
	invariant mass cut for Photon.
int	m_v0FitterMode
	0: store V0 at the first vertex fit, regardless of inner hits, 1: remove hits inside the V0 vertex position, 2: mode 1 + don't use SVD hits if there is only one available SVD hit-pair (default)
bool	m_forcestore
	true only if the V0Fitter mode is 1
bool	m_useOnlyOneSVDHitPair
	false only if the V0Fitter mode is 3
std::unique_ptr< V0VertexFitter >	m_vertexFitter
	Vertex fitter used to fit the V0 vertex.

Friends
class	V0FitterTest_GetTrackHypotheses_Test
class	V0FitterTest_EnableValidation_Test
class	V0FitterTest_InitializeCuts_Test

Detailed Description

V0Fitter class to create V0 mdst's from reconstructed tracks.

To use this class, give the V0Fitter a positive and a negative charged track and call the fitAndStore function.

v0Fitter.fitAndStore(B2TrackPositive, B2TrackNegative, V0HypothesisParticleType);

Definition at line 41 of file V0Fitter.h.

Constructor & Destructor Documentation

V0Fitter()

V0Fitter ( 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 for the V0Fitter.

m_recoTracks

register m_copiedRecoTracks

relation : m_recoTracks <--> m_copiedRecoTracks

Definition at line 35 of file V0Fitter.cc.

  : m_validation(enableValidation), m_recoTracksName(recoTracksName), m_v0FitterMode(1), m_forcestore(false),
    m_useOnlyOneSVDHitPair(true), m_vertexFitter(V0VertexFitterFactory::create("Rave"))
{
  m_trackFitResults.isRequired(trackFitResultsName);
  m_v0s.registerInDataStore(v0sName, DataStore::c_WriteOut | DataStore::c_ErrorIfAlreadyRegistered);
  //Relation to RecoTracks from Tracks is already tested at the module level.
 
  if (m_validation) {
    B2DEBUG(24, "Register DataStore for validation.");
    m_validationV0s.registerInDataStore(v0ValidationVerticesName, DataStore::c_ErrorIfAlreadyRegistered);
    m_v0s.registerRelationTo(m_validationV0s);
  }

  m_recoTracks.isRequired(m_recoTracksName);

  m_copiedRecoTracks.registerInDataStore(copiedRecoTracksName,
                                         DataStore::c_ErrorIfAlreadyRegistered);
  RecoTrack::registerRequiredRelations(m_copiedRecoTracks);

  m_copiedRecoTracks.registerRelationTo(m_recoTracks);
 
 
  B2ASSERT("Material effects not set up.  Please use SetupGenfitExtrapolationModule.",
           genfit::MaterialEffects::getInstance()->isInitialized());
  B2ASSERT("Magnetic field not set up.  Please use SetupGenfitExtrapolationModule.",
           genfit::FieldManager::getInstance()->isInitialized());
}

Member Function Documentation

buildTrackFitResult()

TrackFitResult * buildTrackFitResult ( const genfit::Track & track, const RecoTrack * recoTrack, const genfit::MeasuredStateOnPlane & msop, const double Bz, const Const::ParticleType & trackHypothesis, const int sharedInnermostCluster )

private

Build TrackFitResult of V0 Track and set relation to genfit Track.

Definition at line 130 of file V0Fitter.cc.

{
  const uint64_t hitPatternCDCInitializer = TrackBuilder::getHitPatternCDCInitializer(*recoTrack);
  uint32_t hitPatternVXDInitializer = TrackBuilder::getHitPatternVXDInitializer(*recoTrack);
 
  // If the innermost hit is shared among V0 daughters, assign flag in the infoLayer.
  if (sharedInnermostCluster > 0 && sharedInnermostCluster < 4) {
    HitPatternVXD hitPatternVXD_forflag = HitPatternVXD(hitPatternVXDInitializer);
    hitPatternVXD_forflag.setInnermostHitShareStatus(sharedInnermostCluster);
    hitPatternVXDInitializer = hitPatternVXD_forflag.getInteger();
  }
 
  TrackFitResult* v0TrackFitResult
    = m_trackFitResults.appendNew(ROOT::Math::XYZVector(msop.getPos()), ROOT::Math::XYZVector(msop.getMom()),
                                  msop.get6DCov(), msop.getCharge(),
                                  trackHypothesis,
                                  track.getFitStatus()->getPVal(),
                                  Bz, hitPatternCDCInitializer, hitPatternVXDInitializer, track.getFitStatus()->getNdf());
  return v0TrackFitResult;
}

checkSharedInnermostCluster()

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

private

Compare innermost hits of daughter pairs to check if they are the same (shared) or not.

For SVD hits, compare U- and V- hit pair.

Parameters

recoTrackPlus,recoTrackMinus

input RecoTrack pair

Returns

If 1D- or 2D-hits are shared as the innermost hits among V0 daughters. 0x1(0x2) bit represents V/z(U/r-phi)-hit share. -1 for exception.

If 1D- or 2D-hits are shared as the innermost hits among V0 daughters. 0x1(0x2) bit in flag represents V/z(U/r-phi)-hit share.

if the innermost hit is a SVD U-hit, check the next hit in addition note: for the SVD pair hits, U-hit should be first and the V-hit the next in the sorted RecoHitInformation array.

Definition at line 590 of file V0Fitter.cc.

{
  int flag = 0; // -1 for exception
 
  // get the innermost hit for plus/minus-daughter
  const std::vector<RecoHitInformation*>& recoHitInformationsPlus  = recoTrackPlus->getRecoHitInformations(
        true); // true for sorted info.
  const std::vector<RecoHitInformation*>& recoHitInformationsMinus = recoTrackMinus->getRecoHitInformations(
        true);// true for sorted info.
  unsigned int iInnermostHitPlus, iInnermostHitMinus;
  for (iInnermostHitPlus = 0 ; iInnermostHitPlus < recoHitInformationsPlus.size() ; ++iInnermostHitPlus)
    if (recoHitInformationsPlus[iInnermostHitPlus]->useInFit()) break;
  for (iInnermostHitMinus = 0 ; iInnermostHitMinus < recoHitInformationsMinus.size() ; ++iInnermostHitMinus)
    if (recoHitInformationsMinus[iInnermostHitMinus]->useInFit()) break;
  if (iInnermostHitPlus == recoHitInformationsPlus.size() || iInnermostHitMinus == recoHitInformationsMinus.size()) {
    B2WARNING("checkSharedInnermostCluster function called for recoTrack including no hit used for fit! This should not happen!");
    return -1;
  }
  const auto& recoHitInfoPlus  = recoHitInformationsPlus[iInnermostHitPlus];
  const auto& recoHitInfoMinus = recoHitInformationsMinus[iInnermostHitMinus];
 
  if (recoHitInfoPlus->getTrackingDetector() == recoHitInfoMinus->getTrackingDetector()) {
    if (recoHitInfoPlus->getTrackingDetector() == RecoHitInformation::c_PXD) {
      const PXDCluster* clusterPlus = recoHitInfoPlus->getRelatedTo<PXDCluster>();
      const PXDCluster* clusterMinus = recoHitInfoMinus->getRelatedTo<PXDCluster>();
      if (clusterPlus == clusterMinus) { // if they share a same PXDCluster, set the flag
        flag = 3; // PXD cluster is a 2D-hit
      }
    } else if (recoHitInfoPlus->getTrackingDetector() == RecoHitInformation::c_SVD) {
      const SVDCluster* clusterPlus = recoHitInfoPlus->getRelatedTo<SVDCluster>();
      const SVDCluster* clusterMinus = recoHitInfoMinus->getRelatedTo<SVDCluster>();
      if (clusterPlus->isUCluster() && clusterMinus->isUCluster()) {
        if (recoHitInformationsPlus.size() > iInnermostHitPlus + 1
            && recoHitInformationsMinus.size() > iInnermostHitMinus + 1) { // not to access an array out of boundary
          const auto& recoHitInfoNextPlus  = recoHitInformationsPlus[iInnermostHitPlus + 1];
          const auto& recoHitInfoNextMinus = recoHitInformationsMinus[iInnermostHitMinus + 1];
          // sanity check to access next hits
          if (recoHitInfoNextPlus->useInFit() && recoHitInfoNextMinus->useInFit()  // this should be satisfied by default
              && recoHitInfoNextPlus->getTrackingDetector()  == RecoHitInformation::c_SVD
              && recoHitInfoNextMinus->getTrackingDetector() == RecoHitInformation::c_SVD) {
            const SVDCluster* clusterNextPlus = recoHitInfoNextPlus->getRelatedTo<SVDCluster>();
            const SVDCluster* clusterNextMinus = recoHitInfoNextMinus->getRelatedTo<SVDCluster>();
            if (!(clusterNextPlus->isUCluster()) && !(clusterNextMinus->isUCluster())
                && clusterPlus->getSensorID() == clusterNextPlus->getSensorID()
                && clusterMinus->getSensorID() == clusterNextMinus->getSensorID()) {
              if (clusterPlus == clusterMinus)
                flag += 2; // SVD U-cluster is shared
              if (clusterNextPlus == clusterNextMinus)
                flag += 1; // SVD V-cluster is shared
            } else {
              B2WARNING("SVD cluster to be paired is not on V-side, or not on the same sensor.");
              return -1;
            }
          } else {
            B2WARNING("No SVD cluster to be paired.");
            return -1;
          }
        } else {
          B2WARNING("Innermost SVD U-cluster is the only hit in a daughter track. This should not happen.");
          return -1;
        }
      } else {
        B2WARNING("No SVD U-cluster in the innermost cluster.");
        return -1;
      }
    }
  }
  return flag;
 
}

copyRecoTrack()

RecoTrack * copyRecoTrack ( const RecoTrack * origRecoTrack )

private

Create a copy of RecoTrack.

Track fit should be executed in removeInnerHits function.

Parameters

origRecoTrack

original RecoTrack

Returns

copied RecoTrack stored in the m_copiedRecoTracks, nullptr if track fit fails (this should not happen)

Definition at line 452 of file V0Fitter.cc.

{
  RecoTrack* newRecoTrack = origRecoTrack->copyToStoreArray(m_copiedRecoTracks);
  newRecoTrack->addHitsFromRecoTrack(origRecoTrack);
  newRecoTrack->addRelationTo(origRecoTrack);
  return newRecoTrack;
}

copyRecoTrackAndFit()

RecoTrack * copyRecoTrackAndFit ( const RecoTrack * origRecoTrack, const int trackPDG )

private

Create a copy of RecoTrack and fit the Track.

Parameters

origRecoTrack	original RecoTrack
trackPDG	signed PDG used for the track fit hypothesis

Returns

copied RecoTrack stored in the m_copiedRecoTracks, nullptr if track fit fails (this should not happen)

original track information

only a positive PDG number is allowed for the input

fit newRecoTrack

check fit status of original track

Definition at line 460 of file V0Fitter.cc.

{
  Const::ChargedStable particleUsedForFitting(std::abs(trackPDG));
  const genfit::AbsTrackRep* origTrackRep = origRecoTrack->getTrackRepresentationForPDG(std::abs(
                                              trackPDG));
 
  RecoTrack* newRecoTrack = copyRecoTrack(origRecoTrack);

  TrackFitter fitter;
  if (not fitter.fit(*newRecoTrack, particleUsedForFitting)) {
    // This is not expected, but happens sometimes.
    B2DEBUG(20, "track fit failed for copied RecoTrack.");
    if (not origRecoTrack->wasFitSuccessful(origTrackRep))
      B2DEBUG(20, "\t original track fit was also failed.");
    return nullptr;
  }
 
  return newRecoTrack;
}

extrapolateToVertex()

bool extrapolateToVertex ( genfit::MeasuredStateOnPlane & stPlus, genfit::MeasuredStateOnPlane & stMinus, const ROOT::Math::XYZVector & vertexPosition, unsigned int & hasInnerHitStatus )

staticprivate

Extrapolate the fit results to the perigee to the vertex.

used in the fitAndStore function.

If the daughter tracks have hits inside the V0 vertex, bits in the hasInnerHiStatus variable are set.

if tracks have hits inside the V0 vertex position, bits in hasInnerHitStatus are set.

initialize

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 106 of file V0Fitter.cc.

{
  hasInnerHitStatus = 0;
 
  try {
    const double extralengthPlus  =  stPlus.extrapolateToPoint(XYZToTVector(vertexPosition));
    const double extralengthMinus = stMinus.extrapolateToPoint(XYZToTVector(vertexPosition));
    if (extralengthPlus  > 0) hasInnerHitStatus |= 0x1; 
    if (extralengthMinus > 0) hasInnerHitStatus |= 0x2; 
    B2DEBUG(22, "extralengthPlus=" << extralengthPlus << ", extralengthMinus=" << extralengthMinus);
  } catch (...) {
    B2DEBUG(22, "Could not extrapolate track to vertex.");
    return false;
  }
  return true;
}

fitAndStore()

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

Fit V0 with given hypothesis and store if fit was successful.

remove hits inside the V0 vertex position

Initialize status flag for counting

Existence of corresponding RecoTrack already checked at the module level;

hasInnerHitStatus: 0x1: plus track has hits inside the V0 vertex. 0x2: minus track has hits inside the V0 vertex.

fitted vertex position

Try V0 vertex fit. If the fit fails, return false. If hasInnerHitStatus evaluated in the vertexFitWithRecoTracks function results to be 0 (no hits inside the V0 vertex position in both tracks), TrackFitResult and V0 objects are build and stored, and then terminate this function with returning true. If hasInnerHitStatus!=0, objects are not stored and the tracks are refitted with removing inner hit later.

If one or two tracks have hits inside the V0 vertex. (0x1(0x2) bit in hasInnerHitStatus represents plus(minus)-track), redo vertex fit after refitting the track(s) with removing innermost hit in the track(s). Repeat until all the inner hits are removed or the vertex fit fails.

PDG code (positive number) used as the track hypothesis in the track fitting.

positive number

positive number

If the track has a hit inside the V0 vertex position, use refitted RecoTrack with removing inner hits in the next V0 vertex fit. Else, use the original RecoTrack.

for plus-charged track

if the track refit fails, break out of this loop and revert back to the original vertex fit with the original tracks.

for minus-charged track

if the track refit fails, break out of this loop and revert back to the original vertex fit with the original tracks.

V0 vertex fit

if vertex fit fails, break out of this loop and revert back to the original vertex fit with the original tracks.

end of the while loop

if failflag==true, revert back to the original vertex fit with the original tracks.

Definition at line 170 of file V0Fitter.cc.

{
  isForceStored = false;
  isHitRemoved = false;

  RecoTrack* recoTrackPlus  =  trackPlus->getRelated<RecoTrack>(m_recoTracksName);
  RecoTrack* recoTrackMinus = trackMinus->getRelated<RecoTrack>(m_recoTracksName);

  unsigned int hasInnerHitStatus = 0;

  ROOT::Math::XYZVector vertexPos(0, 0, 0);

  if (not vertexFitWithRecoTracks(trackPlus, trackMinus, recoTrackPlus, recoTrackMinus, v0Hypothesis,
                                  hasInnerHitStatus, vertexPos, m_forcestore))
    return false;
 
  if ((hasInnerHitStatus == 0) or m_forcestore)
    return true;

  bool failflag = false;
  const auto& trackHypotheses = getTrackHypotheses(v0Hypothesis);
  const int pdg_trackPlus   = trackPlus->getTrackFitResultWithClosestMass(
                                trackHypotheses.first)->getParticleType().getPDGCode();
  const int pdg_trackMinus  = trackMinus->getTrackFitResultWithClosestMass(
                                trackHypotheses.second)->getParticleType().getPDGCode();
 
  RecoTrack* recoTrackPlus_forRefit = nullptr;
  RecoTrack* recoTrackMinus_forRefit = nullptr;
  RecoTrack* cache_recoTrackPlus  = nullptr;
  RecoTrack* cache_recoTrackMinus = nullptr;
 
  unsigned int count_removeInnerHits = 0;
  while (hasInnerHitStatus != 0) {
    ++count_removeInnerHits;

    if (hasInnerHitStatus & 0x1) {
      // create a copy of the original RecoTrack w/o track fit
      recoTrackPlus_forRefit  = copyRecoTrack(recoTrackPlus);
      if (recoTrackPlus_forRefit == nullptr)
        return false;
      if (!cache_recoTrackPlus) {
        if (not removeInnerHits(recoTrackPlus, recoTrackPlus_forRefit, pdg_trackPlus, vertexPos)) {
          failflag = true;
          break;
        }
      } else {
        if (not removeInnerHits(cache_recoTrackPlus, recoTrackPlus_forRefit, pdg_trackPlus, vertexPos)) {
          failflag = true;
          break;
        }
      }
      cache_recoTrackPlus = recoTrackPlus_forRefit;
    } else if (recoTrackPlus_forRefit == nullptr) {
      // create a copy of the original RecoTrack w/ track fit (only once)
      recoTrackPlus_forRefit  = copyRecoTrackAndFit(recoTrackPlus, pdg_trackPlus);
      if (recoTrackPlus_forRefit == nullptr)
        return false;
    }

    if (hasInnerHitStatus & 0x2) {
      // create a copy of the original RecoTrack w/o track fit
      recoTrackMinus_forRefit = copyRecoTrack(recoTrackMinus);
      if (recoTrackMinus_forRefit == nullptr)
        return false;
      if (!cache_recoTrackMinus) {
        if (not removeInnerHits(recoTrackMinus, recoTrackMinus_forRefit, pdg_trackMinus, vertexPos)) {
          failflag = true;
          break;
        }
      } else {
        if (not removeInnerHits(cache_recoTrackMinus, recoTrackMinus_forRefit, pdg_trackMinus, vertexPos)) {
          failflag = true;
          break;
        }
      }
      cache_recoTrackMinus = recoTrackMinus_forRefit;
    } else if (recoTrackMinus_forRefit == nullptr) {
      // create a copy of the original RecoTrack w/ track fit (only once)
      recoTrackMinus_forRefit = copyRecoTrackAndFit(recoTrackMinus, pdg_trackMinus);
      if (recoTrackMinus_forRefit == nullptr)
        return false;
    }

    hasInnerHitStatus = 0;
    if (not vertexFitWithRecoTracks(trackPlus, trackMinus, recoTrackPlus_forRefit, recoTrackMinus_forRefit,
                                    v0Hypothesis, hasInnerHitStatus, vertexPos, false)) {
      B2DEBUG(22, "Vertex refit failed, or rejected by invariant mass cut.");
      failflag = true;
      break;
    } else if (hasInnerHitStatus == 0)
      isHitRemoved = true;
    if (count_removeInnerHits >= 5) {
      B2WARNING("Inner hits remained after " << count_removeInnerHits << " times of removing inner hits!");
      failflag = true;
      break;
    }
  }

  if (failflag) {
    bool forcestore = true;
    if (not vertexFitWithRecoTracks(trackPlus, trackMinus, recoTrackPlus, recoTrackMinus, v0Hypothesis,
                                    hasInnerHitStatus, vertexPos, forcestore)) {
      B2DEBUG(22, "Original vertex fit fails. Possibly rejected by invariant mass cut.");
      return false;
    } else
      isForceStored = true;
  }
 
  return true;
}

getTrackHypotheses()

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

static

Get track hypotheses for a given v0 hypothesis.

Definition at line 154 of file V0Fitter.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("Given V0Hypothesis not available.");
  return std::make_pair(Const::invalidParticle, Const::invalidParticle); // return something to avoid triggering cppcheck
}

initializeCuts()

void initializeCuts	(	double	beamPipeRadius,
		double	vertexChi2CutOutside,
		std::tuple< double, double >	invMassRangeKshort,
		std::tuple< double, double >	invMassRangeLambda,
		std::tuple< double, double >	invMassRangePhoton )

Initialize the cuts which will be applied during the fit and store process.

Definition at line 91 of file V0Fitter.cc.

{
  m_beamPipeRadius = beamPipeRadius;
  m_vertexChi2CutOutside = vertexChi2CutOutside;
  m_invMassRangeKshort = invMassRangeKshort;
  m_invMassRangeLambda = invMassRangeLambda;
  m_invMassRangePhoton = invMassRangePhoton;
}

removeInnerHits()

bool removeInnerHits ( RecoTrack * prevRecoTrack, RecoTrack * recoTrack, const int trackPDG, const ROOT::Math::XYZVector & vertexPosition )

private

Remove inner hits from RecoTrack at once.

Hits are removed from the minus-end of the momentum direction. For SVD hits, remove U- and V- hit pair at once. Input RecoTrack is fitted in the function. If track fit fails, return false.

Parameters

prevRecoTrack	original RecoTrack
recoTrack	input RecoTrack, updated in this function
trackPDG	signed PDG used for the track fit hypothesis
vertexPosition	V0 vertex position

Returns

original track information

only a positive PDG number is allowed for the input

disable inner hits

true for sorted info.

true for sorted info.

check recohits one by one whether the vertex is outside/inside them

make a clone, not use the reference so that the genfit::MeasuredStateOnPlane will not be altered.

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

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.

N removed hits should not reach N hits in the track

if the last removed hit is a SVD U-hit, remove the next hit (SVD V-hit as the pair) in addition note: for the SVD pair hits, U-hit should be first and the V-hit the next in the sorted RecoHitInformation array.

if N of remaining SVD hit-pair is only one, don't use the SVD hits

SVD U-hit

SVD V-hit

not SVD hit (CDC)

fit recoTrack

check fit status of original track

Definition at line 483 of file V0Fitter.cc.

{
  if (!prevRecoTrack || !recoTrack) {
    B2ERROR("Input recotrack is nullptr!");
    return false;
  }
  Const::ChargedStable particleUsedForFitting(std::abs(trackPDG));
  const genfit::AbsTrackRep* prevTrackRep = prevRecoTrack->getTrackRepresentationForPDG(std::abs(
                                              trackPDG));

  const std::vector<RecoHitInformation*>& recoHitInformations = recoTrack->getRecoHitInformations(true);
  const std::vector<RecoHitInformation*>& prevRecoHitInformations = prevRecoTrack->getRecoHitInformations(
        true);
  unsigned int nRemoveHits = 0;
  if (recoHitInformations.size() != prevRecoHitInformations.size()) {
    B2WARNING("Copied RecoTrack has different number of hits from its original RecoTrack!");
    return false;
  }
  for (nRemoveHits = 0; nRemoveHits < recoHitInformations.size(); ++nRemoveHits) {
    if (!prevRecoHitInformations[nRemoveHits]->useInFit()) {
      recoHitInformations[nRemoveHits]->setUseInFit(false);
      continue;
    }
    try {
      genfit::MeasuredStateOnPlane stPrevRecoHit = prevRecoTrack->getMeasuredStateOnPlaneFromRecoHit(
                                                     prevRecoHitInformations[nRemoveHits]);
      double extralength = stPrevRecoHit.extrapolateToPoint(XYZToTVector(vertexPosition));
      if (extralength > 0) {
        recoHitInformations[nRemoveHits]->setUseInFit(false);
      } else
        break;
    } catch (NoTrackFitResult()) {
      B2WARNING("Exception: no FitterInfo assigned for TrackPoint created from this RecoHit.");
      recoHitInformations[nRemoveHits]->setUseInFit(false);
      continue;
    } catch (...) {
      B2DEBUG(22, "Could not extrapolate track to vertex when removing inner hits, aborting.");
      return false;
    }
  }
 
  if (nRemoveHits == 0) {
    // This is not expected, but can happen if the track fit is different between copied and original RecoTrack.
    B2DEBUG(20, "No hits removed in removeInnerHits, aborted. Switching to use the original RecoTrack.");
    return false;
  }
 
  if (recoHitInformations.size() <= nRemoveHits) {
    B2DEBUG(20, "Removed all the RecoHits in the RecoTrack, aborted. Switching to use the original RecoTrack.");
    return false;
  }

  if (recoHitInformations[nRemoveHits - 1]->getTrackingDetector() == RecoHitInformation::RecoHitDetector::c_SVD) {
    if (recoHitInformations[nRemoveHits]->getTrackingDetector() == RecoHitInformation::RecoHitDetector::c_SVD) {
      const SVDCluster* lastRemovedSVDHit = recoHitInformations[nRemoveHits - 1]->getRelatedTo<SVDCluster>();
      const SVDCluster* nextSVDHit        = recoHitInformations[nRemoveHits]  ->getRelatedTo<SVDCluster>();
      if (!lastRemovedSVDHit || !nextSVDHit) B2ERROR("Last/Next SVD hit is null!");
      else {
        if (lastRemovedSVDHit->getSensorID() == nextSVDHit->getSensorID() &&
            lastRemovedSVDHit->isUCluster() && !(nextSVDHit->isUCluster())) {
          recoHitInformations[nRemoveHits]->setUseInFit(false);
          ++nRemoveHits;
        }
      }
    }
  }

  if (!m_useOnlyOneSVDHitPair &&
      recoHitInformations[nRemoveHits - 1]->getTrackingDetector() == RecoHitInformation::RecoHitDetector::c_SVD &&
      recoHitInformations.size() > nRemoveHits + 2) {
    if (recoHitInformations[nRemoveHits  ]->getTrackingDetector() == RecoHitInformation::RecoHitDetector::c_SVD && 
        recoHitInformations[nRemoveHits + 1]->getTrackingDetector() == RecoHitInformation::RecoHitDetector::c_SVD && 
        recoHitInformations[nRemoveHits + 2]->getTrackingDetector() != RecoHitInformation::RecoHitDetector::c_SVD) { 
      recoHitInformations[nRemoveHits  ]->setUseInFit(false);
      recoHitInformations[nRemoveHits + 1]->setUseInFit(false);
      nRemoveHits += 2;
    }
  }
 
  B2DEBUG(22, nRemoveHits << " inner hits removed.");

  TrackFitter fitter;
  if (not fitter.fit(*recoTrack, particleUsedForFitting)) {
    B2DEBUG(20, "track fit failed after removing inner hits.");
    if (not prevRecoTrack->wasFitSuccessful(prevTrackRep))
      B2DEBUG(20, "\t previous track fit was also failed.");
    return false;
  }
 
  return true;
}

setFitterMode()

void setFitterMode

(

int

fitterMode

)

set V0 fitter mode.

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

Definition at line 74 of file V0Fitter.cc.

{
  if (not(0 <= fitterMode && fitterMode <= 2)) {
    B2FATAL("Invalid fitter mode!");
  } else {
    m_v0FitterMode = fitterMode;
    if (fitterMode == 0)
      m_forcestore = true;
    else
      m_forcestore = false;
    if (fitterMode == 2)
      m_useOnlyOneSVDHitPair = false;
    else
      m_useOnlyOneSVDHitPair = true;
  }
}

setVertexFitter()

void setVertexFitter

(

std::unique_ptr< V0VertexFitter >

vertexFitter

)

Set the vertex fitter to be used, replacing the default one.

The instances are created by the V0VertexFitterFactory.

Definition at line 69 of file V0Fitter.cc.

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

vertexFitWithRecoTracks()

bool vertexFitWithRecoTracks ( const Track * trackPlus, const Track * trackMinus, RecoTrack * recoTrackPlus, RecoTrack * recoTrackMinus, const Const::ParticleType & v0Hypothesis, unsigned int & hasInnerHitStatus, ROOT::Math::XYZVector & vertexPos, const bool forceStore )

private

fit V0 vertex using RecoTrack's as inputs.

Fit V0 vertex using RecoTracks as inputs.

Return true (false) if the vertex fit has done well (failed). If RecoTracks have hits inside the fitted V0 vertex position, bits in hasInnerHitStatus are set. If there are no inside hits, store the V0 to the DataStore.

Parameters

trackPlus	Track of positively-charged daughter
trackMinus	Track of negatively-charged daughter
recoTrackPlus	RecoTrack of positively-charged daughter
recoTrackMinus	RecoTrack of negatively-charged daughter
v0Hypothesis	ParticleType used in vertex fitting
hasInnerHitStatus	store a result of this function. if the plus(minus) track has hits inside the V0 vertex position, 0x1(0x2) bit is set.
vertexPos	store a result of this function. the fitted vertex position is stored.
forceStore	if true, store the fitted V0 to the DataStore even if there are some inside hits.

Returns

Store V0 and TrackFitResults if hasInnerHitStatus==0 or forceStore==true.

If existing, pass to the genfit::Track the correct cardinal representation

The two vectors should always have the same size, and this never happen

make a clone, not use the reference so that the genfit::MeasuredStateOnPlane and its TrackReps will not be altered.

Apply cuts. We have one set of cuts inside the beam pipe, the other outside.

store V0

Before storing, apply invariant mass cut.

Reconstruct invariant mass.

To build the trackFitResult, use the magnetic field at the origin = (0, 0, 0); the helix is extrapolated to the IP in a constant magnetic field and material effects are neglected so that the vertexing tool executed on the MDST object will find again this vertex position

Definition at line 313 of file V0Fitter.cc.

{
  const auto& trackHypotheses = getTrackHypotheses(v0Hypothesis);
 
  // make a clone, not use the reference so that the genfit::Track and its TrackReps will not be altered.
  genfit::Track gfTrackPlus = RecoTrackGenfitAccess::getGenfitTrack(*recoTrackPlus);
  const int pdgTrackPlus = trackPlus->getTrackFitResultWithClosestMass(trackHypotheses.first)->getParticleType().getPDGCode();
  const genfit::AbsTrackRep* plusRepresentation = recoTrackPlus->getTrackRepresentationForPDG(pdgTrackPlus);
  if ((plusRepresentation == nullptr) or (not recoTrackPlus->wasFitSuccessful(plusRepresentation))) {
    B2ERROR("Track hypothesis with closest mass not available. Should never happen, but I can continue safely anyway.");
    return false;
  }
 
  // make a clone, not use the reference so that the genfit::Track and its TrackReps will not be altered.
  genfit::Track gfTrackMinus = RecoTrackGenfitAccess::getGenfitTrack(*recoTrackMinus);
  const int pdgTrackMinus = trackMinus->getTrackFitResultWithClosestMass(trackHypotheses.second)->getParticleType().getPDGCode();
  const genfit::AbsTrackRep* minusRepresentation = recoTrackMinus->getTrackRepresentationForPDG(pdgTrackMinus);
  if ((minusRepresentation == nullptr) or (not recoTrackMinus->wasFitSuccessful(minusRepresentation))) {
    B2ERROR("Track hypothesis with closest mass not available. Should never happen, but I can continue safely anyway.");
    return false;
  }

  const std::vector<genfit::AbsTrackRep*>& repsPlus = gfTrackPlus.getTrackReps();
  const std::vector<genfit::AbsTrackRep*>& repsMinus = gfTrackMinus.getTrackReps();
  if (repsPlus.size() == repsMinus.size()) {
    for (unsigned int id = 0; id < repsPlus.size(); id++) {
      if (abs(repsPlus[id]->getPDG()) == pdgTrackPlus)
        gfTrackPlus.setCardinalRep(id);
      if (abs(repsMinus[id]->getPDG()) == pdgTrackMinus)
        gfTrackMinus.setCardinalRep(id);
    }
  }
  else {
    for (unsigned int id = 0; id < repsPlus.size(); id++) {
      if (abs(repsPlus[id]->getPDG()) == pdgTrackPlus)
        gfTrackPlus.setCardinalRep(id);
    }
    for (unsigned int id = 0; id < repsMinus.size(); id++) {
      if (abs(repsMinus[id]->getPDG()) == pdgTrackMinus)
        gfTrackMinus.setCardinalRep(id);
    }
  }

  genfit::MeasuredStateOnPlane stPlus  = recoTrackPlus->getMeasuredStateOnPlaneFromFirstHit(plusRepresentation);
  genfit::MeasuredStateOnPlane stMinus = recoTrackMinus->getMeasuredStateOnPlaneFromFirstHit(minusRepresentation);
 
  genfit::GFRaveVertex vert;
  if (not m_vertexFitter->fit(gfTrackPlus, gfTrackMinus, pdgTrackPlus, pdgTrackMinus, vert)) {
    return false;
  }
 
  const ROOT::Math::XYZVector& posVert = ROOT::Math::XYZVector(vert.getPos());
  vertexPos = posVert;

  if (posVert.Rho() < m_beamPipeRadius) {
    return false;
  } else {
    if (vert.getChi2() > m_vertexChi2CutOutside) {
      B2DEBUG(22, "Vertex outside beam pipe, chi^2 too large.");
      return false;
    }
  }
 
  B2DEBUG(22, "Vertex accepted.");
 
  if (not extrapolateToVertex(stPlus, stMinus, posVert, hasInnerHitStatus)) {
    return false;
  }

  if (forceStore || hasInnerHitStatus == 0) {
    const genfit::GFRaveTrackParameters* tr0 = vert.getParameters(0);
    const genfit::GFRaveTrackParameters* tr1 = vert.getParameters(1);
    ROOT::Math::PxPyPzMVector lv0(tr0->getMom().Px(), tr0->getMom().Py(), tr0->getMom().Pz(), trackHypotheses.first.getMass());
    ROOT::Math::PxPyPzMVector lv1(tr1->getMom().Px(), tr1->getMom().Py(), tr1->getMom().Pz(), trackHypotheses.second.getMass());
    double v0InvMass = (lv0 + lv1).M();
    if (v0Hypothesis == Const::Kshort) {
      if (v0InvMass < std::get<0>(m_invMassRangeKshort) || v0InvMass > std::get<1>(m_invMassRangeKshort)) {
        B2DEBUG(22, "Kshort vertex rejected, invariant mass out of range.");
        return false;
      }
    } else if (v0Hypothesis == Const::Lambda || v0Hypothesis == Const::antiLambda) {
      if (v0InvMass < std::get<0>(m_invMassRangeLambda) || v0InvMass > std::get<1>(m_invMassRangeLambda)) {
        B2DEBUG(22, "Lambda vertex rejected, invariant mass out of range.");
        return false;
      }
    } else if (v0Hypothesis == Const::photon) {
      if (v0InvMass < std::get<0>(m_invMassRangePhoton) || v0InvMass > std::get<1>(m_invMassRangePhoton)) {
        B2DEBUG(22, "Photon vertex rejected, invariant mass out of range.");
        return false;
      }
    }
 

    const double Bz = BFieldManager::getFieldInTesla({0, 0, 0}).Z();
 
    int sharedInnermostCluster = checkSharedInnermostCluster(recoTrackPlus, recoTrackMinus);
 
    TrackFitResult* tfrPlusVtx =  buildTrackFitResult(gfTrackPlus, recoTrackPlus, stPlus,  Bz, trackHypotheses.first,
                                                      sharedInnermostCluster);
    TrackFitResult* tfrMinusVtx = buildTrackFitResult(gfTrackMinus, recoTrackMinus, stMinus, Bz, trackHypotheses.second,
                                                      sharedInnermostCluster);
 
    B2DEBUG(20, "Creating new V0.");
    const auto* v0 = m_v0s.appendNew(std::make_pair(trackPlus, tfrPlusVtx),
                                     std::make_pair(trackMinus, tfrMinusVtx),
                                     posVert.X(), posVert.Y(), posVert.Z());
 
    if (m_validation) {
      B2DEBUG(24, "Create StoreArray and Output for validation.");
      const auto* validationV0 = m_validationV0s.appendNew(
                                   std::make_pair(trackPlus, tfrPlusVtx),
                                   std::make_pair(trackMinus, tfrMinusVtx),
                                   ROOT::Math::XYZVector(vert.getPos()),
                                   vert.getCov(),
                                   (lv0 + lv1).P(),
                                   (lv0 + lv1).M(),
                                   vert.getChi2()
                                 );
      v0->addRelationTo(validationV0);
    }
  }
  return true;
}

Friends And Related Symbol Documentation

V0FitterTest_EnableValidation_Test

friend class V0FitterTest_EnableValidation_Test

friend

Definition at line 43 of file V0Fitter.h.

V0FitterTest_GetTrackHypotheses_Test

friend class V0FitterTest_GetTrackHypotheses_Test

friend

Definition at line 42 of file V0Fitter.h.

V0FitterTest_InitializeCuts_Test

friend class V0FitterTest_InitializeCuts_Test

friend

Definition at line 44 of file V0Fitter.h.

Member Data Documentation

m_beamPipeRadius

double m_beamPipeRadius

private

Radius where inside/outside beampipe is defined.

Definition at line 160 of file V0Fitter.h.

m_copiedRecoTracks

StoreArray<RecoTrack> m_copiedRecoTracks

private

RecoTrack used to refit tracks (output)

Definition at line 158 of file V0Fitter.h.

m_forcestore

bool m_forcestore

private

true only if the V0Fitter mode is 1

Definition at line 166 of file V0Fitter.h.

m_invMassRangeKshort

std::tuple<double, double> m_invMassRangeKshort

private

invariant mass cut for Kshort.

Definition at line 162 of file V0Fitter.h.

m_invMassRangeLambda

std::tuple<double, double> m_invMassRangeLambda

private

invariant mass cut for Lambda.

Definition at line 163 of file V0Fitter.h.

m_invMassRangePhoton

std::tuple<double, double> m_invMassRangePhoton

private

invariant mass cut for Photon.

Definition at line 164 of file V0Fitter.h.

m_recoTracks

StoreArray<RecoTrack> m_recoTracks

private

RecoTrack (input)

Definition at line 154 of file V0Fitter.h.

m_recoTracksName

std::string m_recoTracksName

private

RecoTrackColName (input).

Definition at line 153 of file V0Fitter.h.

m_trackFitResults

StoreArray<TrackFitResult> m_trackFitResults

private

TrackFitResult (output).

Definition at line 155 of file V0Fitter.h.

m_useOnlyOneSVDHitPair

bool m_useOnlyOneSVDHitPair

private

false only if the V0Fitter mode is 3

Definition at line 167 of file V0Fitter.h.

m_v0FitterMode

int m_v0FitterMode

private

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

Definition at line 165 of file V0Fitter.h.

m_v0s

StoreArray<V0> m_v0s

private

V0 (output).

Definition at line 156 of file V0Fitter.h.

m_validation

bool m_validation

private

Validation flag.

Definition at line 152 of file V0Fitter.h.

m_validationV0s

StoreArray<V0ValidationVertex> m_validationV0s

private

V0ValidationVertex (output, optional).

Definition at line 157 of file V0Fitter.h.

m_vertexChi2CutOutside

double m_vertexChi2CutOutside

private

Chi2 cut outside beampipe.

Definition at line 161 of file V0Fitter.h.

m_vertexFitter

std::unique_ptr<V0VertexFitter> m_vertexFitter

private

Vertex fitter used to fit the V0 vertex.

Definition at line 168 of file V0Fitter.h.

---

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

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