Reference Manual

float float y

Definition: extBasic3DVector.h:14

float x

Definition: beamSpotDipStandalone.cc:55

◆ getInvRad2()

float mkfit::getInvRad2	(	float	x,
		float	y
	)

inline

Definition at line 32 of file Hit.h.

References x.

32 { return 1.0f / (x * x + y * y); }

float float y

Definition: extBasic3DVector.h:14

float x

Definition: beamSpotDipStandalone.cc:55

◆ getInvRadErr2()

float mkfit::getInvRadErr2	(	float	x,
		float	y,
		float	exx,
		float	eyy,
		float	exy
	)

inline

Definition at line 53 of file Hit.h.

References cube(), f, getRad2(), and x.

                                                                                 {
     return (x * x * exx + y * y * eyy + 2.0f * x * y * exy) / cube(getRad2(x, y));
   }

◆ getMatchBin()

int mkfit::getMatchBin ( const float pt )

inline

Definition at line 237 of file TrackExtra.cc.

References f, and DiDispStaMuonMonitor_cfi::pt.

Referenced by mkfit::TrackExtra::setCMSSWTrackIDInfoByTrkParams().

                                          {
     if (pt < 0.75f)
       return 0;
     else if (pt < 1.f)
       return 1;
     else if (pt < 2.f)
       return 2;
     else if (pt < 5.f)
       return 3;
     else if (pt < 10.f)
       return 4;
     else
       return 5;
   }

◆ getPhi()

float mkfit::getPhi	(	float	x,
		float	y
	)

inline

Definition at line 34 of file Hit.h.

References x.

Referenced by conformalFitMPlex(), mkfit::TrackState::convertFromCartesianToCCS(), mkfit::TrackState::convertFromGlbCurvilinearToCCS(), findSeedsByRoadSearch(), mkfit::Hit::phi(), mkfit::TrackState::posPhi(), mkfit::TrackBase::posPhi(), TrackFitter::run(), mkfit::MkFinder::selectHitIndices(), and HcalNumberingFromPS::unitID().

34 { return std::atan2(y, x); }

float float y

Definition: extBasic3DVector.h:14

float x

Definition: beamSpotDipStandalone.cc:55

◆ getPhiErr2()

float mkfit::getPhiErr2	(	float	x,
		float	y,
		float	exx,
		float	eyy,
		float	exy
	)

inline

Definition at line 57 of file Hit.h.

References f, getRad2(), and x.

Referenced by mkfit::Hit::ephi(), and mkfit::TrackState::eposPhi().

                                                                              {
     const float rad2 = getRad2(x, y);
     return (y * y * exx + x * x * eyy - 2.0f * x * y * exy) / (rad2 * rad2);
   }

◆ getPxPxErr2()

float mkfit::getPxPxErr2	(	float	ipt,
		float	phi,
		float	vipt,
		float	vphi
	)

inline

Definition at line 83 of file Hit.h.

References funct::cos(), and funct::sin().

Referenced by mkfit::TrackState::epxpx().

                                                                          {  // ipt = 1/pT, v = variance
     const float iipt2 = 1.0f / (ipt * ipt);                                 //iipt = 1/(1/pT) = pT
     const float cosP = std::cos(phi);
     const float sinP = std::sin(phi);
     return iipt2 * (iipt2 * cosP * cosP * vipt + sinP * sinP * vphi);
   }

◆ getPyPyErr2()

float mkfit::getPyPyErr2	(	float	ipt,
		float	phi,
		float	vipt,
		float	vphi
	)

inline

Definition at line 90 of file Hit.h.

References funct::cos(), and funct::sin().

Referenced by mkfit::TrackState::epypy(), and mkfit::TrackState::epzpz().

                                                                          {  // ipt = 1/pT, v = variance
     const float iipt2 = 1.0f / (ipt * ipt);                                 //iipt = 1/(1/pT) = pT
     const float cosP = std::cos(phi);
     const float sinP = std::sin(phi);
     return iipt2 * (iipt2 * sinP * sinP * vipt + cosP * cosP * vphi);
   }

◆ getPzPzErr2()

float mkfit::getPzPzErr2	(	float	ipt,
		float	theta,
		float	vipt,
		float	vtheta
	)

inline

Definition at line 97 of file Hit.h.

References funct::sin(), funct::tan(), and theta().

                                                                              {  // ipt = 1/pT, v = variance
     const float iipt2 = 1.0f / (ipt * ipt);                                     //iipt = 1/(1/pT) = pT
     const float cotT = 1.0f / std::tan(theta);
     const float cscT = 1.0f / std::sin(theta);
     return iipt2 * (iipt2 * cotT * cotT * vipt + cscT * cscT * cscT * cscT * vtheta);
   }

◆ getRad2()

float mkfit::getRad2	(	float	x,
		float	y
	)

inline

Definition at line 30 of file Hit.h.

References x.

Referenced by conformalFitMPlex(), findSeedsByRoadSearch(), getEtaErr2(), getInvRadErr2(), getPhiErr2(), getRadErr2(), and getThetaErr2().

30 { return x * x + y * y; }

float float y

Definition: extBasic3DVector.h:14

Referenced by mkfit::MkFinder::bkFitOutputTracks(), mkfit::MkBuilder::find_tracks_in_layers(), mkfit::MkFinder::findCandidates(), mkfit::CombCandidate::importSeed(), mkfit::CombCandidate::mergeCandsAndBestShortOne(), mkfit::Event::print_tracks(), mkfit::StdSeq::score_tracks(), and mkfit::TTreeValidation::setTrackScoresDumbCMSSW().

float x

Definition: beamSpotDipStandalone.cc:55

◆ getRadErr2()

float mkfit::getRadErr2	(	float	x,
		float	y,
		float	exx,
		float	eyy,
		float	exy
	)

inline

Definition at line 49 of file Hit.h.

References f, getRad2(), and x.

Referenced by mkfit::TrackState::eposR().

                                                                              {
     return (x * x * exx + y * y * eyy + 2.0f * x * y * exy) / getRad2(x, y);
   }

◆ getScoreCand() [1/2]

float mkfit::getScoreCand	(	const track_score_func &	score_func,
		const TrackCand &	cand1,
		bool	penalizeTailMissHits = `false`,
		bool	inFindCandidates = `false`
	)

inline

Definition at line 259 of file TrackStructures.h.

References mkfit::TrackBase::chi2(), nano_mu_local_reco_cff::chi2, mkfit::TrackCand::nFoundHits(), mkfit::TrackCand::nInsideMinusOneHits(), mkfit::TrackCand::nOverlapHits(), mkfit::TrackCand::nTailMinusOneHits(), DiDispStaMuonMonitor_cfi::pt, and mkfit::TrackBase::pT().

                                                            {
     int nfoundhits = cand1.nFoundHits();
     int noverlaphits = cand1.nOverlapHits();
     int nmisshits = cand1.nInsideMinusOneHits();
     int ntailmisshits = penalizeTailMissHits ? cand1.nTailMinusOneHits() : 0;
     float pt = cand1.pT();
     float chi2 = cand1.chi2();
     // Do not allow for chi2<0 in score calculation
     if (chi2 < 0)
       chi2 = 0.f;
     return score_func(nfoundhits, ntailmisshits, noverlaphits, nmisshits, chi2, pt, inFindCandidates);
   }

◆ getScoreCand() [2/2]

float mkfit::getScoreCand	(	const track_score_func &	score_func,
		const Track &	cand1,
		bool	penalizeTailMissHits = `false`,
		bool	inFindCandidates = `false`
	)

inline

Definition at line 601 of file Track.h.

References mkfit::TrackBase::chi2(), nano_mu_local_reco_cff::chi2, mkfit::Track::nFoundHits(), mkfit::Track::nInsideMinusOneHits(), mkfit::Track::nOverlapHits(), mkfit::Track::nTailMinusOneHits(), DiDispStaMuonMonitor_cfi::pt, and mkfit::TrackBase::pT().

                                                            {
     int nfoundhits = cand1.nFoundHits();
     int noverlaphits = cand1.nOverlapHits();
     int nmisshits = cand1.nInsideMinusOneHits();
     float ntailmisshits = penalizeTailMissHits ? cand1.nTailMinusOneHits() : 0;
     float pt = cand1.pT();
     float chi2 = cand1.chi2();
     // Do not allow for chi2<0 in score calculation
     if (chi2 < 0)
       chi2 = 0.f;
     return score_func(nfoundhits, ntailmisshits, noverlaphits, nmisshits, chi2, pt, inFindCandidates);
   }

◆ getScoreStruct()

float mkfit::getScoreStruct	(	const track_score_func &	score_func,
		const IdxChi2List &	cand1
	)

inline

Definition at line 617 of file Track.h.

References mkfit::IdxChi2List::chi2, nano_mu_local_reco_cff::chi2, mkfit::IdxChi2List::nhits, mkfit::IdxChi2List::nholes, mkfit::IdxChi2List::noverlaps, mkfit::IdxChi2List::ntailholes, mkfit::IdxChi2List::pt, and DiDispStaMuonMonitor_cfi::pt.

Referenced by mkfit::MkFinder::findCandidatesCloneEngine().

                                                                                             {
     int nfoundhits = cand1.nhits;
     int ntailholes = cand1.ntailholes;
     int noverlaphits = cand1.noverlaps;
     int nmisshits = cand1.nholes;
     float pt = cand1.pt;
     float chi2 = cand1.chi2;
     // Do not allow for chi2<0 in score calculation
     if (chi2 < 0)
       chi2 = 0.f;
     return score_func(nfoundhits, ntailholes, noverlaphits, nmisshits, chi2, pt, true /*inFindCandidates*/);
   }

◆ getScoreWorstPossible()

float mkfit::getScoreWorstPossible ( )

inline

Definition at line 597 of file Track.h.

References SiStripPI::max.

Referenced by mkfit::CombCandidate::reset(), and mkfit::TrackCand::resetShortTrack().

                                        {
     return -std::numeric_limits<float>::max();  // used for handling of best short track during finding
   }

◆ getTheta()

float mkfit::getTheta	(	float	r,
		float	z
	)

inline

Definition at line 36 of file Hit.h.

Referenced by conformalFitMPlex(), mkfit::TrackState::convertFromCartesianToCCS(), mkfit::TrackState::convertFromGlbCurvilinearToCCS(), and getEta().

36 { return std::atan2(r, z); }

detailsBasic3DVector::z

float float float z

Definition: extBasic3DVector.h:14

alignCSCRings.r

r

Definition: alignCSCRings.py:93

◆ getThetaErr2()

float mkfit::getThetaErr2	(	float	x,
		float	y,
		float	z,
		float	exx,
		float	eyy,
		float	ezz,
		float	exy,
		float	exz,
		float	eyz
	)

inline

Definition at line 62 of file Hit.h.

References getRad2(), mathSSE::sqrt(), and x.

                                                                                                    {
     const float rad2 = getRad2(x, y);
     const float rad = std::sqrt(rad2);
     const float hypot2 = rad2 + z * z;
     const float dthetadx = x * z / (rad * hypot2);
     const float dthetady = y * z / (rad * hypot2);
     const float dthetadz = -rad / hypot2;
     return dthetadx * dthetadx * exx + dthetady * dthetady * eyy + dthetadz * dthetadz * ezz +
            2.0f * dthetadx * dthetady * exy + 2.0f * dthetadx * dthetadz * exz + 2.0f * dthetady * dthetadz * eyz;
   }

◆ helixAtPlane()

void mkfit::helixAtPlane	(	const MPlexLV &	inPar,
		const MPlexQI &	inChg,
		const MPlexHV &	plPnt,
		const MPlexHV &	plNrm,
		MPlexQF &	pathL,
		MPlexLV &	outPar,
		MPlexLL &	errorProp,
		MPlexQI &	outFailFlag,
		const int	N_proc,
		const PropagationFlags &	pflags
	)

Definition at line 1074 of file PropagationMPlex.cc.

References f, and NN.

Referenced by propagateHelixToPlaneMPlex().

                                                     {
     errorProp.setVal(0.f);
     outFailFlag.setVal(0.f);
 
     helixAtPlane_impl(inPar, inChg, plPnt, plNrm, pathL, outPar, errorProp, outFailFlag, 0, NN, N_proc, pflags);
   }

◆ helixAtRFromIterativeCCS()

void mkfit::helixAtRFromIterativeCCS	(	const MPlexLV &	inPar,
		const MPlexQI &	inChg,
		const MPlexQF &	msRad,
		MPlexLV &	outPar,
		MPlexLL &	errorProp,
		MPlexQI &	outFailFlag,
		const int	N_proc,
		const PropagationFlags &	pflags
	)

Definition at line 484 of file PropagationMPlex.cc.

References f, and NN.

Referenced by propagateHelixToRMPlex().

                                                                 {
     errorProp.setVal(0.f);
     outFailFlag.setVal(0.f);
 
     helixAtRFromIterativeCCS_impl(inPar, inChg, msRad, outPar, errorProp, outFailFlag, 0, NN, N_proc, pflags);
   }

◆ helixAtRFromIterativeCCSFullJac() [1/2]

void mkfit::helixAtRFromIterativeCCSFullJac	(	const MPlexLV &	inPar,
		const MPlexQI &	inChg,
		const MPlexQF &	msRad,
		MPlexLV &	outPar,
		MPlexLL &	errorProp,
		MPlexQI &	outFailFlag,
		const int	N_proc
	)

◆ helixAtRFromIterativeCCSFullJac() [2/2]

void mkfit::helixAtRFromIterativeCCSFullJac	(	const MPlexLV &	inPar,
		const MPlexQI &	inChg,
		const MPlexQF &	msRad,
		MPlexLV &	outPar,
		MPlexLL &	errorProp,
		const int	N_proc
	)

Definition at line 296 of file PropagationMPlex.cc.

References funct::abs(), mkfit::Config::Bfield, CMS_UNROLL_LOOP_COUNT, ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), funct::cos(), gather_cfg::cout, debug, dprint_np, f, g_debug, hipo(), mps_fire::i, dqmdumpme::k, dqmiodumpmetadata::n, mkfit::Config::Niter, NN, funct::sin(), sincos4(), mkfit::Const::sol, mathSSE::sqrt(), funct::tan(), theta(), and mkfit::Config::useTrigApprox.

                                                          {
     errorProp.setVal(0.f);
     MPlexLL errorPropTmp(0.f);   //initialize to zero
     MPlexLL errorPropSwap(0.f);  //initialize to zero
 
     // loop does not vectorize with llvm16, and it issues a warning
     // that apparently can't be suppressed with a pragma.  Needs to
     // be rechecked if future llvm versions improve vectorization.
 #if !defined(__clang__)
 #pragma omp simd
 #endif
     for (int n = 0; n < NN; ++n) {
       //initialize erroProp to identity matrix
       errorProp(n, 0, 0) = 1.f;
       errorProp(n, 1, 1) = 1.f;
       errorProp(n, 2, 2) = 1.f;
       errorProp(n, 3, 3) = 1.f;
       errorProp(n, 4, 4) = 1.f;
       errorProp(n, 5, 5) = 1.f;
 
       const float k = inChg.constAt(n, 0, 0) * 100.f / (-Const::sol * Config::Bfield);
       const float r = msRad.constAt(n, 0, 0);
       float r0 = hipo(inPar.constAt(n, 0, 0), inPar.constAt(n, 1, 0));
 
       if (std::abs(r - r0) < 0.0001f) {
         dprint_np(n, "distance less than 1mum, skip");
         continue;
       }
 
       const float ipt = inPar.constAt(n, 3, 0);
       const float phiin = inPar.constAt(n, 4, 0);
       const float theta = inPar.constAt(n, 5, 0);
 
       //set those that are 1. before iterations
       errorPropTmp(n, 2, 2) = 1.f;
       errorPropTmp(n, 3, 3) = 1.f;
       errorPropTmp(n, 4, 4) = 1.f;
       errorPropTmp(n, 5, 5) = 1.f;
 
       float cosah = 0., sinah = 0.;
       //no trig approx here, phi and theta can be large
       float cosP = std::cos(phiin), sinP = std::sin(phiin);
       const float cosT = std::cos(theta), sinT = std::sin(theta);
       float pxin = cosP / ipt;
       float pyin = sinP / ipt;
 
       CMS_UNROLL_LOOP_COUNT(Config::Niter)
       for (int i = 0; i < Config::Niter; ++i) {
         dprint_np(n,
                   std::endl
                       << "attempt propagation from r=" << r0 << " to r=" << r << std::endl
                       << "x=" << outPar.At(n, 0, 0) << " y=" << outPar.At(n, 1, 0) << " z=" << outPar.At(n, 2, 0)
                       << " px=" << std::cos(phiin) / ipt << " py=" << std::sin(phiin) / ipt
                       << " pz=" << 1.f / (ipt * tan(theta)) << " q=" << inChg.constAt(n, 0, 0) << std::endl);
 
         r0 = hipo(outPar.constAt(n, 0, 0), outPar.constAt(n, 1, 0));
         const float ialpha = (r - r0) * ipt / k;
         //alpha+=ialpha;
 
         if constexpr (Config::useTrigApprox) {
           sincos4(ialpha * 0.5f, sinah, cosah);
         } else {
           cosah = std::cos(ialpha * 0.5f);
           sinah = std::sin(ialpha * 0.5f);
         }
         const float cosa = 1.f - 2.f * sinah * sinah;
         const float sina = 2.f * sinah * cosah;
 
         //derivatives of alpha
         const float dadx = -outPar.At(n, 0, 0) * ipt / (k * r0);
         const float dady = -outPar.At(n, 1, 0) * ipt / (k * r0);
         const float dadipt = (r - r0) / k;
 
         outPar.At(n, 0, 0) = outPar.constAt(n, 0, 0) + 2.f * k * sinah * (pxin * cosah - pyin * sinah);
         outPar.At(n, 1, 0) = outPar.constAt(n, 1, 0) + 2.f * k * sinah * (pyin * cosah + pxin * sinah);
         const float pxinold = pxin;  //copy before overwriting
         pxin = pxin * cosa - pyin * sina;
         pyin = pyin * cosa + pxinold * sina;
 
         //need phi at origin, so this goes before redefining phi
         //no trig approx here, phi can be large
         cosP = std::cos(outPar.At(n, 4, 0));
         sinP = std::sin(outPar.At(n, 4, 0));
 
         outPar.At(n, 2, 0) = outPar.constAt(n, 2, 0) + k * ialpha * cosT / (ipt * sinT);
         outPar.At(n, 3, 0) = ipt;
         outPar.At(n, 4, 0) = outPar.constAt(n, 4, 0) + ialpha;
         outPar.At(n, 5, 0) = theta;
 
         errorPropTmp(n, 0, 0) = 1.f + k * (cosP * dadx * cosa - sinP * dadx * sina) / ipt;
         errorPropTmp(n, 0, 1) = k * (cosP * dady * cosa - sinP * dady * sina) / ipt;
         errorPropTmp(n, 0, 3) =
             k * (cosP * (ipt * dadipt * cosa - sina) + sinP * ((1.f - cosa) - ipt * dadipt * sina)) / (ipt * ipt);
         errorPropTmp(n, 0, 4) = -k * (sinP * sina + cosP * (1.f - cosa)) / ipt;
 
         errorPropTmp(n, 1, 0) = k * (sinP * dadx * cosa + cosP * dadx * sina) / ipt;
         errorPropTmp(n, 1, 1) = 1.f + k * (sinP * dady * cosa + cosP * dady * sina) / ipt;
         errorPropTmp(n, 1, 3) =
             k * (sinP * (ipt * dadipt * cosa - sina) + cosP * (ipt * dadipt * sina - (1.f - cosa))) / (ipt * ipt);
         errorPropTmp(n, 1, 4) = k * (cosP * sina - sinP * (1.f - cosa)) / ipt;
 
         errorPropTmp(n, 2, 0) = k * cosT * dadx / (ipt * sinT);
         errorPropTmp(n, 2, 1) = k * cosT * dady / (ipt * sinT);
         errorPropTmp(n, 2, 3) = k * cosT * (ipt * dadipt - ialpha) / (ipt * ipt * sinT);
         errorPropTmp(n, 2, 5) = -k * ialpha / (ipt * sinT * sinT);
 
         errorPropTmp(n, 4, 0) = dadx;
         errorPropTmp(n, 4, 1) = dady;
         errorPropTmp(n, 4, 3) = dadipt;
 
         MultHelixPropTemp(errorProp, errorPropTmp, errorPropSwap, n);
         errorProp = errorPropSwap;
       }
 
       dprint_np(
           n,
           "propagation end, dump parameters"
               << std::endl
               << "pos = " << outPar.At(n, 0, 0) << " " << outPar.At(n, 1, 0) << " " << outPar.At(n, 2, 0) << std::endl
               << "mom = " << std::cos(outPar.At(n, 4, 0)) / outPar.At(n, 3, 0) << " "
               << std::sin(outPar.At(n, 4, 0)) / outPar.At(n, 3, 0) << " "
               << 1. / (outPar.At(n, 3, 0) * tan(outPar.At(n, 5, 0)))
               << " r=" << std::sqrt(outPar.At(n, 0, 0) * outPar.At(n, 0, 0) + outPar.At(n, 1, 0) * outPar.At(n, 1, 0))
               << " pT=" << 1. / std::abs(outPar.At(n, 3, 0)) << std::endl);
 
 #ifdef DEBUG
       if (debug && g_debug && n < N_proc) {
         dmutex_guard;
         std::cout << n << " jacobian" << std::endl;
         printf("%5f %5f %5f %5f %5f %5f\n",
                errorProp(n, 0, 0),
                errorProp(n, 0, 1),
                errorProp(n, 0, 2),
                errorProp(n, 0, 3),
                errorProp(n, 0, 4),
                errorProp(n, 0, 5));
         printf("%5f %5f %5f %5f %5f %5f\n",
                errorProp(n, 1, 0),
                errorProp(n, 1, 1),
                errorProp(n, 1, 2),
                errorProp(n, 1, 3),
                errorProp(n, 1, 4),
                errorProp(n, 1, 5));
         printf("%5f %5f %5f %5f %5f %5f\n",
                errorProp(n, 2, 0),
                errorProp(n, 2, 1),
                errorProp(n, 2, 2),
                errorProp(n, 2, 3),
                errorProp(n, 2, 4),
                errorProp(n, 2, 5));
         printf("%5f %5f %5f %5f %5f %5f\n",
                errorProp(n, 3, 0),
                errorProp(n, 3, 1),
                errorProp(n, 3, 2),
                errorProp(n, 3, 3),
                errorProp(n, 3, 4),
                errorProp(n, 3, 5));
         printf("%5f %5f %5f %5f %5f %5f\n",
                errorProp(n, 4, 0),
                errorProp(n, 4, 1),
                errorProp(n, 4, 2),
                errorProp(n, 4, 3),
                errorProp(n, 4, 4),
                errorProp(n, 4, 5));
         printf("%5f %5f %5f %5f %5f %5f\n",
                errorProp(n, 5, 0),
                errorProp(n, 5, 1),
                errorProp(n, 5, 2),
                errorProp(n, 5, 3),
                errorProp(n, 5, 4),
                errorProp(n, 5, 5));
       }
 #endif
     }
   }

