#include <VertexTimeAlgorithmFromTracksPID.h>

Inheritance diagram for VertexTimeAlgorithmFromTracksPID:

Classes
struct	TrackInfo

Public Member Functions
void	setEvent (edm::Event &iEvent, edm::EventSetup const &iSetup) override

bool	vertexTime (float &vtxTime, float &vtxTimeError, TransientVertex const &vtx) const override

	VertexTimeAlgorithmFromTracksPID (const edm::ParameterSet &conf, edm::ConsumesCollector &iC)

	~VertexTimeAlgorithmFromTracksPID () override=default

Public Member Functions inherited from VertexTimeAlgorithmBase
virtual void	fill_vertex_times (std::vector< TransientVertex > &pvs)

VertexTimeAlgorithmBase &	operator= (const VertexTimeAlgorithmBase &)=delete

	VertexTimeAlgorithmBase (const edm::ParameterSet &conf, edm::ConsumesCollector &iC)

	VertexTimeAlgorithmBase (const VertexTimeAlgorithmBase &)=delete

virtual	~VertexTimeAlgorithmBase ()=default

Static Public Member Functions
static void	fillPSetDescription (edm::ParameterSetDescription &iDesc)

Static Public Member Functions inherited from VertexTimeAlgorithmBase
static void	fillPSetDescription (edm::ParameterSetDescription &iDesc)

Protected Attributes
double const	coolingFactor_

double const	minTrackTimeQuality_

double const	minTrackVtxWeight_

double const	probKaon_

double const	probPion_

double const	probProton_

edm::ValueMap< float >	trackMTDSigmaTofK_

edm::EDGetTokenT< edm::ValueMap< float > > const	trackMTDSigmaTofKToken_

edm::ValueMap< float >	trackMTDSigmaTofP_

edm::ValueMap< float >	trackMTDSigmaTofPi_

edm::EDGetTokenT< edm::ValueMap< float > > const	trackMTDSigmaTofPiToken_

edm::EDGetTokenT< edm::ValueMap< float > > const	trackMTDSigmaTofPToken_

edm::ValueMap< float >	trackMTDTimeErrors_

edm::EDGetTokenT< edm::ValueMap< float > > const	trackMTDTimeErrorToken_

edm::ValueMap< float >	trackMTDTimeQualities_

edm::EDGetTokenT< edm::ValueMap< float > > const	trackMTDTimeQualityToken_

edm::ValueMap< float >	trackMTDTimes_

edm::EDGetTokenT< edm::ValueMap< float > > const	trackMTDTimeToken_

edm::ValueMap< float >	trackMTDTofK_

edm::EDGetTokenT< edm::ValueMap< float > > const	trackMTDTofKToken_

edm::ValueMap< float >	trackMTDTofP_

edm::ValueMap< float >	trackMTDTofPi_

edm::EDGetTokenT< edm::ValueMap< float > > const	trackMTDTofPiToken_

edm::EDGetTokenT< edm::ValueMap< float > > const	trackMTDTofPToken_

double const	Tstart_

Detailed Description

Definition at line 10 of file VertexTimeAlgorithmFromTracksPID.h.

Constructor & Destructor Documentation

◆ VertexTimeAlgorithmFromTracksPID()

VertexTimeAlgorithmFromTracksPID::VertexTimeAlgorithmFromTracksPID	(	const edm::ParameterSet &	conf,
		edm::ConsumesCollector &	iC
	)

Definition at line 17 of file VertexTimeAlgorithmFromTracksPID.cc.

     : VertexTimeAlgorithmBase(iConfig, iCC),
       trackMTDTimeToken_(iCC.consumes(iConfig.getParameter<edm::InputTag>("trackMTDTimeVMapTag"))),
       trackMTDTimeErrorToken_(iCC.consumes(iConfig.getParameter<edm::InputTag>("trackMTDTimeErrorVMapTag"))),
       trackMTDTimeQualityToken_(iCC.consumes(iConfig.getParameter<edm::InputTag>("trackMTDTimeQualityVMapTag"))),
       trackMTDTofPiToken_(iCC.consumes(iConfig.getParameter<edm::InputTag>("trackMTDTofPiVMapTag"))),
       trackMTDTofKToken_(iCC.consumes(iConfig.getParameter<edm::InputTag>("trackMTDTofKVMapTag"))),
       trackMTDTofPToken_(iCC.consumes(iConfig.getParameter<edm::InputTag>("trackMTDTofPVMapTag"))),
       trackMTDSigmaTofPiToken_(iCC.consumes(iConfig.getParameter<edm::InputTag>("trackMTDSigmaTofPiVMapTag"))),
       trackMTDSigmaTofKToken_(iCC.consumes(iConfig.getParameter<edm::InputTag>("trackMTDSigmaTofKVMapTag"))),
       trackMTDSigmaTofPToken_(iCC.consumes(iConfig.getParameter<edm::InputTag>("trackMTDSigmaTofPVMapTag"))),
       minTrackVtxWeight_(iConfig.getParameter<double>("minTrackVtxWeight")),
       minTrackTimeQuality_(iConfig.getParameter<double>("minTrackTimeQuality")),
       probPion_(iConfig.getParameter<double>("probPion")),
       probKaon_(iConfig.getParameter<double>("probKaon")),
       probProton_(iConfig.getParameter<double>("probProton")),
       Tstart_(iConfig.getParameter<double>("Tstart")),
       coolingFactor_(iConfig.getParameter<double>("coolingFactor")) {}

