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

Inheritance diagram for FastTrackDeDxProducer:

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

	~FastTrackDeDxProducer () override=default

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 &, const edm::EventSetup &) override

void	makeCalibrationMap (const TrackerGeometry &tkGeom)

void	processHit (const FastTrackerRecHit &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

bool	convertFromGeV2MeV

std::string	m_calibrationPath

std::unique_ptr < BaseDeDxEstimator >	m_estimator

unsigned int	m_off

edm::EDGetTokenT < reco::TrackCollection >	m_tracksTag

unsigned int	MaxNrStrips

float	meVperADCPixel

float	meVperADCStrip

bool	nothick

bool	shapetest

edm::EDGetTokenT < FastTrackerRecHitRefCollection >	simHit2RecHitMapToken

edm::EDGetTokenT < edm::PSimHitContainer >	simHitsToken

edm::ESGetToken < TrackerGeometry, TrackerDigiGeometryRecord >	tkGeomToken

bool	useCalibration

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 67 of file FastTrackDeDxProducer.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 138 of file FastTrackDeDxProducer.cc.

References convertFromGeV2MeV, Exception, edm::ParameterSet::getParameter(), m_calibrationPath, m_estimator, m_tracksTag, meVperADCPixel, meVperADCStrip, nothick, shapetest, tkGeomToken, useCalibration, usePixel, and useStrip.

     : simHitsToken(consumes<edm::PSimHitContainer>(iConfig.getParameter<edm::InputTag>("simHits"))),
       simHit2RecHitMapToken(
           consumes<FastTrackerRecHitRefCollection>(iConfig.getParameter<edm::InputTag>("simHit2RecHitMap"))) {
   produces<ValueMap<DeDxData>>();
 
   auto cCollector = consumesCollector();
   string estimatorName = iConfig.getParameter<string>("estimator");
   if (estimatorName == "median")
     m_estimator = std::unique_ptr<BaseDeDxEstimator>(new MedianDeDxEstimator(iConfig));
   else if (estimatorName == "generic")
     m_estimator = std::unique_ptr<BaseDeDxEstimator>(new GenericAverageDeDxEstimator(iConfig));
   else if (estimatorName == "truncated")
     m_estimator = std::unique_ptr<BaseDeDxEstimator>(new TruncatedAverageDeDxEstimator(iConfig));
   //else if(estimatorName == "unbinnedFit")         m_estimator = std::unique_ptr<BaseDeDxEstimator> (new UnbinnedFitDeDxEstimator(iConfig));//estimator used in FullSimVersion
   else if (estimatorName == "productDiscrim")
     m_estimator = std::unique_ptr<BaseDeDxEstimator>(new ProductDeDxDiscriminator(iConfig, cCollector));
   else if (estimatorName == "btagDiscrim")
     m_estimator = std::unique_ptr<BaseDeDxEstimator>(new BTagLikeDeDxDiscriminator(iConfig, cCollector));
   else if (estimatorName == "smirnovDiscrim")
     m_estimator = std::unique_ptr<BaseDeDxEstimator>(new SmirnovDeDxDiscriminator(iConfig, cCollector));
   else if (estimatorName == "asmirnovDiscrim")
     m_estimator = std::unique_ptr<BaseDeDxEstimator>(new ASmirnovDeDxDiscriminator(iConfig, cCollector));
   else
     throw cms::Exception("fastsim::SimplifiedGeometry::FastTrackDeDxProducer.cc") << " estimator name does not exist";
 
   //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"));
 
   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");
 
   convertFromGeV2MeV = iConfig.getParameter<bool>("convertFromGeV2MeV");
   nothick = iConfig.getParameter<bool>("nothick");
 
   if (!usePixel && !useStrip)
     throw cms::Exception("fastsim::SimplifiedGeometry::FastTrackDeDxProducer.cc")
         << " neither pixel hits nor strips hits will be used to compute de/dx";
 
   if (useCalibration) {
     tkGeomToken = esConsumes<edm::Transition::BeginRun>();
   }
 }

FastTrackDeDxProducer::~FastTrackDeDxProducer ( )

overridedefault

Member Function Documentation

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

overrideprivate

Definition at line 191 of file FastTrackDeDxProducer.cc.

References calibGains, edm::EventSetup::getData(), m_calibrationPath, m_estimator, m_off, DeDxTools::makeCalibrationMap(), GeomDetEnumerators::PixelBarrel, tkGeomToken, and useCalibration.

                                                                                    {
   if (useCalibration && calibGains.empty()) {
     auto const& tkGeom = iSetup.getData(tkGeomToken);
     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);
 }

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

static

Definition at line 116 of file FastTrackDeDxProducer.cc.

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

                                                                                        {
   edm::ParameterSetDescription desc;
   desc.add<string>("estimator", "generic");
   desc.add<edm::InputTag>("tracks", edm::InputTag("generalTracks"));
   desc.add<bool>("UsePixel", false);
   desc.add<bool>("UseStrip", true);
   desc.add<double>("MeVperADCStrip", 3.61e-06 * 265);
   desc.add<double>("MeVperADCPixel", 3.61e-06);
   desc.add<bool>("ShapeTest", true);
   desc.add<bool>("UseCalibration", false);
   desc.add<string>("calibrationPath", "");
   desc.add<string>("Reccord", "SiStripDeDxMip_3D_Rcd");
   desc.add<string>("ProbabilityMode", "Accumulation");
   desc.add<double>("fraction", 0.4);
   desc.add<double>("exponent", -2.0);
   desc.add<bool>("convertFromGeV2MeV", true);
   desc.add<bool>("nothick", false);
   desc.add<edm::InputTag>("simHits");
   desc.add<edm::InputTag>("simHit2RecHitMap");
   descriptions.add("FastTrackDeDxProducer", desc);
 }

void FastTrackDeDxProducer::makeCalibrationMap ( const TrackerGeometry & tkGeom )

private

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

private

Definition at line 246 of file FastTrackDeDxProducer.cc.

References RecoTauCleanerPlugins::charge, runTheMatrix::const, convertFromGeV2MeV, TrackingRecHit::detUnit(), FastTrackerRecHit::energyLoss(), TrackingRecHit::geographicalId(), FastTrackerRecHit::isPixel(), TrackingRecHit::isValid(), nothick, shapetest, usePixel, and useStrip.

Referenced by produce().

                                                                 {
   if (!recHit.isValid())
     return;
 
   auto const& thit = static_cast<BaseTrackerRecHit const&>(recHit);
   if (!thit.isValid())
     return;
   if (!thit.hasPositionAndError())
     return;
 
   if (recHit.isPixel()) {
     if (!usePixel)
       return;
 
     auto& detUnit = *(recHit.detUnit());
     float pathLen = detUnit.surface().bounds().thickness() / fabs(cosine);
     if (nothick)
       pathLen = 1.0;
     float charge = recHit.energyLoss() / pathLen;
     if (convertFromGeV2MeV)
       charge *= 1000;
     dedxHits.push_back(DeDxHit(charge, trackMomentum, pathLen, recHit.geographicalId()));
   } else if (!recHit.isPixel()) {  // && !recHit.isMatched()){//check what recHit.isMatched is doing
     if (!useStrip)
       return;
     auto& detUnit = *(recHit.detUnit());
     float pathLen = detUnit.surface().bounds().thickness() / fabs(cosine);
     if (nothick)
       pathLen = 1.0;
     float dedxOfRecHit = recHit.energyLoss() / pathLen;
     if (convertFromGeV2MeV)
       dedxOfRecHit *= 1000;
     if (!shapetest) {
       dedxHits.push_back(DeDxHit(dedxOfRecHit, trackMomentum, pathLen, recHit.geographicalId()));
     }
   }
 }

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

overrideprivate

Definition at line 202 of file FastTrackDeDxProducer.cc.

References cms::cuda::assert(), edm::Event::getByToken(), h, hcalSimParameters_cfi::hb, TrackingRecHit::isValid(), dqmiolumiharvest::j, m_estimator, m_tracksTag, eostools::move(), processHit(), edm::Handle< T >::product(), edm::Event::put(), HLT_FULL_cff::track, and HLT_FULL_cff::trackCollection.

                                                                           {
   auto trackDeDxEstimateAssociation = std::make_unique<ValueMap<DeDxData>>();
   ValueMap<DeDxData>::Filler filler(*trackDeDxEstimateAssociation);
 
   edm::Handle<reco::TrackCollection> trackCollectionHandle;
   iEvent.getByToken(m_tracksTag, trackCollectionHandle);
   const auto& trackCollection = *trackCollectionHandle;
   std::vector<DeDxData> dedxEstimate(trackCollection.size());
 
   for (unsigned int j = 0; j < trackCollection.size(); j++) {
     const reco::TrackRef track = reco::TrackRef(trackCollectionHandle.product(), j);
 
     int NClusterSaturating = 0;
     DeDxHitCollection dedxHits;
 
     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++) {
       const FastTrackerRecHit& recHit = static_cast<const FastTrackerRecHit&>(*(*(hb + h)));
       if (!recHit.isValid())
         continue;  //FastTrackerRecHit recHit = *(hb+h);
       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));
 }