Inheritance diagram for HGCalTrackCollectionProducer:

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

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

Private Member Functions
void	beginLuminosityBlock (const edm::LuminosityBlock &, const edm::EventSetup &) override

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

Private Attributes
const MagneticField *	bField_

float	diskInnerRadius_

float	diskOuterRadius_

const std::vector< double >	DPtovPtCut_

std::array< std::string, 1 >	hgc_names_

std::array< const HGCalGeometry *, 1 >	hgcGeometries_

std::array< edm::ESGetToken< HGCalGeometry, IdealGeometryRecord >, 1 >	hgcGeometryTokens_

const edm::ESGetToken< MagneticField, IdealMagneticFieldRecord >	magneticFieldToken_

std::unique_ptr< PropagatorWithMaterial >	mat_prop_

std::array< std::vector< ReferenceCountingPointer< BoundDisk > >, 1 >	minusSurface_

const std::vector< unsigned >	NHitCut_

std::array< std::vector< ReferenceCountingPointer< BoundDisk > >, 1 >	plusSurface_

edm::EDGetTokenT< edm::View< reco::PFRecTrack > >	src_

const edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord >	tkerGeomToken_

const TrackerGeometry *	tkGeom_

const reco::TrackBase::TrackQuality	trackQuality_

const bool	useIterTracking_

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

Definition at line 39 of file HGCalTrackCollectionProducer.cc.

Constructor & Destructor Documentation

◆ HGCalTrackCollectionProducer()

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

Definition at line 75 of file HGCalTrackCollectionProducer.cc.

References edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterSet(), hgc_names_, hgcGeometryTokens_, mps_fire::i, LogDebug, and AlCaHLTBitMon_QueryRunRegistry::string.

     : src_(consumes<edm::View<reco::PFRecTrack> >(iConfig.getParameter<edm::InputTag>("src"))),
       trackQuality_((iConfig.existsAs<std::string>("trackQuality"))
                         ? reco::TrackBase::qualityByName(iConfig.getParameter<std::string>("trackQuality"))
                         : reco::TrackBase::highPurity),
       DPtovPtCut_(iConfig.getParameter<std::vector<double> >("DPtOverPtCuts_byTrackAlgo")),
       NHitCut_(iConfig.getParameter<std::vector<unsigned> >("NHitCuts_byTrackAlgo")),
       useIterTracking_(iConfig.getParameter<bool>("useIterativeTracking")),
       magneticFieldToken_(esConsumes<edm::Transition::BeginLuminosityBlock>()),
       tkerGeomToken_(esConsumes<edm::Transition::BeginLuminosityBlock>()) {
   LogDebug("HGCalTrackCollectionProducer")
       << " HGCalTrackCollectionProducer::HGCalTrackCollectionProducer " << std::endl;
 
   const edm::ParameterSet& geoconf = iConfig.getParameterSet("hgcalGeometryNames");
   hgc_names_[0] = geoconf.getParameter<std::string>("HGC_ECAL");
   for (unsigned i = 0; i < hgcGeometryTokens_.size(); i++) {
     hgcGeometryTokens_[i] = esConsumes<edm::Transition::BeginLuminosityBlock>(edm::ESInputTag("", hgc_names_[i]));
   }
 
   produces<reco::PFRecTrackCollection>("TracksInHGCal");
   produces<reco::PFRecTrackCollection>("TracksNotInHGCal");
 }

Member Function Documentation

◆ beginLuminosityBlock()

void HGCalTrackCollectionProducer::beginLuminosityBlock	(	const edm::LuminosityBlock &	lumi,
		const edm::EventSetup &	es
	)

overrideprivate

Definition at line 100 of file HGCalTrackCollectionProducer.cc.

References funct::abs(), alongMomentum, bField_, ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), diskInnerRadius_, diskOuterRadius_, edm::EventSetup::getData(), HGCalDDDConstants::getTrForms(), hgcGeometries_, hgcGeometryTokens_, mps_fire::i, LogDebug, ph2tkdigialgo::m_pion, magneticFieldToken_, mat_prop_, minusSurface_, plusSurface_, makeMuonMisalignmentScenario::rot, tkerGeomToken_, tkGeom_, and beamSpotPI::Z.

                                                                                                                {
   constexpr float m_pion = 0.1396;
   // get dependencies for setting up propagator
   bField_ = &es.getData(magneticFieldToken_);
   tkGeom_ = &es.getData(tkerGeomToken_);
   // get HGC geometries (assume that layers are ordered in Z!)
   for (unsigned i = 0; i < hgcGeometries_.size(); ++i) {
     hgcGeometries_[i] = &es.getData(hgcGeometryTokens_[i]);
   }
 
   // make propagator
   mat_prop_ = std::make_unique<PropagatorWithMaterial>(alongMomentum, m_pion, bField_);
   // setup HGC layers for track propagation
   Surface::RotationType rot;  //unit rotation matrix
   for (unsigned i = 0; i < hgcGeometries_.size(); ++i) {
     minusSurface_[i].clear();
     plusSurface_[i].clear();
     const HGCalDDDConstants& dddCons = hgcGeometries_[i]->topology().dddConstants();
     std::map<float, float> zrhoCoord;
     std::map<float, float> innerRadiusCoord;
     auto theTrForms = dddCons.getTrForms();
     const auto& firstLayerIt = theTrForms.back();
     float Z(std::abs(firstLayerIt.h3v.z()));
     // use hardcoded radii for now (FIX ME)
     diskInnerRadius_ = 31.5;
     diskOuterRadius_ = 161.0f;
     LogDebug("HGCalTrackCollectionProducer") << "O HAI I'm making a bound disk with Outer R=" << diskOuterRadius_
                                              << " Inner R=" << diskInnerRadius_ << " and Z=" << Z << std::endl;
     minusSurface_[i].push_back(ReferenceCountingPointer<BoundDisk>(new BoundDisk(
         Surface::PositionType(0, 0, -Z), rot, new SimpleDiskBounds(diskInnerRadius_, diskOuterRadius_, -0.001, 0.001))));
     plusSurface_[i].push_back(ReferenceCountingPointer<BoundDisk>(new BoundDisk(
         Surface::PositionType(0, 0, +Z), rot, new SimpleDiskBounds(diskInnerRadius_, diskOuterRadius_, -0.001, 0.001))));
   }
 }

