TrackBuilder Class Reference

TrackBuilder class to create the Track/TrackFitResult mdst output from the RecoTrack. More...

#include <TrackBuilder.h>

Collaboration diagram for TrackBuilder:

Public Member Functions
	TrackBuilder (const std::string &trackColName, const std::string &trackFitResultColName, const B2Vector3D &beamSpot=B2Vector3D(0., 0., 0.), const B2Vector3D &beamAxis=B2Vector3D(0., 0., 1.))
	Constructor of the class.
bool	storeTrackFromRecoTrack (RecoTrack &recoTrack, const bool useClosestHitToIP=false, const bool useBFieldAtHit=false)
	Stores a Belle2 Track from a Reco Track.

Static Public Member Functions
static uint32_t	getHitPatternVXDInitializer (const RecoTrack &recoTrack, const genfit::AbsTrackRep *representation=nullptr)
	Get the HitPattern in the VXD.
static uint64_t	getHitPatternCDCInitializer (const RecoTrack &recoTrack, const genfit::AbsTrackRep *representation=nullptr)
	Get the HitPattern in the CDC.

Private Attributes
std::string	m_trackColName
	TrackColName (output).
std::string	m_trackFitResultColName
	TrackFitResultColName (output).
B2Vector3D	m_beamSpot
	Extrapolation target, origin.
B2Vector3D	m_beamAxis
	Extrapolation target, positive z direction.

Detailed Description

TrackBuilder class to create the Track/TrackFitResult mdst output from the RecoTrack.

To use this class, iterate over all Reco tracks and call trackBuilder.storeTrackFromRecoTrack. All fitted hypotheses will be stored into one Track with the TrackFitResult array indices stored in the Track. for (auto& recoTrack : recoTracks) { trackBuilder.storeTrackFromRecoTrack(recoTrack); }

If you want to make sure that all hypotheses are fitted and stored, call the fitter again. If the tracks are fitted already, this produces no overhead. TrackFitter trackFitter; TrackBuilder trackBuilder; for (auto& recoTrack : recoTracks) { for (const auto& pdg : m_pdgCodes) { trackFitter.fit(recoTrack, Const::ParticleType(abs(pdg))); } trackBuilder.storeTrackFromRecoTrack(recoTrack); }

Definition at line 41 of file TrackBuilder.h.

Constructor & Destructor Documentation

TrackBuilder()

TrackBuilder ( const std::string & trackColName, const std::string & trackFitResultColName, const B2Vector3D & beamSpot = B2Vector3D(0., 0., 0.), const B2Vector3D & beamAxis = B2Vector3D(0., 0., 1.) )

inline

Constructor of the class.

Parameters

trackColName	Name of the store array for tracks (output).
trackFitResultColName	Name of the store array for track fit results (output).
beamSpot	Origin.
beamAxis	Positive z-direction.

Definition at line 50 of file TrackBuilder.h.

      :
      m_trackColName(trackColName),
      m_trackFitResultColName(trackFitResultColName),
      m_beamSpot(beamSpot),
      m_beamAxis(beamAxis)
    {};

Member Function Documentation

getHitPatternCDCInitializer()

uint64_t getHitPatternCDCInitializer ( const RecoTrack & recoTrack, const genfit::AbsTrackRep * representation = nullptr )

static

Get the HitPattern in the CDC.

Definition at line 226 of file TrackBuilder.cc.

