diff --git a/Rich/RichFutureRecCheckers/src/RichMCCKResParameterisation.cpp b/Rich/RichFutureRecCheckers/src/RichMCCKResParameterisation.cpp index 8fd5a07abaef0e74876a2df2ef8a1266a9039b1b..f2d07d4b50181797c47896184dceeca3ea2713d7 100644 --- a/Rich/RichFutureRecCheckers/src/RichMCCKResParameterisation.cpp +++ b/Rich/RichFutureRecCheckers/src/RichMCCKResParameterisation.cpp @@ -325,16 +325,6 @@ void CKResParameterisation::operator()( const Summary::Track::Vector& // Make a local MC helper object Helper mcHelper( tkrels, digitSums ); - // local buffers - auto hb_ckResFakeCKBins = h_ckResFakeCKBins.buffer(); - auto hb_ckThetaFakeCKBins = h_ckThetaFakeCKBins.buffer(); - auto hb_ckResFakePBins = h_ckResFakePBins.buffer(); - auto hb_ckThetaFakePBins = h_ckThetaFakePBins.buffer(); - auto hb_ckResTrueCKBins = h_ckResTrueCKBins.buffer(); - auto hb_ckThetaTrueCKBins = h_ckThetaTrueCKBins.buffer(); - auto hb_ckResTruePBins = h_ckResTruePBins.buffer(); - auto hb_ckThetaTruePBins = h_ckThetaTruePBins.buffer(); - // loop over the track info for ( const auto&& [sumTk, tk] : Ranges::ConstZip( sumTracks, tracks ) ) { @@ -420,15 +410,15 @@ void CKResParameterisation::operator()( const Summary::Track::Vector& // fill some plots if ( !trueCKSig ) { - hb_ckResFakeCKBins[rich][pid][ckbin][deltaTheta] += mcPW; - hb_ckThetaFakeCKBins[rich][pid][ckbin][thetaRec] += mcPW; - hb_ckResFakePBins[rich][pid][pbin][deltaTheta] += mcPW; - hb_ckThetaFakePBins[rich][pid][pbin][thetaRec] += mcPW; + h_ckResFakeCKBins[rich][pid][ckbin][deltaTheta] += mcPW; + h_ckThetaFakeCKBins[rich][pid][ckbin][thetaRec] += mcPW; + h_ckResFakePBins[rich][pid][pbin][deltaTheta] += mcPW; + h_ckThetaFakePBins[rich][pid][pbin][thetaRec] += mcPW; } else { - hb_ckResTrueCKBins[rich][pid][ckbin][deltaTheta] += mcPW; - hb_ckThetaTrueCKBins[rich][pid][ckbin][thetaRec] += mcPW; - hb_ckResTruePBins[rich][pid][pbin][deltaTheta] += mcPW; - hb_ckThetaTruePBins[rich][pid][pbin][thetaRec] += mcPW; + h_ckResTrueCKBins[rich][pid][ckbin][deltaTheta] += mcPW; + h_ckThetaTrueCKBins[rich][pid][ckbin][thetaRec] += mcPW; + h_ckResTruePBins[rich][pid][pbin][deltaTheta] += mcPW; + h_ckThetaTruePBins[rich][pid][pbin][thetaRec] += mcPW; } } // in range diff --git a/Rich/RichFutureRecCheckers/src/RichMCCherenkovResolution.cpp b/Rich/RichFutureRecCheckers/src/RichMCCherenkovResolution.cpp index e5a885ecb86b79d73ea28733b45aafaab838cdc9..c71413c667943116e4fac2f433dad91c973f4098 100644 --- a/Rich/RichFutureRecCheckers/src/RichMCCherenkovResolution.cpp +++ b/Rich/RichFutureRecCheckers/src/RichMCCherenkovResolution.cpp @@ -359,29 +359,6 @@ void CherenkovResolution::operator()( const Summary::Track::Vector& // Make a local MC helper object Helper mcHelper( tkrels, digitSums ); - // local buffers - auto hb_expCKang = h_expCKang.buffer(); - auto hb_ckres = h_ckres.buffer(); - auto hb_ckresVcktheta = h_ckresVcktheta.buffer(); - auto hb_ckresVptot = h_ckresVptot.buffer(); - auto hb_diffckVckang = h_diffckVckang.buffer(); - auto hb_diffckVPtot = h_diffckVPtot.buffer(); - auto hb_fabsdiffckVckang = h_fabsdiffckVckang.buffer(); - auto hb_fabsdiffckVPtot = h_fabsdiffckVPtot.buffer(); - auto hb_diffckVckangInner = h_diffckVckangInner.buffer(); - auto hb_diffckVPtotInner = h_diffckVPtotInner.buffer(); - auto hb_fabsdiffckVckangInner = h_fabsdiffckVckangInner.buffer(); - auto hb_fabsdiffckVPtotInner = h_fabsdiffckVPtotInner.buffer(); - auto hb_diffckVckangOuter = h_diffckVckangOuter.buffer(); - auto hb_diffckVPtotOuter = h_diffckVPtotOuter.buffer(); - auto hb_fabsdiffckVckangOuter = h_fabsdiffckVckangOuter.buffer(); - auto hb_fabsdiffckVPtotOuter = h_fabsdiffckVPtotOuter.buffer(); - auto hb_ckPullVckang = h_ckPullVckang.buffer(); - auto hb_ckPullVPtot = h_ckPullVPtot.buffer(); - auto hb_fabsCkPullVckang = h_fabsCkPullVckang.buffer(); - auto hb_fabsCkPullVPtot = h_fabsCkPullVPtot.buffer(); - // auto hb_pullBins = h_pullBins.buffer(); // FixMe - // loop over the track info for ( const auto&& [sumTk, tk] : Ranges::ConstZip( sumTracks, tracks ) ) { // loop over photons for this track @@ -419,10 +396,10 @@ void CherenkovResolution::operator()( const Summary::Track::Vector& // loop over mass hypos for ( const auto hypo : activeParticlesNoBT() ) { if ( expCKangles[hypo] > 0 ) { - ++hb_expCKang[rich][hypo][expCKangles[hypo]]; - ++hb_ckres[rich][hypo][ckRes[hypo]]; - hb_ckresVcktheta[rich][hypo][expCKangles[hypo]] += ckRes[hypo]; - hb_ckresVptot[rich][hypo][pTot] += ckRes[hypo]; + ++h_expCKang[rich][hypo][expCKangles[hypo]]; + ++h_ckres[rich][hypo][ckRes[hypo]]; + h_ckresVcktheta[rich][hypo][expCKangles[hypo]] += ckRes[hypo]; + h_ckresVptot[rich][hypo][pTot] += ckRes[hypo]; } } @@ -468,29 +445,29 @@ void CherenkovResolution::operator()( const Summary::Track::Vector& // fill some plots for true photons only if ( trueCKSig ) { // Res versus Ptot and CK theta - hb_diffckVckang[rich][pid][thetaExp] += { deltaTheta, mcPW }; - hb_diffckVPtot[rich][pid][pTot] += { deltaTheta, mcPW }; - hb_fabsdiffckVckang[rich][pid][thetaExp] += { fabs( deltaTheta ), mcPW }; - hb_fabsdiffckVPtot[rich][pid][pTot] += { fabs( deltaTheta ), mcPW }; + h_diffckVckang[rich][pid][thetaExp] += { deltaTheta, mcPW }; + h_diffckVPtot[rich][pid][pTot] += { deltaTheta, mcPW }; + h_fabsdiffckVckang[rich][pid][thetaExp] += { fabs( deltaTheta ), mcPW }; + h_fabsdiffckVPtot[rich][pid][pTot] += { fabs( deltaTheta ), mcPW }; if ( simdPix.isInnerRegion()[i] ) { - hb_diffckVckangInner[rich][pid][thetaExp] += { deltaTheta, mcPW }; - hb_diffckVPtotInner[rich][pid][pTot] += { deltaTheta, mcPW }; - hb_fabsdiffckVckangInner[rich][pid][thetaExp] += { fabs( deltaTheta ), mcPW }; - hb_fabsdiffckVPtotInner[rich][pid][pTot] += { fabs( deltaTheta ), mcPW }; + h_diffckVckangInner[rich][pid][thetaExp] += { deltaTheta, mcPW }; + h_diffckVPtotInner[rich][pid][pTot] += { deltaTheta, mcPW }; + h_fabsdiffckVckangInner[rich][pid][thetaExp] += { fabs( deltaTheta ), mcPW }; + h_fabsdiffckVPtotInner[rich][pid][pTot] += { fabs( deltaTheta ), mcPW }; } else { - hb_diffckVckangOuter[rich][pid][thetaExp] += { deltaTheta, mcPW }; - hb_diffckVPtotOuter[rich][pid][pTot] += { deltaTheta, mcPW }; - hb_fabsdiffckVckangOuter[rich][pid][thetaExp] += { fabs( deltaTheta ), mcPW }; - hb_fabsdiffckVPtotOuter[rich][pid][pTot] += { fabs( deltaTheta ), mcPW }; + h_diffckVckangOuter[rich][pid][thetaExp] += { deltaTheta, mcPW }; + h_diffckVPtotOuter[rich][pid][pTot] += { deltaTheta, mcPW }; + h_fabsdiffckVckangOuter[rich][pid][thetaExp] += { fabs( deltaTheta ), mcPW }; + h_fabsdiffckVPtotOuter[rich][pid][pTot] += { fabs( deltaTheta ), mcPW }; } // pulls if ( ckRes[pid] > 0 ) { const auto pull = deltaTheta / ckRes[pid]; h_pullBins[rich][pid].at( pullBin( pTot, rich ) )[pull] += mcPW; - hb_ckPullVckang[rich][pid][thetaExp] += { pull, mcPW }; - hb_ckPullVPtot[rich][pid][pTot] += { pull, mcPW }; - hb_fabsCkPullVckang[rich][pid][thetaExp] += { fabs( pull ), mcPW }; - hb_fabsCkPullVPtot[rich][pid][pTot] += { fabs( pull ), mcPW }; + h_ckPullVckang[rich][pid][thetaExp] += { pull, mcPW }; + h_ckPullVPtot[rich][pid][pTot] += { pull, mcPW }; + h_fabsCkPullVckang[rich][pid][thetaExp] += { fabs( pull ), mcPW }; + h_fabsCkPullVPtot[rich][pid][pTot] += { fabs( pull ), mcPW }; } } diff --git a/Rich/RichFutureRecCheckers/src/RichMCDetectorHits.cpp b/Rich/RichFutureRecCheckers/src/RichMCDetectorHits.cpp index f44793a31202345ef77822c688750a5e6ea4374a..1f3e3776bf19663a51f04ea64934b83018319908 100644 --- a/Rich/RichFutureRecCheckers/src/RichMCDetectorHits.cpp +++ b/Rich/RichFutureRecCheckers/src/RichMCDetectorHits.cpp @@ -67,12 +67,6 @@ namespace Rich::Future::Rec::MC::Moni { // MC helper SmartIDUtils smartIDMCHelper( digitSums ); - // local buffers - auto hb_hitsPerID = h_hitsPerID.buffer(); - auto hb_digitsPerID = h_digitsPerID.buffer(); - auto hb_signalPerID = h_signalPerID.buffer(); - auto hb_sigFracVOcc = h_sigFracVOcc.buffer(); - // Loop over RICHes for ( const auto rich : activeDetectors() ) { // Loop over pixels for this RICH @@ -107,10 +101,10 @@ namespace Rich::Future::Rec::MC::Moni { const auto sigFrac = ( !histCodes.empty() ? (double)nSignal / (double)histCodes.size() : 0.0 ); // fill histos - ++hb_hitsPerID[rich][histCodes.size()]; - ++hb_digitsPerID[rich][count]; - ++hb_signalPerID[rich][nSignal]; - hb_sigFracVOcc[rich][histCodes.size()] += sigFrac; + ++h_hitsPerID[rich][histCodes.size()]; + ++h_digitsPerID[rich][count]; + ++h_signalPerID[rich][nSignal]; + h_sigFracVOcc[rich][histCodes.size()] += sigFrac; } } diff --git a/Rich/RichFutureRecCheckers/src/RichMCOpticalPhotons.cpp b/Rich/RichFutureRecCheckers/src/RichMCOpticalPhotons.cpp index bb069f98cdb0040be95939a395ce0b7f7011a429..d5d0b32e5795e3a20c37ca24e3ecc20bfeb7bdd1 100644 --- a/Rich/RichFutureRecCheckers/src/RichMCOpticalPhotons.cpp +++ b/Rich/RichFutureRecCheckers/src/RichMCOpticalPhotons.cpp @@ -544,74 +544,6 @@ namespace Rich::Future::Rec::MC::Moni { // MC OpticalPhoton helper const MCOpticalPhotonUtils photHelper( mcphotons ); - // local buffers - auto hb_mcYield = h_mcYield.buffer(); - auto hb_mcYieldVp = h_mcYieldVp.buffer(); - auto hb_mcYieldVx = h_mcYieldVx.buffer(); - auto hb_mcYieldVy = h_mcYieldVy.buffer(); - auto hb_mcYieldVxy = h_mcYieldVxy.buffer(); - auto hb_mcYieldDiff = h_mcYieldDiff.buffer(); - auto hb_mcYieldDiffVp = h_mcYieldDiffVp.buffer(); - auto hb_tkMCEmissX = h_tkMCEmissX.buffer(); - auto hb_tkMCEmissY = h_tkMCEmissY.buffer(); - auto hb_tkMCEmissZ = h_tkMCEmissZ.buffer(); - auto hb_tkRecEmissX = h_tkRecEmissX.buffer(); - auto hb_tkRecEmissY = h_tkRecEmissY.buffer(); - auto hb_tkRecEmissZ = h_tkRecEmissZ.buffer(); - auto hb_tkEmissXDiff = h_tkEmissXDiff.buffer(); - auto hb_tkEmissXDiffvX = h_tkEmissXDiffvX.buffer(); - auto hb_tkEmissXDiffvY = h_tkEmissXDiffvY.buffer(); - auto hb_tkEmissXDiffvZ = h_tkEmissXDiffvZ.buffer(); - auto hb_tkEmissXDiffvXY = h_tkEmissXDiffvXY.buffer(); - auto hb_tkEmissYDiff = h_tkEmissYDiff.buffer(); - auto hb_tkEmissYDiffvX = h_tkEmissYDiffvX.buffer(); - auto hb_tkEmissYDiffvY = h_tkEmissYDiffvY.buffer(); - auto hb_tkEmissYDiffvZ = h_tkEmissYDiffvZ.buffer(); - auto hb_tkEmissYDiffvXY = h_tkEmissYDiffvXY.buffer(); - auto hb_tkEmissZDiff = h_tkEmissZDiff.buffer(); - auto hb_tkEmissZDiffvX = h_tkEmissZDiffvX.buffer(); - auto hb_tkEmissZDiffvY = h_tkEmissZDiffvY.buffer(); - auto hb_tkEmissZDiffvZ = h_tkEmissZDiffvZ.buffer(); - auto hb_tkEmissZDiffvXY = h_tkEmissZDiffvXY.buffer(); - auto hb_tkAngle = h_tkAngle.buffer(); - auto hb_tkAngleVX = h_tkAngleVX.buffer(); - auto hb_tkAngleVY = h_tkAngleVY.buffer(); - auto hb_tkAngleVXY = h_tkAngleVXY.buffer(); - auto hb_tkAngleVP = h_tkAngleVP.buffer(); - auto hb_tkMCSlopeX = h_tkMCSlopeX.buffer(); - auto hb_tkMCSlopeY = h_tkMCSlopeY.buffer(); - auto hb_tkRecSlopeX = h_tkRecSlopeX.buffer(); - auto hb_tkRecSlopeY = h_tkRecSlopeY.buffer(); - auto hb_tkMCSlopeXvX = h_tkMCSlopeXvX.buffer(); - auto hb_tkMCSlopeYvY = h_tkMCSlopeYvY.buffer(); - auto hb_tkRecSlopeXvX = h_tkRecSlopeXvX.buffer(); - auto hb_tkRecSlopeYvY = h_tkRecSlopeYvY.buffer(); - auto hb_tkAngleX = h_tkAngleX.buffer(); - auto hb_tkAngleXvP = h_tkAngleXvP.buffer(); - auto hb_tkAngleXvX = h_tkAngleXvX.buffer(); - auto hb_tkAngleXvY = h_tkAngleXvY.buffer(); - auto hb_tkAngleXvXY = h_tkAngleXvXY.buffer(); - auto hb_tkAngleY = h_tkAngleY.buffer(); - auto hb_tkAngleYvP = h_tkAngleYvP.buffer(); - auto hb_tkAngleYvX = h_tkAngleYvX.buffer(); - auto hb_tkAngleYvY = h_tkAngleYvY.buffer(); - auto hb_tkAngleYvXY = h_tkAngleYvXY.buffer(); - auto hb_pixXGloShift = h_pixXGloShift.buffer(); - auto hb_pixYGloShift = h_pixYGloShift.buffer(); - auto hb_pixXGloShift2D = h_pixXGloShift2D.buffer(); - auto hb_pixYGloShift2D = h_pixYGloShift2D.buffer(); - auto hb_pixXLocShift = h_pixXLocShift.buffer(); - auto hb_pixYLocShift = h_pixYLocShift.buffer(); - auto hb_pixXLocShift2D = h_pixXLocShift2D.buffer(); - auto hb_pixYLocShift2D = h_pixYLocShift2D.buffer(); - auto hb_recoYield = h_recoYield.buffer(); - auto hb_recoYieldVp = h_recoYieldVp.buffer(); - auto hb_recoYieldVx = h_recoYieldVx.buffer(); - auto hb_recoYieldVy = h_recoYieldVy.buffer(); - auto hb_recoYieldVxy = h_recoYieldVxy.buffer(); - auto hb_recoYieldDiff = h_recoYieldDiff.buffer(); - auto hb_recoYieldDiffVp = h_recoYieldDiffVp.buffer(); - // loop over segments for ( const auto&& [seg, tkIndex, yield] : Ranges::ConstZip( segments, segToTkRel, yields ) ) { @@ -650,14 +582,14 @@ namespace Rich::Future::Rec::MC::Moni { return ( mcH && mcH->radiator() == rad && mcH->isSignal() ); } ); if ( nPhots > 0 ) { - ++hb_mcYield[rich][pid][nPhots]; - hb_mcYieldVp[rich][pid][pTot] += nPhots; - hb_mcYieldVx[rich][pid][seg.entryPoint().X()] += nPhots; - hb_mcYieldVy[rich][pid][seg.entryPoint().Y()] += nPhots; - hb_mcYieldVxy[rich][pid][{ seg.entryPoint().X(), seg.entryPoint().Y() }] += nPhots; + ++h_mcYield[rich][pid][nPhots]; + h_mcYieldVp[rich][pid][pTot] += nPhots; + h_mcYieldVx[rich][pid][seg.entryPoint().X()] += nPhots; + h_mcYieldVy[rich][pid][seg.entryPoint().Y()] += nPhots; + h_mcYieldVxy[rich][pid][{ seg.entryPoint().X(), seg.entryPoint().Y() }] += nPhots; const auto yield_diff = yield[pid] - (double)nPhots; - ++hb_mcYieldDiff[rich][pid][yield_diff]; - hb_mcYieldDiffVp[rich][pid][pTot] += yield_diff; + ++h_mcYieldDiff[rich][pid][yield_diff]; + h_mcYieldDiffVp[rich][pid][pTot] += yield_diff; } } } @@ -772,50 +704,50 @@ namespace Rich::Future::Rec::MC::Moni { const auto xSlopeDiff = theta * cosPhi; const auto ySlopeDiff = theta * sinPhi; // fill histos - hb_tkMCEmissX[charge][rich][mc_x] += mcPW; - hb_tkMCEmissY[charge][rich][mc_y] += mcPW; - hb_tkMCEmissZ[charge][rich][mc_z] += mcPW; - hb_tkRecEmissX[charge][rich][rec_x] += mcPW; - hb_tkRecEmissY[charge][rich][rec_y] += mcPW; - hb_tkRecEmissZ[charge][rich][rec_z] += mcPW; - hb_tkEmissXDiff[charge][rich][diff_x] += mcPW; - hb_tkEmissXDiffvX[charge][rich][mc_x] += { diff_x, mcPW }; - hb_tkEmissXDiffvY[charge][rich][mc_y] += { diff_x, mcPW }; - hb_tkEmissXDiffvZ[charge][rich][mc_z] += { diff_x, mcPW }; - hb_tkEmissXDiffvXY[charge][rich][{ mc_x, mc_y }] += { diff_x, mcPW }; - hb_tkEmissYDiff[charge][rich][diff_y] += mcPW; - hb_tkEmissYDiffvX[charge][rich][mc_x] += { diff_y, mcPW }; - hb_tkEmissYDiffvY[charge][rich][mc_y] += { diff_y, mcPW }; - hb_tkEmissYDiffvZ[charge][rich][mc_z] += { diff_y, mcPW }; - hb_tkEmissYDiffvXY[charge][rich][{ mc_x, mc_y }] += { diff_y, mcPW }; - hb_tkEmissZDiff[charge][rich][diff_z] += mcPW; - hb_tkEmissZDiffvX[charge][rich][mc_x] += { diff_z, mcPW }; - hb_tkEmissZDiffvY[charge][rich][mc_y] += { diff_z, mcPW }; - hb_tkEmissZDiffvZ[charge][rich][mc_z] += { diff_z, mcPW }; - hb_tkEmissZDiffvXY[charge][rich][{ mc_x, mc_y }] += { diff_z, mcPW }; - hb_tkAngle[charge][rich][theta] += mcPW; - hb_tkAngleVX[charge][rich][mc_x] += { theta, mcPW }; - hb_tkAngleVY[charge][rich][mc_y] += { theta, mcPW }; - hb_tkAngleVXY[charge][rich][{ mc_x, mc_y }] += { theta, mcPW }; - hb_tkAngleVP[charge][rich][pTot] += { theta, mcPW }; - hb_tkMCSlopeX[charge][rich][mc_tx] += mcPW; - hb_tkMCSlopeY[charge][rich][mc_ty] += mcPW; - hb_tkRecSlopeX[charge][rich][rec_tx] += mcPW; - hb_tkRecSlopeY[charge][rich][rec_ty] += mcPW; - hb_tkMCSlopeXvX[charge][rich][mc_x] += { mc_tx, mcPW }; - hb_tkMCSlopeYvY[charge][rich][mc_y] += { mc_ty, mcPW }; - hb_tkRecSlopeXvX[charge][rich][mc_x] += { rec_tx, mcPW }; - hb_tkRecSlopeYvY[charge][rich][mc_y] += { rec_ty, mcPW }; - hb_tkAngleX[charge][rich][xSlopeDiff] += mcPW; - hb_tkAngleXvP[charge][rich][pTot] += { xSlopeDiff, mcPW }; - hb_tkAngleXvX[charge][rich][mc_x] += { ySlopeDiff, mcPW }; - hb_tkAngleXvY[charge][rich][mc_y] += { ySlopeDiff, mcPW }; - hb_tkAngleXvXY[charge][rich][{ mc_x, mc_y }] += { xSlopeDiff, mcPW }; - hb_tkAngleY[charge][rich][ySlopeDiff] += mcPW; - hb_tkAngleYvP[charge][rich][pTot] += { ySlopeDiff, mcPW }; - hb_tkAngleYvX[charge][rich][mc_x] += { ySlopeDiff, mcPW }; - hb_tkAngleYvY[charge][rich][mc_y] += { ySlopeDiff, mcPW }; - hb_tkAngleYvXY[charge][rich][{ mc_x, mc_y }] += { ySlopeDiff, mcPW }; + h_tkMCEmissX[charge][rich][mc_x] += mcPW; + h_tkMCEmissY[charge][rich][mc_y] += mcPW; + h_tkMCEmissZ[charge][rich][mc_z] += mcPW; + h_tkRecEmissX[charge][rich][rec_x] += mcPW; + h_tkRecEmissY[charge][rich][rec_y] += mcPW; + h_tkRecEmissZ[charge][rich][rec_z] += mcPW; + h_tkEmissXDiff[charge][rich][diff_x] += mcPW; + h_tkEmissXDiffvX[charge][rich][mc_x] += { diff_x, mcPW }; + h_tkEmissXDiffvY[charge][rich][mc_y] += { diff_x, mcPW }; + h_tkEmissXDiffvZ[charge][rich][mc_z] += { diff_x, mcPW }; + h_tkEmissXDiffvXY[charge][rich][{ mc_x, mc_y }] += { diff_x, mcPW }; + h_tkEmissYDiff[charge][rich][diff_y] += mcPW; + h_tkEmissYDiffvX[charge][rich][mc_x] += { diff_y, mcPW }; + h_tkEmissYDiffvY[charge][rich][mc_y] += { diff_y, mcPW }; + h_tkEmissYDiffvZ[charge][rich][mc_z] += { diff_y, mcPW }; + h_tkEmissYDiffvXY[charge][rich][{ mc_x, mc_y }] += { diff_y, mcPW }; + h_tkEmissZDiff[charge][rich][diff_z] += mcPW; + h_tkEmissZDiffvX[charge][rich][mc_x] += { diff_z, mcPW }; + h_tkEmissZDiffvY[charge][rich][mc_y] += { diff_z, mcPW }; + h_tkEmissZDiffvZ[charge][rich][mc_z] += { diff_z, mcPW }; + h_tkEmissZDiffvXY[charge][rich][{ mc_x, mc_y }] += { diff_z, mcPW }; + h_tkAngle[charge][rich][theta] += mcPW; + h_tkAngleVX[charge][rich][mc_x] += { theta, mcPW }; + h_tkAngleVY[charge][rich][mc_y] += { theta, mcPW }; + h_tkAngleVXY[charge][rich][{ mc_x, mc_y }] += { theta, mcPW }; + h_tkAngleVP[charge][rich][pTot] += { theta, mcPW }; + h_tkMCSlopeX[charge][rich][mc_tx] += mcPW; + h_tkMCSlopeY[charge][rich][mc_ty] += mcPW; + h_tkRecSlopeX[charge][rich][rec_tx] += mcPW; + h_tkRecSlopeY[charge][rich][rec_ty] += mcPW; + h_tkMCSlopeXvX[charge][rich][mc_x] += { mc_tx, mcPW }; + h_tkMCSlopeYvY[charge][rich][mc_y] += { mc_ty, mcPW }; + h_tkRecSlopeXvX[charge][rich][mc_x] += { rec_tx, mcPW }; + h_tkRecSlopeYvY[charge][rich][mc_y] += { rec_ty, mcPW }; + h_tkAngleX[charge][rich][xSlopeDiff] += mcPW; + h_tkAngleXvP[charge][rich][pTot] += { xSlopeDiff, mcPW }; + h_tkAngleXvX[charge][rich][mc_x] += { ySlopeDiff, mcPW }; + h_tkAngleXvY[charge][rich][mc_y] += { ySlopeDiff, mcPW }; + h_tkAngleXvXY[charge][rich][{ mc_x, mc_y }] += { xSlopeDiff, mcPW }; + h_tkAngleY[charge][rich][ySlopeDiff] += mcPW; + h_tkAngleYvP[charge][rich][pTot] += { ySlopeDiff, mcPW }; + h_tkAngleYvX[charge][rich][mc_x] += { ySlopeDiff, mcPW }; + h_tkAngleYvY[charge][rich][mc_y] += { ySlopeDiff, mcPW }; + h_tkAngleYvXY[charge][rich][{ mc_x, mc_y }] += { ySlopeDiff, mcPW }; } // Hit position resolution @@ -827,14 +759,14 @@ namespace Rich::Future::Rec::MC::Moni { const auto yDiffGlo = pixPtnGlo.Y()[i] - mcHitPtnGlo.Y(); const auto xDiffLoc = xLoc - mcHitPtnLoc.X(); const auto yDiffLoc = yLoc - mcHitPtnLoc.Y(); - ++hb_pixXGloShift[rich][xDiffGlo]; - ++hb_pixYGloShift[rich][yDiffGlo]; - hb_pixXGloShift2D[rich][{ xLoc, yLoc }] += xDiffGlo; - hb_pixYGloShift2D[rich][{ xLoc, yLoc }] += yDiffGlo; - ++hb_pixXLocShift[rich][xDiffLoc]; - ++hb_pixYLocShift[rich][yDiffLoc]; - hb_pixXLocShift2D[rich][{ xLoc, yLoc }] += xDiffLoc; - hb_pixYLocShift2D[rich][{ xLoc, yLoc }] += yDiffLoc; + ++h_pixXGloShift[rich][xDiffGlo]; + ++h_pixYGloShift[rich][yDiffGlo]; + h_pixXGloShift2D[rich][{ xLoc, yLoc }] += xDiffGlo; + h_pixYGloShift2D[rich][{ xLoc, yLoc }] += yDiffGlo; + ++h_pixXLocShift[rich][xDiffLoc]; + ++h_pixYLocShift[rich][yDiffLoc]; + h_pixXLocShift2D[rich][{ xLoc, yLoc }] += xDiffLoc; + h_pixYLocShift2D[rich][{ xLoc, yLoc }] += yDiffLoc; } // MC photons @@ -859,14 +791,14 @@ namespace Rich::Future::Rec::MC::Moni { if ( !betaC ) { continue; } const auto nPhots = nSigPhots[rad]; if ( nPhots > 0 ) { - ++hb_recoYield[rich][pid][nPhots]; - hb_recoYieldVp[rich][pid][pTot] += nPhots; - hb_recoYieldVx[rich][pid][seg.entryPoint().X()] += nPhots; - hb_recoYieldVy[rich][pid][seg.entryPoint().Y()] += nPhots; - hb_recoYieldVxy[rich][pid][{ seg.entryPoint().X(), seg.entryPoint().Y() }] += nPhots; + ++h_recoYield[rich][pid][nPhots]; + h_recoYieldVp[rich][pid][pTot] += nPhots; + h_recoYieldVx[rich][pid][seg.entryPoint().X()] += nPhots; + h_recoYieldVy[rich][pid][seg.entryPoint().Y()] += nPhots; + h_recoYieldVxy[rich][pid][{ seg.entryPoint().X(), seg.entryPoint().Y() }] += nPhots; const auto yield_diff = yield[pid] - (double)nPhots; - ++hb_recoYieldDiff[rich][pid][yield_diff]; - hb_recoYieldDiffVp[rich][pid][pTot] += yield_diff; + ++h_recoYieldDiff[rich][pid][yield_diff]; + h_recoYieldDiffVp[rich][pid][pTot] += yield_diff; } } } diff --git a/Rich/RichFutureRecCheckers/src/RichMCSIMDPhotonCherenkovAngles.cpp b/Rich/RichFutureRecCheckers/src/RichMCSIMDPhotonCherenkovAngles.cpp index 91a107fc1412156d03f0d0f79c2c292154535a71..9e6aa7c45ec282fe218feaccfbbf7850cf193e07 100644 --- a/Rich/RichFutureRecCheckers/src/RichMCSIMDPhotonCherenkovAngles.cpp +++ b/Rich/RichFutureRecCheckers/src/RichMCSIMDPhotonCherenkovAngles.cpp @@ -315,28 +315,6 @@ void SIMDPhotonCherenkovAngles::operator()( const Summary::Track::Vector& // Make a local MC helper object const Helper mcHelper( tkrels, digitSums ); - // local buffers - auto hb_ckexpVptot = h_ckexpVptot.buffer(); - auto hb_ckResAll = h_ckResAll.buffer(); - auto hb_ckResAllBetaCut = h_ckResAllBetaCut.buffer(); - auto hb_ckResFake = h_ckResFake.buffer(); - auto hb_ckResFakeBetaCut = h_ckResFakeBetaCut.buffer(); - auto hb_thetaRecFake = h_thetaRecFake.buffer(); - auto hb_phiRecFake = h_phiRecFake.buffer(); - auto hb_ckResTrue = h_ckResTrue.buffer(); - auto hb_ckResTrueBetaCut = h_ckResTrueBetaCut.buffer(); - auto hb_thetaRecTrue = h_thetaRecTrue.buffer(); - auto hb_phiRecTrue = h_phiRecTrue.buffer(); - auto hb_ckResTrueVP = h_ckResTrueVP.buffer(); - auto hb_ckResTrueInner = h_ckResTrueInner.buffer(); - auto hb_ckResTrueOuter = h_ckResTrueOuter.buffer(); - auto hb_ckResAllPion = h_ckResAllPion.buffer(); - auto hb_ckResFakePion = h_ckResFakePion.buffer(); - auto hb_ckResTruePion = h_ckResTruePion.buffer(); - auto hb_ckResAllPionBetaCut = h_ckResAllPionBetaCut.buffer(); - auto hb_ckResFakePionBetaCut = h_ckResFakePionBetaCut.buffer(); - auto hb_ckResTruePionBetaCut = h_ckResTruePionBetaCut.buffer(); - // loop over segments for ( const auto&& [seg, ckexp] : Ranges::ConstZip( segments, expTkCKThetas ) ) { // radiator @@ -345,7 +323,7 @@ void SIMDPhotonCherenkovAngles::operator()( const Summary::Track::Vector& // momentum const auto pTot = seg.bestMomentumMag(); // loop over PID types - for ( const auto hypo : activeParticlesNoBT() ) { hb_ckexpVptot[rich][hypo][pTot] += ckexp[hypo]; } + for ( const auto hypo : activeParticlesNoBT() ) { h_ckexpVptot[rich][hypo][pTot] += ckexp[hypo]; } } // loop over the photon info @@ -431,21 +409,21 @@ void SIMDPhotonCherenkovAngles::operator()( const Summary::Track::Vector& const auto deltaTheta = thetaRec - thetaExp; // fill some plots - hb_ckResAll[rich][deltaTheta] += mcPW; - if ( betaC ) { hb_ckResAllBetaCut[rich][deltaTheta] += mcPW; } + h_ckResAll[rich][deltaTheta] += mcPW; + if ( betaC ) { h_ckResAllBetaCut[rich][deltaTheta] += mcPW; } if ( !trueCKSig ) { - hb_ckResFake[rich][deltaTheta] += mcPW; - if ( betaC ) { hb_ckResFakeBetaCut[rich][deltaTheta] += mcPW; } - hb_thetaRecFake[rich][thetaRec] += mcPW; - hb_phiRecFake[rich][phiRec] += mcPW; + h_ckResFake[rich][deltaTheta] += mcPW; + if ( betaC ) { h_ckResFakeBetaCut[rich][deltaTheta] += mcPW; } + h_thetaRecFake[rich][thetaRec] += mcPW; + h_phiRecFake[rich][phiRec] += mcPW; } else { - hb_ckResTrue[rich][deltaTheta] += mcPW; - if ( betaC ) { hb_ckResTrueBetaCut[rich][deltaTheta] += mcPW; } - hb_thetaRecTrue[rich][thetaRec] += mcPW; - hb_phiRecTrue[rich][phiRec] += mcPW; - hb_ckResTrueVP[rich][pTot] += { fabs( deltaTheta ), mcPW }; + h_ckResTrue[rich][deltaTheta] += mcPW; + if ( betaC ) { h_ckResTrueBetaCut[rich][deltaTheta] += mcPW; } + h_thetaRecTrue[rich][thetaRec] += mcPW; + h_phiRecTrue[rich][phiRec] += mcPW; + h_ckResTrueVP[rich][pTot] += { fabs( deltaTheta ), mcPW }; const auto isInner = simdPix.isInnerRegion()[i]; - ( isInner ? hb_ckResTrueInner[rich] : hb_ckResTrueOuter[rich] )[deltaTheta] += mcPW; + ( isInner ? h_ckResTrueInner[rich] : h_ckResTrueOuter[rich] )[deltaTheta] += mcPW; } } // loop over associated MCPs @@ -460,18 +438,18 @@ void SIMDPhotonCherenkovAngles::operator()( const Summary::Track::Vector& const auto deltaTheta = thetaRec - expCKangles[Rich::Pion]; // fill some plots - ++hb_ckResAllPion[rich][deltaTheta]; + ++h_ckResAllPion[rich][deltaTheta]; if ( trueCKMCPs.empty() ) { - ++hb_ckResFakePion[rich][deltaTheta]; + ++h_ckResFakePion[rich][deltaTheta]; } else { - ++hb_ckResTruePion[rich][deltaTheta]; + ++h_ckResTruePion[rich][deltaTheta]; } if ( pionBetaC ) { - ++hb_ckResAllPionBetaCut[rich][deltaTheta]; + ++h_ckResAllPionBetaCut[rich][deltaTheta]; if ( trueCKMCPs.empty() ) { - ++hb_ckResFakePionBetaCut[rich][deltaTheta]; + ++h_ckResFakePionBetaCut[rich][deltaTheta]; } else { - ++hb_ckResTruePionBetaCut[rich][deltaTheta]; + ++h_ckResTruePionBetaCut[rich][deltaTheta]; } } } // pion plots diff --git a/Rich/RichFutureRecCheckers/src/RichMCSIMDPhotonTime.cpp b/Rich/RichFutureRecCheckers/src/RichMCSIMDPhotonTime.cpp index c7432493bbc5a9953dfecd8e761ebaeb82aa3e67..2d705146600df44f5b056412725b670eff1e9c2e 100644 --- a/Rich/RichFutureRecCheckers/src/RichMCSIMDPhotonTime.cpp +++ b/Rich/RichFutureRecCheckers/src/RichMCSIMDPhotonTime.cpp @@ -283,39 +283,6 @@ void SIMDPhotonTime::operator()( const Summary::Track::Vector& // Make a local MC helper object const Helper mcHelper( tkrels, digitSums ); - // local buffers - auto hb_hitTimeAll = h_hitTimeAll.buffer(); - auto hb_hitTimeTrue = h_hitTimeTrue.buffer(); - auto hb_hitTimeFake = h_hitTimeFake.buffer(); - auto hb_tkOriginTime = h_tkOriginTime.buffer(); - auto hb_tkOriginX = h_tkOriginX.buffer(); - auto hb_tkOriginY = h_tkOriginY.buffer(); - auto hb_tkOriginZ = h_tkOriginZ.buffer(); - auto hb_tkPVTime = h_tkPVTime.buffer(); - auto hb_tkPVZ = h_tkPVZ.buffer(); - auto hb_tkPVt0 = h_tkPVt0.buffer(); - auto hb_PVTime_PVZ_All = h_PVTime_PVZ_All.buffer(); - auto hb_timeResAll = h_timeResAll.buffer(); - auto hb_hitTime2All = h_hitTime2All.buffer(); - auto hb_hitTime2_t0_All = h_hitTime2_t0_All.buffer(); - auto hb_hitTime2_PVt0_momentum_All = h_hitTime2_PVt0_momentum_All.buffer(); - auto hb_hitTime2_timeRes_momentum_All = h_hitTime2_timeRes_momentum_All.buffer(); - auto hb_PVTime_CkAngle_All = h_PVTime_CkAngle_All.buffer(); - auto hb_PVZ_CkAngle_All = h_PVZ_CkAngle_All.buffer(); - auto hb_PVTime_Pred_noPV_All = h_PVTime_Pred_noPV_All.buffer(); - auto hb_hitTime2_timeRes_CkAngle_All = h_hitTime2_timeRes_CkAngle_All.buffer(); - auto hb_timeResTrue = h_timeResTrue.buffer(); - auto hb_hitTime2True = h_hitTime2True.buffer(); - auto hb_hitTime2_t0_True = h_hitTime2_t0_True.buffer(); - auto hb_hitTime2_PVt0_momentum_True = h_hitTime2_PVt0_momentum_True.buffer(); - auto hb_hitTime2_timeRes_momentum_True = h_hitTime2_timeRes_momentum_True.buffer(); - auto hb_PVTime_CkAngle_True = h_PVTime_CkAngle_True.buffer(); - auto hb_PVZ_CkAngle_True = h_PVZ_CkAngle_True.buffer(); - auto hb_PVTime_Pred_noPV_True = h_PVTime_Pred_noPV_True.buffer(); - auto hb_hitTime2_timeRes_CkAngle_True = h_hitTime2_timeRes_CkAngle_True.buffer(); - auto hb_timeResFake = h_timeResFake.buffer(); - auto hb_hitTime2Fake = h_hitTime2Fake.buffer(); - // Loop over the hits for ( const auto& pix : pixels ) { // Which RICH @@ -324,9 +291,9 @@ void SIMDPhotonTime::operator()( const Summary::Track::Vector& // Scalar loop for ( std::size_t i = 0; i < SIMDPixel::SIMDFP::Size; ++i ) { if ( !pix.validMask()[i] ) { continue; } - ++hb_hitTimeAll[rich][pix.hitTime()[i]]; + ++h_hitTimeAll[rich][pix.hitTime()[i]]; const auto isTrue = mcHelper.isCherenkovRadiation( pix.smartID()[i] ); - ++( isTrue ? hb_hitTimeTrue[rich] : hb_hitTimeFake[rich] )[pix.hitTime()[i]]; + ++( isTrue ? h_hitTimeTrue[rich] : h_hitTimeFake[rich] )[pix.hitTime()[i]]; } } } @@ -336,10 +303,10 @@ void SIMDPhotonTime::operator()( const Summary::Track::Vector& const auto rich = seg.rich(); if ( !richIsActive( rich ) ) { continue; } // Track plots - ++hb_tkOriginTime[rich][seg.originTime()]; - ++hb_tkOriginX[rich][seg.originVertex().X()]; - ++hb_tkOriginY[rich][seg.originVertex().Y()]; - ++hb_tkOriginZ[rich][seg.originVertex().Z()]; + ++h_tkOriginTime[rich][seg.originTime()]; + ++h_tkOriginX[rich][seg.originVertex().X()]; + ++h_tkOriginY[rich][seg.originVertex().Y()]; + ++h_tkOriginZ[rich][seg.originVertex().Z()]; } // loop over the photon info @@ -354,10 +321,10 @@ void SIMDPhotonTime::operator()( const Summary::Track::Vector& const auto PVtime = mcP->primaryVertex()->time(); const auto PVZpos = mcP->primaryVertex()->position().z(); const auto PVt0 = PVtime - ( PVZpos / Gaudi::Units::c_light ); - ++hb_tkPVTime[PVtime]; - ++hb_tkPVZ[PVZpos]; - ++hb_tkPVt0[PVt0]; - ++hb_PVTime_PVZ_All[{ PVtime, PVZpos }]; + ++h_tkPVTime[PVtime]; + ++h_tkPVZ[PVZpos]; + ++h_tkPVt0[PVt0]; + ++h_PVTime_PVZ_All[{ PVtime, PVZpos }]; } } @@ -430,28 +397,28 @@ void SIMDPhotonTime::operator()( const Summary::Track::Vector& const auto trueCKSig = std::find( trueCKMCPs.begin(), trueCKMCPs.end(), mcP ) != trueCKMCPs.end(); // fill time and time res plots - hb_timeResAll[rich][timeRes] += mcPW; - hb_hitTime2All[rich][hitTime] += mcPW; - hb_hitTime2_t0_All[rich][hitTime - PVt0] += mcPW; - hb_hitTime2_PVt0_momentum_All[rich][{ mcP_momentum, ( hitTime - PVt0 ) }] += mcPW; - hb_hitTime2_timeRes_momentum_All[rich][{ mcP_momentum, timeRes }] += mcPW; - hb_PVTime_CkAngle_All[rich][{ PVtime, thetaRec }] += mcPW; - hb_PVZ_CkAngle_All[rich][{ PVZpos, thetaRec }] += mcPW; - hb_PVTime_Pred_noPV_All[rich][{ PVtime, recoTime - PVtime }] += mcPW; - hb_hitTime2_timeRes_CkAngle_All[rich][{ thetaRec, timeRes }] += mcPW; + h_timeResAll[rich][timeRes] += mcPW; + h_hitTime2All[rich][hitTime] += mcPW; + h_hitTime2_t0_All[rich][hitTime - PVt0] += mcPW; + h_hitTime2_PVt0_momentum_All[rich][{ mcP_momentum, ( hitTime - PVt0 ) }] += mcPW; + h_hitTime2_timeRes_momentum_All[rich][{ mcP_momentum, timeRes }] += mcPW; + h_PVTime_CkAngle_All[rich][{ PVtime, thetaRec }] += mcPW; + h_PVZ_CkAngle_All[rich][{ PVZpos, thetaRec }] += mcPW; + h_PVTime_Pred_noPV_All[rich][{ PVtime, recoTime - PVtime }] += mcPW; + h_hitTime2_timeRes_CkAngle_All[rich][{ thetaRec, timeRes }] += mcPW; if ( trueCKSig ) { - hb_timeResTrue[rich][timeRes] += mcPW; - hb_hitTime2True[rich][hitTime] += mcPW; - hb_hitTime2_t0_True[rich][hitTime - PVt0] += mcPW; - hb_hitTime2_PVt0_momentum_True[rich][{ mcP_momentum, ( hitTime - PVt0 ) }] += mcPW; - hb_hitTime2_timeRes_momentum_True[rich][{ mcP_momentum, timeRes }] += mcPW; - hb_PVTime_CkAngle_True[rich][{ PVtime, thetaRec }] += mcPW; - hb_PVZ_CkAngle_True[rich][{ PVZpos, thetaRec }] += mcPW; - hb_PVTime_Pred_noPV_True[rich][{ PVtime, recoTime - PVtime }] += mcPW; - hb_hitTime2_timeRes_CkAngle_True[rich][{ thetaRec, timeRes }] += mcPW; + h_timeResTrue[rich][timeRes] += mcPW; + h_hitTime2True[rich][hitTime] += mcPW; + h_hitTime2_t0_True[rich][hitTime - PVt0] += mcPW; + h_hitTime2_PVt0_momentum_True[rich][{ mcP_momentum, ( hitTime - PVt0 ) }] += mcPW; + h_hitTime2_timeRes_momentum_True[rich][{ mcP_momentum, timeRes }] += mcPW; + h_PVTime_CkAngle_True[rich][{ PVtime, thetaRec }] += mcPW; + h_PVZ_CkAngle_True[rich][{ PVZpos, thetaRec }] += mcPW; + h_PVTime_Pred_noPV_True[rich][{ PVtime, recoTime - PVtime }] += mcPW; + h_hitTime2_timeRes_CkAngle_True[rich][{ thetaRec, timeRes }] += mcPW; } else { - hb_timeResFake[rich][timeRes] += mcPW; - hb_hitTime2Fake[rich][hitTime] += mcPW; + h_timeResFake[rich][timeRes] += mcPW; + h_hitTime2Fake[rich][hitTime] += mcPW; } } // loop over associated MCPs diff --git a/Rich/RichFutureRecCheckers/src/RichMCTrackResolution.cpp b/Rich/RichFutureRecCheckers/src/RichMCTrackResolution.cpp index 303bca494ae67b65c26fc1fd83f06a9c3b443116..d2129281e21183e0aa32c8d2af5bfe8ae27b7df9 100644 --- a/Rich/RichFutureRecCheckers/src/RichMCTrackResolution.cpp +++ b/Rich/RichFutureRecCheckers/src/RichMCTrackResolution.cpp @@ -77,10 +77,6 @@ namespace Rich::Future::Rec::MC::Moni { // Make a local MC helper object Rich::Future::MC::Relations::TrackToMCParticle mcHelper( tkrels ); - // local buffers - auto hb_mcpVrecoP = h_mcpVrecoP.buffer(); - auto hb_pdiffVrecoP = h_pdiffVrecoP.buffer(); - // loop over segments for ( const auto&& [seg, tkIndex] : Ranges::ConstZip( segments, segToTkRel ) ) { @@ -114,8 +110,8 @@ namespace Rich::Future::Rec::MC::Moni { const auto pTotMC = mcP->p(); // fill histograms - hb_mcpVrecoP[rich][pid][pTot] += { pTotMC, mcPW }; - hb_pdiffVrecoP[rich][pid][pTot] += { pTot - pTotMC, mcPW }; + h_mcpVrecoP[rich][pid][pTot] += { pTotMC, mcPW }; + h_pdiffVrecoP[rich][pid][pTot] += { pTot - pTotMC, mcPW }; } } } diff --git a/Rich/RichFutureRecCheckers/src/RichPIDQC.cpp b/Rich/RichFutureRecCheckers/src/RichPIDQC.cpp index e0d8de786f873d5e734aef28b09dbbd8fabf5a82..9f76964a1f9f2f883b76280ac7cd2bf1721ff53a 100644 --- a/Rich/RichFutureRecCheckers/src/RichPIDQC.cpp +++ b/Rich/RichFutureRecCheckers/src/RichPIDQC.cpp @@ -201,15 +201,13 @@ void PIDQC::operator()( const LHCb::Track::Range& tracks, const Rich::Future::MC::Relations::TkToMCPRels& rels ) const { // buffers - auto protonEff = m_protonEff.buffer(); - auto kaonEff = m_kaonEff.buffer(); - auto pionEff = m_pionEff.buffer(); - auto tksWithID = m_tracksWithID.buffer(); - auto withR1 = m_withR1.buffer(); - auto withR2 = m_withR2.buffer(); - auto withR1R2 = m_withR1R2.buffer(); - auto hb_nRFrac = h_nRFrac.buffer(); - auto hb_pidTable = h_pidTable.buffer(); + auto protonEff = m_protonEff.buffer(); + auto kaonEff = m_kaonEff.buffer(); + auto pionEff = m_pionEff.buffer(); + auto tksWithID = m_tracksWithID.buffer(); + auto withR1 = m_withR1.buffer(); + auto withR2 = m_withR2.buffer(); + auto withR1R2 = m_withR1R2.buffer(); unsigned int pidCount = 0; @@ -270,7 +268,7 @@ void PIDQC::operator()( const LHCb::Track::Range& tracks, // Did we get any MCPs ? if ( mcPs.empty() ) { // Fill once with MC type unknown (Below threshold) - hb_pidTable[{ (int)bpid, (int)Rich::BelowThreshold }] += 1.0; + h_pidTable[{ (int)bpid, (int)Rich::BelowThreshold }] += 1.0; } else { // Get the sum off all MCP weights const auto wSum = std::accumulate( mcPs.begin(), mcPs.end(), 0.0, @@ -287,8 +285,8 @@ void PIDQC::operator()( const LHCb::Track::Range& tracks, if ( Rich::Unknown == mcpid ) { mcpid = Rich::BelowThreshold; } // acceptance plots (fill before we possibily reassign MCPID BT) if ( Rich::BelowThreshold != mcpid ) { - hb_nRFrac[Rich::Rich1][mcpid][tk->p()] += { ( pid->usedRich1Gas() ? 100.0 : 0.0 ), mcPW }; - hb_nRFrac[Rich::Rich2][mcpid][tk->p()] += { ( pid->usedRich2Gas() ? 100.0 : 0.0 ), mcPW }; + h_nRFrac[Rich::Rich1][mcpid][tk->p()] += { ( pid->usedRich1Gas() ? 100.0 : 0.0 ), mcPW }; + h_nRFrac[Rich::Rich2][mcpid][tk->p()] += { ( pid->usedRich2Gas() ? 100.0 : 0.0 ), mcPW }; } // If a real type, but below threshold, set below threshold const bool reassignMCBT = ( m_allowBTreassign && !pid->isAboveThreshold( mcpid ) ); @@ -299,7 +297,7 @@ void PIDQC::operator()( const LHCb::Track::Range& tracks, m_mcPIDBT += reassignMCBT; _ri_verbo << " -> MC PID = " << mcpid << endmsg; // fill table - hb_pidTable[{ (int)bpid, (int)mcpid }] += mcPW; + h_pidTable[{ (int)bpid, (int)mcpid }] += mcPW; // fill ID counters if ( Rich::BelowThreshold != bpid ) { // For protons use DLL cut diff --git a/Rich/RichFutureRecMonitors/src/RichDLLs.cpp b/Rich/RichFutureRecMonitors/src/RichDLLs.cpp index b48974e402d032056d0b31ef1e554a7f629c0f7a..b95c9d8bd8756db92da9b2659482154fb9b76566 100644 --- a/Rich/RichFutureRecMonitors/src/RichDLLs.cpp +++ b/Rich/RichFutureRecMonitors/src/RichDLLs.cpp @@ -59,7 +59,6 @@ namespace Rich::Future::Rec::Moni { auto withR2 = m_withR2.buffer(); auto withR1R2 = m_withR1R2.buffer(); auto aboveThres = m_aboveThres.buffer(); - auto hb_dlls = h_dlls.buffer(); // count PIDs m_nPIDs += pids.size(); @@ -79,7 +78,7 @@ namespace Rich::Future::Rec::Moni { // Only fill if either X or Y in DLL(X-Y) is above threshold. // note by design Y is always pion if ( pid->isAboveThreshold( Rich::Pion ) || pid->isAboveThreshold( id ) ) { - ++hb_dlls.at( id )[pid->particleDeltaLL( id )]; + ++h_dlls.at( id )[pid->particleDeltaLL( id )]; } } } diff --git a/Rich/RichFutureRecMonitors/src/RichDetectorHits.cpp b/Rich/RichFutureRecMonitors/src/RichDetectorHits.cpp index e2274fa265efde744c421da492a15ed77fc778a8..babe894e4b4a5e4c7550596f9a0044f6bc416623 100644 --- a/Rich/RichFutureRecMonitors/src/RichDetectorHits.cpp +++ b/Rich/RichFutureRecMonitors/src/RichDetectorHits.cpp @@ -63,25 +63,6 @@ namespace Rich::Future::Rec::Moni { /// Functional operator void operator()( const SIMDPixelSummaries& pixels ) const override { - // local buffers - auto hb_nTotalPixsPerPD = h_nTotalPixsPerPD.buffer(); - auto hb_nTotalPixsPerPDInner = h_nTotalPixsPerPDInner.buffer(); - auto hb_nTotalPixsPerPDOuter = h_nTotalPixsPerPDOuter.buffer(); - auto hb_nTotalPixs = h_nTotalPixs.buffer(); - auto hb_pixXYGlo = h_pixXYGlo.buffer(); - auto hb_pixXGlo = h_pixXGlo.buffer(); - auto hb_pixYGlo = h_pixYGlo.buffer(); - auto hb_pixXYLoc = h_pixXYLoc.buffer(); - auto hb_pixXLoc = h_pixXLoc.buffer(); - auto hb_pixYLoc = h_pixYLoc.buffer(); - auto hb_pdXYOcc = h_pdXYOcc.buffer(); - auto hb_pdXOcc = h_pdXOcc.buffer(); - auto hb_pdYOcc = h_pdYOcc.buffer(); - auto hb_hitDensityXY = h_hitDensityXY.buffer(); - auto hb_hitDensityX = h_hitDensityX.buffer(); - auto hb_hitDensityY = h_hitDensityY.buffer(); - auto hb_nActivePDs = h_nActivePDs.buffer(); - // Loop over RICHes for ( const auto rich : activeDetectors() ) { @@ -111,8 +92,8 @@ namespace Rich::Future::Rec::Moni { // If last PD ID is valid fill plots etc. for the last PD if ( lastPD.isValid() ) { // Fill average HPD occ plot - ++hb_nTotalPixsPerPD[rich][curPDhits]; - ++( lastPDIsInner ? hb_nTotalPixsPerPDInner[rich] : hb_nTotalPixsPerPDOuter[rich] )[curPDhits]; + ++h_nTotalPixsPerPD[rich][curPDhits]; + ++( lastPDIsInner ? h_nTotalPixsPerPDInner[rich] : h_nTotalPixsPerPDOuter[rich] )[curPDhits]; // PD occ for ( const auto& [iX, iY] : hitiXiY ) { pdOccXY[iX][iY] = ( 100.0 * curPDhits ) / (double)LHCb::RichSmartID::MaPMT::TotalPixels; @@ -126,7 +107,7 @@ namespace Rich::Future::Rec::Moni { // Fill RICH hits plots const auto nHits = pixels.nHitsScalar( rich ); - if ( nHits > 0 ) { ++hb_nTotalPixs[rich][nHits]; } + if ( nHits > 0 ) { ++h_nTotalPixs[rich][nHits]; } // Loop over pixels for this RICH for ( const auto& pix : pixels.range( rich ) ) { @@ -157,12 +138,12 @@ namespace Rich::Future::Rec::Moni { const auto lPos = pix.locPos( i ); // fill plots - ++hb_pixXYGlo[rich][side][{ gPos.X(), gPos.Y() }]; - ++hb_pixXGlo[rich][side][gPos.X()]; - ++hb_pixYGlo[rich][side][gPos.Y()]; - ++hb_pixXYLoc[rich][{ lPos.X(), lPos.Y() }]; - ++hb_pixXLoc[rich][lPos.X()]; - ++hb_pixYLoc[rich][lPos.Y()]; + ++h_pixXYGlo[rich][side][{ gPos.X(), gPos.Y() }]; + ++h_pixXGlo[rich][side][gPos.X()]; + ++h_pixYGlo[rich][side][gPos.Y()]; + ++h_pixXYLoc[rich][{ lPos.X(), lPos.Y() }]; + ++h_pixXLoc[rich][lPos.X()]; + ++h_pixYLoc[rich][lPos.Y()]; // cache occupancy data const auto& xaxis = h_pdXYOcc[rich].axis<0>(); @@ -185,18 +166,18 @@ namespace Rich::Future::Rec::Moni { const auto X = xaxis.minValue() + ( ( 0.5 + iX ) * ( xaxis.maxValue() - xaxis.minValue() ) / xaxis.nBins ); const auto Y = yaxis.minValue() + ( ( 0.5 + iY ) * ( yaxis.maxValue() - yaxis.minValue() ) / yaxis.nBins ); const auto occ = pdOccXY[iX][iY]; - hb_pdXYOcc[rich][{ X, Y }] += occ; - hb_pdXOcc[rich][X] += occ; - hb_pdYOcc[rich][Y] += occ; + h_pdXYOcc[rich][{ X, Y }] += occ; + h_pdXOcc[rich][X] += occ; + h_pdYOcc[rich][Y] += occ; const auto hitPerMM2 = hitsPerMM2[iX][iY]; - hb_hitDensityXY[rich][{ X, Y }] += hitPerMM2; - hb_hitDensityX[rich][X] += hitPerMM2; - hb_hitDensityY[rich][Y] += hitPerMM2; + h_hitDensityXY[rich][{ X, Y }] += hitPerMM2; + h_hitDensityX[rich][X] += hitPerMM2; + h_hitDensityY[rich][Y] += hitPerMM2; } } // Fill active PD plots - ++hb_nActivePDs[rich][activePDs]; + ++h_nActivePDs[rich][activePDs]; } // RICHes } diff --git a/Rich/RichFutureRecMonitors/src/RichGeometricalEfficiencies.cpp b/Rich/RichFutureRecMonitors/src/RichGeometricalEfficiencies.cpp index 9924fc251ce81fa3a42ab40d69fb3bff858628b9..147f5c0a53e721b43d926cb83059d8e3751bdee0 100644 --- a/Rich/RichFutureRecMonitors/src/RichGeometricalEfficiencies.cpp +++ b/Rich/RichFutureRecMonitors/src/RichGeometricalEfficiencies.cpp @@ -62,9 +62,6 @@ namespace Rich::Future::Rec::Moni { void operator()( const LHCb::RichTrackSegment::Vector& segments, // const GeomEffs::Vector& geoms ) const override { - // local buffers - auto hb_geoms = h_geoms.buffer(); - // loop over segments and geom. eff. data for ( auto&& [segment, geom] : Ranges::ConstZip( segments, geoms ) ) { @@ -75,7 +72,7 @@ namespace Rich::Future::Rec::Moni { // loop over mass hypos for ( const auto pid : activeParticlesNoBT() ) { // fill histo (if > 0 so above threshold) - if ( geom[pid] > 0 ) { ++hb_geoms[rich][pid][geom[pid]]; } + if ( geom[pid] > 0 ) { ++h_geoms[rich][pid][geom[pid]]; } } } // segment loop diff --git a/Rich/RichFutureRecMonitors/src/RichMassHypoRings.cpp b/Rich/RichFutureRecMonitors/src/RichMassHypoRings.cpp index 2ee0e0794fe38ed1fcbd7d4d8b463e18f5c1177a..c625e8f38478396feb2d2d3cf6c5017b1e1eb0cc 100644 --- a/Rich/RichFutureRecMonitors/src/RichMassHypoRings.cpp +++ b/Rich/RichFutureRecMonitors/src/RichMassHypoRings.cpp @@ -74,12 +74,6 @@ namespace Rich::Future::Rec::Moni { const SegmentPanelSpacePoints::Vector& trHitPntsLoc, ///< segment hit points const MassHypoRingsVector& massRings ) const override { - // local buffers - auto hb_ringReuse = h_ringReuse.buffer(); - auto hb_ringPointSegSep = h_ringPointSegSep.buffer(); - auto hb_ringPointSegSepVPhi = h_ringPointSegSepVPhi.buffer(); - auto hb_sepVckt = h_sepVckt.buffer(); - // loop over rings for ( auto&& [segment, ckT, tkLocPtn, ring] : Ranges::ConstZip( segments, ckAngles, trHitPntsLoc, massRings ) ) { @@ -125,12 +119,12 @@ namespace Rich::Future::Rec::Moni { if ( !seps.empty() ) { // compute average seperation for this ring const auto avSep = sumSep / seps.size(); - hb_sepVckt[rich][ckT[id]] += avSep; + h_sepVckt[rich][ckT[id]] += avSep; // fill deviations from average into histo for ( const auto& [phi, sep] : seps ) { const auto sepDiff = sep - avSep; - ++hb_ringPointSegSep[rich][id][sepDiff]; - hb_ringPointSegSepVPhi[rich][id][phi] += sepDiff; + ++h_ringPointSegSep[rich][id][sepDiff]; + h_ringPointSegSepVPhi[rich][id][phi] += sepDiff; } } } @@ -138,7 +132,7 @@ namespace Rich::Future::Rec::Moni { // fill reuse histos for ( const auto id : activeParticlesNoBT() ) { // only fill if ring not empty (i.e. above threshold) - if ( !ring[id].empty() ) { hb_ringReuse[rich][id] += ( reused[id] ? 100.0 : 0.0 ); } + if ( !ring[id].empty() ) { h_ringReuse[rich][id] += ( reused[id] ? 100.0 : 0.0 ); } } } } diff --git a/Rich/RichFutureRecMonitors/src/RichPhotonSIMDEfficiency.cpp b/Rich/RichFutureRecMonitors/src/RichPhotonSIMDEfficiency.cpp index a600fb4cd449b033aa2650bc873e8910e26f3196..09b8f4387f543ca4977e8ce109c6bcdff6360e74 100644 --- a/Rich/RichFutureRecMonitors/src/RichPhotonSIMDEfficiency.cpp +++ b/Rich/RichFutureRecMonitors/src/RichPhotonSIMDEfficiency.cpp @@ -52,8 +52,6 @@ namespace Rich::Future::Rec::Moni { const Relations::PhotonToParents::Vector& photToSegPix, // const LHCb::RichTrackSegment::Vector& segments ) const override { - auto hb_simdEff = h_simdEff.buffer(); - // loop over photon relations for ( const auto& iphot : photToSegPix ) { @@ -70,7 +68,7 @@ namespace Rich::Future::Rec::Moni { const auto& phot = photons[iphot.photonIndex()]; // count the valid scalar photons the SIMD photon represents - ++hb_simdEff[rich][phot.validityMask().count()]; + ++h_simdEff[rich][phot.validityMask().count()]; } } diff --git a/Rich/RichFutureRecMonitors/src/RichPhotonYield.cpp b/Rich/RichFutureRecMonitors/src/RichPhotonYield.cpp index 587ec09ca9278a777c11946f14e0abfc75e403e4..25792ace4beb5a061f3aed3808225be40b6941d2 100644 --- a/Rich/RichFutureRecMonitors/src/RichPhotonYield.cpp +++ b/Rich/RichFutureRecMonitors/src/RichPhotonYield.cpp @@ -61,10 +61,6 @@ namespace Rich::Future::Rec::Moni { void operator()( const LHCb::RichTrackSegment::Vector& segments, // const PhotonYields::Vector& yields ) const override { - // local buffers - auto hb_yields = h_yields.buffer(); - auto hb_yieldVp = h_yieldVp.buffer(); - // loop over segments and yield data for ( auto&& [segment, yield] : Ranges::ConstZip( segments, yields ) ) { @@ -76,8 +72,8 @@ namespace Rich::Future::Rec::Moni { for ( const auto pid : activeParticlesNoBT() ) { // fill histo if ( yield[pid] > 0 ) { - ++hb_yields[rich][pid][yield[pid]]; - hb_yieldVp[rich][pid][segment.bestMomentumMag()] += yield[pid]; + ++h_yields[rich][pid][yield[pid]]; + h_yieldVp[rich][pid][segment.bestMomentumMag()] += yield[pid]; } } diff --git a/Rich/RichFutureRecMonitors/src/RichPixelBackgrounds.cpp b/Rich/RichFutureRecMonitors/src/RichPixelBackgrounds.cpp index ee30cd6270be8dee9ec98de58cb904cb001b02eb..d8f8120b09c01dcf1b4fb8fdaa5705840aef34fa 100644 --- a/Rich/RichFutureRecMonitors/src/RichPixelBackgrounds.cpp +++ b/Rich/RichFutureRecMonitors/src/RichPixelBackgrounds.cpp @@ -62,15 +62,13 @@ namespace Rich::Future::Rec::Moni { void operator()( const SIMDPixelSummaries& pixels, // const SIMDPixelBackgrounds& backgrounds ) const override { - auto hb_pixBkg = h_pixBkg.buffer(); - for ( const auto&& [pix, bkg] : Ranges::ConstZip( pixels, backgrounds ) ) { const auto rich = pix.rich(); if ( richIsActive( rich ) ) { // Loop over the scalar entries for this SIMD pixel for ( std::size_t i = 0; i < SIMDFP::Size; ++i ) { // pixel background - if ( pix.validMask()[i] ) { ++hb_pixBkg[rich][bkg[i]]; } + if ( pix.validMask()[i] ) { ++h_pixBkg[rich][bkg[i]]; } } } } diff --git a/Rich/RichFutureRecMonitors/src/RichPixelClusters.cpp b/Rich/RichFutureRecMonitors/src/RichPixelClusters.cpp index 038ae07cfff0bb3aa90e9f002e122cb312566998..c6dfba105896f87f5f2053b4e4bf3a1cd2530406 100644 --- a/Rich/RichFutureRecMonitors/src/RichPixelClusters.cpp +++ b/Rich/RichFutureRecMonitors/src/RichPixelClusters.cpp @@ -43,14 +43,13 @@ namespace Rich::Future::Rec::Moni { public: /// Functional operator void operator()( const Rich::PDPixelCluster::Vector& clusters ) const override { - auto hb_clusterSize = h_clusterSize.buffer(); // loop over clusters for ( const auto& cluster : clusters ) { if ( cluster.empty() ) { ++m_emptyClusWarn; } else { const auto rich = cluster.rich(); - if ( richIsActive( rich ) ) { ++hb_clusterSize[rich][cluster.size()]; } + if ( richIsActive( rich ) ) { ++h_clusterSize[rich][cluster.size()]; } } } } diff --git a/Rich/RichFutureRecMonitors/src/RichSIMDPhotonCherenkovAngles.cpp b/Rich/RichFutureRecMonitors/src/RichSIMDPhotonCherenkovAngles.cpp index 5e1fa05e7f9d79259b5813f427181714d553e93c..b1fd02af6578327d2012efa961c47aefe943cacd 100644 --- a/Rich/RichFutureRecMonitors/src/RichSIMDPhotonCherenkovAngles.cpp +++ b/Rich/RichFutureRecMonitors/src/RichSIMDPhotonCherenkovAngles.cpp @@ -431,22 +431,6 @@ void SIMDPhotonCherenkovAngles::operator()( const LHCb::Track::Range& const bool hasMirrorData = ( !mirrorData.empty() && mirrorData.size() == photons.size() ); if ( m_detailedHists && hasMirrorData ) { createMirrorHistArrays(); } - // local histo buffers - auto hb_thetaRec = h_thetaRec.buffer(); - auto hb_phiRec = h_phiRec.buffer(); - auto hb_ckResAll = h_ckResAll.buffer(); - auto hb_ckResAllPerPanel = h_ckResAllPerPanel.buffer(); - auto hb_ckResAllPerRegion = h_ckResAllPerRegion.buffer(); - auto hb_ckResAllPerPanelPerRegion = h_ckResAllPerPanelPerRegion.buffer(); - auto hb_ckResAllBetaCut = h_ckResAllBetaCut.buffer(); - auto hb_ckResAllPerPanelBetaCut = h_ckResAllPerPanelBetaCut.buffer(); - auto hb_ckResAllPerCol = h_ckResAllPerCol.buffer(); - auto hb_ckResAllPerColPerRegion = h_ckResAllPerColPerRegion.buffer(); - auto hb_ckResAllVersusPhi = h_ckResAllVersusPhi.buffer(); - auto hb_ckResAllPerQuad = h_ckResAllPerQuad.buffer(); - auto hb_ckResAllVersusPhiPerQuad = h_ckResAllVersusPhiPerQuad.buffer(); - auto hb_ckResAllDiffSide = h_ckResAllDiffSide.buffer(); - // loop over the track containers for ( const auto&& [tk, sumTk] : Ranges::ConstZip( tracks, sumTracks ) ) { // Is this track selected ? @@ -513,26 +497,26 @@ void SIMDPhotonCherenkovAngles::operator()( const LHCb::Track::Range& : seg.bestPoint().x() * simdPix.gloPos().x()[i] > 0.0 ); // fill some general plots - ++hb_thetaRec[rich][thetaRec]; - ++hb_phiRec[rich][phiRec]; - ++hb_ckResAll[rich][deltaTheta]; - if ( !sameSide ) { ++hb_ckResAllDiffSide[rich][deltaTheta]; } - ++hb_ckResAllPerQuad[rich][q][deltaTheta]; - ++hb_ckResAllVersusPhi[rich][{ phiRec, deltaTheta }]; - ++hb_ckResAllVersusPhiPerQuad[rich][q][{ phiRec, deltaTheta }]; + ++h_thetaRec[rich][thetaRec]; + ++h_phiRec[rich][phiRec]; + ++h_ckResAll[rich][deltaTheta]; + if ( !sameSide ) { ++h_ckResAllDiffSide[rich][deltaTheta]; } + ++h_ckResAllPerQuad[rich][q][deltaTheta]; + ++h_ckResAllVersusPhi[rich][{ phiRec, deltaTheta }]; + ++h_ckResAllVersusPhiPerQuad[rich][q][{ phiRec, deltaTheta }]; if ( m_detailedHists ) { const auto phiB = phiBin( phiRec ); ++( h_phiBinHists->ckResAllPhi[rich].at( phiB )[deltaTheta] ); ++( h_phiBinHists->ckResAllPhiPerQuad[rich][q].at( phiB )[deltaTheta] ); } - ++hb_ckResAllPerPanel[rich][side][deltaTheta]; + ++h_ckResAllPerPanel[rich][side][deltaTheta]; if ( rich == Rich::Rich2 ) { - ++hb_ckResAllPerRegion[region][deltaTheta]; - ++hb_ckResAllPerPanelPerRegion[side][region][deltaTheta]; + ++h_ckResAllPerRegion[region][deltaTheta]; + ++h_ckResAllPerPanelPerRegion[side][region][deltaTheta]; } if ( betaC ) { - ++hb_ckResAllBetaCut[rich][deltaTheta]; - ++hb_ckResAllPerPanelBetaCut[rich][side][deltaTheta]; + ++h_ckResAllBetaCut[rich][deltaTheta]; + ++h_ckResAllPerPanelBetaCut[rich][side][deltaTheta]; } // Mirror plots @@ -560,9 +544,9 @@ void SIMDPhotonCherenkovAngles::operator()( const LHCb::Track::Range& // Once support for these old samples is dropped this can be // changed to a full assert check. const std::size_t iCol = id.panelLocalModuleColumn(); - if ( iCol < hb_ckResAllPerCol[rich][side].size() ) { - ++hb_ckResAllPerCol[rich][side][iCol][deltaTheta]; - if ( rich == Rich::Rich2 ) { ++hb_ckResAllPerColPerRegion[side][iCol][region][deltaTheta]; } + if ( iCol < h_ckResAllPerCol[rich][side].size() ) { + ++h_ckResAllPerCol[rich][side][iCol][deltaTheta]; + if ( rich == Rich::Rich2 ) { ++h_ckResAllPerColPerRegion[side][iCol][region][deltaTheta]; } } } // valid scalars diff --git a/Rich/RichFutureRecMonitors/src/RichTrackGeometry.cpp b/Rich/RichFutureRecMonitors/src/RichTrackGeometry.cpp index 12aa89565cb1fc002e80190dd86973dd9b66617f..60fb54de366711b78e6bcec8a21357e8ad9258ae 100644 --- a/Rich/RichFutureRecMonitors/src/RichTrackGeometry.cpp +++ b/Rich/RichFutureRecMonitors/src/RichTrackGeometry.cpp @@ -60,22 +60,16 @@ namespace Rich::Future::Rec::Moni { /// Functional operator void operator()( const LHCb::RichTrackSegment::Vector& segments ) const override { - auto hb_tkPathL = h_tkPathL.buffer(); - auto hb_tkEntZ = h_tkEntZ.buffer(); - auto hb_tkExtZ = h_tkExtZ.buffer(); - auto hb_tkEntXY = h_tkEntXY.buffer(); - auto hb_tkExtXY = h_tkExtXY.buffer(); - // loop over the segments for ( const auto& segment : segments ) { // Which RICH const auto rich = segment.rich(); // fill histos - ++hb_tkPathL[rich][segment.pathLength()]; - ++hb_tkEntZ[rich][segment.entryPoint().Z()]; - ++hb_tkExtZ[rich][segment.exitPoint().Z()]; - ++hb_tkEntXY[rich][{ segment.entryPoint().X(), segment.entryPoint().Y() }]; - ++hb_tkExtXY[rich][{ segment.exitPoint().X(), segment.exitPoint().Y() }]; + ++h_tkPathL[rich][segment.pathLength()]; + ++h_tkEntZ[rich][segment.entryPoint().Z()]; + ++h_tkExtZ[rich][segment.exitPoint().Z()]; + ++h_tkEntXY[rich][{ segment.entryPoint().X(), segment.entryPoint().Y() }]; + ++h_tkExtXY[rich][{ segment.exitPoint().X(), segment.exitPoint().Y() }]; } } diff --git a/Rich/RichFutureRecMonitors/src/RichTrackRadiatorMaterial.cpp b/Rich/RichFutureRecMonitors/src/RichTrackRadiatorMaterial.cpp index 1c2dfef20989a270560d440c9eadbbbef35d7a4d..dcc47b675d36a25b048bccb49113f1982874b00b 100644 --- a/Rich/RichFutureRecMonitors/src/RichTrackRadiatorMaterial.cpp +++ b/Rich/RichFutureRecMonitors/src/RichTrackRadiatorMaterial.cpp @@ -129,11 +129,6 @@ void TrackRadiatorMaterial::operator()( LHCb::RichTrackSegment::Vector const& se auto tsCache = m_transSvc->createCache(); #endif - // local buffers - auto hb_EffL = h_EffL.buffer(); - auto hb_EffLOvPathL = h_EffLOvPathL.buffer(); - auto hb_PathL = h_PathL.buffer(); - // loop over segments for ( const auto& seg : segments ) { @@ -173,9 +168,9 @@ void TrackRadiatorMaterial::operator()( LHCb::RichTrackSegment::Vector const& se ); const auto effLOvL = ( length > 0 ? effL / length : 1e-7 ); // fill plots - ++hb_EffL[rich][std::log10( effL )]; - ++hb_EffLOvPathL[rich][std::log10( effLOvL )]; - ++hb_PathL[rich][length]; + ++h_EffL[rich][std::log10( effL )]; + ++h_EffLOvPathL[rich][std::log10( effLOvL )]; + ++h_PathL[rich][length]; } catch ( const TransportSvcException& excpt ) { ++m_radLwarn; _ri_debug << excpt.message() << endmsg; diff --git a/Rich/RichFutureRecMonitors/src/RichTrackSelEff.cpp b/Rich/RichFutureRecMonitors/src/RichTrackSelEff.cpp index 6a9afa10c4afe5d19f73a1e253615ece5d8d346f..371d5d297dbb24308744a0c2c9c83fbdb566208f 100644 --- a/Rich/RichFutureRecMonitors/src/RichTrackSelEff.cpp +++ b/Rich/RichFutureRecMonitors/src/RichTrackSelEff.cpp @@ -57,13 +57,6 @@ namespace Rich::Future::Rec::Moni { // Count selected tracks unsigned int nSelTracks( 0 ); - // local buffers - auto hb_effVP = h_effVP.buffer(); - auto hb_effVPt = h_effVPt.buffer(); - auto hb_effVChi2PDOF = h_effVChi2PDOF.buffer(); - auto hb_effVGhostProb = h_effVGhostProb.buffer(); - auto hb_effVCloneDist = h_effVCloneDist.buffer(); - // loop over input tracks for ( const auto* track : tracks ) { // Does this track have a PID result associated to it ? @@ -78,11 +71,11 @@ namespace Rich::Future::Rec::Moni { // Efficiencies plots const double richEff = ( sel ? 100.0 : 0.0 ); - hb_effVP[track->p()] += richEff; - hb_effVPt[track->pt()] += richEff; - hb_effVChi2PDOF[track->chi2PerDoF()] += richEff; - hb_effVGhostProb[track->ghostProbability()] += richEff; - hb_effVCloneDist[cloneDist] += richEff; + h_effVP[track->p()] += richEff; + h_effVPt[track->pt()] += richEff; + h_effVChi2PDOF[track->chi2PerDoF()] += richEff; + h_effVGhostProb[track->ghostProbability()] += richEff; + h_effVCloneDist[cloneDist] += richEff; } // fill event plots