◆ helixAtZ()

void mkfit::helixAtZ	(	const MPlexLV &	inPar,
		const MPlexQI &	inChg,
		const MPlexQF &	msZ,
		MPlexLV &	outPar,
		MPlexLL &	errorProp,
		MPlexQI &	outFailFlag,
		const int	N_proc,
		const PropagationFlags &	pflags
	)

Definition at line 752 of file PropagationMPlex.cc.

References funct::abs(), simBeamSpotPI::alpha, mkfit::Config::Bfield, mkfit::Config::bFieldFromZR(), ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), funct::cos(), gather_cfg::cout, debug, l1tTrackerHTMiss_cfi::deltaZ, dprint_np, f, g_debug, hipo(), dqmdumpme::k, dqmiodumpmetadata::n, NN, DiDispStaMuonMonitor_cfi::pt, funct::sin(), sincos4(), mkfit::Const::sol, mathSSE::sqrt(), funct::tan(), theta(), mkfit::PropagationFlags::use_param_b_field, and mkfit::Config::useTrigApprox.

Referenced by propagateHelixToZMPlex().

                                                 {
     errorProp.setVal(0.f);
     outFailFlag.setVal(0.f);
 
     // debug = true;
 #pragma omp simd
     for (int n = 0; n < NN; ++n) {
       //initialize erroProp to identity matrix, except element 2,2 which is zero
       errorProp(n, 0, 0) = 1.f;
       errorProp(n, 1, 1) = 1.f;
       errorProp(n, 3, 3) = 1.f;
       errorProp(n, 4, 4) = 1.f;
       errorProp(n, 5, 5) = 1.f;
     }
     float zout[NN];
     float zin[NN];
     float ipt[NN];
     float phiin[NN];
     float theta[NN];
 #pragma omp simd
     for (int n = 0; n < NN; ++n) {
       //initialize erroProp to identity matrix, except element 2,2 which is zero
       zout[n] = msZ.constAt(n, 0, 0);
       zin[n] = inPar.constAt(n, 2, 0);
       ipt[n] = inPar.constAt(n, 3, 0);
       phiin[n] = inPar.constAt(n, 4, 0);
       theta[n] = inPar.constAt(n, 5, 0);
     }
 
     float k[NN];
     if (pflags.use_param_b_field) {
 #pragma omp simd
       for (int n = 0; n < NN; ++n) {
         k[n] = inChg.constAt(n, 0, 0) * 100.f /
                (-Const::sol * Config::bFieldFromZR(zin[n], hipo(inPar.constAt(n, 0, 0), inPar.constAt(n, 1, 0))));
       }
     } else {
 #pragma omp simd
       for (int n = 0; n < NN; ++n) {
         k[n] = inChg.constAt(n, 0, 0) * 100.f / (-Const::sol * Config::Bfield);
       }
     }
 
     float kinv[NN];
 #pragma omp simd
     for (int n = 0; n < NN; ++n) {
       kinv[n] = 1.f / k[n];
     }
 
 #pragma omp simd
     for (int n = 0; n < NN; ++n) {
       dprint_np(n,
                 std::endl
                     << "input parameters"
                     << " inPar.constAt(n, 0, 0)=" << std::setprecision(9) << inPar.constAt(n, 0, 0)
                     << " inPar.constAt(n, 1, 0)=" << std::setprecision(9) << inPar.constAt(n, 1, 0)
                     << " inPar.constAt(n, 2, 0)=" << std::setprecision(9) << inPar.constAt(n, 2, 0)
                     << " inPar.constAt(n, 3, 0)=" << std::setprecision(9) << inPar.constAt(n, 3, 0)
                     << " inPar.constAt(n, 4, 0)=" << std::setprecision(9) << inPar.constAt(n, 4, 0)
                     << " inPar.constAt(n, 5, 0)=" << std::setprecision(9) << inPar.constAt(n, 5, 0)
                     << " inChg.constAt(n, 0, 0)=" << std::setprecision(9) << inChg.constAt(n, 0, 0));
     }
 #pragma omp simd
     for (int n = 0; n < NN; ++n) {
       dprint_np(n,
                 "propagation start, dump parameters"
                     << std::endl
                     << "pos = " << inPar.constAt(n, 0, 0) << " " << inPar.constAt(n, 1, 0) << " "
                     << inPar.constAt(n, 2, 0) << std::endl
                     << "mom (cart) = " << std::cos(inPar.constAt(n, 4, 0)) / inPar.constAt(n, 3, 0) << " "
                     << std::sin(inPar.constAt(n, 4, 0)) / inPar.constAt(n, 3, 0) << " "
                     << 1. / (inPar.constAt(n, 3, 0) * tan(inPar.constAt(n, 5, 0))) << " r="
                     << std::sqrt(inPar.constAt(n, 0, 0) * inPar.constAt(n, 0, 0) +
                                  inPar.constAt(n, 1, 0) * inPar.constAt(n, 1, 0))
                     << " pT=" << 1. / std::abs(inPar.constAt(n, 3, 0)) << " q=" << inChg.constAt(n, 0, 0)
                     << " targetZ=" << msZ.constAt(n, 0, 0) << std::endl);
     }
 
     float pt[NN];
 #pragma omp simd
     for (int n = 0; n < NN; ++n) {
       pt[n] = 1.f / ipt[n];
     }
 
     //no trig approx here, phi can be large
     float cosP[NN];
     float sinP[NN];
 #pragma omp simd
     for (int n = 0; n < NN; ++n) {
       cosP[n] = std::cos(phiin[n]);
     }
 
 #pragma omp simd
     for (int n = 0; n < NN; ++n) {
       sinP[n] = std::sin(phiin[n]);
     }
 
     float cosT[NN];
     float sinT[NN];
 #pragma omp simd
     for (int n = 0; n < NN; ++n) {
       cosT[n] = std::cos(theta[n]);
     }
 
 #pragma omp simd
     for (int n = 0; n < NN; ++n) {
       sinT[n] = std::sin(theta[n]);
     }
 
     float tanT[NN];
     float icos2T[NN];
     float pxin[NN];
     float pyin[NN];
 #pragma omp simd
     for (int n = 0; n < NN; ++n) {
       tanT[n] = sinT[n] / cosT[n];
       icos2T[n] = 1.f / (cosT[n] * cosT[n]);
       pxin[n] = cosP[n] * pt[n];
       pyin[n] = sinP[n] * pt[n];
     }
 
     float deltaZ[NN];
     float alpha[NN];
 #pragma omp simd
     for (int n = 0; n < NN; ++n) {
       deltaZ[n] = zout[n] - zin[n];
       alpha[n] = deltaZ[n] * tanT[n] * ipt[n] * kinv[n];
     }
 
     float cosahTmp[NN];
     float sinahTmp[NN];
     if constexpr (Config::useTrigApprox) {
 #if !defined(__INTEL_COMPILER)
 #pragma omp simd
 #endif
       for (int n = 0; n < NN; ++n) {
         sincos4(alpha[n] * 0.5f, sinahTmp[n], cosahTmp[n]);
       }
     } else {
 #if !defined(__INTEL_COMPILER)
 #pragma omp simd
 #endif
       for (int n = 0; n < NN; ++n) {
         cosahTmp[n] = std::cos(alpha[n] * 0.5f);
       }
 #if !defined(__INTEL_COMPILER)
 #pragma omp simd
 #endif
       for (int n = 0; n < NN; ++n) {
         sinahTmp[n] = std::sin(alpha[n] * 0.5f);
       }
     }
 
     float cosah[NN];
     float sinah[NN];
     float cosa[NN];
     float sina[NN];
 #pragma omp simd
     for (int n = 0; n < NN; ++n) {
       cosah[n] = cosahTmp[n];
       sinah[n] = sinahTmp[n];
       cosa[n] = 1.f - 2.f * sinah[n] * sinah[n];
       sina[n] = 2.f * sinah[n] * cosah[n];
     }
 
 //update parameters
 #pragma omp simd
     for (int n = 0; n < NN; ++n) {
       outPar.At(n, 0, 0) = outPar.At(n, 0, 0) + 2.f * k[n] * sinah[n] * (pxin[n] * cosah[n] - pyin[n] * sinah[n]);
       outPar.At(n, 1, 0) = outPar.At(n, 1, 0) + 2.f * k[n] * sinah[n] * (pyin[n] * cosah[n] + pxin[n] * sinah[n]);
       outPar.At(n, 2, 0) = zout[n];
       outPar.At(n, 4, 0) = phiin[n] + alpha[n];
     }
 
 #pragma omp simd
     for (int n = 0; n < NN; ++n) {
       dprint_np(n,
                 "propagation to Z end (OLD), dump parameters\n"
                     << "   pos = " << outPar(n, 0, 0) << " " << outPar(n, 1, 0) << " " << outPar(n, 2, 0) << "\t\t r="
                     << std::sqrt(outPar(n, 0, 0) * outPar(n, 0, 0) + outPar(n, 1, 0) * outPar(n, 1, 0)) << std::endl
                     << "   mom = " << outPar(n, 3, 0) << " " << outPar(n, 4, 0) << " " << outPar(n, 5, 0) << std::endl
                     << " cart= " << std::cos(outPar(n, 4, 0)) / outPar(n, 3, 0) << " "
                     << std::sin(outPar(n, 4, 0)) / outPar(n, 3, 0) << " "
                     << 1. / (outPar(n, 3, 0) * tan(outPar(n, 5, 0))) << "\t\tpT=" << 1. / std::abs(outPar(n, 3, 0))
                     << std::endl);
     }
 
     float pxcaMpysa[NN];
 #pragma omp simd
     for (int n = 0; n < NN; ++n) {
       pxcaMpysa[n] = pxin[n] * cosa[n] - pyin[n] * sina[n];
     }
 
 #pragma omp simd
     for (int n = 0; n < NN; ++n) {
       errorProp(n, 0, 2) = -tanT[n] * ipt[n] * pxcaMpysa[n];
       errorProp(n, 0, 3) =
           k[n] * pt[n] * pt[n] *
           (cosP[n] * (alpha[n] * cosa[n] - sina[n]) + sinP[n] * 2.f * sinah[n] * (sinah[n] - alpha[n] * cosah[n]));
       errorProp(n, 0, 4) = -2.f * k[n] * pt[n] * sinah[n] * (sinP[n] * cosah[n] + cosP[n] * sinah[n]);
       errorProp(n, 0, 5) = deltaZ[n] * ipt[n] * pxcaMpysa[n] * icos2T[n];
     }
 
     float pycaPpxsa[NN];
 #pragma omp simd
     for (int n = 0; n < NN; ++n) {
       pycaPpxsa[n] = pyin[n] * cosa[n] + pxin[n] * sina[n];
     }
 
 #pragma omp simd
     for (int n = 0; n < NN; ++n) {
       errorProp(n, 1, 2) = -tanT[n] * ipt[n] * pycaPpxsa[n];
       errorProp(n, 1, 3) =
           k[n] * pt[n] * pt[n] *
           (sinP[n] * (alpha[n] * cosa[n] - sina[n]) - cosP[n] * 2.f * sinah[n] * (sinah[n] - alpha[n] * cosah[n]));
       errorProp(n, 1, 4) = 2.f * k[n] * pt[n] * sinah[n] * (cosP[n] * cosah[n] - sinP[n] * sinah[n]);
       errorProp(n, 1, 5) = deltaZ[n] * ipt[n] * pycaPpxsa[n] * icos2T[n];
     }
 
 #pragma omp simd
     for (int n = 0; n < NN; ++n) {
       errorProp(n, 4, 2) = -ipt[n] * tanT[n] * kinv[n];
       errorProp(n, 4, 3) = tanT[n] * deltaZ[n] * kinv[n];
       errorProp(n, 4, 5) = ipt[n] * deltaZ[n] * kinv[n] * icos2T[n];
     }
 
 #pragma omp simd
     for (int n = 0; n < NN; ++n) {
       dprint_np(
           n,
           "propagation end, dump parameters"
               << std::endl
               << "pos = " << outPar.At(n, 0, 0) << " " << outPar.At(n, 1, 0) << " " << outPar.At(n, 2, 0) << std::endl
               << "mom (cart) = " << std::cos(outPar.At(n, 4, 0)) / outPar.At(n, 3, 0) << " "
               << std::sin(outPar.At(n, 4, 0)) / outPar.At(n, 3, 0) << " "
               << 1. / (outPar.At(n, 3, 0) * tan(outPar.At(n, 5, 0)))
               << " r=" << std::sqrt(outPar.At(n, 0, 0) * outPar.At(n, 0, 0) + outPar.At(n, 1, 0) * outPar.At(n, 1, 0))
               << " pT=" << 1. / std::abs(outPar.At(n, 3, 0)) << std::endl);
     }
 
     // PROP-FAIL-ENABLE Disabled to keep physics changes minimal.
     // To be reviewed, enabled and processed accordingly elsewhere.
     /*
     // Check for errors, set fail-flag.
     for (int n = 0; n < NN; ++n) {
       // We propagate for alpha: mark fail when prop angle more than pi/2
       if (std::abs(alpha[n]) > 1.57) {
         dprintf("helixAtZ: more than quarter turn, alpha = %f\n", alpha[n]);
         outFailFlag[n] = 1;
       } else {
         // Have we reached desired z? We can't know, we copy desired z to actual z.
         // Are we close to apex? Same condition as in propToR, 12.5 deg, cos(78.5deg) = 0.2
         float dotp = (outPar.At(n, 0, 0) * std::cos(outPar.At(n, 4, 0)) +
                       outPar.At(n, 1, 0) * std::sin(outPar.At(n, 4, 0))) /
                      std::hypot(outPar.At(n, 0, 0), outPar.At(n, 1, 0));
         if (dotp < 0.2 || dotp < 0) {
           dprintf("helixAtZ: dot product bad, dotp = %f\n", dotp);
           outFailFlag[n] = 1;
         }
       }
     }
     */
 
 #ifdef DEBUG
     if (debug && g_debug) {
       for (int n = 0; n < N_proc; ++n) {
         dmutex_guard;
         std::cout << n << ": jacobian" << std::endl;
         printf("%5f %5f %5f %5f %5f %5f\n",
                errorProp(n, 0, 0),
                errorProp(n, 0, 1),
                errorProp(n, 0, 2),
                errorProp(n, 0, 3),
                errorProp(n, 0, 4),
                errorProp(n, 0, 5));
         printf("%5f %5f %5f %5f %5f %5f\n",
                errorProp(n, 1, 0),
                errorProp(n, 1, 1),
                errorProp(n, 1, 2),
                errorProp(n, 1, 3),
                errorProp(n, 1, 4),
                errorProp(n, 1, 5));
         printf("%5f %5f %5f %5f %5f %5f\n",
                errorProp(n, 2, 0),
                errorProp(n, 2, 1),
                errorProp(n, 2, 2),
                errorProp(n, 2, 3),
                errorProp(n, 2, 4),
                errorProp(n, 2, 5));
         printf("%5f %5f %5f %5f %5f %5f\n",
                errorProp(n, 3, 0),
                errorProp(n, 3, 1),
                errorProp(n, 3, 2),
                errorProp(n, 3, 3),
                errorProp(n, 3, 4),
                errorProp(n, 3, 5));
         printf("%5f %5f %5f %5f %5f %5f\n",
                errorProp(n, 4, 0),
                errorProp(n, 4, 1),
                errorProp(n, 4, 2),
                errorProp(n, 4, 3),
                errorProp(n, 4, 4),
                errorProp(n, 4, 5));
         printf("%5f %5f %5f %5f %5f %5f\n",
                errorProp(n, 5, 0),
                errorProp(n, 5, 1),
                errorProp(n, 5, 2),
                errorProp(n, 5, 3),
                errorProp(n, 5, 4),
                errorProp(n, 5, 5));
       }
     }
 #endif
   }

