diff --git a/ALICE3/Core/FastTracker.cxx b/ALICE3/Core/FastTracker.cxx index 03f17079396..20eb7087f16 100644 --- a/ALICE3/Core/FastTracker.cxx +++ b/ALICE3/Core/FastTracker.cxx @@ -9,6 +9,12 @@ // granted to it by virtue of its status as an Intergovernmental Organization // or submit itself to any jurisdiction. +/// \file FastTracker.cxx +/// \brief On the fly implementation of DelphesO2 solveTrack +/// \author David Dobrigkeit Chinellato +/// \author Nicolò Jacazio +/// \author Jesper Karlsson Gumprecht + #include "FastTracker.h" #include "DetLayer.h" @@ -34,7 +40,6 @@ #include #include -#include #include #include @@ -44,14 +49,12 @@ #include #include -namespace o2 -{ -namespace fastsim +namespace o2::fastsim { // +-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+ -DetLayer* FastTracker::AddLayer(const TString& name, float r, float z, float x0, float xrho, float resRPhi, float resZ, float eff, int type) +DetLayer* FastTracker::addLayer(const TString& name, float r, float z, float x0, float xrho, float resRPhi, float resZ, float eff, int type) { LOG(debug) << "Adding layer " << name << " r=" << r << " z=" << z << " x0=" << x0 << " xrho=" << xrho << " resRPhi=" << resRPhi << " resZ=" << resZ << " eff=" << eff << " type=" << type; DetLayer newLayer(name, r, z, x0, xrho, resRPhi, resZ, eff, type); @@ -77,7 +80,7 @@ DetLayer* FastTracker::AddLayer(const TString& name, float r, float z, float x0, void FastTracker::addDeadPhiRegionInLayer(const std::string& layerName, float phiStart, float phiEnd) { - const int layerIdx = GetLayerIndex(layerName); + const int layerIdx = getLayerIndex(layerName); if (layerIdx < 0) { LOG(fatal) << "Cannot add dead phi region to non-existing layer " << layerName; return; @@ -85,7 +88,7 @@ void FastTracker::addDeadPhiRegionInLayer(const std::string& layerName, float ph layers[layerIdx].addDeadPhiRegion(phiStart, phiEnd); } -int FastTracker::GetLayerIndex(const std::string& name) const +int FastTracker::getLayerIndex(const std::string& name) const { int i = 0; for (const auto& layer : layers) { @@ -98,7 +101,7 @@ int FastTracker::GetLayerIndex(const std::string& name) const return -1; } -void FastTracker::Print() +void FastTracker::print() { // print out layer setup LOG(info) << "+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+"; @@ -109,7 +112,7 @@ void FastTracker::Print() LOG(info) << "+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+"; } -void FastTracker::AddTPC(float phiResMean, float zResMean) +void FastTracker::addTPC(float phiResMean, float zResMean) { LOG(info) << " Adding standard time projection chamber"; @@ -118,12 +121,11 @@ void FastTracker::AddTPC(float phiResMean, float zResMean) // https://github.com/AliceO2Group/DelphesO2/blob/master/src/DetectorK/DetectorK.cxx#L522 // % Radiation Lengths ... Average per TPC row (i.e. total/159 ) const int kNPassiveBound = 2; - const float radLBoundary[kNPassiveBound] = {1.692612e-01, 8.711904e-02}; - const float xrhoBoundary[kNPassiveBound] = {6.795774e+00, 3.111401e+00}; - const float rBoundary[kNPassiveBound] = {50, 70.0}; // cm + const std::array radLBoundary = {1.692612e-01, 8.711904e-02}; + const std::array xrhoBoundary = {6.795774e+00, 3.111401e+00}; + const std::array rBoundary = {50, 70.0}; // cm float radLPerRow = 0.000036; - float tpcInnerRadialPitch = 0.75; // cm float tpcMiddleRadialPitch = 1.0; // cm float tpcOuterRadialPitch = 1.5; // cm @@ -139,22 +141,23 @@ void FastTracker::AddTPC(float phiResMean, float zResMean) // add boundaries between ITS and TPC for (int i = 0; i < kNPassiveBound; i++) { - AddLayer(Form("tpc_boundary%d", i), rBoundary[i], zLength, radLBoundary[i], xrhoBoundary[i], 0); // dummy errors + addLayer(Form("tpc_boundary%d", i), rBoundary[i], zLength, radLBoundary[i], xrhoBoundary[i], 0); // dummy errors } - for (Int_t k = 0; k < tpcRows; k++) { - Float_t rowRadius = 0; - if (k < innerRows) + for (int k = 0; k < tpcRows; k++) { + float rowRadius = 0; + if (k < innerRows) { rowRadius = rowOneRadius + k * tpcInnerRadialPitch; - else if (k >= innerRows && k < (innerRows + middleRows)) + } else if (k >= innerRows && k < (innerRows + middleRows)) { rowRadius = row64Radius + (k - innerRows + 1) * tpcMiddleRadialPitch; - else if (k >= (innerRows + middleRows) && k < tpcRows) + } else if (k >= (innerRows + middleRows) && k < tpcRows) { rowRadius = row128Radius + (k - innerRows - middleRows + 1) * tpcOuterRadialPitch; + } - AddLayer(Form("tpc_%d", k), rowRadius, zLength, radLPerRow, 0, phiResMean, zResMean, 1.0f, 2); + addLayer(Form("tpc_%d", k), rowRadius, zLength, radLPerRow, 0, phiResMean, zResMean, 1.0f, 2); } } -void FastTracker::AddGenericDetector(const o2::fastsim::GeometryEntry& configMap, o2::ccdb::BasicCCDBManager* ccdbManager) +void FastTracker::addGenericDetector(const o2::fastsim::GeometryEntry& configMap, o2::ccdb::BasicCCDBManager* ccdbManager) { // Layers for (const auto& layer : configMap.getLayerNames()) { @@ -175,19 +178,17 @@ void FastTracker::AddGenericDetector(const o2::fastsim::GeometryEntry& configMap const int type = configMap.getIntValue(layer, "type"); const std::string deadPhiRegions = configMap.getValue(layer, "deadPhiRegions", false); - // void AddLayer(TString name, float r, float z, float x0, float xrho, float resRPhi = 0.0f, float resZ = 0.0f, float eff = 0.0f, int type = 0); LOG(info) << " Adding layer " << layer << " r=" << r << " z=" << z << " x0=" << x0 << " xrho=" << xrho << " resRPhi=" << resRPhi << " resZ=" << resZ << " eff=" << eff << " type=" << type << " deadPhiRegions=" << deadPhiRegions; - - DetLayer* addedLayer = AddLayer(layer.c_str(), r, z, x0, xrho, resRPhi, resZ, eff, type); + DetLayer* addedLayer = addLayer(layer.c_str(), r, z, x0, xrho, resRPhi, resZ, eff, type); if (!deadPhiRegions.empty()) { // Taking it as ccdb path or local file // Check if it begins with ccdb: - if (std::string(deadPhiRegions).rfind("ccdb:", 0) == 0) { - std::string ccdbPath = std::string(deadPhiRegions).substr(5); // remove "ccdb:" prefix + if (deadPhiRegions.starts_with("ccdb:")) { + std::string ccdbPath = deadPhiRegions.substr(5); // remove "ccdb:" prefix if (ccdbManager == nullptr) { LOG(fatal) << "CCDB manager is null, cannot retrieve file " << ccdbPath; return; } - TGraph* g = ccdbManager->getForTimeStamp(ccdbPath, 1); + auto g = ccdbManager->getForTimeStamp(ccdbPath, 1); addedLayer->setDeadPhiRegions(g); } else { // Taking it as local file @@ -196,7 +197,7 @@ void FastTracker::AddGenericDetector(const o2::fastsim::GeometryEntry& configMap LOG(fatal) << "Cannot open dead phi regions file " << deadPhiRegions; return; } - TGraph* g = reinterpret_cast(infile.Get(infile.GetListOfKeys()->At(0)->GetName())); + auto g = dynamic_cast(infile.Get(infile.GetListOfKeys()->At(0)->GetName())); infile.Close(); addedLayer->setDeadPhiRegions(g); } @@ -206,32 +207,35 @@ void FastTracker::AddGenericDetector(const o2::fastsim::GeometryEntry& configMap } } -float FastTracker::Dist(float z, float r) +float FastTracker::dist(float z, float r) { // porting of DetektorK::Dist // see here: // https://github.com/AliceO2Group/DelphesO2/blob/master/src/DetectorK/DetectorK.cxx#L743 int index = 1; int nSteps = 301; + const int nSigma = 4; float dist = 0.0; - float dz0 = (4 * sigmaD - (-4) * sigmaD / (nSteps = 1)); + float dz0 = (nSigma * sigmaD - (-nSigma) * sigmaD / (nSteps - 1)); float z0 = 0.0; for (int i = 0; i < nSteps; i++) { - if (i == nSteps - 1) + if (i == nSteps - 1) { index = 1; + } z0 = -4 * sigmaD + i * dz0; dist += index * (dz0 / 3.) * (1 / o2::math_utils::sqrt(o2::constants::math::TwoPI) / sigmaD) * std::exp(-z0 * z0 / 2. / sigmaD / sigmaD) * (1 / o2::math_utils::sqrt((z - z0) * (z - z0) + r * r)); - if (index != 4) - index = 4; - else + if (index != nSigma) { + index = nSigma; + } else { index = 2; + } } return dist; } -float FastTracker::OneEventHitDensity(float multiplicity, float radius) +float FastTracker::oneEventHitDensity(float multiplicity, float radius) { - // porting of DetektorK::OneEventHitDensity + // porting of DetektorK::oneEventHitDensity // see here: // https://github.com/AliceO2Group/DelphesO2/blob/master/src/DetectorK/DetectorK.cxx#L694 float den = multiplicity / (o2::constants::math::TwoPI * radius * radius); @@ -240,75 +244,75 @@ float FastTracker::OneEventHitDensity(float multiplicity, float radius) return den; } -float FastTracker::IntegratedHitDensity(float multiplicity, float radius) +float FastTracker::integratedHitDensity(float multiplicity, float radius) { // porting of DetektorK::IntegratedHitDensity // see here: // https://github.com/AliceO2Group/DelphesO2/blob/master/src/DetectorK/DetectorK.cxx#L712 float zdcHz = luminosity * 1.e24 * mCrossSectionMinB; - float den = zdcHz * integrationTime / 1000. * multiplicity * Dist(0., radius) / (o2::constants::math::TwoPI * radius); - if (den < OneEventHitDensity(multiplicity, radius)) - den = OneEventHitDensity(multiplicity, radius); + float den = zdcHz * integrationTime / 1000. * multiplicity * dist(0., radius) / (o2::constants::math::TwoPI * radius); + if (den < oneEventHitDensity(multiplicity, radius)) { + den = oneEventHitDensity(multiplicity, radius); + } return den; } -float FastTracker::UpcHitDensity(float radius) +float FastTracker::upcHitDensity(float radius) { // porting of DetektorK::UpcHitDensity // see here: // https://github.com/AliceO2Group/DelphesO2/blob/master/src/DetectorK/DetectorK.cxx#L727 - float mUPCelectrons = 0; - mUPCelectrons = lhcUPCScale * 5456 / (radius * radius) / dNdEtaMinB; - if (mUPCelectrons < 0) + float mUPCelectrons = lhcUPCScale * 5456 / (radius * radius) / dNdEtaMinB; + if (mUPCelectrons < 0) { mUPCelectrons = 0.0; - mUPCelectrons *= IntegratedHitDensity(dNdEtaMinB, radius); + } + mUPCelectrons *= integratedHitDensity(dNdEtaMinB, radius); mUPCelectrons *= upcBackgroundMultiplier; return mUPCelectrons; } -float FastTracker::HitDensity(float radius) +float FastTracker::hitDensity(float radius) { // porting of DetektorK::HitDensity // see here: // https://github.com/AliceO2Group/DelphesO2/blob/master/src/DetectorK/DetectorK.cxx#L663 float arealDensity = 0.; if (radius > maxRadiusSlowDet) { - arealDensity = OneEventHitDensity(dNdEtaCent, radius); - arealDensity += otherBackground * OneEventHitDensity(dNdEtaMinB, radius); + arealDensity = oneEventHitDensity(dNdEtaCent, radius); + arealDensity += otherBackground * oneEventHitDensity(dNdEtaMinB, radius); } // In the version of Delphes used to produce // Look-up tables, UpcHitDensity(radius) always returns 0, // hence it is left commented out for now if (radius < maxRadiusSlowDet) { - arealDensity = OneEventHitDensity(dNdEtaCent, radius); - arealDensity += otherBackground * OneEventHitDensity(dNdEtaMinB, radius) + IntegratedHitDensity(dNdEtaMinB, radius); + arealDensity = oneEventHitDensity(dNdEtaCent, radius); + arealDensity += otherBackground * oneEventHitDensity(dNdEtaMinB, radius) + integratedHitDensity(dNdEtaMinB, radius); // +UpcHitDensity(radius); } return arealDensity; } -float FastTracker::ProbGoodChiSqHit(float radius, float searchRadiusRPhi, float searchRadiusZ) +float FastTracker::probGoodChiSqHit(float radius, float searchRadiusRPhi, float searchRadiusZ) { // porting of DetektorK::ProbGoodChiSqHit // see here: // https://github.com/AliceO2Group/DelphesO2/blob/master/src/DetectorK/DetectorK.cxx#L629 - float sx, goodHit; - sx = o2::constants::math::TwoPI * searchRadiusRPhi * searchRadiusZ * HitDensity(radius); - goodHit = 1. / (1 + sx); + const float sx = o2::constants::math::TwoPI * searchRadiusRPhi * searchRadiusZ * hitDensity(radius); + const float goodHit = 1. / (1 + sx); return goodHit; } // function to provide a reconstructed track from a perfect input track // returns number of intercepts (generic for now) -int FastTracker::FastTrack(o2::track::TrackParCov inputTrack, o2::track::TrackParCov& outputTrack, const float nch, const float maxRadius) +int FastTracker::fastTrack(o2::track::TrackParCov inputTrack, o2::track::TrackParCov& outputTrack, const float nch, const float maxRadius) { dNdEtaCent = nch; // set the number of charged particles per unit rapidity hits.clear(); nIntercepts = 0; nSiliconPoints = 0; nGasPoints = 0; - std::array posIni; // provision for != PV + std::array posIni{}; // provision for != PV inputTrack.getXYZGlo(posIni); const float initialRadius = std::hypot(posIni[0], posIni[1]); const float kTrackingMargin = 0.1; @@ -326,6 +330,7 @@ int FastTracker::FastTrack(o2::track::TrackParCov inputTrack, o2::track::TrackPa } const int xrhosteps = 100; const bool applyAngularCorrection = true; + static constexpr float InterceptFailed = 999.f; // Delphes sets this to 20 instead of the number of layers, // but does not count all points in the tpc as layers which we do here @@ -359,7 +364,7 @@ int FastTracker::FastTrack(o2::track::TrackParCov inputTrack, o2::track::TrackPa // check if layer is reached float targetX = 1e+3; inputTrack.getXatLabR(layers[il].getRadius(), targetX, magneticField); - if (targetX > 999.f) { + if (targetX > InterceptFailed) { LOGF(debug, "Failed to find intercept for layer %d at radius %.2f cm", il, layers[il].getRadius()); break; // failed to find intercept } @@ -369,24 +374,24 @@ int FastTracker::FastTrack(o2::track::TrackParCov inputTrack, o2::track::TrackPa ok = inputTrack.correctForMaterial(layers[il].getRadiationLength(), 0, applyAngularCorrection); } if (ok && mApplyElossCorrection && layers[il].getDensity() > 0) { // correct in small steps - for (int ise = xrhosteps; ise--;) { + for (int ise = xrhosteps; ise > 0; --ise) { ok = inputTrack.correctForMaterial(0, -layers[il].getDensity() / xrhosteps, applyAngularCorrection); - if (!ok) + if (!ok) { break; + } } } LOGF(debug, "Propagation was %s up to layer %d", ok ? "successful" : "unsuccessful", il); // was there a problem on this layer? if (!ok && il > 0) { // may fail to reach target layer due to the eloss - float rad2 = inputTrack.getX() * inputTrack.getX() + inputTrack.getY() * inputTrack.getY(); - float maxR = layers[il - 1].getRadius() + kTrackingMargin * 2; - float minRad = (fMinRadTrack > 0 && fMinRadTrack < maxR) ? fMinRadTrack : maxR; + const float rad2 = inputTrack.getX() * inputTrack.getX() + inputTrack.getY() * inputTrack.getY(); + const float maxR = layers[il - 1].getRadius() + kTrackingMargin * 2; + const float minRad = (fMinRadTrack > 0 && fMinRadTrack < maxR) ? fMinRadTrack : maxR; if (rad2 - minRad * minRad < kTrackingMargin * kTrackingMargin) { // check previously reached layer return -5; // did not reach min requested layer - } else { - break; } + break; } if (std::abs(inputTrack.getZ()) > layers[il].getZ() && mApplyZacceptance) { @@ -423,16 +428,16 @@ int FastTracker::FastTrack(o2::track::TrackParCov inputTrack, o2::track::TrackPa for (int ip = 0; ip < o2::track::kNParams; ip++) { trPars[ip] = outputTrack.getParam(ip); } - static constexpr float kLargeErr2Coord = 5 * 5; - static constexpr float kLargeErr2Dir = 0.7 * 0.7; - static constexpr float kLargeErr2PtI = 30.5 * 30.5; + static constexpr float LargeErr2Coord = 5 * 5; + static constexpr float LargeErr2Dir = 0.7 * 0.7; + static constexpr float LargeErr2PtI = 30.5 * 30.5; std::array largeCov = {0.}; - for (int ic = o2::track::kCovMatSize; ic--;) { + for (int ic = o2::track::kCovMatSize; ic > 0; --ic) { largeCov[ic] = 0.; } - largeCov[o2::track::CovLabels::kSigY2] = largeCov[o2::track::CovLabels::kSigZ2] = kLargeErr2Coord; - largeCov[o2::track::CovLabels::kSigSnp2] = largeCov[o2::track::CovLabels::kSigTgl2] = kLargeErr2Dir; - largeCov[o2::track::CovLabels::kSigQ2Pt2] = kLargeErr2PtI * trPars[o2::track::ParLabels::kQ2Pt] * trPars[o2::track::ParLabels::kQ2Pt]; + largeCov[o2::track::CovLabels::kSigY2] = largeCov[o2::track::CovLabels::kSigZ2] = LargeErr2Coord; + largeCov[o2::track::CovLabels::kSigSnp2] = largeCov[o2::track::CovLabels::kSigTgl2] = LargeErr2Dir; + largeCov[o2::track::CovLabels::kSigQ2Pt2] = LargeErr2PtI * trPars[o2::track::ParLabels::kQ2Pt] * trPars[o2::track::ParLabels::kQ2Pt]; inwardTrack.setCov(largeCov); inwardTrack.checkCovariance(); @@ -443,8 +448,9 @@ int FastTracker::FastTrack(o2::track::TrackParCov inputTrack, o2::track::TrackPa float targetX = 1e+3; inputTrack.getXatLabR(layers[il].getRadius(), targetX, magneticField); - if (targetX > 999) + if (targetX > InterceptFailed) { continue; // failed to find intercept + } if (!inputTrack.propagateTo(targetX, magneticField)) { continue; // failed to propagate @@ -455,25 +461,22 @@ int FastTracker::FastTrack(o2::track::TrackParCov inputTrack, o2::track::TrackPa } // get perfect data point position - std::array spacePoint; + std::array spacePoint{}; inputTrack.getXYZGlo(spacePoint); std::vector thisHit = {spacePoint[0], spacePoint[1], spacePoint[2]}; // towards adding cluster: move to track alpha float alpha = inwardTrack.getAlpha(); - float xyz1[3]{ - std::cos(alpha) * spacePoint[0] + std::sin(alpha) * spacePoint[1], - -std::sin(alpha) * spacePoint[0] + std::cos(alpha) * spacePoint[1], - spacePoint[2]}; + std::array xyz1 = {std::cos(alpha) * spacePoint[0] + std::sin(alpha) * spacePoint[1], + -std::sin(alpha) * spacePoint[0] + std::cos(alpha) * spacePoint[1], + spacePoint[2]}; if (!inwardTrack.propagateTo(xyz1[0], magneticField)) { continue; } if (!layers[il].isInert()) { // only update covm for tracker hits - const o2::track::TrackParametrization::dim2_t hitpoint = { - static_cast(xyz1[1]), - static_cast(xyz1[2])}; + const o2::track::TrackParametrization::dim2_t hitpoint = {xyz1[1], xyz1[2]}; const o2::track::TrackParametrization::dim3_t hitpointcov = {layers[il].getResolutionRPhi() * layers[il].getResolutionRPhi(), 0.f, layers[il].getResolutionZ() * layers[il].getResolutionZ()}; inwardTrack.update(hitpoint, hitpointcov); @@ -489,7 +492,7 @@ int FastTracker::FastTrack(o2::track::TrackParCov inputTrack, o2::track::TrackPa } } if (mApplyElossCorrection && layers[il].getDensity() > 0) { - for (int ise = xrhosteps; ise--;) { // correct in small steps + for (int ise = xrhosteps; ise > 0; --ise) { // correct in small steps if (!inputTrack.correctForMaterial(0, layers[il].getDensity() / xrhosteps, applyAngularCorrection)) { return -7; } @@ -510,7 +513,7 @@ int FastTracker::FastTrack(o2::track::TrackParCov inputTrack, o2::track::TrackPa if (!layers[il].isInert()) { // good hit probability calculation float sigYCmb = o2::math_utils::sqrt(inwardTrack.getSigmaY2() + layers[il].getResolutionRPhi() * layers[il].getResolutionRPhi()); float sigZCmb = o2::math_utils::sqrt(inwardTrack.getSigmaZ2() + layers[il].getResolutionZ() * layers[il].getResolutionZ()); - goodHitProbability[il] = ProbGoodChiSqHit(layers[il].getRadius() * 100, sigYCmb * 100, sigZCmb * 100); + goodHitProbability[il] = probGoodChiSqHit(layers[il].getRadius() * 100, sigYCmb * 100, sigZCmb * 100); goodHitProbability[0] *= goodHitProbability[il]; } } @@ -518,7 +521,7 @@ int FastTracker::FastTrack(o2::track::TrackParCov inputTrack, o2::track::TrackPa // backpropagate to original radius float finalX = 1e+3; bool inPropStatus = inwardTrack.getXatLabR(initialRadius, finalX, magneticField); - if (finalX > 999) { + if (finalX > InterceptFailed) { LOG(debug) << "Failed to find intercept for initial radius " << initialRadius << " cm, x = " << finalX << " and status " << inPropStatus << " and sn = " << inwardTrack.getSnp() << " r = " << inwardTrack.getY() * inwardTrack.getY(); return -3; // failed to find intercept } @@ -528,7 +531,8 @@ int FastTracker::FastTrack(o2::track::TrackParCov inputTrack, o2::track::TrackPa } // only attempt to continue if intercepts are at least four - if (nIntercepts < 4) { + static constexpr int MinIntercepts = 4; + if (nIntercepts < MinIntercepts) { return nIntercepts; } @@ -556,41 +560,44 @@ int FastTracker::FastTrack(o2::track::TrackParCov inputTrack, o2::track::TrackPa for (int ii = 0; ii < o2::track::kCovMatSize; ii++) { covMat[ii] = outputTrack.getCov()[ii]; } - TMatrixDSym m(5); - double fcovm[5][5]; // double precision is needed for regularisation - for (int ii = 0, k = 0; ii < 5; ++ii) { - for (int j = 0; j < ii + 1; ++j, ++k) { - fcovm[ii][j] = covMat[k]; - fcovm[j][ii] = covMat[k]; + std::array, o2::track::kNParams> fcovm{}; // double precision is needed for regularisation + TMatrixDSym m(o2::track::kNParams); + for (int ii = 0, k = 0; ii < o2::track::kNParams; ++ii) { + for (int jj = 0; jj < ii + 1; ++jj, ++k) { + fcovm[ii][jj] = covMat[k]; + fcovm[jj][ii] = covMat[k]; } } // evaluate ruben's conditional, regularise - const bool makePositiveDefinite = (covMatFactor > -1e-5); // apply fix + static constexpr float CovMatFactorThreshold = -1e-5; + const bool makePositiveDefinite = (covMatFactor > CovMatFactorThreshold); // apply fix bool rubenConditional = false; - for (int ii = 0; ii < 5; ii++) { - for (int jj = 0; jj < 5; jj++) { - if (ii == jj) + for (int ii = 0; ii < o2::track::kNParams; ii++) { + for (int jj = 0; jj < o2::track::kNParams; jj++) { + if (ii == jj) { continue; // don't evaluate diagonals + } if (fcovm[ii][jj] * fcovm[ii][jj] > std::abs(fcovm[ii][ii] * fcovm[jj][jj])) { rubenConditional = true; if (makePositiveDefinite) { - fcovm[ii][jj] = TMath::Sign(1, fcovm[ii][jj]) * covMatFactor * sqrt(std::abs(fcovm[ii][ii] * fcovm[jj][jj])); + fcovm[ii][jj] = TMath::Sign(1, fcovm[ii][jj]) * covMatFactor * std::sqrt(std::abs(fcovm[ii][ii] * fcovm[jj][jj])); } } } } // Should have a valid cov matrix now - m.SetMatrixArray(reinterpret_cast(fcovm)); + m.SetMatrixArray(fcovm[0].data()); TMatrixDSymEigen eigen(m); TMatrixD eigVec = eigen.GetEigenVectors(); const TVectorD& eigVal = eigen.GetEigenValues(); bool negEigVal = false; - for (int ii = 0; ii < 5; ii++) { - if (eigVal[ii] < 0.0f) + for (int ii = 0; ii < o2::track::kNParams; ii++) { + if (eigVal[ii] < 0.0f) { negEigVal = true; + } } if (negEigVal && rubenConditional && makePositiveDefinite) { @@ -608,26 +615,28 @@ int FastTracker::FastTrack(o2::track::TrackParCov inputTrack, o2::track::TrackPa covMatOK++; // transform parameter vector and smear - float params_[5]; - for (int ii = 0; ii < 5; ++ii) { + std::array transformedParams{}; + for (int ii = 0; ii < o2::track::kNParams; ++ii) { float val = 0.; - for (int j = 0; j < 5; ++j) - val += eigVec[j][ii] * outputTrack.getParam(j); + for (int jj = 0; jj < o2::track::kNParams; ++jj) { + val += eigVec[jj][ii] * outputTrack.getParam(jj); + } // smear parameters according to eigenvalues - params_[ii] = gRandom->Gaus(val, sqrt(eigVal[ii])); + transformedParams[ii] = gRandom->Gaus(val, std::sqrt(eigVal[ii])); } // invert eigenvector matrix eigVec.Invert(); // transform back params vector - for (int ii = 0; ii < 5; ++ii) { + for (int ii = 0; ii < o2::track::kNParams; ++ii) { float val = 0.; - for (int j = 0; j < 5; ++j) - val += eigVec[j][ii] * params_[j]; + for (int jj = 0; jj < o2::track::kNParams; ++jj) { + val += eigVec[jj][ii] * transformedParams[jj]; + } outputTrack.setParam(val, ii); } // should make a sanity check that par[2] sin(phi) is in [-1, 1] - if (fabs(outputTrack.getParam(2)) > 1.) { + if (std::abs(outputTrack.getParam(2)) > 1.) { LOG(info) << " --- smearTrack failed sin(phi) sanity check: " << outputTrack.getParam(2); return -2; } @@ -636,7 +645,6 @@ int FastTracker::FastTrack(o2::track::TrackParCov inputTrack, o2::track::TrackPa } // +-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+ -} /* namespace fastsim */ -} /* namespace o2 */ +} // namespace o2::fastsim ClassImp(o2::fastsim::FastTracker); diff --git a/ALICE3/Core/FastTracker.h b/ALICE3/Core/FastTracker.h index 814a190dbc8..d3d9a11d4ed 100644 --- a/ALICE3/Core/FastTracker.h +++ b/ALICE3/Core/FastTracker.h @@ -9,6 +9,12 @@ // granted to it by virtue of its status as an Intergovernmental Organization // or submit itself to any jurisdiction. +/// \file FastTracker.h +/// \brief On the fly implementation of DelphesO2 solveTrack +/// \author David Dobrigkeit Chinellato +/// \author Nicolò Jacazio +/// \author Jesper Karlsson Gumprecht + #ifndef ALICE3_CORE_FASTTRACKER_H_ #define ALICE3_CORE_FASTTRACKER_H_ @@ -27,9 +33,7 @@ #include #include -namespace o2 -{ -namespace fastsim +namespace o2::fastsim { // +-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+ @@ -46,30 +50,30 @@ class FastTracker virtual ~FastTracker() {} // Layer and layer configuration - DetLayer* AddLayer(const TString& name, float r, float z, float x0, float xrho, float resRPhi = 0.0f, float resZ = 0.0f, float eff = 0.0f, int type = 0); + DetLayer* addLayer(const TString& name, float r, float z, float x0, float xrho, float resRPhi = 0.0f, float resZ = 0.0f, float eff = 0.0f, int type = 0); /// Add a dead region in phi for a specific layer /// \param layerName Name of the layer to modify /// \param phiStart Start angle of the dead region (in radians) /// \param phiEnd End angle of the dead region (in radians) void addDeadPhiRegionInLayer(const std::string& layerName, float phiStart, float phiEnd); - DetLayer GetLayer(const int layer) const { return layers[layer]; } - std::vector GetLayers() const { return layers; } - int GetLayerIndex(const std::string& name) const; - size_t GetNLayers() const { return layers.size(); } - bool IsLayerInert(const int layer) const { return layers[layer].isInert(); } - void ClearLayers() { layers.clear(); } - void SetRadiationLength(const std::string& layerName, float x0) { layers[GetLayerIndex(layerName)].setRadiationLength(x0); } - void SetRadius(const std::string& layerName, float r) { layers[GetLayerIndex(layerName)].setRadius(r); } - void SetResolutionRPhi(const std::string& layerName, float resRPhi) { layers[GetLayerIndex(layerName)].setResolutionRPhi(resRPhi); } - void SetResolutionZ(const std::string& layerName, float resZ) { layers[GetLayerIndex(layerName)].setResolutionZ(resZ); } - void SetResolution(const std::string& layerName, float resRPhi, float resZ) + [[nodiscard]] DetLayer getLayer(const int layer) const { return layers[layer]; } + [[nodiscard]] std::vector getLayers() const { return layers; } + [[nodiscard]] int getLayerIndex(const std::string& name) const; + [[nodiscard]] size_t getNLayers() const { return layers.size(); } + [[nodiscard]] bool isLayerInert(const int layer) const { return layers[layer].isInert(); } + void clearLayers() { layers.clear(); } + void setRadiationLength(const std::string& layerName, float x0) { layers[getLayerIndex(layerName)].setRadiationLength(x0); } + void setRadius(const std::string& layerName, float r) { layers[getLayerIndex(layerName)].setRadius(r); } + void setResolutionRPhi(const std::string& layerName, float resRPhi) { layers[getLayerIndex(layerName)].setResolutionRPhi(resRPhi); } + void setResolutionZ(const std::string& layerName, float resZ) { layers[getLayerIndex(layerName)].setResolutionZ(resZ); } + void setResolution(const std::string& layerName, float resRPhi, float resZ) { - SetResolutionRPhi(layerName, resRPhi); - SetResolutionZ(layerName, resZ); + setResolutionRPhi(layerName, resRPhi); + setResolutionZ(layerName, resZ); } - void AddTPC(float phiResMean, float zResMean); + void addTPC(float phiResMean, float zResMean); /** * @brief Adds a generic detector configuration from the specified file. @@ -80,9 +84,9 @@ class FastTracker * * @param configMap Configuration map describing the detector. */ - void AddGenericDetector(const o2::fastsim::GeometryEntry& configMap, o2::ccdb::BasicCCDBManager* ccdbManager = nullptr); + void addGenericDetector(const o2::fastsim::GeometryEntry& configMap, o2::ccdb::BasicCCDBManager* ccdbManager = nullptr); - void Print(); + void print(); /** * @brief Performs fast tracking on the input track parameters. @@ -95,44 +99,44 @@ class FastTracker * @param nch Charged particle multiplicity (used for hit density calculations). * @return int i.e. number of intercepts (implementation-defined). */ - int FastTrack(o2::track::TrackParCov inputTrack, o2::track::TrackParCov& outputTrack, const float nch, const float maxRadius = 100.f); + int fastTrack(o2::track::TrackParCov inputTrack, o2::track::TrackParCov& outputTrack, const float nch, const float maxRadius = 100.f); // For efficiency calculation - float Dist(float z, float radius); - float OneEventHitDensity(float multiplicity, float radius); - float IntegratedHitDensity(float multiplicity, float radius); - float UpcHitDensity(float radius); - float HitDensity(float radius); - float ProbGoodChiSqHit(float radius, float searchRadiusRPhi, float searchRadiusZ); + float dist(float z, float radius); + float oneEventHitDensity(float multiplicity, float radius); + float integratedHitDensity(float multiplicity, float radius); + float upcHitDensity(float radius); + float hitDensity(float radius); + float probGoodChiSqHit(float radius, float searchRadiusRPhi, float searchRadiusZ); // Setters and getters for configuration - void SetIntegrationTime(float t) { integrationTime = t; } - void SetMaxRadiusOfSlowDetectors(float r) { maxRadiusSlowDet = r; } - void SetAvgRapidity(float y) { avgRapidity = y; } - void SetdNdEtaCent(int d) { dNdEtaCent = d; } - void SetLhcUPCscale(float s) { lhcUPCScale = s; } - void SetBField(float b) { magneticField = b; } - void SetMinRadTrack(float r) { fMinRadTrack = r; } - void SetMagneticField(float b) { magneticField = b; } - void SetApplyZacceptance(bool b) { mApplyZacceptance = b; } - void SetApplyMSCorrection(bool b) { mApplyMSCorrection = b; } - void SetApplyElossCorrection(bool b) { mApplyElossCorrection = b; } - void SetApplyEffCorrection(bool b) { mApplyEffCorrection = b; } + void setIntegrationTime(float t) { integrationTime = t; } + void setMaxRadiusOfSlowDetectors(float r) { maxRadiusSlowDet = r; } + void setAvgRapidity(float y) { avgRapidity = y; } + void setdNdEtaCent(int d) { dNdEtaCent = d; } + void setLhcUPCscale(float s) { lhcUPCScale = s; } + void setBField(float b) { magneticField = b; } + void setMinRadTrack(float r) { fMinRadTrack = r; } + void setMagneticField(float b) { magneticField = b; } + void setApplyZacceptance(bool b) { mApplyZacceptance = b; } + void setApplyMSCorrection(bool b) { mApplyMSCorrection = b; } + void setApplyElossCorrection(bool b) { mApplyElossCorrection = b; } + void setApplyEffCorrection(bool b) { mApplyEffCorrection = b; } // Getters for the last track - int GetNIntercepts() const { return nIntercepts; } - int GetNSiliconPoints() const { return nSiliconPoints; } - int GetNGasPoints() const { return nGasPoints; } - float GetGoodHitProb(int layer) const + [[nodiscard]] int getNIntercepts() const { return nIntercepts; } + [[nodiscard]] int getNSiliconPoints() const { return nSiliconPoints; } + [[nodiscard]] int getNGasPoints() const { return nGasPoints; } + [[nodiscard]] float getGoodHitProb(int layer) const { return (layer >= 0 && static_cast(layer) < goodHitProbability.size()) ? goodHitProbability[layer] : 0.0f; } - std::size_t GetNHits() const { return hits.size(); } - float GetHitX(const int i) const { return hits[i][0]; } - float GetHitY(const int i) const { return hits[i][1]; } - float GetHitZ(const int i) const { return hits[i][2]; } - uint64_t GetCovMatOK() const { return covMatOK; } - uint64_t GetCovMatNotOK() const { return covMatNotOK; } + [[nodiscard]] std::size_t getNHits() const { return hits.size(); } + [[nodiscard]] float getHitX(const int i) const { return hits[i][0]; } + [[nodiscard]] float getHitY(const int i) const { return hits[i][1]; } + [[nodiscard]] float getHitZ(const int i) const { return hits[i][2]; } + uint64_t getCovMatOK() const { return covMatOK; } + uint64_t getCovMatNotOK() const { return covMatNotOK; } private: // Definition of detector layers @@ -146,8 +150,8 @@ class FastTracker bool mApplyEffCorrection = true; /// Apply correction for hit efficiency int mVerboseLevel = 0; /// 0: not verbose, >0 more verbose const float mCrossSectionMinB = 8; /// Minimum bias Cross section for event under study (PbPb MinBias ~ 8 Barns) - int dNdEtaCent = 2200; /// dN/deta e.g. at centrality 0-5% (for 5 TeV PbPb) - int dNdEtaMinB = 1; /// dN/deta for minimum bias events + float dNdEtaCent = 2200.f; /// dN/deta e.g. at centrality 0-5% (for 5 TeV PbPb) + float dNdEtaMinB = 1.f; /// dN/deta for minimum bias events float integrationTime = 0.02f; /// Integration time in ms float magneticField = 20.f; /// Magnetic field in kiloGauss (5 = 0.5T, 20 = 2T, etc) float covMatFactor = 0.99f; /// covmat off-diagonal factor to use for covmat fix (negative: no factor) @@ -175,7 +179,6 @@ class FastTracker // +-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+ -} // namespace fastsim -} // namespace o2 +} // namespace o2::fastsim #endif // ALICE3_CORE_FASTTRACKER_H_ diff --git a/ALICE3/Core/FlatLutWriter.cxx b/ALICE3/Core/FlatLutWriter.cxx index 3a83e78e270..4fe806c4ef4 100644 --- a/ALICE3/Core/FlatLutWriter.cxx +++ b/ALICE3/Core/FlatLutWriter.cxx @@ -85,7 +85,7 @@ bool FlatLutWriter::fatSolve(lutEntry_t& lutEntry, o2::upgrade::convertTLorentzVectorToO2Track(q, tlv, {0.f, 0.f, 0.f}, trkIn); o2::track::TrackParCov trkOut; - const int status = fat.FastTrack(trkIn, trkOut, nch); + const int status = fat.fastTrack(trkIn, trkOut, nch); if (status <= mAtLeastHits) { LOGF(debug, "fatSolve: FastTrack failed with status %d (threshold %d)", status, mAtLeastHits); return false; @@ -94,8 +94,8 @@ bool FlatLutWriter::fatSolve(lutEntry_t& lutEntry, LOGF(debug, "fatSolve: FastTrack succeeded with status %d", status); lutEntry.valid = true; - lutEntry.itof = fat.GetGoodHitProb(itof); - lutEntry.otof = fat.GetGoodHitProb(otof); + lutEntry.itof = fat.getGoodHitProb(itof); + lutEntry.otof = fat.getGoodHitProb(otof); static constexpr int nCov = 15; for (int i = 0; i < nCov; ++i) @@ -104,16 +104,16 @@ bool FlatLutWriter::fatSolve(lutEntry_t& lutEntry, // Define the efficiency auto totfake = 0.f; lutEntry.eff = 1.f; - for (size_t i = 1; i < fat.GetNLayers(); ++i) { - if (fat.IsLayerInert(i)) + for (size_t i = 1; i < fat.getNLayers(); ++i) { + if (fat.isLayerInert(i)) continue; // skip inert layers - auto igoodhit = fat.GetGoodHitProb(i); + auto igoodhit = fat.getGoodHitProb(i); if (igoodhit <= 0.f || i == itof || i == otof) continue; lutEntry.eff *= igoodhit; auto pairfake = 0.f; - for (size_t j = i + 1; j < fat.GetNLayers(); ++j) { - auto jgoodhit = fat.GetGoodHitProb(j); + for (size_t j = i + 1; j < fat.getNLayers(); ++j) { + auto jgoodhit = fat.getGoodHitProb(j); if (jgoodhit <= 0.f || j == itof || j == otof) continue; pairfake = (1.f - igoodhit) * (1.f - jgoodhit); @@ -290,7 +290,7 @@ void FlatLutWriter::lutWrite(const char* filename, int pdg, float field, size_t LOGF(info, "Writing nch bin %d/%d", inch, nnch); auto nch = lutHeader.nchmap.eval(inch); lutEntry.nch = nch; - fat.SetdNdEtaCent(nch); + fat.setdNdEtaCent(nch); for (int irad = 0; irad < nrad; ++irad) { for (int ieta = 0; ieta < neta; ++ieta) { diff --git a/ALICE3/TableProducer/OTF/onTheFlyTracker.cxx b/ALICE3/TableProducer/OTF/onTheFlyTracker.cxx index ea200240565..3ba58520e3b 100644 --- a/ALICE3/TableProducer/OTF/onTheFlyTracker.cxx +++ b/ALICE3/TableProducer/OTF/onTheFlyTracker.cxx @@ -532,12 +532,12 @@ struct OnTheFlyTracker { fastPrimaryTrackerSettings.fastTrackPrimaries || fastPrimaryTrackerSettings.fastTrackShortLivedParticles) { fastTracker.emplace_back(std::make_unique()); - fastTracker[icfg]->SetMagneticField(mMagneticField); - fastTracker[icfg]->SetApplyZacceptance(fastTrackerSettings.applyZacceptance); - fastTracker[icfg]->SetApplyMSCorrection(fastTrackerSettings.applyMSCorrection); - fastTracker[icfg]->SetApplyElossCorrection(fastTrackerSettings.applyElossCorrection); - fastTracker[icfg]->AddGenericDetector(mGeoContainer.getEntry(icfg), ccdb.operator->()); - fastTracker[icfg]->Print(); // print fastTracker settings + fastTracker[icfg]->setMagneticField(mMagneticField); + fastTracker[icfg]->setApplyZacceptance(fastTrackerSettings.applyZacceptance); + fastTracker[icfg]->setApplyMSCorrection(fastTrackerSettings.applyMSCorrection); + fastTracker[icfg]->setApplyElossCorrection(fastTrackerSettings.applyElossCorrection); + fastTracker[icfg]->addGenericDetector(mGeoContainer.getEntry(icfg), ccdb.operator->()); + fastTracker[icfg]->print(); // print fastTracker settings if (cascadeDecaySettings.doXiQA) { insertHist(histPath + "hXiBuilding", "hXiBuilding", kTH1F, {{10, -0.5f, 9.5f}}); @@ -1031,9 +1031,9 @@ struct OnTheFlyTracker { nSiliconHitsCascadeProngs[i] = 0; nTPCHitsCascadeProngs[i] = 0; if (enableSecondarySmearing) { - nHitsCascadeProngs[i] = fastTracker[icfg]->FastTrack(xiDaughterTrackParCovsPerfect[i], xiDaughterTrackParCovsTracked[i], dNdEta); - nSiliconHitsCascadeProngs[i] = fastTracker[icfg]->GetNSiliconPoints(); - nTPCHitsCascadeProngs[i] = fastTracker[icfg]->GetNGasPoints(); + nHitsCascadeProngs[i] = fastTracker[icfg]->fastTrack(xiDaughterTrackParCovsPerfect[i], xiDaughterTrackParCovsTracked[i], dNdEta); + nSiliconHitsCascadeProngs[i] = fastTracker[icfg]->getNSiliconPoints(); + nTPCHitsCascadeProngs[i] = fastTracker[icfg]->getNGasPoints(); if (nHitsCascadeProngs[i] < 0 && cascadeDecaySettings.doXiQA) { // QA getHist(histPath + "hFastTrackerQA")->Fill(o2::math_utils::abs(nHitsCascadeProngs[i])); @@ -1053,8 +1053,8 @@ struct OnTheFlyTracker { } isReco[i] = true; - for (uint32_t ih = 0; ih < fastTracker[icfg]->GetNHits() && cascadeDecaySettings.doXiQA; ih++) { - getHist(histPath + "hFastTrackerHits")->Fill(fastTracker[icfg]->GetHitZ(ih), std::hypot(fastTracker[icfg]->GetHitX(ih), fastTracker[icfg]->GetHitY(ih))); + for (uint32_t ih = 0; ih < fastTracker[icfg]->getNHits() && cascadeDecaySettings.doXiQA; ih++) { + getHist(histPath + "hFastTrackerHits")->Fill(fastTracker[icfg]->getHitZ(ih), std::hypot(fastTracker[icfg]->getHitX(ih), fastTracker[icfg]->getHitY(ih))); } } else { isReco[i] = true; @@ -1219,8 +1219,8 @@ struct OnTheFlyTracker { if (cascadeDecaySettings.trackXi) { // optionally, add the points in the layers before the decay of the Xi // will back-track the perfect MC cascade to relevant layers, find hit, smear and add to smeared cascade - for (int i = fastTracker[icfg]->GetLayers().size() - 1; i >= 0; --i) { - o2::fastsim::DetLayer layer = fastTracker[icfg]->GetLayer(i); + for (int i = fastTracker[icfg]->getLayers().size() - 1; i >= 0; --i) { + o2::fastsim::DetLayer layer = fastTracker[icfg]->getLayer(i); if (layer.isInert()) { continue; // Not an active tracking layer } @@ -1294,7 +1294,7 @@ struct OnTheFlyTracker { if (isReco[0] && ((cascadeDecaySettings.doKinkReco == 1 && tryKinkReco) || cascadeDecaySettings.doKinkReco == 2)) { // mode 1 or 2 o2::track::TrackParCov trackedCascade; const o2::track::TrackParCov& trackedBach = xiDaughterTrackParCovsTracked[0]; - const int nCascHits = fastTracker[icfg]->FastTrack(perfectCascadeTrack, trackedCascade, dNdEta, xiDecayRadius2D); + const int nCascHits = fastTracker[icfg]->fastTrack(perfectCascadeTrack, trackedCascade, dNdEta, xiDecayRadius2D); reconstructedCascade = fastTrackerSettings.minSiliconHitsForKinkReco < nCascHits; if (reconstructedCascade) { std::array pCasc{}; @@ -1519,9 +1519,9 @@ struct OnTheFlyTracker { nV0SiliconHits[i] = 0; nV0TPCHits[i] = 0; if (enableSecondarySmearing) { - nV0Hits[i] = fastTracker[icfg]->FastTrack(v0DaughterTrackParCovsPerfect[i], v0DaughterTrackParCovsTracked[i], dNdEta); - nV0SiliconHits[i] = fastTracker[icfg]->GetNSiliconPoints(); - nV0TPCHits[i] = fastTracker[icfg]->GetNGasPoints(); + nV0Hits[i] = fastTracker[icfg]->fastTrack(v0DaughterTrackParCovsPerfect[i], v0DaughterTrackParCovsTracked[i], dNdEta); + nV0SiliconHits[i] = fastTracker[icfg]->getNSiliconPoints(); + nV0TPCHits[i] = fastTracker[icfg]->getNGasPoints(); if (nV0SiliconHits[i] >= fastTrackerSettings.minSiliconHits || (nV0SiliconHits[i] >= fastTrackerSettings.minSiliconHitsIfTPCUsed && @@ -1535,8 +1535,8 @@ struct OnTheFlyTracker { if (nV0Hits[i] < 0) { fillHist(Form("V0Building_Configuration_%i/hFastTrackerQA", icfg), o2::math_utils::abs(nV0Hits[i])); } - for (uint32_t ih = 0; ih < fastTracker[icfg]->GetNHits(); ih++) { - fillHist(Form("V0Building_Configuration_%i/hFastTrackerHits", icfg), fastTracker[icfg]->GetHitZ(ih), std::hypot(fastTracker[icfg]->GetHitX(ih), fastTracker[icfg]->GetHitY(ih))); + for (uint32_t ih = 0; ih < fastTracker[icfg]->getNHits(); ih++) { + fillHist(Form("V0Building_Configuration_%i/hFastTrackerHits", icfg), fastTracker[icfg]->getHitZ(ih), std::hypot(fastTracker[icfg]->getHitX(ih), fastTracker[icfg]->getHitY(ih))); } } } else { @@ -1955,7 +1955,7 @@ struct OnTheFlyTracker { o2::track::TrackParCov perfectTrackParCov = o2::upgrade::convertMCParticleToO2Track(mcParticle, pdgDB); perfectTrackParCov.setPID(pdgCodeToPID(mcParticle.pdgCode())); computeBremsstrahlungLoss(icfg, mcParticle, perfectTrackParCov); - nTrkHits = fastTracker[icfg]->FastTrack(perfectTrackParCov, trackParCov, dNdEta); + nTrkHits = fastTracker[icfg]->fastTrack(perfectTrackParCov, trackParCov, dNdEta); if (nTrkHits < fastPrimaryTrackerSettings.minSiliconHits) { reconstructed = false; } @@ -1965,7 +1965,7 @@ struct OnTheFlyTracker { computeBremsstrahlungLoss(icfg, mcParticle, perfectTrackParCov); const std::array decayVtx = decayer.generateDecayVertex(mcParticle, pdgDB); const float decayRadius2D = std::hypot(decayVtx[0], decayVtx[1]); - nTrkHits = fastTracker[icfg]->FastTrack(perfectTrackParCov, trackParCov, dNdEta, decayRadius2D); + nTrkHits = fastTracker[icfg]->fastTrack(perfectTrackParCov, trackParCov, dNdEta, decayRadius2D); if (nTrkHits < fastPrimaryTrackerSettings.minSiliconHits) { reconstructed = false; } @@ -2085,8 +2085,8 @@ struct OnTheFlyTracker { // do bookkeeping of fastTracker tracking if (enableSecondarySmearing) { - histos.fill(HIST("hCovMatOK"), 0.0f, fastTracker[icfg]->GetCovMatNotOK()); - histos.fill(HIST("hCovMatOK"), 1.0f, fastTracker[icfg]->GetCovMatOK()); + histos.fill(HIST("hCovMatOK"), 0.0f, fastTracker[icfg]->getCovMatNotOK()); + histos.fill(HIST("hCovMatOK"), 1.0f, fastTracker[icfg]->getCovMatOK()); } if (doExtraQA) { histos.fill(HIST("hRecoVsSimMultiplicity"), multiplicityCounter, recoPrimaries.size()); @@ -2184,7 +2184,7 @@ struct OnTheFlyTracker { o2::track::TrackParCov perfectTrackParCov = o2::upgrade::convertMCParticleToO2Track(mcParticle, pdgDB); perfectTrackParCov.setPID(pdgCodeToPID(mcParticle.pdgCode())); computeBremsstrahlungLoss(icfg, mcParticle, perfectTrackParCov); - nTrkHits = fastTracker[icfg]->FastTrack(perfectTrackParCov, trackParCov, dNdEta, mcParticle.decayRadius()); + nTrkHits = fastTracker[icfg]->fastTrack(perfectTrackParCov, trackParCov, dNdEta, mcParticle.decayRadius()); getHist(histPath + "h2dGenShortLivedParticleRadius")->Fill(mcParticle.decayRadius(), perfectTrackParCov.getPt()); getHist(histPath + "h2dGenRadiusIniVsDecay")->Fill(std::hypot(perfectTrackParCov.getX(), perfectTrackParCov.getY()), mcParticle.decayRadius()); if (nTrkHits < fastPrimaryTrackerSettings.minSiliconHits) { @@ -2201,7 +2201,7 @@ struct OnTheFlyTracker { o2::upgrade::convertMCParticleToO2Track(mcParticle, perfectTrackParCov, pdgDB); computeBremsstrahlungLoss(icfg, mcParticle, perfectTrackParCov); perfectTrackParCov.setPID(pdgCodeToPID(mcParticle.pdgCode())); - nTrkHits = fastTracker[icfg]->FastTrack(perfectTrackParCov, trackParCov, dNdEta); + nTrkHits = fastTracker[icfg]->fastTrack(perfectTrackParCov, trackParCov, dNdEta); reconstructed = nTrkHits >= fastTrackerSettings.minSiliconHits; }