From 332440461ece9cba3c742d8f206dec54e2afdae6 Mon Sep 17 00:00:00 2001 From: ALICE Action Bot Date: Fri, 23 Aug 2024 19:50:36 +0000 Subject: [PATCH] Please consider the following formatting changes --- ALICE3/Core/DetLayer.h | 7 +- ALICE3/Core/FastTracker.cxx | 480 ++++++++++--------- ALICE3/Core/FastTracker.h | 10 +- ALICE3/TableProducer/OTF/onTheFlyTracker.cxx | 22 +- 4 files changed, 269 insertions(+), 250 deletions(-) diff --git a/ALICE3/Core/DetLayer.h b/ALICE3/Core/DetLayer.h index 8de2b2b50b7..fe231e35e1b 100644 --- a/ALICE3/Core/DetLayer.h +++ b/ALICE3/Core/DetLayer.h @@ -24,8 +24,7 @@ namespace o2::fastsim { -struct DetLayer -{ +struct DetLayer { // TString for holding name TString name; @@ -34,14 +33,14 @@ struct DetLayer float z; // z dimension in centimeters // material variables - float x0; // radiation length + float x0; // radiation length float xrho; // density // resolution variables for active layers float resRPhi; // RPhi resolution in centimeters float resZ; // Z resolution in centimeters - // efficiency + // efficiency float eff; // detection efficiency }; diff --git a/ALICE3/Core/FastTracker.cxx b/ALICE3/Core/FastTracker.cxx index ee3680638cd..d6b93aea608 100644 --- a/ALICE3/Core/FastTracker.cxx +++ b/ALICE3/Core/FastTracker.cxx @@ -26,16 +26,16 @@ FastTracker::FastTracker() { // base constructor magneticField = 5; // in kiloGauss - applyZacceptance = false; - covMatFactor = 0.99f; + applyZacceptance = false; + covMatFactor = 0.99f; verboseLevel = 0; } -FastTracker::~FastTracker() {}; +FastTracker::~FastTracker(){}; void FastTracker::AddLayer(TString name, float r, float z, float x0, float xrho, float resRPhi, float resZ, float eff) { - DetLayer newLayer{name.Data(), r, z, x0, xrho, resRPhi, resZ, eff}; + DetLayer newLayer{name.Data(), r, z, x0, xrho, resRPhi, resZ, eff}; layers.push_back(newLayer); } @@ -43,26 +43,27 @@ void FastTracker::Print() { // print out layer setup LOG(info) << "+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+"; - LOG(info) << " Printing detector layout with "<-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+"; } void FastTracker::AddSiliconALICE3v4() { - LOG(info) << " Adding ALICE 3 v4 ITS layers"; - float x0IT = 0.001; // 0.1% - float x0OT = 0.005; // 0.5% - float xrhoIB = 1.1646e-02; // 50 mum Si - float xrhoOB = 1.1646e-01; // 500 mum Si - - float resRPhiIT = 0.00025; // 2.5 mum - float resZIT = 0.00025; // 2.5 mum - float resRPhiOT = 0.0005; // 5 mum - float resZOT = 0.0005; // 5 mum - float eff = 1.00; + LOG(info) << " Adding ALICE 3 v4 ITS layers"; + float x0IT = 0.001; // 0.1% + float x0OT = 0.005; // 0.5% + float xrhoIB = 1.1646e-02; // 50 mum Si + float xrhoOB = 1.1646e-01; // 500 mum Si + + float resRPhiIT = 0.00025; // 2.5 mum + float resZIT = 0.00025; // 2.5 mum + float resRPhiOT = 0.0005; // 5 mum + float resZOT = 0.0005; // 5 mum + float eff = 1.00; layers.push_back(DetLayer{"bpipe0", 0.48, 250, 0.00042, 2.772e-02, 0.0f, 0.0f, 0.0f}); // 150 mum Be layers.push_back(DetLayer{"ddd0", 0.5, 250, x0IT, xrhoIB, resRPhiIT, resZIT, eff}); @@ -80,17 +81,17 @@ void FastTracker::AddSiliconALICE3v4() void FastTracker::AddSiliconALICE3v1() { - LOG(info) << " Adding ALICE 3 v1 ITS layers"; - float x0IT = 0.001; // 0.1% - float x0OT = 0.005; // 0.5% - float xrhoIB = 2.3292e-02; // 100 mum Si - float xrhoOB = 2.3292e-01; // 1000 mum Si - - float resRPhiIT = 0.00025; // 2.5 mum - float resZIT = 0.00025; // 2.5 mum - float resRPhiOT = 0.00100; // 5 mum - float resZOT = 0.00100; // 5 mum - float eff = 1.00; + LOG(info) << " Adding ALICE 3 v1 ITS layers"; + float x0IT = 0.001; // 0.1% + float x0OT = 0.005; // 0.5% + float xrhoIB = 2.3292e-02; // 100 mum Si + float xrhoOB = 2.3292e-01; // 1000 mum Si + + float resRPhiIT = 0.00025; // 2.5 mum + float resZIT = 0.00025; // 2.5 mum + float resRPhiOT = 0.00100; // 5 mum + float resZOT = 0.00100; // 5 mum + float eff = 1.00; layers.push_back(DetLayer{"bpipe0", 0.48, 250, 0.00042, 2.772e-02, 0.0f, 0.0f, 0.0f}); // 150 mum Be layers.push_back(DetLayer{"B00", 0.5, 250, x0IT, xrhoIB, resRPhiIT, resZIT, eff}); @@ -109,11 +110,11 @@ void FastTracker::AddSiliconALICE3v1() void FastTracker::AddTPC(float phiResMean, float zResMean) { - LOG(info) << " Adding standard time projection chamber"; - + LOG(info) << " Adding standard time projection chamber"; + // porting of DetectorK::AddTPC - // see here: - // https://github.com/AliceO2Group/DelphesO2/blob/master/src/DetectorK/DetectorK.cxx + // see here: + // https://github.com/AliceO2Group/DelphesO2/blob/master/src/DetectorK/DetectorK.cxx // % Radiation Lengths ... Average per TPC row (i.e. total/159 ) const int kNPassiveBound = 2; const float radLBoundary[kNPassiveBound] = {1.692612e-01, 8.711904e-02}; @@ -121,233 +122,252 @@ void FastTracker::AddTPC(float phiResMean, float zResMean) const float rBoundary[kNPassiveBound] = {50, 70.0}; // cm float radLPerRow = 0.000036; - - float tpcInnerRadialPitch = 0.75 ; // cm - float tpcMiddleRadialPitch = 1.0 ; // cm - float tpcOuterRadialPitch = 1.5 ; // cm - float innerRows = 63 ; - float middleRows = 64 ; - float outerRows = 32 ; - float tpcRows = (innerRows + middleRows + outerRows) ; - float rowOneRadius = 85.2 ; // cm - float row64Radius = 135.1 ; // cm - float row128Radius = 199.2 ; // cm + + float tpcInnerRadialPitch = 0.75; // cm + float tpcMiddleRadialPitch = 1.0; // cm + float tpcOuterRadialPitch = 1.5; // cm + float innerRows = 63; + float middleRows = 64; + float outerRows = 32; + float tpcRows = (innerRows + middleRows + outerRows); + float rowOneRadius = 85.2; // cm + float row64Radius = 135.1; // cm + float row128Radius = 199.2; // cm float zLength = 250.0f; // to be checked // add boundaries between ITS and TPC - for (int i=0;i= innerRows && k < (innerRows + middleRows)) + rowRadius = row64Radius + (k - innerRows + 1) * tpcMiddleRadialPitch; + 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); } - for ( Int_t k = 0 ; k < tpcRows ; k++ ) { - Float_t rowRadius =0; - if (k=innerRows && k<(innerRows+middleRows) ) - rowRadius = row64Radius + (k-innerRows+1)*tpcMiddleRadialPitch ; - else if (k>=(innerRows+middleRows) && k posIni; // provision for != PV - inputTrack.getXYZGlo(posIni); - float initialRadius = std::hypot(posIni[0], posIni[1]); - - // +-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+ - // Outward pass to find intercepts - int firstLayerReached = -1; - int lastLayerReached = -1; - for(int il=0; il 999) - break; // failed to find intercept - - if (!inputTrack.propagateTo(targetX, magneticField)) { - break; // failed to propagate - } - if (std::abs(inputTrack.getZ())>layers[il].z && applyZacceptance) { - break; // out of acceptance bounds - } - - // layer is reached - if(firstLayerReached<0) - firstLayerReached = il; - lastLayerReached = il; - nIntercepts++; + hits.clear(); + int nIntercepts = 0; + std::array posIni; // provision for != PV + inputTrack.getXYZGlo(posIni); + float initialRadius = std::hypot(posIni[0], posIni[1]); + + // +-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+ + // Outward pass to find intercepts + int firstLayerReached = -1; + int lastLayerReached = -1; + for (int il = 0; il < layers.size(); il++) { + // check if layer is doable + if (layers[il].r < initialRadius) + continue; // this layer should not be attempted, but go ahead + if (layers[il].eff < 1e-5) + continue; // inert layer, skip + + // check if layer is reached + float targetX = 1e+3; + inputTrack.getXatLabR(layers[il].r, targetX, magneticField); + if (targetX > 999) + break; // failed to find intercept + + if (!inputTrack.propagateTo(targetX, magneticField)) { + break; // failed to propagate } - - // +-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+ - // initialize track at outer point - new (&outputTrack)(o2::track::TrackParCov)(inputTrack); - - // Enlarge covariance matrix - std::array trPars = {0.}; - for(int ip=0;ip<5;ip++){ - trPars[ip] = outputTrack.getParam(ip); + if (std::abs(inputTrack.getZ()) > layers[il].z && applyZacceptance) { + break; // out of acceptance bounds } - std::array largeCov = {0.}; - enum {kY,kZ,kSnp,kTgl,kPtI}; // track parameter aliases - enum {kY2,kYZ,kZ2,kYSnp,kZSnp,kSnp2,kYTgl,kZTgl,kSnpTgl,kTgl2,kYPtI,kZPtI,kSnpPtI,kTglPtI,kPtI2}; // cov.matrix aliases - const double kLargeErr2Coord = 5*5; - const double kLargeErr2Dir = 0.7*0.7; - const double kLargeErr2PtI = 30.5*30.5; - for (int ic=15;ic--;) largeCov[ic] = 0.; - largeCov[kY2] = largeCov[kZ2] = kLargeErr2Coord; - largeCov[kSnp2] = largeCov[kTgl2] = kLargeErr2Dir; - largeCov[kPtI2] = kLargeErr2PtI*trPars[kPtI]*trPars[kPtI]; - - outputTrack.setCov(largeCov); - outputTrack.checkCovariance(); - - // +-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+ - // Inward pass to calculate covariances - for(int il=lastLayerReached; il>=firstLayerReached; il--){ - float targetX = 1e+3; - inputTrack.getXatLabR(layers[il].r, targetX, magneticField); - if (targetX > 999) - continue; // failed to find intercept - - if (!inputTrack.propagateTo(targetX, magneticField)) { - continue; // failed to propagate - } - if (std::abs(inputTrack.getZ())>layers[il].z && applyZacceptance) { - continue; // out of acceptance bounds but continue inwards - } - // get perfect data point position - std::array spacePoint; - inputTrack.getXYZGlo(spacePoint); - std::vector thisHit = {spacePoint[0], spacePoint[1], spacePoint[2]}; - - // towards adding cluster: move to track alpha - double alpha = outputTrack.getAlpha(); - double xyz1[3]{ - TMath::Cos(alpha) * spacePoint[0] + TMath::Sin(alpha) * spacePoint[1], - -TMath::Sin(alpha) * spacePoint[0] + TMath::Cos(alpha) * spacePoint[1], - spacePoint[2]}; - if (!(outputTrack.propagateTo(xyz1[0], magneticField))) - continue; - - const o2::track::TrackParametrization::dim2_t hitpoint = { - static_cast(xyz1[1]), - static_cast(xyz1[2])}; - const o2::track::TrackParametrization::dim3_t hitpointcov = {layers[il].resRPhi * layers[il].resRPhi, 0.f, layers[il].resZ * layers[il].resZ}; - outputTrack.update(hitpoint, hitpointcov); - - hits.push_back(thisHit); - outputTrack.checkCovariance(); + // layer is reached + if (firstLayerReached < 0) + firstLayerReached = il; + lastLayerReached = il; + nIntercepts++; + } + + // +-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+ + // initialize track at outer point + new (&outputTrack)(o2::track::TrackParCov)(inputTrack); + // Enlarge covariance matrix + std::array trPars = {0.}; + for (int ip = 0; ip < 5; ip++) { + trPars[ip] = outputTrack.getParam(ip); + } + std::array largeCov = {0.}; + enum { kY, + kZ, + kSnp, + kTgl, + kPtI }; // track parameter aliases + enum { kY2, + kYZ, + kZ2, + kYSnp, + kZSnp, + kSnp2, + kYTgl, + kZTgl, + kSnpTgl, + kTgl2, + kYPtI, + kZPtI, + kSnpPtI, + kTglPtI, + kPtI2 }; // cov.matrix aliases + const double kLargeErr2Coord = 5 * 5; + const double kLargeErr2Dir = 0.7 * 0.7; + const double kLargeErr2PtI = 30.5 * 30.5; + for (int ic = 15; ic--;) + largeCov[ic] = 0.; + largeCov[kY2] = largeCov[kZ2] = kLargeErr2Coord; + largeCov[kSnp2] = largeCov[kTgl2] = kLargeErr2Dir; + largeCov[kPtI2] = kLargeErr2PtI * trPars[kPtI] * trPars[kPtI]; + + outputTrack.setCov(largeCov); + outputTrack.checkCovariance(); + + // +-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+ + // Inward pass to calculate covariances + for (int il = lastLayerReached; il >= firstLayerReached; il--) { + float targetX = 1e+3; + inputTrack.getXatLabR(layers[il].r, targetX, magneticField); + if (targetX > 999) + continue; // failed to find intercept + + if (!inputTrack.propagateTo(targetX, magneticField)) { + continue; // failed to propagate + } + if (std::abs(inputTrack.getZ()) > layers[il].z && applyZacceptance) { + continue; // out of acceptance bounds but continue inwards } - // backpropagate to original radius - float finalX = 1e+3; - outputTrack.getXatLabR(initialRadius, finalX, magneticField); - if (finalX > 999) - return -3; // failed to find intercept + // get perfect data point position + std::array spacePoint; + inputTrack.getXYZGlo(spacePoint); + std::vector thisHit = {spacePoint[0], spacePoint[1], spacePoint[2]}; + + // towards adding cluster: move to track alpha + double alpha = outputTrack.getAlpha(); + double xyz1[3]{ + TMath::Cos(alpha) * spacePoint[0] + TMath::Sin(alpha) * spacePoint[1], + -TMath::Sin(alpha) * spacePoint[0] + TMath::Cos(alpha) * spacePoint[1], + spacePoint[2]}; + if (!(outputTrack.propagateTo(xyz1[0], magneticField))) + continue; + + const o2::track::TrackParametrization::dim2_t hitpoint = { + static_cast(xyz1[1]), + static_cast(xyz1[2])}; + const o2::track::TrackParametrization::dim3_t hitpointcov = {layers[il].resRPhi * layers[il].resRPhi, 0.f, layers[il].resZ * layers[il].resZ}; + outputTrack.update(hitpoint, hitpointcov); + + hits.push_back(thisHit); + outputTrack.checkCovariance(); + } - if (!outputTrack.propagateTo(finalX, magneticField)) { - return -4; // failed to propagate - } + // backpropagate to original radius + float finalX = 1e+3; + outputTrack.getXatLabR(initialRadius, finalX, magneticField); + if (finalX > 999) + return -3; // failed to find intercept - // only attempt to continue if intercepts are at least four - if(nIntercepts<4) return nIntercepts; - - // Use covariance matrix based smearing - std::array covMat = {0.}; - for(int ii=0; ii<15; ii++) - covMat[ii] = outputTrack.getCov()[ii]; - TMatrixDSym m(5); - double fcovm[5][5]; - - 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]; - } - } + if (!outputTrack.propagateTo(finalX, magneticField)) { + return -4; // failed to propagate + } - // evaluate ruben's conditional, regularise - bool makePositiveDefinite = (covMatFactor > 0.0f); // apply fix - bool rubenConditional = false; - for(int ii=0; ii<5; ii++){ - for(int jj=0; jj<5; 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])); - } - } - } - } + // only attempt to continue if intercepts are at least four + if (nIntercepts < 4) + return nIntercepts; - // Should have a valid cov matrix now - m.SetMatrixArray((double*)fcovm); - TMatrixDSymEigen eigen(m); - TMatrixD eigVec = eigen.GetEigenVectors(); - TVectorD eigVal = eigen.GetEigenValues(); - bool negEigVal = false; - for(int ii=0; ii<5; ii++){ - if(eigVal[ii]<0.0f) - negEigVal = true; + // Use covariance matrix based smearing + std::array covMat = {0.}; + for (int ii = 0; ii < 15; ii++) + covMat[ii] = outputTrack.getCov()[ii]; + TMatrixDSym m(5); + double fcovm[5][5]; + + 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]; } + } - if(negEigVal && rubenConditional && makePositiveDefinite){ - if(verboseLevel>0){ - LOG(info)<<"WARNING: this diagonalization (at pt = "< 0.0f); // apply fix + bool rubenConditional = false; + for (int ii = 0; ii < 5; ii++) { + for (int jj = 0; jj < 5; 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])); + } } - nIntercepts = -1; // mark as problematic so that it isn't used - return -1; } + } - // transform parameter vector and smear - double params_[5]; - for (int ii = 0; ii < 5; ++ii) { - double val = 0.; - for (int j = 0; j < 5; ++j) - val += eigVec[j][ii] * outputTrack.getParam(j); - // smear parameters according to eigenvalues - params_[ii] = gRandom->Gaus(val, sqrt(eigVal[ii])); - } + // Should have a valid cov matrix now + m.SetMatrixArray((double*)fcovm); + TMatrixDSymEigen eigen(m); + TMatrixD eigVec = eigen.GetEigenVectors(); + TVectorD eigVal = eigen.GetEigenValues(); + bool negEigVal = false; + for (int ii = 0; ii < 5; ii++) { + if (eigVal[ii] < 0.0f) + negEigVal = true; + } - // invert eigenvector matrix - eigVec.Invert(); - // transform back params vector - for (int ii = 0; ii < 5; ++ii) { - double val = 0.; - for (int j = 0; j < 5; ++j) - val += eigVec[j][ii] * params_[j]; - outputTrack.setParam(val, ii); - } - // should make a sanity check that par[2] sin(phi) is in [-1, 1] - if (fabs(outputTrack.getParam(2)) > 1.) { - LOG(info) << " --- smearTrack failed sin(phi) sanity check: " << outputTrack.getParam(2); - return -2; + if (negEigVal && rubenConditional && makePositiveDefinite) { + if (verboseLevel > 0) { + LOG(info) << "WARNING: this diagonalization (at pt = " << inputTrack.getPt() << ") has negative eigenvalues despite Ruben's fix! Please be careful!"; + LOG(info) << "Printing info:"; + LOG(info) << "Kalman updates: " << nIntercepts; + LOG(info) << "Cov matrix: "; + m.Print(); } + nIntercepts = -1; // mark as problematic so that it isn't used + return -1; + } - return nIntercepts; + // transform parameter vector and smear + double params_[5]; + for (int ii = 0; ii < 5; ++ii) { + double val = 0.; + for (int j = 0; j < 5; ++j) + val += eigVec[j][ii] * outputTrack.getParam(j); + // smear parameters according to eigenvalues + params_[ii] = gRandom->Gaus(val, sqrt(eigVal[ii])); + } + + // invert eigenvector matrix + eigVec.Invert(); + // transform back params vector + for (int ii = 0; ii < 5; ++ii) { + double val = 0.; + for (int j = 0; j < 5; ++j) + val += eigVec[j][ii] * params_[j]; + outputTrack.setParam(val, ii); + } + // should make a sanity check that par[2] sin(phi) is in [-1, 1] + if (fabs(outputTrack.getParam(2)) > 1.) { + LOG(info) << " --- smearTrack failed sin(phi) sanity check: " << outputTrack.getParam(2); + return -2; + } + return nIntercepts; } // +-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+ diff --git a/ALICE3/Core/FastTracker.h b/ALICE3/Core/FastTracker.h index 1e1fb103c7e..7829fe11370 100644 --- a/ALICE3/Core/FastTracker.h +++ b/ALICE3/Core/FastTracker.h @@ -23,7 +23,7 @@ namespace fastsim // +-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+-~-<*>-~-+ -// this class implements a synthetic smearer that allows +// this class implements a synthetic smearer that allows // for on-demand smearing of TrackParCovs in a certain flexible t // detector layout. class FastTracker @@ -46,11 +46,11 @@ class FastTracker std::vector layers; std::vector> hits; // bookkeep last added hits - // operational - float magneticField; // in kiloGauss (5 = 0.5T, etc) + // operational + float magneticField; // in kiloGauss (5 = 0.5T, etc) bool applyZacceptance; // check z acceptance or not - float covMatFactor; // covmat off-diagonal factor to use for covmat fix (negative: no factor) - int verboseLevel; // 0: not verbose, >0 more verbose + float covMatFactor; // covmat off-diagonal factor to use for covmat fix (negative: no factor) + int verboseLevel; // 0: not verbose, >0 more verbose ClassDef(FastTracker, 1); }; diff --git a/ALICE3/TableProducer/OTF/onTheFlyTracker.cxx b/ALICE3/TableProducer/OTF/onTheFlyTracker.cxx index bd1cf37d073..56f9a1162e3 100644 --- a/ALICE3/TableProducer/OTF/onTheFlyTracker.cxx +++ b/ALICE3/TableProducer/OTF/onTheFlyTracker.cxx @@ -135,7 +135,7 @@ struct OnTheFlyTracker { ConfigurableAxis axisRadius{"axisRadius", {2500, 0.0f, +250.0f}, "R (cm)"}; ConfigurableAxis axisZ{"axisZ", {100, -250.0f, +250.0f}, "Z (cm)"}; - } axes; + } axes; // for topo var QA struct : ConfigurableGroup { @@ -389,15 +389,15 @@ struct OnTheFlyTracker { fastTracker.magneticField = magneticField; fastTracker.applyZacceptance = fastTrackerSettings.applyZacceptance; - if(fastTrackerSettings.alice3detector == 0){ + if (fastTrackerSettings.alice3detector == 0) { fastTracker.AddSiliconALICE3v1(); } - if(fastTrackerSettings.alice3detector == 1){ + if (fastTrackerSettings.alice3detector == 1) { fastTracker.AddSiliconALICE3v4(); fastTracker.AddTPC(0.1, 0.1); } - // print fastTracker settings + // print fastTracker settings fastTracker.Print(); } @@ -632,19 +632,19 @@ struct OnTheFlyTracker { for (int i = 0; i < 3; i++) { isReco[i] = false; - if(enableSecondarySmearing){ - + if (enableSecondarySmearing) { + nHits[i] = fastTracker.FastTrack(xiDaughterTrackParCovsPerfect[i], xiDaughterTrackParCovsTracked[i]); - - if(nHits[i]>=fastTrackerSettings.minSiliconHits){ + + if (nHits[i] >= fastTrackerSettings.minSiliconHits) { isReco[i] = true; - }else{ + } else { continue; // extra sure } - for(uint32_t ih=0; ih