◆ hipo()

float mkfit::hipo	(	float	x,
		float	y
	)

inline

Definition at line 9 of file Matrix.h.

References mathSSE::sqrt(), and x.

Referenced by conformalFitMPlex(), helixAtRFromIterativeCCSFullJac(), helixAtZ(), propagateHelixToRMPlex(), propagateLineToRMPlex(), and mkfit::MkBase::radius().

9 { return std::sqrt(x * x + y * y); }

mathSSE::sqrt

T sqrt(T t)

Definition: SSEVec.h:19

float float y

Definition: extBasic3DVector.h:14

float x

Definition: beamSpotDipStandalone.cc:55

◆ hipo_sqr()

float mkfit::hipo_sqr	(	float	x,
		float	y
	)

inline

Definition at line 11 of file Matrix.h.

References x.

Referenced by mkfit::MkBase::radiusSqr().

11 { return x * x + y * y; }

float float y

Definition: extBasic3DVector.h:14

References analysisFilters_cff::algorithms, mkfit::Config::backwardFit, mkfit::MkBuilder::backwardFitBH(), mkfit::MkBuilder::begin_event(), mkfit::Config::cmssw_val, dtime(), mkfit::MkBuilder::end_event(), makeMEIFBenchmarkPlots::ev, spr::find(), mkfit::MkBuilder::find_tracks_load_seeds_BH(), mkfit::MkBuilder::findTracksBestHit(), mkfit::Config::ItrInfo, mkfit::IterationMaskIfc::m_mask_vector, mkfit::IterationConfig::m_track_algorithm, mkfit::StdSeq::Quality::quality_val(), mkfit::Config::quality_val, mkfit::MkBuilder::ref_tracks(), mkfit::EventOfHits::refBeamSpot(), mkfit::StdSeq::root_val(), alignCSCRings::s, mkfit::Config::sim_val, hcalRecHitTable_cff::time, and mkfit::Config::TrkInfo.

float x

Definition: beamSpotDipStandalone.cc:55

◆ hit2pos()

RVec mkfit::hit2pos ( const Hit & h )

Definition at line 24 of file RntConversions.h.

References h.

Referenced by mkfit::MkFinder::selectHitIndicesV2().

24 { return {h.x(), h.y(), h.z()}; }

h

The Signals That Services Can Subscribe To This is based on ActivityRegistry h

Helper function to determine trigger accepts.

Definition: Activities.doc:4

◆ intersectThirdLayer()

void mkfit::intersectThirdLayer	(	const float	a,
		const float	b,
		const float	hit1_x,
		const float	hit1_y,
		float &	lay2_x,
		float &	lay2_y
	)

inline

Definition at line 9 of file seedtestMPlex.cc.

References a, testProducerWithPsetDescEmpty_cfi::a2, b, b2, f, getHypot(), mkfit::Config::maxCurvR, and mathSSE::sqrt().

Referenced by findSeedsByRoadSearch().

                                                                                                           {
     const float a2 = a * a;
     const float b2 = b * b;
     const float a2b2 = a2 + b2;
     const float lay2rad2 = (Config::fRadialSpacing * Config::fRadialSpacing) * 9.0f;  // average third radius squared
     const float maxCurvR2 = Config::maxCurvR * Config::maxCurvR;
 
     const float quad =
         std::sqrt(2.0f * maxCurvR2 * (a2b2 + lay2rad2) - (a2b2 - lay2rad2) * (a2b2 - lay2rad2) - maxCurvR2 * maxCurvR2);
     const float pos[2] = {(a2 * a + a * (b2 + lay2rad2 - maxCurvR2) - b * quad) / a2b2,
                           (b2 * b + b * (a2 + lay2rad2 - maxCurvR2) + a * quad) / a2b2};
     const float neg[2] = {(a2 * a + a * (b2 + lay2rad2 - maxCurvR2) + b * quad) / a2b2,
                           (b2 * b + b * (a2 + lay2rad2 - maxCurvR2) - a * quad) / a2b2};
 
     // since we have two intersection points, arbitrate which one is closer to layer2 hit
     if (getHypot(pos[0] - hit1_x, pos[1] - hit1_y) < getHypot(neg[0] - hit1_x, neg[1] - hit1_y)) {
       lay2_x = pos[0];
       lay2_y = pos[1];
     } else {
       lay2_x = neg[0];
       lay2_y = neg[1];
     }
   }

◆ isFinite()

constexpr bool mkfit::isFinite ( float x )

Definition at line 13 of file cms_common_macros.h.

References ztail::d, edm::isFinite(), MainPageGenerator::l, ALPAKA_ACCELERATOR_NAMESPACE::pixelClustering::pixelStatus::mask, findQualityFiles::v, and x.

Referenced by mkfit::MkFinder::bkFitOutputTracks(), mkfit::TrackBase::hasNanNSillyValues(), mkfit::TrackBase::hasSillyValues(), and mkfit::MkFinder::selectHitIndices().

                                    {
 #ifdef MKFIT_STANDALONE
     const unsigned int mask = 0x7f800000;
     union {
       unsigned int l;
       float d;
     } v = {.d = x};
     return (v.l & mask) != mask;
 #else
     return edm::isFinite(x);
 #endif
   }

◆ isStripQCompatible()

bool mkfit::isStripQCompatible	(	int	itrack,
		bool	isBarrel,
		const MPlexLS &	pErr,
		const MPlexLV &	pPar,
		const MPlexHS &	msErr,
		const MPlexHV &	msPar
	)

Definition at line 1273 of file MkFinder.cc.

References funct::abs(), dprint, f, PixelPluginsPhase0_cfi::isBarrel, SiStripPI::max, amptDefault_cfi::proj, and mathSSE::sqrt().

Referenced by mkfit::MkFinder::findCandidates(), and mkfit::MkFinder::findCandidatesCloneEngine().

                                                                                                                        {
     //check module compatibility via long strip side = L/sqrt(12)
     if (isBarrel) {  //check z direction only
       const float res = std::abs(msPar.constAt(itrack, 2, 0) - pPar.constAt(itrack, 2, 0));
       const float hitHL = sqrt(msErr.constAt(itrack, 2, 2) * 3.f);  //half-length
       const float qErr = sqrt(pErr.constAt(itrack, 2, 2));
       dprint("qCompat " << hitHL << " + " << 3.f * qErr << " vs " << res);
       return hitHL + std::max(3.f * qErr, 0.5f) > res;
     } else {  //project on xy, assuming the strip Length >> Width
       const float res[2]{msPar.constAt(itrack, 0, 0) - pPar.constAt(itrack, 0, 0),
                          msPar.constAt(itrack, 1, 0) - pPar.constAt(itrack, 1, 0)};
       const float hitT2 = msErr.constAt(itrack, 0, 0) + msErr.constAt(itrack, 1, 1);
       const float hitT2inv = 1.f / hitT2;
       const float proj[3] = {msErr.constAt(itrack, 0, 0) * hitT2inv,
                              msErr.constAt(itrack, 0, 1) * hitT2inv,
                              msErr.constAt(itrack, 1, 1) * hitT2inv};
       const float qErr =
           sqrt(std::abs(pErr.constAt(itrack, 0, 0) * proj[0] + 2.f * pErr.constAt(itrack, 0, 1) * proj[1] +
                         pErr.constAt(itrack, 1, 1) * proj[2]));  //take abs to avoid non-pos-def cases
       const float resProj =
           sqrt(res[0] * proj[0] * res[0] + 2.f * res[1] * proj[1] * res[0] + res[1] * proj[2] * res[1]);
       dprint("qCompat " << sqrt(hitT2 * 3.f) << " + " << 3.f * qErr << " vs " << resProj);
       return sqrt(hitT2 * 3.f) + std::max(3.f * qErr, 0.5f) > resProj;
     }
   }

◆ kalmanComputeChi2()

void mkfit::kalmanComputeChi2	(	const MPlexLS &	psErr,
		const MPlexLV &	psPar,
		const MPlexQI &	inChg,
		const MPlexHS &	msErr,
		const MPlexHV &	msPar,
		MPlexQF &	outChi2,
		const int	N_proc
	)

Definition at line 753 of file KalmanUtilsMPlex.cc.

References kalmanOperation(), and KFO_Calculate_Chi2.

                                            {
     kalmanOperation(KFO_Calculate_Chi2, psErr, psPar, msErr, msPar, dummy_err, dummy_par, outChi2, N_proc);
   }

◆ kalmanComputeChi2Endcap()

void mkfit::kalmanComputeChi2Endcap	(	const MPlexLS &	psErr,
		const MPlexLV &	psPar,
		const MPlexQI &	inChg,
		const MPlexHS &	msErr,
		const MPlexHV &	msPar,
		MPlexQF &	outChi2,
		const int	N_proc
	)

Definition at line 1380 of file KalmanUtilsMPlex.cc.

References kalmanOperationEndcap(), and KFO_Calculate_Chi2.

                                                  {
     kalmanOperationEndcap(KFO_Calculate_Chi2, psErr, psPar, msErr, msPar, dummy_err, dummy_par, outChi2, N_proc);
   }

◆ kalmanComputeChi2Plane()

void mkfit::kalmanComputeChi2Plane	(	const MPlexLS &	psErr,
		const MPlexLV &	psPar,
		const MPlexQI &	inChg,
		const MPlexHS &	msErr,
		const MPlexHV &	msPar,
		const MPlexHV &	plNrm,
		const MPlexHV &	plDir,
		MPlexQF &	outChi2,
		const int	N_proc
	)

Definition at line 1075 of file KalmanUtilsMPlex.cc.

References kalmanOperationPlane(), and KFO_Calculate_Chi2.

                                                 {
     kalmanOperationPlane(
         KFO_Calculate_Chi2, psErr, psPar, msErr, msPar, plNrm, plDir, dummy_err, dummy_par, outChi2, N_proc);
   }

◆ kalmanOperation()

void mkfit::kalmanOperation	(	const int	kfOp,
		const MPlexLS &	psErr,
		const MPlexLV &	psPar,
		const MPlexHS &	msErr,
		const MPlexHV &	msPar,
		MPlexLS &	outErr,
		MPlexLV &	outPar,
		MPlexQF &	outChi2,
		const int	N_proc
	)

Definition at line 797 of file KalmanUtilsMPlex.cc.

References Matriplex::hypot(), mps_fire::i, Matriplex::invertCramerSym(), dqmiolumiharvest::j, KFO_Calculate_Chi2, KFO_Local_Cov, KFO_Update_Params, dqmiodumpmetadata::n, NN, and squashPhiMPlex().

Referenced by mkfit::MkFinder::bkFitFitTracks(), mkfit::MkFinder::bkFitFitTracksBH(), kalmanComputeChi2(), kalmanPropagateAndComputeChi2(), kalmanPropagateAndUpdate(), and kalmanUpdate().

                                          {
 #ifdef DEBUG
     {
       dmutex_guard;
       printf("psPar:\n");
       for (int i = 0; i < 6; ++i) {
         printf("%8f ", psPar.constAt(0, 0, i));
         printf("\n");
       }
       printf("\n");
       printf("psErr:\n");
       for (int i = 0; i < 6; ++i) {
         for (int j = 0; j < 6; ++j)
           printf("%8f ", psErr.constAt(0, i, j));
         printf("\n");
       }
       printf("\n");
       printf("msPar:\n");
       for (int i = 0; i < 3; ++i) {
         printf("%8f ", msPar.constAt(0, 0, i));
         printf("\n");
       }
       printf("\n");
       printf("msErr:\n");
       for (int i = 0; i < 3; ++i) {
         for (int j = 0; j < 3; ++j)
           printf("%8f ", msErr.constAt(0, i, j));
         printf("\n");
       }
       printf("\n");
     }
 #endif
 
     // Rotate global point on tangent plane to cylinder
     // Tangent point is half way between hit and propagate position
 
     // Rotation matrix
     //  rotT00  0  rotT01
     //  rotT01  0 -rotT00
     //     0    1    0
     // Minimize temporaries: only two float are needed!
 
     MPlexQF rotT00;
     MPlexQF rotT01;
     for (int n = 0; n < NN; ++n) {
       if (n < N_proc) {
         const float r = std::hypot(msPar.constAt(n, 0, 0), msPar.constAt(n, 1, 0));
         rotT00.At(n, 0, 0) = -(msPar.constAt(n, 1, 0) + psPar.constAt(n, 1, 0)) / (2 * r);
         rotT01.At(n, 0, 0) = (msPar.constAt(n, 0, 0) + psPar.constAt(n, 0, 0)) / (2 * r);
       } else {
         rotT00.At(n, 0, 0) = 0.0f;
         rotT01.At(n, 0, 0) = 0.0f;
       }
     }
 
     MPlexHV res_glo;  //position residual in global coordinates
     SubtractFirst3(msPar, psPar, res_glo);
 
     MPlexHS resErr_glo;  //covariance sum in global position coordinates
     AddIntoUpperLeft3x3(psErr, msErr, resErr_glo);
 
     MPlex2V res_loc;  //position residual in local coordinates
     RotateResidualsOnTangentPlane(rotT00, rotT01, res_glo, res_loc);
     MPlex2S resErr_loc;  //covariance sum in local position coordinates
     MPlexHH tempHH;
     ProjectResErr(rotT00, rotT01, resErr_glo, tempHH);
     ProjectResErrTransp(rotT00, rotT01, tempHH, resErr_loc);
 
 #ifdef DEBUG
     {
       dmutex_guard;
       printf("res_glo:\n");
       for (int i = 0; i < 3; ++i) {
         printf("%8f ", res_glo.At(0, i, 0));
       }
       printf("\n");
       printf("resErr_glo:\n");
       for (int i = 0; i < 3; ++i) {
         for (int j = 0; j < 3; ++j)
           printf("%8f ", resErr_glo.At(0, i, j));
         printf("\n");
       }
       printf("\n");
       printf("res_loc:\n");
       for (int i = 0; i < 2; ++i) {
         printf("%8f ", res_loc.At(0, i, 0));
       }
       printf("\n");
       printf("tempHH:\n");
       for (int i = 0; i < 3; ++i) {
         for (int j = 0; j < 3; ++j)
           printf("%8f ", tempHH.At(0, i, j));
         printf("\n");
       }
       printf("\n");
       printf("resErr_loc:\n");
       for (int i = 0; i < 2; ++i) {
         for (int j = 0; j < 2; ++j)
           printf("%8f ", resErr_loc.At(0, i, j));
         printf("\n");
       }
       printf("\n");
     }
 #endif
 
     //invert the 2x2 matrix
     Matriplex::invertCramerSym(resErr_loc);
 
     if (kfOp & KFO_Calculate_Chi2) {
       Chi2Similarity(res_loc, resErr_loc, outChi2);
 
 #ifdef DEBUG
       {
         dmutex_guard;
         printf("resErr_loc (Inv):\n");
         for (int i = 0; i < 2; ++i) {
           for (int j = 0; j < 2; ++j)
             printf("%8f ", resErr_loc.At(0, i, j));
           printf("\n");
         }
         printf("\n");
         printf("chi2: %8f\n", outChi2.At(0, 0, 0));
       }
 #endif
     }
 
     if (kfOp & KFO_Update_Params) {
       MPlexLS psErrLoc = psErr;
       if (kfOp & KFO_Local_Cov)
         CovXYconstrain(rotT00, rotT01, psErr, psErrLoc);
 
       MPlexLH K;                                      // kalman gain, fixme should be L2
       KalmanHTG(rotT00, rotT01, resErr_loc, tempHH);  // intermediate term to get kalman gain (H^T*G)
       KalmanGain(psErrLoc, tempHH, K);
 
       MultResidualsAdd(K, psPar, res_loc, outPar);
 
       squashPhiMPlex(outPar, N_proc);  // ensure phi is between |pi|
 
       MPlexLL tempLL;
       KHMult(K, rotT00, rotT01, tempLL);
       KHC(tempLL, psErrLoc, outErr);
       outErr.subtract(psErrLoc, outErr);
 
 #ifdef DEBUG
       {
         dmutex_guard;
         if (kfOp & KFO_Local_Cov) {
           printf("psErrLoc:\n");
           for (int i = 0; i < 6; ++i) {
             for (int j = 0; j < 6; ++j)
               printf("% 8e ", psErrLoc.At(0, i, j));
             printf("\n");
           }
           printf("\n");
         }
         printf("resErr_loc (Inv):\n");
         for (int i = 0; i < 2; ++i) {
           for (int j = 0; j < 2; ++j)
             printf("%8f ", resErr_loc.At(0, i, j));
           printf("\n");
         }
         printf("\n");
         printf("tempHH:\n");
         for (int i = 0; i < 3; ++i) {
           for (int j = 0; j < 3; ++j)
             printf("%8f ", tempHH.At(0, i, j));
           printf("\n");
         }
         printf("\n");
         printf("K:\n");
         for (int i = 0; i < 6; ++i) {
           for (int j = 0; j < 3; ++j)
             printf("%8f ", K.At(0, i, j));
           printf("\n");
         }
         printf("\n");
         printf("tempLL:\n");
         for (int i = 0; i < 6; ++i) {
           for (int j = 0; j < 6; ++j)
             printf("%8f ", tempLL.At(0, i, j));
           printf("\n");
         }
         printf("\n");
         printf("outPar:\n");
         for (int i = 0; i < 6; ++i) {
           printf("%8f  ", outPar.At(0, i, 0));
         }
         printf("\n");
         printf("outErr:\n");
         for (int i = 0; i < 6; ++i) {
           for (int j = 0; j < 6; ++j)
             printf("%8f ", outErr.At(0, i, j));
           printf("\n");
         }
         printf("\n");
       }
 #endif
     }
   }

◆ kalmanOperationEndcap()

void mkfit::kalmanOperationEndcap	(	const int	kfOp,
		const MPlexLS &	psErr,
		const MPlexLV &	psPar,
		const MPlexHS &	msErr,
		const MPlexHV &	msPar,
		MPlexLS &	outErr,
		MPlexLV &	outPar,
		MPlexQF &	outChi2,
		const int	N_proc
	)

Definition at line 1420 of file KalmanUtilsMPlex.cc.

References mps_fire::i, Matriplex::invertCramerSym(), dqmiolumiharvest::j, KFO_Calculate_Chi2, KFO_Update_Params, and squashPhiMPlex().

