#include <RecoTracker/DeDxEstimatorProducer/src/DeDxEstimatorProducer.cc>

Inheritance diagram for DeDxEstimatorProducer:

Public Member Functions
	DeDxEstimatorProducer (const edm::ParameterSet &)

	~DeDxEstimatorProducer () override

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Private Member Functions
void	beginRun (edm::Run const &run, const edm::EventSetup &) override

void	makeCalibrationMap (const TrackerGeometry &tkGeom)

void	processHit (const TrackingRecHit *recHit, float trackMomentum, float &cosine, reco::DeDxHitCollection &dedxHits, int &NClusterSaturating)

void	produce (edm::Event &, const edm::EventSetup &) override

Private Attributes
std::vector< std::vector< float > >	calibGains

std::string	m_calibrationPath

std::unique_ptr< BaseDeDxEstimator >	m_estimator

unsigned int	m_off

edm::EDGetTokenT< reco::TrackDeDxHitsCollection >	m_pixelDeDxHitsTag

edm::EDGetTokenT< reco::TrackDeDxHitsCollection >	m_stripDeDxHitsTag

edm::EDGetTokenT< reco::TrackCollection >	m_tracksTag

unsigned int	MaxNrStrips

float	meVperADCPixel

float	meVperADCStrip

bool	shapetest

const TrackerGeometry *	tkGeom = nullptr

const edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord >	tkGeomToken

bool	useCalibration

bool	useDeDxHits

bool	usePixel

bool	useStrip

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Description: <one line="" class="" summary>="">

Implementation: <Notes on="" implementation>="">

Definition at line 45 of file DeDxEstimatorProducer.h.

Constructor & Destructor Documentation

◆ DeDxEstimatorProducer()

DeDxEstimatorProducer::DeDxEstimatorProducer ( const edm::ParameterSet & iConfig )

explicit

Definition at line 52 of file DeDxEstimatorProducer.cc.

References edm::BeginRun, edm::ParameterSet::getParameter(), m_calibrationPath, m_estimator, m_pixelDeDxHitsTag, m_stripDeDxHitsTag, m_tracksTag, meVperADCPixel, meVperADCStrip, shapetest, useCalibration, useDeDxHits, usePixel, and useStrip.

     : tkGeomToken(esConsumes<TrackerGeometry, TrackerDigiGeometryRecord, edm::Transition::BeginRun>()) {
   produces<ValueMap<DeDxData>>();
 
   auto cCollector = consumesCollector();
   string estimatorName = iConfig.getParameter<string>("estimator");
   if (estimatorName == "median")
     m_estimator = std::make_unique<MedianDeDxEstimator>(iConfig);
   else if (estimatorName == "generic")
     m_estimator = std::make_unique<GenericAverageDeDxEstimator>(iConfig);
   else if (estimatorName == "truncated")
     m_estimator = std::make_unique<TruncatedAverageDeDxEstimator>(iConfig);
   else if (estimatorName == "genericTruncated")
     m_estimator = std::make_unique<GenericTruncatedAverageDeDxEstimator>(iConfig);
   else if (estimatorName == "unbinnedFit")
     m_estimator = std::make_unique<UnbinnedFitDeDxEstimator>(iConfig);
   else if (estimatorName == "likelihoodFit")
     m_estimator = std::make_unique<LikelihoodFitDeDxEstimator>(iConfig);
   else if (estimatorName == "productDiscrim")
     m_estimator = std::make_unique<ProductDeDxDiscriminator>(iConfig, cCollector);
   else if (estimatorName == "btagDiscrim")
     m_estimator = std::make_unique<BTagLikeDeDxDiscriminator>(iConfig, cCollector);
   else if (estimatorName == "smirnovDiscrim")
     m_estimator = std::make_unique<SmirnovDeDxDiscriminator>(iConfig, cCollector);
   else if (estimatorName == "asmirnovDiscrim")
     m_estimator = std::make_unique<ASmirnovDeDxDiscriminator>(iConfig, cCollector);
 
   //Commented for now, might be used in the future
   //   MaxNrStrips         = iConfig.getUntrackedParameter<unsigned>("maxNrStrips"        ,  255);
 
   m_tracksTag = consumes<reco::TrackCollection>(iConfig.getParameter<edm::InputTag>("tracks"));
 
   useDeDxHits = iConfig.getParameter<bool>("UseDeDxHits");
   m_pixelDeDxHitsTag = consumes<reco::TrackDeDxHitsCollection>(iConfig.getParameter<edm::InputTag>("pixelDeDxHits"));
   m_stripDeDxHitsTag = consumes<reco::TrackDeDxHitsCollection>(iConfig.getParameter<edm::InputTag>("stripDeDxHits"));
 
   usePixel = iConfig.getParameter<bool>("UsePixel");
   useStrip = iConfig.getParameter<bool>("UseStrip");
   meVperADCPixel = iConfig.getParameter<double>("MeVperADCPixel");
   meVperADCStrip = iConfig.getParameter<double>("MeVperADCStrip");
 
   shapetest = iConfig.getParameter<bool>("ShapeTest");
   useCalibration = iConfig.getParameter<bool>("UseCalibration");
   m_calibrationPath = iConfig.getParameter<string>("calibrationPath");
 
   if (!usePixel && !useStrip)
     edm::LogWarning("DeDxHitsProducer")
         << "Pixel Hits AND Strip Hits will not be used to estimate dEdx --> BUG, Please Update the config file";
 }