◆ ~VertexTimeAlgorithmFromTracksPID()

VertexTimeAlgorithmFromTracksPID::~VertexTimeAlgorithmFromTracksPID ( )

overridedefault

Member Function Documentation

◆ fillPSetDescription()

void VertexTimeAlgorithmFromTracksPID::fillPSetDescription ( edm::ParameterSetDescription & iDesc )

static

Definition at line 37 of file VertexTimeAlgorithmFromTracksPID.cc.

References edm::ParameterSetDescription::add(), VertexTimeAlgorithmBase::fillPSetDescription(), ProducerED_cfi::InputTag, and edm::ParameterDescriptionNode::setComment().

Referenced by PrimaryVertexProducer::fillDescriptions().

                                                                                             {
   VertexTimeAlgorithmBase::fillPSetDescription(iDesc);
 
   iDesc.add<edm::InputTag>("trackMTDTimeVMapTag", edm::InputTag("trackExtenderWithMTD:generalTracktmtd"))
       ->setComment("Input ValueMap for track time at MTD");
   iDesc.add<edm::InputTag>("trackMTDTimeErrorVMapTag", edm::InputTag("trackExtenderWithMTD:generalTracksigmatmtd"))
       ->setComment("Input ValueMap for track time uncertainty at MTD");
   iDesc.add<edm::InputTag>("trackMTDTimeQualityVMapTag", edm::InputTag("mtdTrackQualityMVA:mtdQualMVA"))
       ->setComment("Input ValueMap for track MVA quality value");
   iDesc.add<edm::InputTag>("trackMTDTofPiVMapTag", edm::InputTag("trackExtenderWithMTD:generalTrackTofPi"))
       ->setComment("Input ValueMap for track tof as pion");
   iDesc.add<edm::InputTag>("trackMTDTofKVMapTag", edm::InputTag("trackExtenderWithMTD:generalTrackTofK"))
       ->setComment("Input ValueMap for track tof as kaon");
   iDesc.add<edm::InputTag>("trackMTDTofPVMapTag", edm::InputTag("trackExtenderWithMTD:generalTrackTofP"))
       ->setComment("Input ValueMap for track tof as proton");
   iDesc.add<edm::InputTag>("trackMTDSigmaTofPiVMapTag", edm::InputTag("trackExtenderWithMTD:generalTrackSigmaTofPi"))
       ->setComment("Input ValueMap for track tof uncertainty as pion");
   iDesc.add<edm::InputTag>("trackMTDSigmaTofKVMapTag", edm::InputTag("trackExtenderWithMTD:generalTrackSigmaTofK"))
       ->setComment("Input ValueMap for track tof uncertainty as kaon");
   iDesc.add<edm::InputTag>("trackMTDSigmaTofPVMapTag", edm::InputTag("trackExtenderWithMTD:generalTrackSigmaTofP"))
       ->setComment("Input ValueMap for track tof uncertainty as proton");
 
   iDesc.add<double>("minTrackVtxWeight", 0.5)->setComment("Minimum track weight");
   iDesc.add<double>("minTrackTimeQuality", 0.8)->setComment("Minimum MVA Quality selection on tracks");
 
   iDesc.add<double>("probPion", 0.7)->setComment("A priori probability pions");
   iDesc.add<double>("probKaon", 0.2)->setComment("A priori probability kaons");
   iDesc.add<double>("probProton", 0.1)->setComment("A priori probability protons");
 
   iDesc.add<double>("Tstart", 256.)->setComment("DA initial temperature T");
   iDesc.add<double>("coolingFactor", 0.5)->setComment("DA cooling factor");
 }

◆ setEvent()

void VertexTimeAlgorithmFromTracksPID::setEvent	(	edm::Event &	iEvent,
		edm::EventSetup const &	iSetup
	)

overridevirtual

Implements VertexTimeAlgorithmBase.

Definition at line 70 of file VertexTimeAlgorithmFromTracksPID.cc.