Referenced by mkfit::MkFinder::bkFitFitTracks(), mkfit::MkFinder::bkFitFitTracksBH(), kalmanComputeChi2Endcap(), kalmanPropagateAndComputeChi2Endcap(), kalmanPropagateAndUpdateEndcap(), and kalmanUpdateEndcap().

                                                {
 #ifdef DEBUG
     {
       dmutex_guard;
       printf("updateParametersEndcapMPlex\n");
       printf("psPar:\n");
       for (int i = 0; i < 6; ++i) {
         printf("%8f ", psPar.constAt(0, 0, i));
         printf("\n");
       }
       printf("\n");
       printf("msPar:\n");
       for (int i = 0; i < 3; ++i) {
         printf("%8f ", msPar.constAt(0, 0, i));
         printf("\n");
       }
       printf("\n");
       printf("psErr:\n");
       for (int i = 0; i < 6; ++i) {
         for (int j = 0; j < 6; ++j)
           printf("%8f ", psErr.constAt(0, i, j));
         printf("\n");
       }
       printf("\n");
       printf("msErr:\n");
       for (int i = 0; i < 3; ++i) {
         for (int j = 0; j < 3; ++j)
           printf("%8f ", msErr.constAt(0, i, j));
         printf("\n");
       }
       printf("\n");
     }
 #endif
 
     MPlex2V res;
     SubtractFirst2(msPar, psPar, res);
 
     MPlex2S resErr;
     AddIntoUpperLeft2x2(psErr, msErr, resErr);
 
 #ifdef DEBUG
     {
       dmutex_guard;
       printf("resErr:\n");
       for (int i = 0; i < 2; ++i) {
         for (int j = 0; j < 2; ++j)
           printf("%8f ", resErr.At(0, i, j));
         printf("\n");
       }
       printf("\n");
     }
 #endif
 
     //invert the 2x2 matrix
     Matriplex::invertCramerSym(resErr);
 
     if (kfOp & KFO_Calculate_Chi2) {
       Chi2Similarity(res, resErr, outChi2);
 
 #ifdef DEBUG
       {
         dmutex_guard;
         printf("resErr_loc (Inv):\n");
         for (int i = 0; i < 2; ++i) {
           for (int j = 0; j < 2; ++j)
             printf("%8f ", resErr.At(0, i, j));
           printf("\n");
         }
         printf("\n");
         printf("chi2: %8f\n", outChi2.At(0, 0, 0));
       }
 #endif
     }
 
     if (kfOp & KFO_Update_Params) {
       MPlexL2 K;
       KalmanGain(psErr, resErr, K);
 
       MultResidualsAdd(K, psPar, res, outPar);
 
       squashPhiMPlex(outPar, N_proc);  // ensure phi is between |pi|
 
       KHC(K, psErr, outErr);
 
 #ifdef DEBUG
       {
         dmutex_guard;
         printf("outErr before subtract:\n");
         for (int i = 0; i < 6; ++i) {
           for (int j = 0; j < 6; ++j)
             printf("%8f ", outErr.At(0, i, j));
           printf("\n");
         }
         printf("\n");
       }
 #endif
 
       outErr.subtract(psErr, outErr);
 
 #ifdef DEBUG
       {
         dmutex_guard;
         printf("res:\n");
         for (int i = 0; i < 2; ++i) {
           printf("%8f ", res.At(0, i, 0));
         }
         printf("\n");
         printf("resErr (Inv):\n");
         for (int i = 0; i < 2; ++i) {
           for (int j = 0; j < 2; ++j)
             printf("%8f ", resErr.At(0, i, j));
           printf("\n");
         }
         printf("\n");
         printf("K:\n");
         for (int i = 0; i < 6; ++i) {
           for (int j = 0; j < 2; ++j)
             printf("%8f ", K.At(0, i, j));
           printf("\n");
         }
         printf("\n");
         printf("outPar:\n");
         for (int i = 0; i < 6; ++i) {
           printf("%8f  ", outPar.At(0, i, 0));
         }
         printf("\n");
         printf("outErr:\n");
         for (int i = 0; i < 6; ++i) {
           for (int j = 0; j < 6; ++j)
             printf("%8f ", outErr.At(0, i, j));
           printf("\n");
         }
         printf("\n");
       }
 #endif
     }
   }

◆ kalmanOperationPlane()

void mkfit::kalmanOperationPlane	(	const int	kfOp,
		const MPlexLS &	psErr,
		const MPlexLV &	psPar,
		const MPlexHS &	msErr,
		const MPlexHV &	msPar,
		const MPlexHV &	plNrm,
		const MPlexHV &	plDir,
		MPlexLS &	outErr,
		MPlexLV &	outPar,
		MPlexQF &	outChi2,
		const int	N_proc
	)

Definition at line 1116 of file KalmanUtilsMPlex.cc.

References mps_fire::i, Matriplex::invertCramerSym(), dqmiolumiharvest::j, KFO_Calculate_Chi2, KFO_Local_Cov, KFO_Update_Params, dqmiodumpmetadata::n, NN, and squashPhiMPlex().

Referenced by kalmanComputeChi2Plane(), kalmanPropagateAndComputeChi2Plane(), kalmanPropagateAndUpdatePlane(), and kalmanUpdatePlane().

                                               {
 #ifdef DEBUG
     {
       dmutex_guard;
       printf("psPar:\n");
       for (int i = 0; i < 6; ++i) {
         printf("%8f ", psPar.constAt(0, 0, i));
         printf("\n");
       }
       printf("\n");
       printf("psErr:\n");
       for (int i = 0; i < 6; ++i) {
         for (int j = 0; j < 6; ++j)
           printf("%8f ", psErr.constAt(0, i, j));
         printf("\n");
       }
       printf("\n");
       printf("msPar:\n");
       for (int i = 0; i < 3; ++i) {
         printf("%8f ", msPar.constAt(0, 0, i));
         printf("\n");
       }
       printf("\n");
       printf("msErr:\n");
       for (int i = 0; i < 3; ++i) {
         for (int j = 0; j < 3; ++j)
           printf("%8f ", msErr.constAt(0, i, j));
         printf("\n");
       }
       printf("\n");
     }
 #endif
 
     // Rotate global point on tangent plane to cylinder
     // Tangent point is half way between hit and propagate position
 
     // Rotation matrix
     //    D0  D1   D2
     //    X0  X1   X2
     //    N0  N1   N2
     // where D is the strip direction vector plDir, N is the normal plNrm, and X is the cross product between the two
 
     MPlex2H prj;
     for (int n = 0; n < NN; ++n) {
       prj(n, 0, 0) = plDir(n, 0, 0);
       prj(n, 0, 1) = plDir(n, 1, 0);
       prj(n, 0, 2) = plDir(n, 2, 0);
       prj(n, 1, 0) = plNrm(n, 1, 0) * plDir(n, 2, 0) - plNrm(n, 2, 0) * plDir(n, 1, 0);
       prj(n, 1, 1) = plNrm(n, 2, 0) * plDir(n, 0, 0) - plNrm(n, 0, 0) * plDir(n, 2, 0);
       prj(n, 1, 2) = plNrm(n, 0, 0) * plDir(n, 1, 0) - plNrm(n, 1, 0) * plDir(n, 0, 0);
     }
 
     MPlexHV res_glo;  //position residual in global coordinates
     SubtractFirst3(msPar, psPar, res_glo);
 
     MPlexHS resErr_glo;  //covariance sum in global position coordinates
     AddIntoUpperLeft3x3(psErr, msErr, resErr_glo);
 
     MPlex2V res_loc;  //position residual in local coordinates
     RotateResidualsOnPlane(prj, res_glo, res_loc);
     MPlex2S resErr_loc;  //covariance sum in local position coordinates
     MPlex2H temp2H;
     ProjectResErr(prj, resErr_glo, temp2H);
     ProjectResErrTransp(prj, temp2H, resErr_loc);
 
 #ifdef DEBUG
     {
       dmutex_guard;
       printf("prj:\n");
       for (int i = 0; i < 2; ++i) {
         for (int j = 0; j < 3; ++j)
           printf("%8f ", prj.At(0, i, j));
         printf("\n");
       }
       printf("\n");
       printf("res_glo:\n");
       for (int i = 0; i < 3; ++i) {
         printf("%8f ", res_glo.At(0, i, 0));
       }
       printf("\n");
       printf("resErr_glo:\n");
       for (int i = 0; i < 3; ++i) {
         for (int j = 0; j < 3; ++j)
           printf("%8f ", resErr_glo.At(0, i, j));
         printf("\n");
       }
       printf("\n");
       printf("res_loc:\n");
       for (int i = 0; i < 2; ++i) {
         printf("%8f ", res_loc.At(0, i, 0));
       }
       printf("\n");
       printf("temp2H:\n");
       for (int i = 0; i < 2; ++i) {
         for (int j = 0; j < 3; ++j)
           printf("%8f ", temp2H.At(0, i, j));
         printf("\n");
       }
       printf("\n");
       printf("resErr_loc:\n");
       for (int i = 0; i < 2; ++i) {
         for (int j = 0; j < 2; ++j)
           printf("%8f ", resErr_loc.At(0, i, j));
         printf("\n");
       }
       printf("\n");
     }
 #endif
 
     //invert the 2x2 matrix
     Matriplex::invertCramerSym(resErr_loc);
 
     if (kfOp & KFO_Calculate_Chi2) {
       Chi2Similarity(res_loc, resErr_loc, outChi2);
 
 #ifdef DEBUG
       {
         dmutex_guard;
         printf("resErr_loc (Inv):\n");
         for (int i = 0; i < 2; ++i) {
           for (int j = 0; j < 2; ++j)
             printf("%8f ", resErr_loc.At(0, i, j));
           printf("\n");
         }
         printf("\n");
         printf("chi2: %8f\n", outChi2.At(0, 0, 0));
       }
 #endif
     }
 
     if (kfOp & KFO_Update_Params) {
       MPlexLS psErrLoc = psErr;
 
       MPlexH2 tempH2;
       MPlexL2 K;                           // kalman gain, fixme should be L2
       KalmanHTG(prj, resErr_loc, tempH2);  // intermediate term to get kalman gain (H^T*G)
       KalmanGain(psErrLoc, tempH2, K);
 
       MultResidualsAdd(K, psPar, res_loc, outPar);
 
       squashPhiMPlex(outPar, N_proc);  // ensure phi is between |pi|
 
       MPlexLL tempLL;
       KHMult(K, prj, tempLL);
       KHC(tempLL, psErrLoc, outErr);
       outErr.subtract(psErrLoc, outErr);
 
 #ifdef DEBUG
       {
         dmutex_guard;
         if (kfOp & KFO_Local_Cov) {
           printf("psErrLoc:\n");
           for (int i = 0; i < 6; ++i) {
             for (int j = 0; j < 6; ++j)
               printf("% 8e ", psErrLoc.At(0, i, j));
             printf("\n");
           }
           printf("\n");
         }
         printf("resErr_loc (Inv):\n");
         for (int i = 0; i < 2; ++i) {
           for (int j = 0; j < 2; ++j)
             printf("%8f ", resErr_loc.At(0, i, j));
           printf("\n");
         }
         printf("\n");
         printf("tempH2:\n");
         for (int i = 0; i < 3; ++i) {
           for (int j = 0; j < 2; ++j)
             printf("%8f ", tempH2.At(0, i, j));
           printf("\n");
         }
         printf("\n");
         printf("K:\n");
         for (int i = 0; i < 6; ++i) {
           for (int j = 0; j < 2; ++j)
             printf("%8f ", K.At(0, i, j));
           printf("\n");
         }
         printf("\n");
         printf("tempLL:\n");
         for (int i = 0; i < 6; ++i) {
           for (int j = 0; j < 6; ++j)
             printf("%8f ", tempLL.At(0, i, j));
           printf("\n");
         }
         printf("\n");
         printf("outPar:\n");
         for (int i = 0; i < 6; ++i) {
           printf("%8f  ", outPar.At(0, i, 0));
         }
         printf("\n");
         printf("outErr:\n");
         for (int i = 0; i < 6; ++i) {
           for (int j = 0; j < 6; ++j)
             printf("%8f ", outErr.At(0, i, j));
           printf("\n");
         }
         printf("\n");
       }
 #endif
     }
   }

◆ kalmanPropagateAndComputeChi2()

void mkfit::kalmanPropagateAndComputeChi2	(	const MPlexLS &	psErr,
		const MPlexLV &	psPar,
		const MPlexQI &	inChg,
		const MPlexHS &	msErr,
		const MPlexHV &	msPar,
		MPlexQF &	outChi2,
		MPlexLV &	propPar,
		MPlexQI &	outFailFlag,
		const int	N_proc,
		const PropagationFlags &	propFlags,
		const bool	propToHit
	)

Definition at line 763 of file KalmanUtilsMPlex.cc.

References Matriplex::hypot(), kalmanOperation(), KFO_Calculate_Chi2, dqmiodumpmetadata::n, NN, and propagateHelixToRMPlex().

                                                            {
     propPar = psPar;
     if (propToHit) {
       MPlexLS propErr;
       MPlexQF msRad;
 #pragma omp simd
       for (int n = 0; n < NN; ++n) {
         if (n < N_proc) {
           msRad.At(n, 0, 0) = std::hypot(msPar.constAt(n, 0, 0), msPar.constAt(n, 1, 0));
         } else {
           msRad.At(n, 0, 0) = 0.0f;
         }
       }
 
       propagateHelixToRMPlex(psErr, psPar, inChg, msRad, propErr, propPar, outFailFlag, N_proc, propFlags);
 
       kalmanOperation(KFO_Calculate_Chi2, propErr, propPar, msErr, msPar, dummy_err, dummy_par, outChi2, N_proc);
     } else {
       kalmanOperation(KFO_Calculate_Chi2, psErr, psPar, msErr, msPar, dummy_err, dummy_par, outChi2, N_proc);
     }
   }

◆ kalmanPropagateAndComputeChi2Endcap()

void mkfit::kalmanPropagateAndComputeChi2Endcap	(	const MPlexLS &	psErr,
		const MPlexLV &	psPar,
		const MPlexQI &	inChg,
		const MPlexHS &	msErr,
		const MPlexHV &	msPar,
		MPlexQF &	outChi2,
		MPlexLV &	propPar,
		MPlexQI &	outFailFlag,
		const int	N_proc,
		const PropagationFlags &	propFlags,
		const bool	propToHit
	)

Definition at line 1390 of file KalmanUtilsMPlex.cc.

References kalmanOperationEndcap(), KFO_Calculate_Chi2, dqmiodumpmetadata::n, NN, and propagateHelixToZMPlex().

                                                                  {
     propPar = psPar;
     if (propToHit) {
       MPlexLS propErr;
       MPlexQF msZ;
 #pragma omp simd
       for (int n = 0; n < NN; ++n) {
         msZ.At(n, 0, 0) = msPar.constAt(n, 2, 0);
       }
 
       propagateHelixToZMPlex(psErr, psPar, inChg, msZ, propErr, propPar, outFailFlag, N_proc, propFlags);
 
       kalmanOperationEndcap(KFO_Calculate_Chi2, propErr, propPar, msErr, msPar, dummy_err, dummy_par, outChi2, N_proc);
     } else {
       kalmanOperationEndcap(KFO_Calculate_Chi2, psErr, psPar, msErr, msPar, dummy_err, dummy_par, outChi2, N_proc);
     }
   }

◆ kalmanPropagateAndComputeChi2Plane()

void mkfit::kalmanPropagateAndComputeChi2Plane	(	const MPlexLS &	psErr,
		const MPlexLV &	psPar,
		const MPlexQI &	inChg,
		const MPlexHS &	msErr,
		const MPlexHV &	msPar,
		const MPlexHV &	plNrm,
		const MPlexHV &	plDir,
		MPlexQF &	outChi2,
		MPlexLV &	propPar,
		MPlexQI &	outFailFlag,
		const int	N_proc,
		const PropagationFlags &	propFlags,
		const bool	propToHit
	)

Definition at line 1088 of file KalmanUtilsMPlex.cc.

References kalmanOperationPlane(), KFO_Calculate_Chi2, and propagateHelixToPlaneMPlex().

Referenced by mkfit::MkFinder::findCandidates(), and mkfit::MkFinder::findCandidatesCloneEngine().

                                                                 {
     propPar = psPar;
     if (propToHit) {
       MPlexLS propErr;
       propagateHelixToPlaneMPlex(psErr, psPar, inChg, msPar, plNrm, propErr, propPar, outFailFlag, N_proc, propFlags);
 
       kalmanOperationPlane(
           KFO_Calculate_Chi2, propErr, propPar, msErr, msPar, plNrm, plDir, dummy_err, dummy_par, outChi2, N_proc);
     } else {
       kalmanOperationPlane(
           KFO_Calculate_Chi2, psErr, psPar, msErr, msPar, plNrm, plDir, dummy_err, dummy_par, outChi2, N_proc);
     }
   }

◆ kalmanPropagateAndUpdate()

void mkfit::kalmanPropagateAndUpdate	(	const MPlexLS &	psErr,
		const MPlexLV &	psPar,
		MPlexQI &	Chg,
		const MPlexHS &	msErr,
		const MPlexHV &	msPar,
		MPlexLS &	outErr,
		MPlexLV &	outPar,
		MPlexQI &	outFailFlag,
		const int	N_proc,
		const PropagationFlags &	propFlags,
		const bool	propToHit
	)

Definition at line 715 of file KalmanUtilsMPlex.cc.

References Matriplex::hypot(), kalmanOperation(), KFO_Local_Cov, KFO_Update_Params, dqmiodumpmetadata::n, NN, and propagateHelixToRMPlex().

                                                       {
     if (propToHit) {
       MPlexLS propErr;
       MPlexLV propPar;
       MPlexQF msRad;
 #pragma omp simd
       for (int n = 0; n < NN; ++n) {
         msRad.At(n, 0, 0) = std::hypot(msPar.constAt(n, 0, 0), msPar.constAt(n, 1, 0));
       }
 
       propagateHelixToRMPlex(psErr, psPar, Chg, msRad, propErr, propPar, outFailFlag, N_proc, propFlags);
 
       kalmanOperation(
           KFO_Update_Params | KFO_Local_Cov, propErr, propPar, msErr, msPar, outErr, outPar, dummy_chi2, N_proc);
     } else {
       kalmanOperation(
           KFO_Update_Params | KFO_Local_Cov, psErr, psPar, msErr, msPar, outErr, outPar, dummy_chi2, N_proc);
     }
     for (int n = 0; n < NN; ++n) {
       if (n < N_proc && outPar.At(n, 3, 0) < 0) {
         Chg.At(n, 0, 0) = -Chg.At(n, 0, 0);
         outPar.At(n, 3, 0) = -outPar.At(n, 3, 0);
       }
     }
   }

◆ kalmanPropagateAndUpdateEndcap()