◆ produce()

void HGCalTrackCollectionProducer::produce	(	edm::Event &	evt,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 135 of file HGCalTrackCollectionProducer.cc.

References funct::abs(), bField_, diskInnerRadius_, diskOuterRadius_, HLT_2024v12_cff::distance, DPtovPtCut_, newFWLiteAna::found, edm::Event::getByToken(), TrajectoryStateOnSurface::globalPosition(), PFTrackAlgoTools::goodPtResolution(), mps_fire::i, TrajectoryStateOnSurface::isValid(), nano_mu_digi_cff::layer, LogDebug, mat_prop_, minusSurface_, eostools::move(), NHitCut_, trajectoryStateTransform::outerStateOnSurface(), plusSurface_, DiDispStaMuonMonitor_cfi::pt, edm::Event::put(), mathSSE::sqrt(), src_, tkGeom_, HLT_2024v12_cff::track, trackQuality_, DiMuonV_cfg::tracks, useIterTracking_, and PV3DBase< T, PVType, FrameType >::z().

                                                                                      {
   edm::Handle<edm::View<reco::PFRecTrack> > trackHandle;
   evt.getByToken(src_, trackHandle);
   const auto& tracks = *trackHandle;
 
   auto outputInHGCal = std::make_unique<reco::PFRecTrackCollection>();
   auto outputNotInHGCal = std::make_unique<reco::PFRecTrackCollection>();
 
   for (unsigned int i = 0; i < tracks.size(); i++) {
     const auto track = tracks.ptrAt(i);
     bool isGood =
         PFTrackAlgoTools::goodPtResolution(track->trackRef(), DPtovPtCut_, NHitCut_, useIterTracking_, trackQuality_);
     LogDebug("HGCalTrackCollectionProducer") << "HGCalTrackCollectionProducer Track number " << i
                                              << " has a goodPtResolution result of " << isGood << std::endl;
     if (!isGood)
       continue;
     bool found = false;
     const TrajectoryStateOnSurface myTSOS =
         trajectoryStateTransform::outerStateOnSurface(*(track->trackRef()), *tkGeom_, bField_);
     auto detbegin = myTSOS.globalPosition().z() > 0 ? plusSurface_.begin() : minusSurface_.begin();
     auto detend = myTSOS.globalPosition().z() > 0 ? plusSurface_.end() : minusSurface_.end();
     for (auto det = detbegin; det != detend; ++det) {
       LogDebug("HGCalTrackCollectionProducer") << "at HGC detector: " << std::distance(detbegin, det) << std::endl;
       unsigned layer_count = 1;
       for (const auto& layer : *det) {
         LogDebug("HGCalTrackCollectionProducer") << "  at DET layer: " << layer_count++ << std::endl;
         TrajectoryStateOnSurface piStateAtSurface = mat_prop_->propagate(myTSOS, *layer);
         if (piStateAtSurface.isValid()) {
           LogDebug("HGCalTrackCollectionProducer") << "Extrapolation is valid!" << std::endl;
           GlobalPoint pt = piStateAtSurface.globalPosition();
           if (pt.perp() < diskOuterRadius_) {
             if (pt.perp() > diskInnerRadius_) {
               LogDebug("HGCalTrackCollectionProducer")
                   << "(x,y,z,r)=(" << pt.x() << ", " << pt.y() << ", " << pt.z() << ", "
                   << sqrt(pt.x() * pt.x() + pt.y() * pt.y()) << ")" << std::endl;
               if (std::abs(track->trackRef()->eta()) < 1.47)
                 LogDebug("HGCalTrackCollectionProducer") << " ETA IN BARREL REGION: " << track->trackRef()->eta()
                                                          << " (PT: " << track->trackRef()->pt() << ")" << std::endl;
               found = true;
             } else {
               LogDebug("HGCalTrackCollectionProducer")
                   << " but r=" << pt.perp() << " < diskInnerRadius=" << diskInnerRadius_ << " so skipping "
                   << std::endl;
             }
           } else {
             LogDebug("HGCalTrackCollectionProducer")
                 << " but r=" << pt.perp() << " > diskOuterRadius=" << diskOuterRadius_ << " so skipping " << std::endl;
           }
         } else {
           LogDebug("HGCalTrackCollectionProducer") << "Extrapolation is NOT valid!" << std::endl;
         }
       }
     }
     if (found) {
       LogDebug("HGCalTrackCollectionProducer") << " Track going to outputInHGCal pt eta " << track->trackRef()->pt()
                                                << " " << track->trackRef()->eta() << std::endl;
       outputInHGCal->push_back(*track);
     } else {
       outputNotInHGCal->push_back(*track);
     }
   }  // track loop
 
   evt.put(std::move(outputInHGCal), "TracksInHGCal");
   evt.put(std::move(outputNotInHGCal), "TracksNotInHGCal");
 }