{
  HitPatternCDC hitPatternCDC;
 
  int nCDChits = 0;
  int nNotFittedCDChits = 0;
 
  const auto& hitPointsWithMeasurements = recoTrack.getHitPointsWithMeasurement();
 
  for (const auto& trackPoint : hitPointsWithMeasurements) { // Loop on TrackPoint
 
    genfit::KalmanFitterInfo* kalmanInfo = trackPoint->getKalmanFitterInfo(representation);
 
    for (size_t measurementId = 0; measurementId < trackPoint->getNumRawMeasurements(); measurementId++) { //Loop on raw measurement
 
      genfit::AbsMeasurement* absMeas = trackPoint->getRawMeasurement(measurementId);
      CDCRecoHit* cdcHit = dynamic_cast<CDCRecoHit*>(absMeas);
 
      if (!cdcHit)
        continue; // consider only CDC hits
 
      if (kalmanInfo) {
        bool isValidWeight = false;
        for (unsigned int kfinfoId = 0; kfinfoId < kalmanInfo->getNumMeasurements(); kfinfoId++) { // Loop on KalmanFitterInfo
          const double weight = kalmanInfo->getWeights().at(kfinfoId);
          if (weight < 1.e-9)
            continue;           // skip kfinfo with negligible weight
          else {
            isValidWeight = true;
            B2DEBUG(27, "CDC: " << nCDChits << "\t" << cdcHit->getWireID().getEWire() << "\t" << kfinfoId << "\t" << weight);
            break;
          }
        }                       // end of KalmanFitterInfo loop
 
        if (isValidWeight) {    // fill nCDChits only one time per each raw measurement
          WireID wire = cdcHit->getWireID();
          hitPatternCDC.setLayer(wire.getICLayer());
          nCDChits++;             // counts CDC hits where there is KalmanFitterInfo and not negligible weight
        }
 
      }   // end of if kalmanInfo
      else {
        // i.e. if !kalmanInfo)
        ++nNotFittedCDChits;    // counts TrackPoints with CDC hits without KalmanFitterInfo
        continue;
      }
 
    } // end of loop on raw measurements
  } // end of loop on TrackPoint
 
  if (nNotFittedCDChits > 0) {
    B2DEBUG(27, " No KalmanFitterInfo associated to some TrackPoints with CDC hits, not filling the HitPatternCDC");
    B2DEBUG(27, nNotFittedCDChits << " out of " << nCDChits << " had no FitterInfo");
  }
  hitPatternCDC.setNHits(nCDChits);
 
  return hitPatternCDC.getInteger();
 
}

getHitPatternVXDInitializer()

uint32_t getHitPatternVXDInitializer ( const RecoTrack & recoTrack, const genfit::AbsTrackRep * representation = nullptr )

static

Get the HitPattern in the VXD.

Definition at line 157 of file TrackBuilder.cc.

{
  HitPatternVXD hitPatternVXD;
 
  const auto& hitPointsWithMeasurements = recoTrack.getHitPointsWithMeasurement();
  int nNotFittedVXDhits = 0;
 
  for (const auto& trackPoint : hitPointsWithMeasurements) {  // Loop on TrackPoint
 
    genfit::KalmanFitterInfo* kalmanInfo = trackPoint->getKalmanFitterInfo(representation);
 
    for (size_t measurementId = 0; measurementId < trackPoint->getNumRawMeasurements(); measurementId++) {  //Loop on raw measurement
 
      genfit::AbsMeasurement* absMeas = trackPoint->getRawMeasurement(measurementId);
 
      PXDRecoHit* pxdHit = dynamic_cast<PXDRecoHit*>(absMeas);
      SVDRecoHit* svdHit = dynamic_cast<SVDRecoHit*>(absMeas);
      SVDRecoHit2D* svdHit2D = dynamic_cast<SVDRecoHit2D*>(absMeas);
 
      if (!pxdHit && !svdHit2D && !svdHit)
        continue; // consider only VXD hits
 
      if (kalmanInfo) {
 
        if (kalmanInfo->getNumMeasurements() > 1)
          B2WARNING("VXD TrackPoint contains more than one KalmanFitterInfo: only the first will be considered");
 
        const double weight = kalmanInfo->getWeights().at(0); // only 1st KalmanFitterInfo considered
        if (weight < 1.e-9)
          continue;           // skip kfinfo with negligible weight
 
        if (pxdHit) {
          const int layerNumber = pxdHit->getSensorID().getLayerNumber();
          const int currentHits = hitPatternVXD.getPXDLayer(layerNumber, HitPatternVXD::PXDMode::normal);
          hitPatternVXD.setPXDLayer(layerNumber, currentHits + 1, HitPatternVXD::PXDMode::normal);
        }
 
        if (svdHit2D) {
          const int layerNumber = svdHit2D->getSensorID().getLayerNumber();
          const auto& currentHits = hitPatternVXD.getSVDLayer(layerNumber);
          hitPatternVXD.setSVDLayer(layerNumber, currentHits.first + 1, currentHits.second + 1);
        } else if (svdHit) {
          const int layerNumber = svdHit->getSensorID().getLayerNumber();
          const auto& currentHits = hitPatternVXD.getSVDLayer(layerNumber);
 
          if (svdHit->isU())
            hitPatternVXD.setSVDLayer(layerNumber, currentHits.first + 1, currentHits.second);
          else
            hitPatternVXD.setSVDLayer(layerNumber, currentHits.first, currentHits.second + 1);
        }
 
      }   // end of if kalmanInfo
      else {
        // i.e. if !kalmanInfo)
        ++nNotFittedVXDhits;    // counts TrackPoints with VXD hits without KalmanFitterInfo
        continue;
      }
 
    } // end of loop on raw measurements
  } // end of loop on TrackPoint
 
  if (nNotFittedVXDhits > 0) {
    B2DEBUG(27, " No KalmanFitterInfo associated to some TrackPoints with VXD hits, not filling the HitPatternVXD");
    B2DEBUG(27, nNotFittedVXDhits << " had no FitterInfo");
  }
  return hitPatternVXD.getInteger();
}