void mkfit::kalmanPropagateAndUpdateEndcap	(	const MPlexLS &	psErr,
		const MPlexLV &	psPar,
		MPlexQI &	Chg,
		const MPlexHS &	msErr,
		const MPlexHV &	msPar,
		MPlexLS &	outErr,
		MPlexLV &	outPar,
		MPlexQI &	outFailFlag,
		const int	N_proc,
		const PropagationFlags &	propFlags,
		const bool	propToHit
	)

Definition at line 1344 of file KalmanUtilsMPlex.cc.

References kalmanOperationEndcap(), KFO_Update_Params, dqmiodumpmetadata::n, NN, and propagateHelixToZMPlex().

                                                             {
     if (propToHit) {
       MPlexLS propErr;
       MPlexLV propPar;
       MPlexQF msZ;
 #pragma omp simd
       for (int n = 0; n < NN; ++n) {
         msZ.At(n, 0, 0) = msPar.constAt(n, 2, 0);
       }
 
       propagateHelixToZMPlex(psErr, psPar, Chg, msZ, propErr, propPar, outFailFlag, N_proc, propFlags);
 
       kalmanOperationEndcap(KFO_Update_Params, propErr, propPar, msErr, msPar, outErr, outPar, dummy_chi2, N_proc);
     } else {
       kalmanOperationEndcap(KFO_Update_Params, psErr, psPar, msErr, msPar, outErr, outPar, dummy_chi2, N_proc);
     }
     for (int n = 0; n < NN; ++n) {
       if (n < N_proc && outPar.At(n, 3, 0) < 0) {
         Chg.At(n, 0, 0) = -Chg.At(n, 0, 0);
         outPar.At(n, 3, 0) = -outPar.At(n, 3, 0);
       }
     }
   }

◆ kalmanPropagateAndUpdatePlane()

void mkfit::kalmanPropagateAndUpdatePlane	(	const MPlexLS &	psErr,
		const MPlexLV &	psPar,
		MPlexQI &	Chg,
		const MPlexHS &	msErr,
		const MPlexHV &	msPar,
		const MPlexHV &	plNrm,
		const MPlexHV &	plDir,
		MPlexLS &	outErr,
		MPlexLV &	outPar,
		MPlexQI &	outFailFlag,
		const int	N_proc,
		const PropagationFlags &	propFlags,
		const bool	propToHit
	)

Definition at line 1023 of file KalmanUtilsMPlex.cc.

References kalmanOperationPlane(), KFO_Local_Cov, KFO_Update_Params, dqmiodumpmetadata::n, NN, and propagateHelixToPlaneMPlex().

Referenced by mkfit::MkFinder::updateWithLoadedHit().

                                                            {
     if (propToHit) {
       MPlexLS propErr;
       MPlexLV propPar;
       propagateHelixToPlaneMPlex(psErr, psPar, Chg, msPar, plNrm, propErr, propPar, outFailFlag, N_proc, propFlags);
 
       kalmanOperationPlane(KFO_Update_Params | KFO_Local_Cov,
                            propErr,
                            propPar,
                            msErr,
                            msPar,
                            plNrm,
                            plDir,
                            outErr,
                            outPar,
                            dummy_chi2,
                            N_proc);
     } else {
       kalmanOperationPlane(KFO_Update_Params | KFO_Local_Cov,
                            psErr,
                            psPar,
                            msErr,
                            msPar,
                            plNrm,
                            plDir,
                            outErr,
                            outPar,
                            dummy_chi2,
                            N_proc);
     }
     for (int n = 0; n < NN; ++n) {
       if (outPar.At(n, 3, 0) < 0) {
         Chg.At(n, 0, 0) = -Chg.At(n, 0, 0);
         outPar.At(n, 3, 0) = -outPar.At(n, 3, 0);
       }
     }
   }

◆ kalmanUpdate()

void mkfit::kalmanUpdate	(	const MPlexLS &	psErr,
		const MPlexLV &	psPar,
		const MPlexHS &	msErr,
		const MPlexHV &	msPar,
		MPlexLS &	outErr,
		MPlexLV &	outPar,
		const int	N_proc
	)

Definition at line 705 of file KalmanUtilsMPlex.cc.

References kalmanOperation(), KFO_Local_Cov, and KFO_Update_Params.

Referenced by mkfit::MkFitter::fitTracksWithInterSlurp().

                                       {
     kalmanOperation(KFO_Update_Params | KFO_Local_Cov, psErr, psPar, msErr, msPar, outErr, outPar, dummy_chi2, N_proc);
   }

◆ kalmanUpdateEndcap()

void mkfit::kalmanUpdateEndcap	(	const MPlexLS &	psErr,
		const MPlexLV &	psPar,
		const MPlexHS &	msErr,
		const MPlexHV &	msPar,
		MPlexLS &	outErr,
		MPlexLV &	outPar,
		const int	N_proc
	)

Definition at line 1334 of file KalmanUtilsMPlex.cc.

References kalmanOperationEndcap(), and KFO_Update_Params.

                                             {
     kalmanOperationEndcap(KFO_Update_Params, psErr, psPar, msErr, msPar, outErr, outPar, dummy_chi2, N_proc);
   }

◆ kalmanUpdatePlane()

void mkfit::kalmanUpdatePlane	(	const MPlexLS &	psErr,
		const MPlexLV &	psPar,
		const MPlexHS &	msErr,
		const MPlexHV &	msPar,
		const MPlexHV &	plNrm,
		const MPlexHV &	plDir,
		MPlexLS &	outErr,
		MPlexLV &	outPar,
		const int	N_proc
	)

Definition at line 1010 of file KalmanUtilsMPlex.cc.

References kalmanOperationPlane(), KFO_Local_Cov, and KFO_Update_Params.

                                            {
     kalmanOperationPlane(
         KFO_Update_Params | KFO_Local_Cov, psErr, psPar, msErr, msPar, plNrm, plDir, outErr, outPar, dummy_chi2, N_proc);
   }

◆ operator==()

template<class T , class U >

bool mkfit::operator==	(	const CcAlloc< T > &	a,
		const CcAlloc< U > &	b
	)

Definition at line 151 of file TrackStructures.h.

References a, and b.

                                                             {
     return a.pool_id() == b.pool_id();
   }

◆ passStripChargePCMfromTrack()

bool mkfit::passStripChargePCMfromTrack	(	int	itrack,
		bool	isBarrel,
		unsigned int	pcm,
		unsigned int	pcmMin,
		const MPlexLV &	pPar,
		const MPlexHS &	msErr
	)

Definition at line 1305 of file MkFinder.cc.

References funct::abs(), funct::cos(), dprint, f, PixelPluginsPhase0_cfi::isBarrel, mkfit::Hit::maxChargePerCM(), amptDefault_cfi::proj, funct::sin(), and mathSSE::sqrt().

Referenced by mkfit::MkFinder::findCandidates(), and mkfit::MkFinder::findCandidatesCloneEngine().

                                                                                                                    {
     //skip the overflow case
     if (pcm >= Hit::maxChargePerCM())
       return true;
 
     float qSF;
     if (isBarrel) {  //project in x,y, assuming zero-error direction is in this plane
       const float hitT2 = msErr.constAt(itrack, 0, 0) + msErr.constAt(itrack, 1, 1);
       const float hitT2inv = 1.f / hitT2;
       const float proj[3] = {msErr.constAt(itrack, 0, 0) * hitT2inv,
                              msErr.constAt(itrack, 0, 1) * hitT2inv,
                              msErr.constAt(itrack, 1, 1) * hitT2inv};
       const bool detXY_OK =
           std::abs(proj[0] * proj[2] - proj[1] * proj[1]) < 0.1f;  //check that zero-direction is close
       const float cosP = cos(pPar.constAt(itrack, 4, 0));
       const float sinP = sin(pPar.constAt(itrack, 4, 0));
       const float sinT = std::abs(sin(pPar.constAt(itrack, 5, 0)));
       //qSF = sqrt[(px,py)*(1-proj)*(px,py)]/p = sinT*sqrt[(cosP,sinP)*(1-proj)*(cosP,sinP)].
       qSF = detXY_OK ? sinT * std::sqrt(std::abs(1.f + cosP * cosP * proj[0] + sinP * sinP * proj[2] -
                                                  2.f * cosP * sinP * proj[1]))
                      : 1.f;
     } else {  //project on z
       // p_zLocal/p = p_z/p = cosT
       qSF = std::abs(cos(pPar.constAt(itrack, 5, 0)));
     }
 
     const float qCorr = pcm * qSF;
     dprint("pcm " << pcm << " * " << qSF << " = " << qCorr << " vs " << pcmMin);
     return qCorr > pcmMin;
   }

◆ print() [1/5]

void mkfit::print	(	std::string_view	label,
		const MeasurementState &	s
	)

Definition at line 8 of file Hit.cc.

References gather_cfg::cout, dumpMatrix(), label, and alignCSCRings::s.

Referenced by mkfit::Shell::Compare(), conformalFitMPlex(), print(), and mkfit::StdSeq::track_print().

                                                               {
     std::cout << label << std::endl;
     std::cout << "x: " << s.parameters()[0] << " y: " << s.parameters()[1] << " z: " << s.parameters()[2] << std::endl
               << "errors: " << std::endl;
     dumpMatrix(s.errors());
     std::cout << std::endl;
   }

◆ print() [2/5]

void mkfit::print ( const TrackState & s )

Definition at line 402 of file Track.cc.

References gather_cfg::cout, dumpMatrix(), and alignCSCRings::s.

                                   {
     std::cout << " x:  " << s.parameters[0] << " y:  " << s.parameters[1] << " z:  " << s.parameters[2] << std::endl
               << " px: " << s.parameters[3] << " py: " << s.parameters[4] << " pz: " << s.parameters[5] << std::endl
               << "valid: " << s.valid << " errors: " << std::endl;
     dumpMatrix(s.errors);
     std::cout << std::endl;
   }

◆ print() [3/5]

void mkfit::print	(	std::string	pfx,
		int	itrack,
		const Track &	trk,
		bool	print_hits = `false`
	)

Definition at line 410 of file Track.cc.

References gather_cfg::cout, mkfit::Track::getHitIdx(), mkfit::Track::getHitLyr(), mps_fire::i, mkfit::TrackBase::label(), mkfit::Track::nFoundHits(), mkfit::Track::nTotalHits(), geometryDiffVisualizer::pfx, print(), and mkfit::TrackBase::state().

                                                                            {
     std::cout << std::endl
               << pfx << ": " << itrack << " hits: " << trk.nFoundHits() << " label: " << trk.label() << " State"
               << std::endl;
     print(trk.state());
     if (print_hits) {
       for (int i = 0; i < trk.nTotalHits(); ++i)
         printf("  %2d: lyr %2d idx %d\n", i, trk.getHitLyr(i), trk.getHitIdx(i));
     }
   }

◆ print() [4/5]

void mkfit::print	(	std::string	pfx,
		const TrackState &	s
	)

Definition at line 421 of file Track.cc.

References gather_cfg::cout, geometryDiffVisualizer::pfx, print(), and alignCSCRings::s.

                                                  {
     std::cout << pfx << std::endl;
     print(s);
   }

◆ print() [5/5]

void mkfit::print	(	std::string	pfx,
		int	itrack,
		const Track &	trk,
		const Event &	ev
	)

Definition at line 1072 of file Event.cc.

References gather_cfg::cout, makeMEIFBenchmarkPlots::ev, mkfit::Track::getHitOnTrack(), h, mps_fire::i, mkfit::TrackBase::label(), mkfit::Track::nFoundHits(), mkfit::Track::nTotalHits(), geometryDiffVisualizer::pfx, print(), and mkfit::TrackBase::state().

                                                                            {
     std::cout << std::endl
               << pfx << ": " << itrack << " hits: " << trk.nFoundHits() << " label: " << trk.label()
               << " State:" << std::endl;
     print(trk.state());
 
     for (int i = 0; i < trk.nTotalHits(); ++i) {
       auto hot = trk.getHitOnTrack(i);
       printf("  %2d: lyr %2d idx %5d", i, hot.layer, hot.index);
       if (hot.index >= 0) {
         auto &h = ev.layerHits_[hot.layer][hot.index];
         int hl = ev.simHitsInfo_[h.mcHitID()].mcTrackID_;
         printf("  %4d  %8.3f %8.3f %8.3f  r=%.3f\n", hl, h.x(), h.y(), h.z(), h.r());
       } else {
         printf("\n");
       }
     }
   }

◆ propagateHelixToPlaneMPlex()

void mkfit::propagateHelixToPlaneMPlex	(	const MPlexLS &	inErr,
		const MPlexLV &	inPar,
		const MPlexQI &	inChg,
		const MPlexHV &	plPnt,
		const MPlexHV &	plNrm,
		MPlexLS &	outErr,
		MPlexLV &	outPar,
		MPlexQI &	outFailFlag,
		const int	N_proc,
		const PropagationFlags &	pflags,
		const MPlexQI *	noMatEffPtr
	)

Definition at line 1090 of file PropagationMPlex.cc.

References funct::abs(), mkfit::PropagationFlags::apply_material, applyMaterialEffects(), funct::cos(), debug, dprint_np, dprintf, g_debug, helixAtPlane(), Matriplex::hypot(), mps_fire::i, dqmiolumiharvest::j, GetRecoTauVFromDQM_MC_cff::kk, mkfit::TrackerInfo::material_checked(), dqmiodumpmetadata::n, NN, mkfit::TrackerInfo::Material::radl, funct::sin(), mathSSE::sqrt(), squashPhiMPlex(), funct::tan(), groupFilesInBlocks::temp, and mkfit::PropagationFlags::tracker_info.

Referenced by kalmanPropagateAndComputeChi2Plane(), and kalmanPropagateAndUpdatePlane().

                                                               {
     // debug = true;
 
     outErr = inErr;
     outPar = inPar;
 
     MPlexQF pathL;
     MPlexLL errorProp;
 
     helixAtPlane(inPar, inChg, plPnt, plNrm, pathL, outPar, errorProp, outFailFlag, N_proc, pflags);
 
     for (int n = 0; n < NN; ++n) {
       dprint_np(
           n,
           "propagation to plane end, dump parameters\n"
               //<< "   D = " << s[n] << " alpha = " << s[n] * std::sin(inPar(n, 5, 0)) * inPar(n, 3, 0) * kinv[n] << " kinv = " << kinv[n] << std::endl
               << "   pos = " << outPar(n, 0, 0) << " " << outPar(n, 1, 0) << " " << outPar(n, 2, 0) << "\t\t r="
               << std::sqrt(outPar(n, 0, 0) * outPar(n, 0, 0) + outPar(n, 1, 0) * outPar(n, 1, 0)) << std::endl
               << "   mom = " << outPar(n, 3, 0) << " " << outPar(n, 4, 0) << " " << outPar(n, 5, 0) << std::endl
               << " cart= " << std::cos(outPar(n, 4, 0)) / outPar(n, 3, 0) << " "
               << std::sin(outPar(n, 4, 0)) / outPar(n, 3, 0) << " " << 1. / (outPar(n, 3, 0) * tan(outPar(n, 5, 0)))
               << "\t\tpT=" << 1. / std::abs(outPar(n, 3, 0)) << std::endl);
     }
 
 #ifdef DEBUG
     if (debug && g_debug) {
       for (int kk = 0; kk < N_proc; ++kk) {
         dprintf("inPar %d\n", kk);
         for (int i = 0; i < 6; ++i) {
           dprintf("%8f ", inPar.constAt(kk, i, 0));
         }
         dprintf("\n");
         dprintf("inErr %d\n", kk);
         for (int i = 0; i < 6; ++i) {
           for (int j = 0; j < 6; ++j)
             dprintf("%8f ", inErr.constAt(kk, i, j));
           dprintf("\n");
         }
         dprintf("\n");
 
         for (int kk = 0; kk < N_proc; ++kk) {
           dprintf("plNrm %d\n", kk);
           for (int j = 0; j < 3; ++j)
             dprintf("%8f ", plNrm.constAt(kk, 0, j));
         }
         dprintf("\n");
 
         for (int kk = 0; kk < N_proc; ++kk) {
           dprintf("pathL %d\n", kk);
           for (int j = 0; j < 1; ++j)
             dprintf("%8f ", pathL.constAt(kk, 0, j));
         }
         dprintf("\n");
 
         dprintf("errorProp %d\n", kk);
         for (int i = 0; i < 6; ++i) {
           for (int j = 0; j < 6; ++j)
             dprintf("%8f ", errorProp.At(kk, i, j));
           dprintf("\n");
         }
         dprintf("\n");
       }
     }
 #endif
 
     // Matriplex version of:
     // result.errors = ROOT::Math::Similarity(errorProp, outErr);
     MPlexLL temp;
     MultHelixPropFull(errorProp, outErr, temp);
     MultHelixPropTranspFull(errorProp, temp, outErr);
 
 #ifdef DEBUG
     if (debug && g_debug) {
       for (int kk = 0; kk < N_proc; ++kk) {
         dprintf("outErr %d\n", kk);
         for (int i = 0; i < 6; ++i) {
           for (int j = 0; j < 6; ++j)
             dprintf("%8f ", outErr.constAt(kk, i, j));
           dprintf("\n");
         }
         dprintf("\n");
       }
     }
 #endif
 
     if (pflags.apply_material) {
       MPlexQF hitsRl;
       MPlexQF hitsXi;
       MPlexQF propSign;
 
       const TrackerInfo& tinfo = *pflags.tracker_info;
 
 #pragma omp simd
       for (int n = 0; n < NN; ++n) {
         if (n >= N_proc || (noMatEffPtr && noMatEffPtr->constAt(n, 0, 0))) {
           hitsRl(n, 0, 0) = 0.f;
           hitsXi(n, 0, 0) = 0.f;
         } else {
           const float hypo = std::hypot(outPar(n, 0, 0), outPar(n, 1, 0));
           auto mat = tinfo.material_checked(std::abs(outPar(n, 2, 0)), hypo);
           hitsRl(n, 0, 0) = mat.radl;
           hitsXi(n, 0, 0) = mat.bbxi;
         }
         propSign(n, 0, 0) = (pathL(n, 0, 0) > 0.f ? 1.f : -1.f);
       }
       applyMaterialEffects(hitsRl, hitsXi, propSign, plNrm, outErr, outPar, N_proc);
 #ifdef DEBUG
       if (debug && g_debug) {
         for (int kk = 0; kk < N_proc; ++kk) {
           dprintf("propSign %d\n", kk);
           for (int i = 0; i < 1; ++i) {
             dprintf("%8f ", propSign.constAt(kk, i, 0));
           }
           dprintf("\n");
           dprintf("plNrm %d\n", kk);
           for (int i = 0; i < 3; ++i) {
             dprintf("%8f ", plNrm.constAt(kk, i, 0));
           }
           dprintf("\n");
           dprintf("outErr(after material) %d\n", kk);
           for (int i = 0; i < 6; ++i) {
             for (int j = 0; j < 6; ++j)
               dprintf("%8f ", outErr.constAt(kk, i, j));
             dprintf("\n");
           }
           dprintf("\n");
         }
       }
 #endif
     }
 
     squashPhiMPlex(outPar, N_proc);  // ensure phi is between |pi|
 
     // PROP-FAIL-ENABLE To keep physics changes minimal, we always restore the
     // state to input when propagation fails -- as was the default before.
     // if (pflags.copy_input_state_on_fail) {
     for (int i = 0; i < N_proc; ++i) {
       if (outFailFlag(i, 0, 0)) {
         outPar.copySlot(i, inPar);
         outErr.copySlot(i, inErr);
       }
     }
     // }
   }