References iEvent, trackMTDSigmaTofK_, trackMTDSigmaTofKToken_, trackMTDSigmaTofP_, trackMTDSigmaTofPi_, trackMTDSigmaTofPiToken_, trackMTDSigmaTofPToken_, trackMTDTimeErrors_, trackMTDTimeErrorToken_, trackMTDTimeQualities_, trackMTDTimeQualityToken_, trackMTDTimes_, trackMTDTimeToken_, trackMTDTofK_, trackMTDTofKToken_, trackMTDTofP_, trackMTDTofPi_, trackMTDTofPiToken_, and trackMTDTofPToken_.

                                                                                       {
   // additional collections required for vertex-time calculation
   trackMTDTimes_ = iEvent.get(trackMTDTimeToken_);
   trackMTDTimeErrors_ = iEvent.get(trackMTDTimeErrorToken_);
   trackMTDTimeQualities_ = iEvent.get(trackMTDTimeQualityToken_);
   trackMTDTofPi_ = iEvent.get(trackMTDTofPiToken_);
   trackMTDTofK_ = iEvent.get(trackMTDTofKToken_);
   trackMTDTofP_ = iEvent.get(trackMTDTofPToken_);
   trackMTDSigmaTofPi_ = iEvent.get(trackMTDSigmaTofPiToken_);
   trackMTDSigmaTofK_ = iEvent.get(trackMTDSigmaTofKToken_);
   trackMTDSigmaTofP_ = iEvent.get(trackMTDSigmaTofPToken_);
 }

◆ vertexTime()

bool VertexTimeAlgorithmFromTracksPID::vertexTime	(	float &	vtxTime,
		float &	vtxTimeError,
		TransientVertex const &	vtx
	)		const

overridevirtual

estimate the vertex time and time uncertainty for transient vertex

returns true when a valid time has been determined, otherwise return false

Implements VertexTimeAlgorithmBase.

Definition at line 83 of file VertexTimeAlgorithmFromTracksPID.cc.