storeTrackFromRecoTrack()

bool storeTrackFromRecoTrack	(	RecoTrack &	recoTrack,
		const bool	useClosestHitToIP = false,
		const bool	useBFieldAtHit = false )

Stores a Belle2 Track from a Reco Track.

Every fitted hypothesis will be extrapolated to the perigee and stored as a TrackFitResult when the fit and the extrapolation were successful. We will only create a Track mdst object, when we are sure that we have at least one valid hypothesis available. If we do not have this, we discard the track no matter what.

The StoreArrayIndex is stored in the Belle2 Track, no relation is set.

Parameters

recoTrack	The reco track the fit results are stored for
useClosestHitToIP	Flag to turn on special handling which measurement to choose; especially useful for Cosmics
useBFieldAtHit	Flag to calculate the BField at the used hit (closest to IP or first one), instead of the one at the POCA. This is also useful for cosmics only.

Returns

Definition at line 35 of file TrackBuilder.cc.

{
  StoreArray<Track> tracks(m_trackColName);
  StoreArray<TrackFitResult> trackFitResults(m_trackFitResultColName);
 
  const auto& trackReps = recoTrack.getRepresentations();
  B2DEBUG(27, trackReps.size() << " track representations available.");
  std::optional<Track> ownedTrack;
  Track* relatedTrack = recoTrack.getRelatedFrom<Track>();
  bool newTrackCreated = false;
  if (!relatedTrack) {
    ownedTrack.emplace(recoTrack.getQualityIndicator());
    relatedTrack = &*ownedTrack;
    newTrackCreated = true;
  }
 
  bool repAlreadySet = false;
  unsigned int repIDPlusOne = 0;
  for (const auto& trackRep : trackReps) {
    repIDPlusOne++;
 
    // Check if the fitted particle type is in our charged stable set.
    const Const::ParticleType particleType(std::abs(trackRep->getPDG()));
    if (not Const::chargedStableSet.contains(particleType)) {
      B2DEBUG(27, "Track fitted with hypothesis that is not a ChargedStable (PDG code = " << particleType.getPDGCode() << ")");
      continue;
    }
 
    // Check if the fit worked.
    if (not recoTrack.wasFitSuccessful(trackRep)) {
      B2DEBUG(27, "The fit with the given track representation (" << std::abs(trackRep->getPDG()) <<
              ") was not successful. Skipping ...");
      continue;
    }
 
    // Skip hypotheses already stored by a previous TrackBuilder call (e.g. from a prior TrackCreator module).
    if (not newTrackCreated && relatedTrack->getTrackFitResult(particleType)) {
      continue;
    }
 
    if (not repAlreadySet) {
      RecoTrackGenfitAccess::getGenfitTrack(recoTrack).setCardinalRep(repIDPlusOne - 1);
      repAlreadySet = true;
    }
 
    // Extrapolate the tracks to the perigee.
    genfit::MeasuredStateOnPlane msop;
    try {
      if (useClosestHitToIP) {
        msop = recoTrack.getMeasuredStateOnPlaneClosestTo(ROOT::Math::XYZVector(0, 0, 0), trackRep);
      } else {
        msop = recoTrack.getMeasuredStateOnPlaneFromFirstHit(trackRep);
      }
    } catch (genfit::Exception& exception) {
      B2WARNING(exception.what());
      continue;
    } catch (const std::runtime_error& er) {
      B2WARNING("Runtime error encountered: " << er.what());
      continue;
    } catch (...) {
      B2WARNING("Undefined exception encountered.");
      continue;
    }
 
    genfit::MeasuredStateOnPlane extrapolatedMSoP = msop;
    try {
      extrapolatedMSoP.extrapolateToLine(m_beamSpot, m_beamAxis);
    } catch (...) {
      B2DEBUG(29, "Could not extrapolate the fit result for pdg " << particleType.getPDGCode() <<
              " to the perigee point.");
      continue;
    }
 
    // Build track fit result.
 
    TVector3 poca(0., 0., 0.);
    TVector3 dirInPoca(0., 0., 0.);
    TMatrixDSym cov(6);
    extrapolatedMSoP.getPosMomCov(poca, dirInPoca, cov);
    B2DEBUG(29, "Point of closest approach: " << poca.x() << "  " << poca.y() << "  " << poca.z());
    B2DEBUG(29, "Track direction in POCA: " << dirInPoca.x() << "  " << dirInPoca.y() << "  " << dirInPoca.z());
 
    const int charge = recoTrack.getTrackFitStatus(trackRep)->getCharge();
    const double pValue = recoTrack.getTrackFitStatus(trackRep)->getPVal();
    const double nDF = recoTrack.getTrackFitStatus(trackRep)->getNdf();
 
    double Bx, By, Bz;  // In cgs units
    if (useBFieldAtHit) {
      const B2Vector3D& hitPosition = msop.getPos();
      genfit::FieldManager::getInstance()->getFieldVal(hitPosition.X(), hitPosition.Y(), hitPosition.Z(), Bx, By, Bz);
    } else {
      genfit::FieldManager::getInstance()->getFieldVal(poca.X(), poca.Y(), poca.Z(), Bx, By, Bz);
    }
    Bz = Bz / 10.; // In SI-Units
 
    const uint64_t hitPatternCDCInitializer = getHitPatternCDCInitializer(recoTrack, trackRep);
    const uint32_t hitPatternVXDInitializer = getHitPatternVXDInitializer(recoTrack, trackRep);
 
    const auto newTrackFitResult = trackFitResults.appendNew(
                                     ROOT::Math::XYZVector(poca), ROOT::Math::XYZVector(dirInPoca), cov, charge, particleType, pValue, Bz,
                                     hitPatternCDCInitializer, hitPatternVXDInitializer, nDF
                                   );
 
    const int newTrackFitResultArrayIndex = newTrackFitResult->getArrayIndex();
    relatedTrack->setTrackFitResultIndex(particleType, newTrackFitResultArrayIndex);
  }
 
  B2DEBUG(27, "Number of fitted hypothesis = " << relatedTrack->getNumberOfFittedHypotheses());
  if (relatedTrack->getNumberOfFittedHypotheses() > 0) {
    if (newTrackCreated) {
      Track* addedTrack = tracks.appendNew(*relatedTrack);
      addedTrack->addRelationTo(&recoTrack);
    }
    return true;
  } else {
    B2DEBUG(28, "No valid fit for any given hypothesis. No Track is added to the Tracks StoreArray.");
  }
  return true;
}

Member Data Documentation

m_beamAxis

B2Vector3D m_beamAxis

private

Extrapolation target, positive z direction.

Definition at line 93 of file TrackBuilder.h.

m_beamSpot

B2Vector3D m_beamSpot

private

Extrapolation target, origin.

Definition at line 91 of file TrackBuilder.h.

m_trackColName

std::string m_trackColName

private

TrackColName (output).

Definition at line 87 of file TrackBuilder.h.

m_trackFitResultColName

std::string m_trackFitResultColName

private

TrackFitResultColName (output).

Definition at line 89 of file TrackBuilder.h.

---

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

• tracking/trackFitting/trackBuilder/factories/include/TrackBuilder.h
• tracking/trackFitting/trackBuilder/factories/src/TrackBuilder.cc