◆ propagateHelixToRMPlex()

void mkfit::propagateHelixToRMPlex	(	const MPlexLS &	inErr,
		const MPlexLV &	inPar,
		const MPlexQI &	inChg,
		const MPlexQF &	msRad,
		MPlexLS &	outErr,
		MPlexLV &	outPar,
		MPlexQI &	outFailFlag,
		const int	N_proc,
		const PropagationFlags &	pflags,
		const MPlexQI *	noMatEffPtr
	)

Definition at line 498 of file PropagationMPlex.cc.

References funct::abs(), mkfit::PropagationFlags::apply_material, applyMaterialEffects(), funct::cos(), debug, dprintf, g_debug, helixAtRFromIterativeCCS(), hipo(), mps_fire::i, dqmiolumiharvest::j, GetRecoTauVFromDQM_MC_cff::kk, mkfit::TrackerInfo::material_checked(), dqmiodumpmetadata::n, NN, mkfit::TrackerInfo::Material::radl, funct::sin(), squashPhiMPlex(), groupFilesInBlocks::temp, and mkfit::PropagationFlags::tracker_info.

Referenced by kalmanPropagateAndComputeChi2(), kalmanPropagateAndUpdate(), mkfit::MkBase::propagateTracksToHitR(), and mkfit::MkBase::propagateTracksToR().

                                                           {
     // bool debug = true;
 
     // This is used further down when calculating similarity with errorProp (and before in DEBUG).
     // MT: I don't think this really needed if we use inErr where required.
     outErr = inErr;
     // This requirement for helixAtRFromIterativeCCS_impl() and for helixAtRFromIterativeCCSFullJac().
     // MT: This should be properly handled in both functions (expecting input in output parameters sucks).
     outPar = inPar;
 
     MPlexLL errorProp;
 
     helixAtRFromIterativeCCS(inPar, inChg, msRad, outPar, errorProp, outFailFlag, N_proc, pflags);
 
 #ifdef DEBUG
     if (debug && g_debug) {
       for (int kk = 0; kk < N_proc; ++kk) {
         dprintf("outErr before prop %d\n", kk);
         for (int i = 0; i < 6; ++i) {
           for (int j = 0; j < 6; ++j)
             dprintf("%8f ", outErr.At(kk, i, j));
           dprintf("\n");
         }
         dprintf("\n");
 
         dprintf("errorProp %d\n", kk);
         for (int i = 0; i < 6; ++i) {
           for (int j = 0; j < 6; ++j)
             dprintf("%8f ", errorProp.At(kk, i, j));
           dprintf("\n");
         }
         dprintf("\n");
       }
     }
 #endif
 
     // MultHelixProp can be optimized for CCS coordinates, see GenMPlexOps.pl
     MPlexLL temp;
     MultHelixProp(errorProp, outErr, temp);
     MultHelixPropTransp(errorProp, temp, outErr);
     // can replace with: MultHelixPropFull(errorProp, outErr, temp); MultHelixPropTranspFull(errorProp, temp, outErr);
 
     if (pflags.apply_material) {
       MPlexQF hitsRl;
       MPlexQF hitsXi;
       MPlexQF propSign;
 
       const TrackerInfo& tinfo = *pflags.tracker_info;
 
 #pragma omp simd
       for (int n = 0; n < NN; ++n) {
         if (n < N_proc) {
           if (outFailFlag(n, 0, 0) || (noMatEffPtr && noMatEffPtr->constAt(n, 0, 0))) {
             hitsRl(n, 0, 0) = 0.f;
             hitsXi(n, 0, 0) = 0.f;
           } else {
             auto mat = tinfo.material_checked(std::abs(outPar(n, 2, 0)), msRad(n, 0, 0));
             hitsRl(n, 0, 0) = mat.radl;
             hitsXi(n, 0, 0) = mat.bbxi;
           }
           const float r0 = hipo(inPar(n, 0, 0), inPar(n, 1, 0));
           const float r = msRad(n, 0, 0);
           propSign(n, 0, 0) = (r > r0 ? 1. : -1.);
         }
       }
       MPlexHV plNrm;
 #pragma omp simd
       for (int n = 0; n < NN; ++n) {
         plNrm(n, 0, 0) = std::cos(outPar.constAt(n, 4, 0));
         plNrm(n, 1, 0) = std::sin(outPar.constAt(n, 4, 0));
         plNrm(n, 2, 0) = 0.f;
       }
       applyMaterialEffects(hitsRl, hitsXi, propSign, plNrm, outErr, outPar, N_proc);
     }
 
     squashPhiMPlex(outPar, N_proc);  // ensure phi is between |pi|
 
     // Matriplex version of:
     // result.errors = ROOT::Math::Similarity(errorProp, outErr);
 
     /*
      // To be used with: MPT_DIM = 1
      if (fabs(sqrt(outPar[0]*outPar[0]+outPar[1]*outPar[1]) - msRad[0]) > 0.0001)
      {
        std::cout << "DID NOT GET TO R, FailFlag=" << failFlag[0]
                  << " dR=" << msRad[0] - std::hypot(outPar[0],outPar[1])
                  << " r="  << msRad[0] << " rin=" << std::hypot(inPar[0],inPar[1]) << " rout=" << std::hypot(outPar[0],outPar[1])
                  << std::endl;
        // std::cout << "    pt=" << pt << " pz=" << inPar.At(n, 2) << std::endl;
      }
    */
 
     // PROP-FAIL-ENABLE To keep physics changes minimal, we always restore the
     // state to input when propagation fails -- as was the default before.
     // if (pflags.copy_input_state_on_fail) {
     for (int i = 0; i < N_proc; ++i) {
       if (outFailFlag(i, 0, 0)) {
         outPar.copySlot(i, inPar);
         outErr.copySlot(i, inErr);
       }
     }
     // }
   }

◆ propagateHelixToZMPlex()

void mkfit::propagateHelixToZMPlex	(	const MPlexLS &	inErr,
		const MPlexLV &	inPar,
		const MPlexQI &	inChg,
		const MPlexQF &	msZ,
		MPlexLS &	outErr,
		MPlexLV &	outPar,
		MPlexQI &	outFailFlag,
		const int	N_proc,
		const PropagationFlags &	pflags,
		const MPlexQI *	noMatEffPtr
	)

Definition at line 613 of file PropagationMPlex.cc.

References funct::abs(), mkfit::PropagationFlags::apply_material, applyMaterialEffects(), debug, dprintf, g_debug, helixAtZ(), Matriplex::hypot(), mps_fire::i, dqmiolumiharvest::j, GetRecoTauVFromDQM_MC_cff::kk, mkfit::TrackerInfo::material_checked(), dqmiodumpmetadata::n, NN, mkfit::TrackerInfo::Material::radl, squashPhiMPlex(), groupFilesInBlocks::temp, and mkfit::PropagationFlags::tracker_info.

Referenced by kalmanPropagateAndComputeChi2Endcap(), kalmanPropagateAndUpdateEndcap(), mkfit::MkBase::propagateTracksToHitZ(), mkfit::MkBase::propagateTracksToPCAZ(), and mkfit::MkBase::propagateTracksToZ().

                                                           {
     // debug = true;
 
     outErr = inErr;
     outPar = inPar;
 
     MPlexLL errorProp;
 
     //helixAtZ_new(inPar, inChg, msZ, outPar, errorProp, outFailFlag, N_proc, pflags);
     helixAtZ(inPar, inChg, msZ, outPar, errorProp, outFailFlag, N_proc, pflags);
 
 #ifdef DEBUG
     if (debug && g_debug) {
       for (int kk = 0; kk < N_proc; ++kk) {
         dprintf("inPar %d\n", kk);
         for (int i = 0; i < 6; ++i) {
           dprintf("%8f ", inPar.constAt(kk, i, 0));
         }
         dprintf("\n");
 
         dprintf("inErr %d\n", kk);
         for (int i = 0; i < 6; ++i) {
           for (int j = 0; j < 6; ++j)
             dprintf("%8f ", inErr.constAt(kk, i, j));
           dprintf("\n");
         }
         dprintf("\n");
 
         dprintf("errorProp %d\n", kk);
         for (int i = 0; i < 6; ++i) {
           for (int j = 0; j < 6; ++j)
             dprintf("%8f ", errorProp.At(kk, i, j));
           dprintf("\n");
         }
         dprintf("\n");
       }
     }
 #endif
 
 #ifdef DEBUG
     if (debug && g_debug) {
       for (int kk = 0; kk < N_proc; ++kk) {
         dprintf("outErr %d\n", kk);
         for (int i = 0; i < 6; ++i) {
           for (int j = 0; j < 6; ++j)
             dprintf("%8f ", outErr.constAt(kk, i, j));
           dprintf("\n");
         }
         dprintf("\n");
       }
     }
 #endif
 
     // Matriplex version of: result.errors = ROOT::Math::Similarity(errorProp, outErr);
     MPlexLL temp;
     MultHelixPropEndcap(errorProp, outErr, temp);
     MultHelixPropTranspEndcap(errorProp, temp, outErr);
     // can replace with: MultHelixPropFull(errorProp, outErr, temp); MultHelixPropTranspFull(errorProp, temp, outErr);
 
     if (pflags.apply_material) {
       MPlexQF hitsRl;
       MPlexQF hitsXi;
       MPlexQF propSign;
 
       const TrackerInfo& tinfo = *pflags.tracker_info;
 
 #pragma omp simd
       for (int n = 0; n < NN; ++n) {
         if (n >= N_proc || (noMatEffPtr && noMatEffPtr->constAt(n, 0, 0))) {
           hitsRl(n, 0, 0) = 0.f;
           hitsXi(n, 0, 0) = 0.f;
         } else {
           const float hypo = std::hypot(outPar(n, 0, 0), outPar(n, 1, 0));
           auto mat = tinfo.material_checked(std::abs(msZ(n, 0, 0)), hypo);
           hitsRl(n, 0, 0) = mat.radl;
           hitsXi(n, 0, 0) = mat.bbxi;
         }
         if (n < N_proc) {
           const float zout = msZ.constAt(n, 0, 0);
           const float zin = inPar.constAt(n, 2, 0);
           propSign(n, 0, 0) = (std::abs(zout) > std::abs(zin) ? 1.f : -1.f);
         }
       }
       MPlexHV plNrm;
 #pragma omp simd
       for (int n = 0; n < NN; ++n) {
         plNrm(n, 0, 0) = 0.f;
         plNrm(n, 1, 0) = 0.f;
         plNrm(n, 2, 0) = 1.f;
       }
       applyMaterialEffects(hitsRl, hitsXi, propSign, plNrm, outErr, outPar, N_proc);
 #ifdef DEBUG
       if (debug && g_debug) {
         for (int kk = 0; kk < N_proc; ++kk) {
           dprintf("propSign %d\n", kk);
           for (int i = 0; i < 1; ++i) {
             dprintf("%8f ", propSign.constAt(kk, i, 0));
           }
           dprintf("\n");
           dprintf("plNrm %d\n", kk);
           for (int i = 0; i < 3; ++i) {
             dprintf("%8f ", plNrm.constAt(kk, i, 0));
           }
           dprintf("\n");
           dprintf("outErr(after material) %d\n", kk);
           for (int i = 0; i < 6; ++i) {
             for (int j = 0; j < 6; ++j)
               dprintf("%8f ", outErr.constAt(kk, i, j));
             dprintf("\n");
           }
           dprintf("\n");
         }
       }
 #endif
     }
 
     squashPhiMPlex(outPar, N_proc);  // ensure phi is between |pi|
 
     // PROP-FAIL-ENABLE To keep physics changes minimal, we always restore the
     // state to input when propagation fails -- as was the default before.
     // if (pflags.copy_input_state_on_fail) {
     for (int i = 0; i < N_proc; ++i) {
       if (outFailFlag(i, 0, 0)) {
         outPar.copySlot(i, inPar);
         outErr.copySlot(i, inErr);
       }
     }
     // }
   }

◆ propagateLineToRMPlex()

void mkfit::propagateLineToRMPlex	(	const MPlexLS &	psErr,
		const MPlexLV &	psPar,
		const MPlexHS &	msErr,
		const MPlexHV &	msPar,
		MPlexLS &	outErr,
		MPlexLV &	outPar,
		const int	N_proc
	)

Definition at line 19 of file PropagationMPlex.cc.

References A, B, dprint_np, hipo(), N, dqmiodumpmetadata::n, NN, AlCaHLTBitMon_ParallelJobs::p, DiDispStaMuonMonitor_cfi::pt, and mathSSE::sqrt().

                                                {
     // XXX Regenerate parts below with a script.
 
     const Matriplex::idx_t N = NN;
 
 #pragma omp simd
     for (int n = 0; n < NN; ++n) {
       const float cosA = (psPar[0 * N + n] * psPar[3 * N + n] + psPar[1 * N + n] * psPar[4 * N + n]) /
                          (std::sqrt((psPar[0 * N + n] * psPar[0 * N + n] + psPar[1 * N + n] * psPar[1 * N + n]) *
                                     (psPar[3 * N + n] * psPar[3 * N + n] + psPar[4 * N + n] * psPar[4 * N + n])));
       const float dr = (hipo(msPar[0 * N + n], msPar[1 * N + n]) - hipo(psPar[0 * N + n], psPar[1 * N + n])) / cosA;
 
       dprint_np(n, "propagateLineToRMPlex dr=" << dr);
 
       const float pt = hipo(psPar[3 * N + n], psPar[4 * N + n]);
       const float p = dr / pt;  // path
       const float psq = p * p;
 
       outPar[0 * N + n] = psPar[0 * N + n] + p * psPar[3 * N + n];
       outPar[1 * N + n] = psPar[1 * N + n] + p * psPar[4 * N + n];
       outPar[2 * N + n] = psPar[2 * N + n] + p * psPar[5 * N + n];
       outPar[3 * N + n] = psPar[3 * N + n];
       outPar[4 * N + n] = psPar[4 * N + n];
       outPar[5 * N + n] = psPar[5 * N + n];
 
       {
         const MPlexLS& A = psErr;
         MPlexLS& B = outErr;
 
         B.fArray[0 * N + n] = A.fArray[0 * N + n];
         B.fArray[1 * N + n] = A.fArray[1 * N + n];
         B.fArray[2 * N + n] = A.fArray[2 * N + n];
         B.fArray[3 * N + n] = A.fArray[3 * N + n];
         B.fArray[4 * N + n] = A.fArray[4 * N + n];
         B.fArray[5 * N + n] = A.fArray[5 * N + n];
         B.fArray[6 * N + n] = A.fArray[6 * N + n] + p * A.fArray[0 * N + n];
         B.fArray[7 * N + n] = A.fArray[7 * N + n] + p * A.fArray[1 * N + n];
         B.fArray[8 * N + n] = A.fArray[8 * N + n] + p * A.fArray[3 * N + n];
         B.fArray[9 * N + n] =
             A.fArray[9 * N + n] + p * (A.fArray[6 * N + n] + A.fArray[6 * N + n]) + psq * A.fArray[0 * N + n];
         B.fArray[10 * N + n] = A.fArray[10 * N + n] + p * A.fArray[1 * N + n];
         B.fArray[11 * N + n] = A.fArray[11 * N + n] + p * A.fArray[2 * N + n];
         B.fArray[12 * N + n] = A.fArray[12 * N + n] + p * A.fArray[4 * N + n];
         B.fArray[13 * N + n] =
             A.fArray[13 * N + n] + p * (A.fArray[7 * N + n] + A.fArray[10 * N + n]) + psq * A.fArray[1 * N + n];
         B.fArray[14 * N + n] =
             A.fArray[14 * N + n] + p * (A.fArray[11 * N + n] + A.fArray[11 * N + n]) + psq * A.fArray[2 * N + n];
         B.fArray[15 * N + n] = A.fArray[15 * N + n] + p * A.fArray[3 * N + n];
         B.fArray[16 * N + n] = A.fArray[16 * N + n] + p * A.fArray[4 * N + n];
         B.fArray[17 * N + n] = A.fArray[17 * N + n] + p * A.fArray[5 * N + n];
         B.fArray[18 * N + n] =
             A.fArray[18 * N + n] + p * (A.fArray[8 * N + n] + A.fArray[15 * N + n]) + psq * A.fArray[3 * N + n];
         B.fArray[19 * N + n] =
             A.fArray[19 * N + n] + p * (A.fArray[12 * N + n] + A.fArray[16 * N + n]) + psq * A.fArray[4 * N + n];
         B.fArray[20 * N + n] =
             A.fArray[20 * N + n] + p * (A.fArray[17 * N + n] + A.fArray[17 * N + n]) + psq * A.fArray[5 * N + n];
       }
 
       dprint_np(n, "propagateLineToRMPlex arrive at r=" << hipo(outPar[0 * N + n], outPar[1 * N + n]));
     }
   }

◆ run_OneIteration()

void mkfit::run_OneIteration	(	const TrackerInfo &	trackerInfo,
		const IterationConfig &	itconf,
		const EventOfHits &	eoh,
		const std::vector< const std::vector< bool > *> &	hit_masks,
		MkBuilder &	builder,
		TrackVec &	seeds,
		TrackVec &	out_tracks,
		bool	do_seed_clean,
		bool	do_backward_fit,
		bool	do_remove_duplicates
	)

Definition at line 29 of file runFunctions.cc.