◆ ~DeDxEstimatorProducer()

DeDxEstimatorProducer::~DeDxEstimatorProducer ( )

override

Definition at line 102 of file DeDxEstimatorProducer.cc.

102 {}

Member Function Documentation

◆ beginRun()

void DeDxEstimatorProducer::beginRun	(	edm::Run const &	run,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 105 of file DeDxEstimatorProducer.cc.

References calibGains, edm::EventSetup::getData(), m_calibrationPath, m_estimator, m_off, deDxTools::makeCalibrationMap(), TrackerGeometry::offsetDU(), GeomDetEnumerators::PixelBarrel, writedatasetfile::run, tkGeom, tkGeomToken, and useCalibration.

                                                                                    {
   tkGeom = &iSetup.getData(tkGeomToken);
   if (useCalibration && calibGains.empty()) {
     m_off = tkGeom->offsetDU(GeomDetEnumerators::PixelBarrel);  //index start at the first pixel
 
     deDxTools::makeCalibrationMap(m_calibrationPath, *tkGeom, calibGains, m_off);
   }
 
   m_estimator->beginRun(run, iSetup);
 }

◆ fillDescriptions()

void DeDxEstimatorProducer::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 29 of file DeDxEstimatorProducer.cc.

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, and ProducerED_cfi::InputTag.

                                                                                        {
   edm::ParameterSetDescription desc;
   desc.add<string>("estimator", "generic");
   desc.add<edm::InputTag>("tracks", edm::InputTag("generalTracks"));
   desc.add<bool>("UseDeDxHits", false);
   desc.add<edm::InputTag>("pixelDeDxHits", {});
   desc.add<edm::InputTag>("stripDeDxHits", {});
   desc.add<bool>("UsePixel", false);
   desc.add<bool>("UseStrip", true);
   desc.add<double>("MeVperADCPixel", 3.61e-06);
   desc.add<double>("MeVperADCStrip", 3.61e-06 * 265);
   desc.add<bool>("ShapeTest", true);
   desc.add<bool>("UseCalibration", false);
   desc.add<string>("calibrationPath", "");
   desc.add<string>("Record", "SiStripDeDxMip_3D_Rcd");
   desc.add<string>("ProbabilityMode", "Accumulation");
   desc.add<double>("fraction", 0.4);
   desc.add<double>("exponent", -2.0);
   desc.add<bool>("truncate", true);
 
   descriptions.add("DeDxEstimatorProducer", desc);
 }

◆ makeCalibrationMap()

void DeDxEstimatorProducer::makeCalibrationMap ( const TrackerGeometry & tkGeom )

private

◆ processHit()

void DeDxEstimatorProducer::processHit	(	const TrackingRecHit *	recHit,
		float	trackMomentum,
		float &	cosine,
		reco::DeDxHitCollection &	dedxHits,
		int &	NClusterSaturating
	)

private

Definition at line 173 of file DeDxEstimatorProducer.cc.

References Surface::bounds(), calibGains, ALCARECOTkAlJpsiMuMu_cff::charge, runTheMatrix::const, TrackingRecHit::det(), deDxTools::getCharge(), TrackerGeometry::idToDet(), m_off, meVperADCPixel, meVperADCStrip, SiStripMatchedRecHit2D::monoCluster(), GluedGeomDet::monoDet(), SiStripMatchedRecHit2D::monoId(), rpcPointValidation_cfi::recHit, deDxTools::shapeSelection(), shapetest, SiStripMatchedRecHit2D::stereoCluster(), GluedGeomDet::stereoDet(), SiStripMatchedRecHit2D::stereoId(), GeomDet::surface(), Bounds::thickness(), tkGeom, reco::btau::trackMomentum, usePixel, and useStrip.

Referenced by produce().

                                                                 {
   auto const& thit = static_cast<BaseTrackerRecHit const&>(*recHit);
   if (!thit.isValid())
     return;
 
   auto const& clus = thit.firstClusterRef();
   if (!clus.isValid())
     return;
 
   if (clus.isPixel()) {
     if (!usePixel)
       return;
 
     const auto* detUnit = recHit->detUnit();
     if (detUnit == nullptr)
       detUnit = tkGeom->idToDet(thit.geographicalId());
     float pathLen = detUnit->surface().bounds().thickness() / fabs(cosine);
     float chargeAbs = clus.pixelCluster().charge();
     float charge = meVperADCPixel * chargeAbs / pathLen;
     dedxHits.push_back(DeDxHit(charge, trackMomentum, pathLen, thit.geographicalId()));
   } else if (clus.isStrip() && !thit.isMatched()) {
     if (!useStrip)
       return;
 
     const auto* detUnit = recHit->detUnit();
     if (detUnit == nullptr)
       detUnit = tkGeom->idToDet(thit.geographicalId());
     int NSaturating = 0;
     float pathLen = detUnit->surface().bounds().thickness() / fabs(cosine);
     float chargeAbs = deDxTools::getCharge(&(clus.stripCluster()), NSaturating, *detUnit, calibGains, m_off);
     float charge = meVperADCStrip * chargeAbs / pathLen;
     if (!shapetest || (shapetest && deDxTools::shapeSelection(clus.stripCluster()))) {
       dedxHits.push_back(DeDxHit(charge, trackMomentum, pathLen, thit.geographicalId()));
       if (NSaturating > 0)
         NClusterSaturating++;
     }
   } else if (clus.isStrip() && thit.isMatched()) {
     if (!useStrip)
       return;
     const SiStripMatchedRecHit2D* matchedHit = dynamic_cast<const SiStripMatchedRecHit2D*>(recHit);
     if (!matchedHit)
       return;
     const GluedGeomDet* gdet = static_cast<const GluedGeomDet*>(matchedHit->det());
     if (gdet == nullptr)
       gdet = static_cast<const GluedGeomDet*>(tkGeom->idToDet(thit.geographicalId()));
 
     auto& detUnitM = *(gdet->monoDet());
     int NSaturating = 0;
     float pathLen = detUnitM.surface().bounds().thickness() / fabs(cosine);
     float chargeAbs = deDxTools::getCharge(&(matchedHit->monoCluster()), NSaturating, detUnitM, calibGains, m_off);
     float charge = meVperADCStrip * chargeAbs / pathLen;
     if (!shapetest || (shapetest && deDxTools::shapeSelection(matchedHit->monoCluster()))) {
       dedxHits.push_back(DeDxHit(charge, trackMomentum, pathLen, matchedHit->monoId()));
       if (NSaturating > 0)
         NClusterSaturating++;
     }
 
     auto& detUnitS = *(gdet->stereoDet());
     NSaturating = 0;
     pathLen = detUnitS.surface().bounds().thickness() / fabs(cosine);
     chargeAbs = deDxTools::getCharge(&(matchedHit->stereoCluster()), NSaturating, detUnitS, calibGains, m_off);
     charge = meVperADCStrip * chargeAbs / pathLen;
     if (!shapetest || (shapetest && deDxTools::shapeSelection(matchedHit->stereoCluster()))) {
       dedxHits.push_back(DeDxHit(charge, trackMomentum, pathLen, matchedHit->stereoId()));
       if (NSaturating > 0)
         NClusterSaturating++;
     }
   }
 }

◆ produce()

void DeDxEstimatorProducer::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 116 of file DeDxEstimatorProducer.cc.

References cms::cuda::assert(), trigObjTnPSource_cfi::filler, h, hcalSimParameters_cfi::hb, hfClusterShapes_cfi::hits, iEvent, trackerHitRTTI::isFromDet(), dqmiolumiharvest::j, m_estimator, m_pixelDeDxHitsTag, m_stripDeDxHitsTag, m_tracksTag, eostools::move(), dedxEstimators_cff::pixelDeDxHits, processHit(), rpcPointValidation_cfi::recHit, jetUpdater_cfi::sort, dedxEstimators_cff::stripDeDxHits, HLT_2024v14_cff::track, useDeDxHits, usePixel, and useStrip.

                                                                                  {
   auto trackDeDxEstimateAssociation = std::make_unique<ValueMap<DeDxData>>();
   ValueMap<DeDxData>::Filler filler(*trackDeDxEstimateAssociation);
 
   edm::Handle<reco::TrackCollection> trackCollectionHandle;
   iEvent.getByToken(m_tracksTag, trackCollectionHandle);
   const auto& pixelDeDxHits = iEvent.getHandle(m_pixelDeDxHitsTag);
   const auto& stripDeDxHits = iEvent.getHandle(m_stripDeDxHitsTag);
 
   std::vector<DeDxData> dedxEstimate(trackCollectionHandle->size());
 
   for (unsigned int j = 0; j < trackCollectionHandle->size(); j++) {
     const reco::TrackRef track = reco::TrackRef(trackCollectionHandle, j);
 
     int NClusterSaturating = 0;
     DeDxHitCollection dedxHits;
 
     if (useDeDxHits) {
       if (usePixel)
         dedxHits = (*pixelDeDxHits)[track];
       if (useStrip) {
         const auto& hits = (*stripDeDxHits)[track];
         dedxHits.insert(dedxHits.end(), hits.begin(), hits.end());
       }
     } else {
       auto const& trajParams = track->extra()->trajParams();
       assert(trajParams.size() == track->recHitsSize());
       auto hb = track->recHitsBegin();
       dedxHits.reserve(track->recHitsSize() / 2);
       for (unsigned int h = 0; h < track->recHitsSize(); h++) {
         auto recHit = *(hb + h);
         if (!trackerHitRTTI::isFromDet(*recHit))
           continue;
 
         auto trackDirection = trajParams[h].direction();
         float cosine = trackDirection.z() / trackDirection.mag();
         processHit(recHit, track->p(), cosine, dedxHits, NClusterSaturating);
       }
     }
 
     sort(dedxHits.begin(), dedxHits.end(), less<DeDxHit>());
     std::pair<float, float> val_and_error = m_estimator->dedx(dedxHits);
 
     //WARNING: Since the dEdX Error is not properly computed for the moment
     //It was decided to store the number of saturating cluster in that dataformat
     val_and_error.second = NClusterSaturating;
     dedxEstimate[j] = DeDxData(val_and_error.first, val_and_error.second, dedxHits.size());
   }
 
   filler.insert(trackCollectionHandle, dedxEstimate.begin(), dedxEstimate.end());
 
   // fill the association map and put it into the event
   filler.fill();
   iEvent.put(std::move(trackDeDxEstimateAssociation));
 }