References a, funct::abs(), HLT_2024v13_cff::beta, coolingFactor_, dt, MillePedeFileConverter_cfg::e, dqmiolumiharvest::j, LOG, SiStripPI::min, minTrackTimeQuality_, minTrackVtxWeight_, probKaon_, probPion_, probProton_, mathSSE::sqrt(), FrontierCondition_GT_autoExpress_cfi::t0, trackMTDSigmaTofK_, trackMTDSigmaTofP_, trackMTDSigmaTofPi_, trackMTDTimeErrors_, trackMTDTimeQualities_, trackMTDTimes_, trackMTDTofK_, trackMTDTofP_, trackMTDTofPi_, Tstart_, parallelization::uint, L1BJetProducer_cff::vtx, w(), and beamSpotPI::Z.

                                                                                     {
   if (vtx.originalTracks().empty()) {
     return false;
   }
 
   auto const vtxTime_init = vtxTime;
   auto const vtxTimeError_init = vtxTimeError;
   const int max_iterations = 100;
 
   double tsum = 0;
   double wsum = 0;
   double w2sum = 0;
 
   double const a[3] = {probPion_, probKaon_, probProton_};
 
   std::vector<TrackInfo> v_trackInfo;
   v_trackInfo.reserve(vtx.originalTracks().size());
 
   // initial guess
   for (const auto& trk : vtx.originalTracks()) {
     auto const trkWeight = vtx.trackWeight(trk);
     if (trkWeight > minTrackVtxWeight_) {
       auto const trkTimeQuality = trackMTDTimeQualities_[trk.trackBaseRef()];
 
       if (trkTimeQuality >= minTrackTimeQuality_) {
         auto const trkTime = trackMTDTimes_[trk.trackBaseRef()];
         auto const trkTimeError = trackMTDTimeErrors_[trk.trackBaseRef()];
 
         v_trackInfo.emplace_back();
         auto& trkInfo = v_trackInfo.back();
 
         trkInfo.trkWeight = trkWeight;
         trkInfo.trkTimeErrorHyp[0] =
             std::sqrt(trkTimeError * trkTimeError +
                       trackMTDSigmaTofPi_[trk.trackBaseRef()] * trackMTDSigmaTofPi_[trk.trackBaseRef()]);
         trkInfo.trkTimeErrorHyp[1] =
             std::sqrt(trkTimeError * trkTimeError +
                       trackMTDSigmaTofK_[trk.trackBaseRef()] * trackMTDSigmaTofK_[trk.trackBaseRef()]);
         trkInfo.trkTimeErrorHyp[2] =
             std::sqrt(trkTimeError * trkTimeError +
                       trackMTDSigmaTofP_[trk.trackBaseRef()] * trackMTDSigmaTofP_[trk.trackBaseRef()]);
 
         trkInfo.trkTimeHyp[0] = trkTime - trackMTDTofPi_[trk.trackBaseRef()];
         trkInfo.trkTimeHyp[1] = trkTime - trackMTDTofK_[trk.trackBaseRef()];
         trkInfo.trkTimeHyp[2] = trkTime - trackMTDTofP_[trk.trackBaseRef()];
 
         double const wgt[3] = {trkWeight / (trkInfo.trkTimeErrorHyp[0] * trkInfo.trkTimeErrorHyp[0]),
                                trkWeight / (trkInfo.trkTimeErrorHyp[1] * trkInfo.trkTimeErrorHyp[1]),
                                trkWeight / (trkInfo.trkTimeErrorHyp[2] * trkInfo.trkTimeErrorHyp[2])};
 
         for (uint j = 0; j < 3; ++j) {
           wsum += wgt[j] * a[j];
           tsum += wgt[j] * a[j] * trkInfo.trkTimeHyp[j];
         }
 
         LOG << "vertexTimeFromTracks:     track"
             << " pt=" << trk.track().pt() << " eta=" << trk.track().eta() << " phi=" << trk.track().phi()
             << " vtxWeight=" << trkWeight << " time=" << trkTime << " timeError=" << trkTimeError
             << " timeQuality=" << trkTimeQuality << " timeHyp[pion]=" << trkInfo.trkTimeHyp[0] << " +/- "
             << trkInfo.trkTimeErrorHyp[0] << " timeHyp[kaon]=" << trkInfo.trkTimeHyp[1] << " +/- "
             << trkInfo.trkTimeErrorHyp[1] << " timeHyp[proton]=" << trkInfo.trkTimeHyp[2] << " +/- "
             << trkInfo.trkTimeErrorHyp[2];
       }
     }
   }
   if (wsum > 0) {
     auto t0 = tsum / wsum;
     auto beta = 1. / Tstart_;
     int nit = 0;
     while ((nit++) < max_iterations) {
       tsum = 0;
       wsum = 0;
       w2sum = 0;
 
       for (auto const& trkInfo : v_trackInfo) {
         double dt[3] = {trkInfo.trkTimeErrorHyp[0], trkInfo.trkTimeErrorHyp[1], trkInfo.trkTimeErrorHyp[2]};
         double e[3] = {0, 0, 0};
         const double cut_off = 4.5;
         double Z = vdt::fast_exp(
             -beta * cut_off);  // outlier rejection term Z_0 = exp(-beta * cut_off) = exp(-beta * 0.5 * 3 * 3)
 
         for (unsigned int j = 0; j < 3; j++) {
           auto const tpull = (trkInfo.trkTimeHyp[j] - t0) / dt[j];
           e[j] = vdt::fast_exp(-0.5 * beta * tpull * tpull);
           Z += a[j] * e[j];
         }
 
         double wsum_trk = 0, wsum_sigma_trk = 0;
         for (uint j = 0; j < 3; j++) {
           double wt = a[j] * e[j] / Z;
           double w = wt * trkInfo.trkWeight / (dt[j] * dt[j]);
           wsum_trk += w;
           wsum_sigma_trk += w * dt[j];
           tsum += w * trkInfo.trkTimeHyp[j];
         }
 
         wsum += wsum_trk;
         w2sum += wsum_sigma_trk * wsum_sigma_trk;
       }
 
       if (wsum < 1e-10) {
         LOG << "vertexTimeFromTracks:   failed while iterating";
         return false;
       }
 
       vtxTime = tsum / wsum;
 
       LOG << "vertexTimeFromTracks:   iteration=" << nit << ", T= " << 1 / beta << ", t=" << vtxTime
           << ", t-t0=" << vtxTime - t0;
 
       if ((std::abs(vtxTime - t0) < 1e-4 / std::sqrt(beta)) and beta >= 1.) {
         vtxTimeError = std::sqrt(w2sum) / wsum;
 
         LOG << "vertexTimeFromTracks:   tfit = " << vtxTime << " +/- " << vtxTimeError << " trec = " << vtx.time()
             << ", iteration=" << nit;
 
         return true;
       }
 
       if ((std::abs(vtxTime - t0) < 1e-3) and beta < 1.) {
         beta = std::min(1., beta / coolingFactor_);
       }
 
       t0 = vtxTime;
     }
 
     LOG << "vertexTimeFromTracks: failed to converge";
   } else {
     LOG << "vertexTimeFromTracks: has no track timing info";
   }
 
   vtxTime = vtxTime_init;
   vtxTimeError = vtxTimeError_init;
 
   return false;
 }