Referenced by MkFitProducer::produce().

                                                    {
     IterationMaskIfcCmssw it_mask_ifc(trackerInfo, hit_masks);
 
     MkJob job({trackerInfo, itconf, eoh, eoh.refBeamSpot(), &it_mask_ifc});
 
     builder.begin_event(&job, nullptr, __func__);
 
     // Seed cleaning not done on all iterations.
     do_seed_clean = do_seed_clean && itconf.m_seed_cleaner;
 
     if (do_seed_clean)
       itconf.m_seed_cleaner(seeds, itconf, eoh.refBeamSpot());
 
     // Check nans in seeds -- this should not be needed when Slava fixes
     // the track parameter coordinate transformation.
     builder.seed_post_cleaning(seeds);
 
     if (itconf.m_requires_seed_hit_sorting) {
       for (auto &s : seeds)
         s.sortHitsByLayer();  // sort seed hits for the matched hits (I hope it works here)
     }
 
     builder.find_tracks_load_seeds(seeds, do_seed_clean);
 
     builder.findTracksCloneEngine();
 
     // Pre backward-fit filtering.
     filter_candidates_func pre_filter;
     if (do_backward_fit && itconf.m_pre_bkfit_filter)
       pre_filter = [&](const TrackCand &tc, const MkJob &jb) -> bool {
         return itconf.m_pre_bkfit_filter(tc, jb) && StdSeq::qfilter_nan_n_silly<TrackCand>(tc, jb);
       };
     else if (itconf.m_pre_bkfit_filter)
       pre_filter = itconf.m_pre_bkfit_filter;
     else if (do_backward_fit)
       pre_filter = StdSeq::qfilter_nan_n_silly<TrackCand>;
     // pre_filter can be null if we are not doing backward fit as nan_n_silly will be run below.
     if (pre_filter)
       builder.filter_comb_cands(pre_filter, true);
 
     job.switch_to_backward();
 
     if (do_backward_fit) {
       if (itconf.m_backward_search) {
         builder.compactifyHitStorageForBestCand(itconf.m_backward_drop_seed_hits, itconf.m_backward_fit_min_hits);
       }
 
       builder.backwardFit();
 
       if (itconf.m_backward_search) {
         builder.beginBkwSearch();
         builder.findTracksCloneEngine(SteeringParams::IT_BkwSearch);
       }
     }
 
     // Post backward-fit filtering.
     filter_candidates_func post_filter;
     if (do_backward_fit && itconf.m_post_bkfit_filter)
       post_filter = [&](const TrackCand &tc, const MkJob &jb) -> bool {
         return itconf.m_post_bkfit_filter(tc, jb) && StdSeq::qfilter_nan_n_silly<TrackCand>(tc, jb);
       };
     else
       post_filter = StdSeq::qfilter_nan_n_silly<TrackCand>;
     // post_filter is always at least doing nan_n_silly filter.
     builder.filter_comb_cands(post_filter, true);
 
     if (do_backward_fit && itconf.m_backward_search)
       builder.endBkwSearch();
 
     builder.export_best_comb_cands(out_tracks, true);
 
     if (do_remove_duplicates && itconf.m_duplicate_cleaner) {
       itconf.m_duplicate_cleaner(out_tracks, itconf);
     }
 
     builder.end_event();
     builder.release_memory();
   }

◆ runBtpCe_MultiIter()

std::vector< double > mkfit::runBtpCe_MultiIter	(	Event &	ev,
		const EventOfHits &	eoh,
		MkBuilder &	builder,
		int	n
	)

Definition at line 416 of file buildtestMPlex.cc.

Referenced by test_standard().

                                                                                                      {
     std::vector<double> timevec;
     if (n <= 0)
       return timevec;
     timevec.resize(n + 1, 0.0);
 
     const bool validation_on = (Config::sim_val || Config::quality_val);
 
     TrackVec seeds_used;
     TrackVec seeds1;
 
     if (validation_on) {
       for (auto const &s : ev.seedTracks_) {
         //keep seeds form the first n iterations for processing
         if (std::find(algorithms, algorithms + n, s.algoint()) != algorithms + n)
           seeds1.push_back(s);
       }
       ev.seedTracks_.swap(seeds1);  //necessary for the validation - PrepareSeeds
       ev.relabel_bad_seedtracks();  //necessary for the validation - PrepareSeeds
     }
 
     IterationMaskIfc mask_ifc;
     TrackVec seeds;
     TrackVec tmp_tvec;
 
     for (int it = 0; it <= n - 1; ++it) {
       const IterationConfig &itconf = Config::ItrInfo[it];
 
       // To disable hit-masks, pass nullptr in place of &mask_ifc to MkJob ctor
       // and optionally comment out ev.fill_hitmask_bool_vectors() call.
 
       ev.fill_hitmask_bool_vectors(itconf.m_track_algorithm, mask_ifc.m_mask_vector);
 
       MkJob job({Config::TrkInfo, itconf, eoh, eoh.refBeamSpot(), &mask_ifc});
 
       builder.begin_event(&job, &ev, __func__);
 
       {  // We could partition seeds once, store beg, end for each iteration in a map or vector.
         seeds.clear();
         int nc = 0;
         for (auto &s : ev.seedTracks_) {
           if (s.algoint() == itconf.m_track_algorithm) {
             if (itconf.m_requires_seed_hit_sorting) {
               s.sortHitsByLayer();
             }
             seeds.push_back(s);
             ++nc;
           } else if (nc > 0)
             break;
         }
       }
 
       bool do_seed_clean = bool(itconf.m_seed_cleaner);
 
       if (do_seed_clean)
         itconf.m_seed_cleaner(seeds, itconf, eoh.refBeamSpot());
 
       builder.seed_post_cleaning(seeds);
 
       // Add protection in case no seeds are found for iteration
       if (seeds.size() <= 0)
         continue;
       ev.setCurrentSeedTracks(seeds);
 
       builder.find_tracks_load_seeds(seeds, do_seed_clean);
 
       double time = dtime();
 
       builder.findTracksCloneEngine();
 
       timevec[it] = dtime() - time;
       timevec[n] += timevec[it];
 
       // Print min and max size of hots vectors of CombCands.
       // builder.find_min_max_hots_size();
 
       if (validation_on)
         seeds_used.insert(seeds_used.end(), seeds.begin(), seeds.end());  //cleaned seeds need to be stored somehow
 
       // Pre backward-fit filtering.
       // Note -- slightly different logic than run_OneIteration as we always do nan filters for
       // export for validation.
       filter_candidates_func pre_filter;
       if (itconf.m_pre_bkfit_filter)
         pre_filter = [&](const TrackCand &tc, const MkJob &jb) -> bool {
           return itconf.m_pre_bkfit_filter(tc, jb) && StdSeq::qfilter_nan_n_silly<TrackCand>(tc, jb);
         };
       else
         pre_filter = StdSeq::qfilter_nan_n_silly<TrackCand>;
       // pre_filter is always at least doing nan_n_silly filter.
       builder.filter_comb_cands(pre_filter, true);
 
       builder.select_best_comb_cands();
 
       {
         builder.export_tracks(tmp_tvec);
         if (itconf.m_duplicate_cleaner)
           itconf.m_duplicate_cleaner(builder.ref_tracks_nc(), itconf);
         ev.candidateTracks_.reserve(ev.candidateTracks_.size() + tmp_tvec.size());
         for (auto &&t : tmp_tvec)
           ev.candidateTracks_.emplace_back(std::move(t));
         tmp_tvec.clear();
       }
 
       job.switch_to_backward();
 
       // now do backwards fit... do we want to time this section?
       if (Config::backwardFit) {
         // a) TrackVec version:
         // builder.backwardFitBH();
 
         // b) Version that runs on CombCand / TrackCand
         const bool do_backward_search = Config::backwardSearch && itconf.m_backward_search;
 
         // We copy seed-hits into Candidates ... now we have to remove them so backward fit stops
         // before reaching seeding region. Ideally, we wouldn't add them in the first place but
         // if we want to export full tracks above we need to hold on to them (alternatively, we could
         // have a pointer to seed track in CombCandidate and copy them from there).
         if (do_backward_search)
           builder.compactifyHitStorageForBestCand(itconf.m_backward_drop_seed_hits, itconf.m_backward_fit_min_hits);
 
         builder.backwardFit();
 
         if (do_backward_search) {
           builder.beginBkwSearch();
           builder.findTracksCloneEngine(SteeringParams::IT_BkwSearch);
         }
 
         // Post backward-fit filtering.
         // Note -- slightly different logic than run_OneIteration as we export both pre and post
         // backward-fit tracks.
         filter_candidates_func post_filter;
         if (itconf.m_post_bkfit_filter)
           post_filter = [&](const TrackCand &tc, const MkJob &jb) -> bool {
             return itconf.m_post_bkfit_filter(tc, jb) && StdSeq::qfilter_nan_n_silly<TrackCand>(tc, jb);
           };
         else
           post_filter = StdSeq::qfilter_nan_n_silly<TrackCand>;
         // post_filter is always at least doing nan_n_silly filter.
         builder.filter_comb_cands(post_filter, true);
 
         if (do_backward_search)
           builder.endBkwSearch();
 
         builder.select_best_comb_cands(true);  // true -> clear m_tracks as they were already filled once above
 
         if (itconf.m_duplicate_cleaner)
           itconf.m_duplicate_cleaner(builder.ref_tracks_nc(), itconf);
 
         builder.export_tracks(ev.fitTracks_);
       }
       ev.resetCurrentSeedTracks();
 
       builder.end_event();
     }
 
     // MIMI - Fake back event pointer for final processing (that should be done elsewhere)
     MkJob job({Config::TrkInfo, Config::ItrInfo[0], eoh, eoh.refBeamSpot()});
     builder.begin_event(&job, &ev, __func__);
 
     if (validation_on) {
       StdSeq::prep_simtracks(&ev);
       //swap for the cleaned seeds
       ev.seedTracks_.swap(seeds_used);
     }
 
     check_nan_n_silly_candidates(ev);
 
     if (Config::backwardFit)
       check_nan_n_silly_bkfit(ev);
 
     // validation section
     if (Config::quality_val) {
       StdSeq::Quality qval;
       qval.quality_val(&ev);
     } else if (Config::sim_val || Config::cmssw_val) {
       StdSeq::root_val(&ev);
     }
 
     // ev.print_tracks(ev.candidateTracks_, true);
 
     // MIMI Unfake.
     builder.end_event();
 
     // In CMSSW runOneIter we now release memory for comb-cands:
     builder.release_memory();
 
     return timevec;
   }

◆ runBuildingTestPlexBestHit()

double mkfit::runBuildingTestPlexBestHit	(	Event &	ev,
		const EventOfHits &	eoh,
		MkBuilder &	builder
	)

Definition at line 108 of file buildtestMPlex.cc.

Referenced by test_standard().

                                                                                            {
     const IterationConfig &itconf = Config::ItrInfo[0];
 
     const bool validation_on = (Config::sim_val || Config::quality_val);
 
     TrackVec seeds1;
     if (validation_on) {
       unsigned int algorithms[] = {4};  //only initialStep
 
       for (auto const &s : ev.seedTracks_) {
         //keep seeds form the first iteration for processing
         if (std::find(algorithms, algorithms + 1, s.algoint()) != algorithms + 1)
           seeds1.push_back(s);
       }
       ev.seedTracks_.swap(seeds1);  //necessary for the validation - PrepareSeeds
       ev.relabel_bad_seedtracks();  //necessary for the validation - PrepareSeeds
     }
 
     IterationMaskIfc mask_ifc;
 
     // To disable hit-masks, pass nullptr in place of &mask_ifc to MkJob ctor
     // and optionally comment out ev.fill_hitmask_bool_vectors() call.
 
     ev.fill_hitmask_bool_vectors(itconf.m_track_algorithm, mask_ifc.m_mask_vector);
 
     MkJob job({Config::TrkInfo, itconf, eoh, eoh.refBeamSpot(), &mask_ifc});
 
     builder.begin_event(&job, &ev, __func__);
 
     bool seeds_sorted = false;
     // CCCC builder.PrepareSeeds();
 
     // EventOfCandidates event_of_cands;
     builder.find_tracks_load_seeds_BH(ev.seedTracks_, seeds_sorted);
 
 #ifdef USE_VTUNE_PAUSE
     __SSC_MARK(0x111);  // use this to resume Intel SDE at the same point
     __itt_resume();
 #endif
 
     double time = dtime();
 
     builder.findTracksBestHit();
 
     time = dtime() - time;
 
 #ifdef USE_VTUNE_PAUSE
     __itt_pause();
     __SSC_MARK(0x222);  // use this to pause Intel SDE at the same point
 #endif
 
     // Hack, get the tracks out.
     ev.candidateTracks_ = builder.ref_tracks();
 
     // For best hit, the candidateTracks_ vector is the direct input to the backward fit so only need to do clean_duplicates once
     if (Config::quality_val || Config::sim_val || Config::cmssw_val) {
       //Mark tracks as duplicates; if within CMSSW, remove duplicate tracks before backward fit
       // CCCC if (Config::removeDuplicates) {
       // CCCC   StdSeq::clean_duplicates(ev.candidateTracks_);
       // CCCC }
     }
 
     job.switch_to_backward();
 
     // now do backwards fit... do we want to time this section?
     if (Config::backwardFit) {
       builder.backwardFitBH();
       ev.fitTracks_ = builder.ref_tracks();
     }
 
     if (Config::quality_val) {
       StdSeq::Quality qval;
       qval.quality_val(&ev);
     } else if (Config::sim_val || Config::cmssw_val) {
       StdSeq::root_val(&ev);
     }
 
     builder.end_event();
 
     // ev.print_tracks(ev.candidateTracks_, true);
 
     if (validation_on) {
       ev.seedTracks_.swap(seeds1);
     }
 
     return time;
   }

◆ runBuildingTestPlexCloneEngine()

double mkfit::runBuildingTestPlexCloneEngine	(	Event &	ev,
		const EventOfHits &	eoh,
		MkBuilder &	builder
	)

Definition at line 296 of file buildtestMPlex.cc.

Referenced by test_standard().

                                                                                                {
     const IterationConfig &itconf = Config::ItrInfo[0];
 
     const bool validation_on = (Config::sim_val || Config::quality_val);
 
     TrackVec seeds1;
     if (validation_on) {
       unsigned int algorithms[] = {4};  //only initialStep
 
       for (auto const &s : ev.seedTracks_) {
         //keep seeds form the first iteration for processing
         if (std::find(algorithms, algorithms + 1, s.algoint()) != algorithms + 1)
           seeds1.push_back(s);
       }
       ev.seedTracks_.swap(seeds1);  //necessary for the validation - PrepareSeeds
       ev.relabel_bad_seedtracks();  //necessary for the validation - PrepareSeeds
     }
 
     IterationMaskIfc mask_ifc;
 
     // To disable hit-masks, pass nullptr in place of &mask_ifc to MkJob ctor
     // and optionally comment out ev.fill_hitmask_bool_vectors() call.
 
     ev.fill_hitmask_bool_vectors(itconf.m_track_algorithm, mask_ifc.m_mask_vector);
 
     MkJob job({Config::TrkInfo, itconf, eoh, eoh.refBeamSpot(), &mask_ifc});
 
     builder.begin_event(&job, &ev, __func__);
 
     bool seeds_sorted = false;
     // CCCC builder.PrepareSeeds();
     ev.setCurrentSeedTracks(ev.seedTracks_);
 
     builder.find_tracks_load_seeds(ev.seedTracks_, seeds_sorted);
 
 #ifdef USE_VTUNE_PAUSE
     __SSC_MARK(0x111);  // use this to resume Intel SDE at the same point
     __itt_resume();
 #endif
 
     double time = dtime();
 
     builder.findTracksCloneEngine();
 
     time = dtime() - time;
 
 #ifdef USE_VTUNE_PAUSE
     __itt_pause();
     __SSC_MARK(0x222);  // use this to pause Intel SDE at the same point
 #endif
 
     check_nan_n_silly_candidates(ev);
 
     // first store candidate tracks - needed for BH backward fit and root_validation
     ev.candidateTracks_.clear();
     builder.export_best_comb_cands(ev.candidateTracks_);
 
     job.switch_to_backward();
 
     // now do backwards fit... do we want to time this section?
     if (Config::backwardFit) {
       // a) TrackVec version:
       builder.select_best_comb_cands();
       builder.backwardFitBH();
       ev.fitTracks_ = builder.ref_tracks();
 
       // b) Version that runs on CombCand / TrackCand
       // builder.backwardFit();
       // builder.quality_store_tracks(ev.fitTracks_);
 
       check_nan_n_silly_bkfit(ev);
     }
 
     // CCCC StdSeq::handle_duplicates(&ev);
 
     // validation section
     if (Config::quality_val) {
       StdSeq::Quality qval;
       qval.quality_val(&ev);
     } else if (Config::sim_val || Config::cmssw_val) {
       StdSeq::root_val(&ev);
     }
 
     ev.resetCurrentSeedTracks();
 
     builder.end_event();
 
     // ev.print_tracks(ev.candidateTracks_, true);
 
     if (validation_on) {
       ev.seedTracks_.swap(seeds1);
     }
 
     return time;
   }

◆ runBuildingTestPlexDumbCMSSW()

void mkfit::runBuildingTestPlexDumbCMSSW	(	Event &	ev,
		const EventOfHits &	eoh,
		MkBuilder &	builder
	)

Definition at line 90 of file buildtestMPlex.cc.

References mkfit::MkBuilder::begin_event(), mkfit::MkBuilder::end_event(), makeMEIFBenchmarkPlots::ev, mkfit::Config::ItrInfo, mkfit::EventOfHits::refBeamSpot(), mkfit::StdSeq::root_val_dumb_cmssw(), mkfit::Config::sim_val_for_cmssw, and mkfit::Config::TrkInfo.

Referenced by test_standard().

                                                                                            {
     const IterationConfig &itconf = Config::ItrInfo[0];
 
     MkJob job({Config::TrkInfo, itconf, eoh, eoh.refBeamSpot()});
 
     builder.begin_event(&job, &ev, __func__);
 
     if (Config::sim_val_for_cmssw) {
       StdSeq::root_val_dumb_cmssw(&ev);
     }
 
     builder.end_event();
   }

◆ runBuildingTestPlexStandard()

double mkfit::runBuildingTestPlexStandard	(	Event &	ev,
		const EventOfHits &	eoh,
		MkBuilder &	builder
	)

Definition at line 200 of file buildtestMPlex.cc.

Referenced by test_standard().

                                                                                             {
     const IterationConfig &itconf = Config::ItrInfo[0];
 
     const bool validation_on = (Config::sim_val || Config::quality_val);
 
     TrackVec seeds1;
     if (validation_on) {
       unsigned int algorithms[] = {4};  //only initialStep
 
       for (auto const &s : ev.seedTracks_) {
         //keep seeds form the first iteration for processing
         if (std::find(algorithms, algorithms + 1, s.algoint()) != algorithms + 1)
           seeds1.push_back(s);
       }
       ev.seedTracks_.swap(seeds1);  //necessary for the validation - PrepareSeeds
       ev.relabel_bad_seedtracks();  //necessary for the validation - PrepareSeeds
     }
 
     IterationMaskIfc mask_ifc;
 
     // To disable hit-masks, pass nullptr in place of &mask_ifc to MkJob ctor
     // and optionally comment out ev.fill_hitmask_bool_vectors() call.
 
     ev.fill_hitmask_bool_vectors(itconf.m_track_algorithm, mask_ifc.m_mask_vector);
 
     MkJob job({Config::TrkInfo, itconf, eoh, eoh.refBeamSpot(), &mask_ifc});
 
     builder.begin_event(&job, &ev, __func__);
 
     bool seeds_sorted = false;
     // CCCC builder.PrepareSeeds();
     ev.setCurrentSeedTracks(ev.seedTracks_);
 
     builder.find_tracks_load_seeds(ev.seedTracks_, seeds_sorted);
 
 #ifdef USE_VTUNE_PAUSE
     __SSC_MARK(0x111);  // use this to resume Intel SDE at the same point
     __itt_resume();
 #endif
 
     double time = dtime();
 
     builder.findTracksStandard();
 
     time = dtime() - time;
 
 #ifdef USE_VTUNE_PAUSE
     __itt_pause();
     __SSC_MARK(0x222);  // use this to pause Intel SDE at the same point
 #endif
 
     check_nan_n_silly_candidates(ev);
 
     // first store candidate tracks
     ev.candidateTracks_.clear();
     builder.export_best_comb_cands(ev.candidateTracks_);
 
     job.switch_to_backward();
 
     // now do backwards fit... do we want to time this section?
     if (Config::backwardFit) {
       // Using the TrackVec version until we home in on THE backward fit etc.
       // builder.backwardFit();
       builder.select_best_comb_cands();
       builder.backwardFitBH();
       ev.fitTracks_ = builder.ref_tracks();
 
       check_nan_n_silly_bkfit(ev);
     }
 
     // CCCC StdSeq::handle_duplicates(&ev);
 
     if (Config::quality_val) {
       StdSeq::Quality qval;
       qval.quality_val(&ev);
     } else if (Config::sim_val || Config::cmssw_val) {
       StdSeq::root_val(&ev);
     }
 
     ev.resetCurrentSeedTracks();
 
     builder.end_event();
 
     // ev.print_tracks(ev.candidateTracks_, true);
 
     if (validation_on) {
       ev.seedTracks_.swap(seeds1);
     }
 
     return time;
   }

