#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

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

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 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

bool	useCalibration

bool	usePixel

bool	useStrip

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

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Detailed Description

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

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

Definition at line 66 of file FastTrackDeDxProducer.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 137 of file FastTrackDeDxProducer.cc.

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

     : simHitsToken(consumes<edm::PSimHitContainer>(iConfig.getParameter<edm::InputTag>("simHits"))),
       simHit2RecHitMapToken(
           consumes<FastTrackerRecHitRefCollection>(iConfig.getParameter<edm::InputTag>("simHit2RecHitMap"))) {
   produces<ValueMap<DeDxData>>();
 
   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));
   else if (estimatorName == "btagDiscrim")
     m_estimator = std::unique_ptr<BaseDeDxEstimator>(new BTagLikeDeDxDiscriminator(iConfig));
   else if (estimatorName == "smirnovDiscrim")
     m_estimator = std::unique_ptr<BaseDeDxEstimator>(new SmirnovDeDxDiscriminator(iConfig));
   else if (estimatorName == "asmirnovDiscrim")
     m_estimator = std::unique_ptr<BaseDeDxEstimator>(new ASmirnovDeDxDiscriminator(iConfig));
   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";
 }

FastTrackDeDxProducer::~FastTrackDeDxProducer ( )

overridedefault

Member Function Documentation

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

overrideprivate

Definition at line 185 of file FastTrackDeDxProducer.cc.

References calibGains, edm::EventSetup::get(), m_calibrationPath, m_estimator, m_off, DeDxTools::makeCalibrationMap(), TrackerGeometry::offsetDU(), GeomDetEnumerators::PixelBarrel, and useCalibration.

                                                                                    {
   if (useCalibration && calibGains.empty()) {
     edm::ESHandle<TrackerGeometry> tkGeom;
     iSetup.get<TrackerDigiGeometryRecord>().get(tkGeom);
     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 115 of file FastTrackDeDxProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), and HLT_2018_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 241 of file FastTrackDeDxProducer.cc.

References ALCARECOTkAlJpsiMuMu_cff::charge, watchdog::const, convertFromGeV2MeV, DEFINE_FWK_MODULE, TrackingRecHit::detUnit(), FastTrackerRecHit::energyLoss(), TrackingRecHit::geographicalId(), FastTrackerRecHit::isPixel(), TrackingRecHit::isValid(), nothick, rpcPointValidation_cfi::recHit, 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 &	iSetup
	)

overrideprivate

Definition at line 197 of file FastTrackDeDxProducer.cc.

References trigObjTnPSource_cfi::filler, 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(), rpcPointValidation_cfi::recHit, HLT_2018_cff::track, and duplicaterechits_cfi::trackCollection.

Referenced by JSONExport.JsonExport::export(), HTMLExport.HTMLExport::export(), and HTMLExport.HTMLExportStatic::export().

                                                                                  {
   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));
 }