◆ runFittingTestPlex()

double mkfit::runFittingTestPlex	(	Event &	ev,
		std::vector< Track > &	rectracks
	)

Definition at line 40 of file fittestMPlex.cc.

References submitPVResolutionJobs::count, dtime(), makeMEIFBenchmarkPlots::ev, mkfit::Config::fit_val, g_exe_ctx, mps_fire::i, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, mkfit::ExecutionContext::m_fitters, SiStripPI::max, mkfit::Config::nLayers, NN, mkfit::Config::numSeedsPerTask, mkfit::Config::numThreadsFinder, mkfit::ExecutionContext::populate(), and hcalRecHitTable_cff::time.

                                                                     {
     g_exe_ctx.populate(Config::numThreadsFinder);
     std::vector<Track>& simtracks = ev.simTracks_;
 
     const int Nhits = Config::nLayers;
     // XXX What if there's a missing / double layer?
     // Eventually, should sort track vector by number of hits!
     // And pass the number in on each "setup" call.
     // Reserves should be made for maximum possible number (but this is just
     // measurments errors, params).
 
     int theEnd = simtracks.size();
     int count = (theEnd + NN - 1) / NN;
 
 #ifdef USE_VTUNE_PAUSE
     __SSC_MARK(0x111);  // use this to resume Intel SDE at the same point
     __itt_resume();
 #endif
 
     double time = dtime();
 
     tbb::parallel_for(tbb::blocked_range<int>(0, count, std::max(1, Config::numSeedsPerTask / NN)),
                       [&](const tbb::blocked_range<int>& i) {
                         std::unique_ptr<MkFitter, decltype(retfitr)> mkfp(g_exe_ctx.m_fitters.GetFromPool(), retfitr);
                         mkfp->setNhits(Nhits);
                         for (int it = i.begin(); it < i.end(); ++it) {
                           int itrack = it * NN;
                           int end = itrack + NN;
                           /*
          * MT, trying to slurp and fit at the same time ...
       if (theEnd < end) {
         end = theEnd;
         mkfp->inputTracksAndHits(simtracks, ev.layerHits_, itrack, end);
       } else {
         mkfp->slurpInTracksAndHits(simtracks, ev.layerHits_, itrack, end); // only safe for a full matriplex
       }
       
       if (Config::cf_fitting) mkfp->ConformalFitTracks(true, itrack, end);
       mkfp->FitTracks(end - itrack, &ev, true);
         */
 
                           mkfp->inputTracksForFit(simtracks, itrack, end);
 
                           // XXXX MT - for this need 3 points in ... right
                           // XXXX if (Config::cf_fitting) mkfp->ConformalFitTracks(true, itrack, end);
 
                           mkfp->fitTracksWithInterSlurp(ev.layerHits_, end - itrack);
 
                           mkfp->outputFittedTracks(rectracks, itrack, end);
                         }
                       });
 
     time = dtime() - time;
 
 #ifdef USE_VTUNE_PAUSE
     __itt_pause();
     __SSC_MARK(0x222);  // use this to pause Intel SDE at the same point
 #endif
 
     if (Config::fit_val)
       ev.validate();
 
     return time;
   }

◆ sincos4()

void mkfit::sincos4	(	const float	x,
		float &	sin,
		float &	cos
	)

inline

Definition at line 13 of file Matrix.h.

References funct::cos(), funct::sin(), and x.

Referenced by helixAtRFromIterativeCCSFullJac(), and helixAtZ().

                                                              {
     // Had this writen with explicit division by factorial.
     // The *whole* fitting test ran like 2.5% slower on MIC, sigh.
 
     const float x2 = x * x;
     cos = 1.f - 0.5f * x2 + 0.04166667f * x2 * x2;
     sin = x - 0.16666667f * x * x2;
   }

◆ sortByEta()

bool mkfit::sortByEta	(	const Hit &	hit1,
		const Hit &	hit2
	)

inline

Definition at line 25 of file buildtestMPlex.cc.

References mkfit::Hit::eta().

25 { return hit1.eta() < hit2.eta(); }

◆ sortByHitsChi2() [1/2]

bool mkfit::sortByHitsChi2	(	const std::pair< Track, TrackState > &	cand1,
		const std::pair< Track, TrackState > &	cand2
	)

inline

Definition at line 14 of file buildtestMPlex.cc.

                                                                                                                {
     if (cand1.first.nFoundHits() == cand2.first.nFoundHits())
       return cand1.first.chi2() < cand2.first.chi2();
 
     return cand1.first.nFoundHits() > cand2.first.nFoundHits();
   }

◆ sortByHitsChi2() [2/2]

bool mkfit::sortByHitsChi2	(	const Track &	cand1,
		const Track &	cand2
	)

inline

Definition at line 585 of file Track.h.

References mkfit::TrackBase::chi2(), and mkfit::Track::nFoundHits().

                                                                      {
     if (cand1.nFoundHits() == cand2.nFoundHits())
       return cand1.chi2() < cand2.chi2();
     return cand1.nFoundHits() > cand2.nFoundHits();
   }

◆ sortByPhi()

bool mkfit::sortByPhi	(	const Hit &	hit1,
		const Hit &	hit2
	)

inline

Definition at line 21 of file buildtestMPlex.cc.

References mkfit::Hit::x(), and mkfit::Hit::y().

                                                           {
     return std::atan2(hit1.y(), hit1.x()) < std::atan2(hit2.y(), hit2.x());
   }

◆ sortByScoreCand()

bool mkfit::sortByScoreCand	(	const Track &	cand1,
		const Track &	cand2
	)

inline

Definition at line 591 of file Track.h.

References mkfit::TrackBase::score().

Referenced by mkfit::TTreeValidation::mapRefTkToRecoTks().

591 { return cand1.score() > cand2.score(); }

◆ sortByScoreStruct()

bool mkfit::sortByScoreStruct	(	const IdxChi2List &	cand1,
		const IdxChi2List &	cand2
	)

inline

Definition at line 593 of file Track.h.

References mkfit::IdxChi2List::score.

                                                                                     {
     return cand1.score > cand2.score;
   }

◆ sortByScoreTrackCand()

bool mkfit::sortByScoreTrackCand	(	const TrackCand &	cand1,
		const TrackCand &	cand2
	)

inline

Definition at line 255 of file TrackStructures.h.

References mkfit::TrackBase::score().

Referenced by mkfit::CombCandidate::mergeCandsAndBestShortOne(), and mkfit::CandCloner::processSeedRange().

                                                                                    {
     return cand1.score() > cand2.score();
   }

◆ sortByZ()

bool mkfit::sortByZ	(	const Hit &	hit1,
		const Hit &	hit2
	)

inline

Definition at line 43 of file buildtestMPlex.cc.

References mkfit::Hit::z().

43 { return hit1.z() < hit2.z(); }

Hit::z

double z

global z - AlignmentGeometry::z0, mm

Definition: HitCollection.h:27

◆ sortIDsByChi2()

bool mkfit::sortIDsByChi2	(	const idchi2Pair &	cand1,
		const idchi2Pair &	cand2
	)

inline

Definition at line 235 of file TrackExtra.cc.

Referenced by mkfit::TrackExtra::setCMSSWTrackIDInfoByTrkParams().

235 { return cand1.second < cand2.second; }

◆ sortTracksByEta()

bool mkfit::sortTracksByEta	(	const Track &	track1,
		const Track &	track2
	)

inline

Definition at line 27 of file buildtestMPlex.cc.

References mkfit::TrackBase::momEta().

27 { return track1.momEta() < track2.momEta(); }

◆ sortTracksByPhi()

bool mkfit::sortTracksByPhi	(	const Track &	track1,
		const Track &	track2
	)

inline

Definition at line 29 of file buildtestMPlex.cc.

References mkfit::TrackBase::momPhi().

29 { return track1.momPhi() < track2.momPhi(); }

◆ sqr()

template<typename T >

T mkfit::sqr ( T x )

inline

Definition at line 14 of file Hit.h.

References x.

                     {
     return x * x;
   }

◆ squashPhiGeneral() [1/2]

float mkfit::squashPhiGeneral ( float phi )

inline

Definition at line 22 of file Hit.h.

References mkfit::Const::InvPI, mkfit::Const::PI, and mkfit::Const::TwoPI.

Referenced by computeHelixChi2(), mkfit::TrackExtra::setCMSSWTrackIDInfoByHits(), mkfit::TrackExtra::setCMSSWTrackIDInfoByTrkParams(), mkfit::TrackExtra::setMCTrackIDInfo(), squashPhiGeneral(), and mkfit::TrackBase::swimPhiToR().

                                            {
     return phi - floor(0.5 * Const::InvPI * (phi + Const::PI)) * Const::TwoPI;
   }

◆ squashPhiGeneral() [2/2]

template<typename Vector >

void mkfit::squashPhiGeneral ( Vector & v )

inline

Definition at line 631 of file Track.h.

References mps_fire::i, squashPhiGeneral(), and findQualityFiles::v.

                                           {
     const int i = v.kSize - 2;  // phi index
     v[i] = squashPhiGeneral(v[i]);
   }

◆ squashPhiMinimal()

float mkfit::squashPhiMinimal ( float phi )

inline

Definition at line 26 of file Hit.h.

References mkfit::Const::PI, and mkfit::Const::TwoPI.

Referenced by mkfit::StdSeq::clean_duplicates(), mkfit::StdSeq::clean_duplicates_sharedhits(), and mkfit::StdSeq::clean_duplicates_sharedhits_pixelseed().

                                            {
     return phi >= Const::PI ? phi - Const::TwoPI : (phi < -Const::PI ? phi + Const::TwoPI : phi);
   }

◆ squashPhiMPlex()

void mkfit::squashPhiMPlex	(	MPlexLV &	par,
		const int	N_proc
	)

inline

Definition at line 10 of file PropagationMPlex.h.

References dqmiodumpmetadata::n, NN, mkfit::Const::PI, and mkfit::Const::TwoPI.

Referenced by kalmanOperation(), kalmanOperationEndcap(), kalmanOperationPlane(), propagateHelixToPlaneMPlex(), propagateHelixToRMPlex(), and propagateHelixToZMPlex().

                                                              {
 #pragma omp simd
     for (int n = 0; n < NN; ++n) {
       if (n < N_proc) {
         if (par(n, 4, 0) >= Const::PI)
           par(n, 4, 0) -= Const::TwoPI;
         if (par(n, 4, 0) < -Const::PI)
           par(n, 4, 0) += Const::TwoPI;
       }
     }
   }

◆ squashPhiMPlexGeneral()

void mkfit::squashPhiMPlexGeneral	(	MPlexLV &	par,
		const int	N_proc
	)

inline

Definition at line 22 of file PropagationMPlex.h.

References f, mkfit::Const::InvPI, dqmiodumpmetadata::n, NN, mkfit::Const::PI, and mkfit::Const::TwoPI.

                                                                     {
 #pragma omp simd
     for (int n = 0; n < NN; ++n) {
       par(n, 4, 0) -= std::floor(0.5f * Const::InvPI * (par(n, 4, 0) + Const::PI)) * Const::TwoPI;
     }
   }

◆ state2mom()

RVec mkfit::state2mom ( const miprops::State & s )

Definition at line 14 of file RntConversions.h.

References alignCSCRings::s.

Referenced by mkfit::MkFinder::selectHitIndicesV2(), and state2state().

14 { return {s.px, s.py, s.pz}; }

s

Definition: alignCSCRings.py:92

◆ state2pos()

RVec mkfit::state2pos ( const miprops::State & s )

Definition at line 13 of file RntConversions.h.

References alignCSCRings::s.

Referenced by mkfit::MkFinder::selectHitIndicesV2(), and state2state().

13 { return {s.x, s.y, s.z}; }

s

Definition: alignCSCRings.py:92

◆ state2state()

State mkfit::state2state ( const miprops::State & s )

Definition at line 15 of file RntConversions.h.

References alignCSCRings::s, state2mom(), and state2pos().

15 { return {state2pos(s), state2mom(s)}; }

mkfit::state2mom

RVec state2mom(const miprops::State &s)

Definition: RntConversions.h:14

s

Definition: alignCSCRings.py:92

mkfit::state2pos

RVec state2pos(const miprops::State &s)

Definition: RntConversions.h:13

◆ statep2mom()

RVec mkfit::statep2mom	(	const miprops::StatePlex &	s,
		int	i
	)

Definition at line 18 of file RntConversions.h.

References mps_fire::i, and alignCSCRings::s.

Referenced by statep2state().

18 { return {s.px[i], s.py[i], s.pz[i]}; }

mps_fire.i

i

Definition: mps_fire.py:429

s

Definition: alignCSCRings.py:92

◆ statep2pos()

RVec mkfit::statep2pos	(	const miprops::StatePlex &	s,
		int	i
	)

Definition at line 17 of file RntConversions.h.

References mps_fire::i, and alignCSCRings::s.

Referenced by statep2state().

17 { return {s.x[i], s.y[i], s.z[i]}; }

mps_fire.i

i

Definition: mps_fire.py:429

s

Definition: alignCSCRings.py:92

◆ statep2propstate()

PropState mkfit::statep2propstate	(	const miprops::StatePlex &	s,
		int	i
	)

Definition at line 20 of file RntConversions.h.

References mps_fire::i, alignCSCRings::s, and statep2state().

Referenced by mkfit::MkFinder::selectHitIndicesV2().

                                                                {
     return {statep2state(s, i), s.dalpha[i], s.fail_flag[i]};
   }

◆ statep2state()

State mkfit::statep2state	(	const miprops::StatePlex &	s,
		int	i
	)

Definition at line 19 of file RntConversions.h.

References mps_fire::i, alignCSCRings::s, statep2mom(), and statep2pos().

Referenced by statep2propstate().

19 { return {statep2pos(s, i), statep2mom(s, i)}; }

mkfit::statep2mom

RVec statep2mom(const miprops::StatePlex &s, int i)

Definition: RntConversions.h:18

mps_fire.i

i

Definition: mps_fire.py:429

s

Definition: alignCSCRings.py:92

mkfit::statep2pos

RVec statep2pos(const miprops::StatePlex &s, int i)

Definition: RntConversions.h:17

◆ to_json() [1/12]

void mkfit::to_json	(	nlohmann::ordered_json &	nlohmann_json_j,
		const mkfit::LayerControl &	nlohmann_json_t
	)

inline

Definition at line 37 of file IterationConfig.cc.

◆ to_json() [2/12]

void mkfit::to_json	(	nlohmann::json &	nlohmann_json_j,
		const mkfit::LayerControl &	nlohmann_json_t
	)

inline

Definition at line 37 of file IterationConfig.cc.

Referenced by mkfit::ConfigJson::save_Iterations().

◆ to_json() [3/12]

void mkfit::to_json	(	nlohmann::ordered_json &	nlohmann_json_j,
		const mkfit::SteeringParams &	nlohmann_json_t
	)

inline

Definition at line 45 of file IterationConfig.cc.

◆ to_json() [4/12]

void mkfit::to_json	(	nlohmann::json &	nlohmann_json_j,
		const mkfit::SteeringParams &	nlohmann_json_t
	)

inline

Definition at line 45 of file IterationConfig.cc.

◆ to_json() [5/12]

void mkfit::to_json	(	nlohmann::json &	nlohmann_json_j,
		const mkfit::IterationLayerConfig &	nlohmann_json_t
	)

inline

Definition at line 54 of file IterationConfig.cc.

◆ to_json() [6/12]

void mkfit::to_json	(	nlohmann::ordered_json &	nlohmann_json_j,
		const mkfit::IterationLayerConfig &	nlohmann_json_t
	)

inline

Definition at line 54 of file IterationConfig.cc.

◆ to_json() [7/12]

void mkfit::to_json	(	nlohmann::json &	nlohmann_json_j,
		const mkfit::IterationParams &	nlohmann_json_t
	)

inline

Definition at line 68 of file IterationConfig.cc.

◆ to_json() [8/12]

void mkfit::to_json	(	nlohmann::ordered_json &	nlohmann_json_j,
		const mkfit::IterationParams &	nlohmann_json_t
	)

inline

Definition at line 68 of file IterationConfig.cc.

◆ to_json() [9/12]

void mkfit::to_json	(	nlohmann::ordered_json &	nlohmann_json_j,
		const mkfit::IterationConfig &	nlohmann_json_t
	)

inline

Definition at line 101 of file IterationConfig.cc.

◆ to_json() [10/12]

void mkfit::to_json	(	nlohmann::json &	nlohmann_json_j,
		const mkfit::IterationConfig &	nlohmann_json_t
	)

inline

Definition at line 101 of file IterationConfig.cc.

◆ to_json() [11/12]

void mkfit::to_json	(	nlohmann::json &	nlohmann_json_j,
		const mkfit::IterationsInfo &	nlohmann_json_t
	)

inline

Definition at line 104 of file IterationConfig.cc.

110 {

◆ to_json() [12/12]

void mkfit::to_json	(	nlohmann::ordered_json &	nlohmann_json_j,
		const mkfit::IterationsInfo &	nlohmann_json_t
	)

inline

Definition at line 104 of file IterationConfig.cc.

References CMS_SA_ALLOW, and mutex.

110 {

◆ track2mom()

RVec mkfit::track2mom ( const TrackBase & s )

Definition at line 26 of file RntConversions.h.

References alignCSCRings::s.

Referenced by track2state().

26 { return {s.px(), s.py(), s.pz()}; }

s

Definition: alignCSCRings.py:92

◆ track2pos()

RVec mkfit::track2pos ( const TrackBase & s )

Definition at line 25 of file RntConversions.h.

References alignCSCRings::s.

Referenced by track2state().

25 { return {s.x(), s.y(), s.z()}; }

s

Definition: alignCSCRings.py:92

◆ track2state()

State mkfit::track2state ( const TrackBase & s )

Definition at line 27 of file RntConversions.h.

References alignCSCRings::s, track2mom(), and track2pos().

Referenced by evsi2ssinfo().

27 { return {track2pos(s), track2mom(s)}; }