#include <trackJet/JetCoreMCtruthSeedGenerator/plugins/JetCoreMCtruthSeedGenerator.cc>

Inheritance diagram for JetCoreMCtruthSeedGenerator:

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

	~JetCoreMCtruthSeedGenerator () override

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

	EDProducer (const EDProducer &)=delete

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

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

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

bool	wantsInputProcessBlocks () const final

bool	wantsProcessBlocks () const final

Public Member Functions inherited from edm::one::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const

bool	wantsStreamRuns () const

	~EDProducerBase () override

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

std::vector< bool > const &	recordProvenanceList () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

TypeLabelList const &	typeLabelList () const
	used by the fwk to register the list of products of this module More...

	~ProducerBase () noexcept(false) override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

std::vector< ESProxyIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const

std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::array< std::vector< ModuleDescription const > , NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, ProductRegistry const &preg, std::map< std::string, ModuleDescription const *> const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

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

Static Public Member Functions inherited from edm::one::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Public Attributes
bool	inclusiveConeSeed_

double	jetEta_

double	jetPt_

double	pitchX_ = 0.01

double	pitchY_ = 0.015

Static Public Attributes
static constexpr int	jetDimX = 30

static constexpr int	jetDimY = 30

Private Member Functions
void	beginJob () override

std::vector< PSimHit >	coreHitsFilling (std::vector< PSimHit >, const GeomDet *, GlobalVector, const reco::Vertex &)

std::pair< std::vector< SimTrack >, std::vector< SimVertex > >	coreTracksFilling (std::vector< PSimHit >, const std::vector< SimTrack >, const std::vector< SimVertex >)

std::pair< std::vector< SimTrack >, std::vector< SimVertex > >	coreTracksFillingDeltaR (const std::vector< SimTrack >, const std::vector< SimVertex >, const GeomDet *, const reco::Candidate &, const reco::Vertex &)

const GeomDet *	DetectorSelector (int, const reco::Candidate &, GlobalVector, const reco::Vertex &, const TrackerTopology *const, const edmNew::DetSetVector< SiPixelCluster > &)

void	endJob () override

std::pair< bool, Basic3DVector< float > >	findIntersection (const GlobalVector &, const reco::Candidate::Point &, const GeomDet *)

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

std::vector< std::array< double, 5 > >	seedParFilling (std::pair< std::vector< SimTrack >, std::vector< SimVertex >>, const GeomDet *, const reco::Candidate &)

std::vector< GlobalVector >	splittedClusterDirections (const reco::Candidate &, const TrackerTopology const, const PixelClusterParameterEstimator , const reco::Vertex &, int, const edmNew::DetSetVector< SiPixelCluster > &)

Private Attributes
double	centralMIPCharge_

double	chargeFracMin_

edm::EDGetTokenT< edm::View< reco::Candidate > >	cores_

double	deltaR_

const edm::ESGetToken< GlobalTrackingGeometry, GlobalTrackingGeometryRecord >	geomEsToken_

edm::ESHandle< GlobalTrackingGeometry >	geometry_

edm::Handle< edmNew::DetSetVector< SiPixelCluster > >	inputPixelClusters_

edm::EDGetTokenT< edmNew::DetSetVector< SiPixelCluster > >	pixelClusters_

const edm::ESGetToken< PixelClusterParameterEstimator, TkPixelCPERecord >	pixelCPEEsToken_

edm::EDGetTokenT< std::vector< PSimHit > >	PSimHitToken_

double	ptMin_

edm::Handle< std::vector< PSimHit > >	simhits_

edm::EDGetTokenT< std::vector< SimTrack > >	simtracksToken_

edm::EDGetTokenT< std::vector< SimVertex > >	simvertexToken_

const edm::ESGetToken< TrackerTopology, TrackerTopologyRcd >	tTopoEsToken_

edm::EDGetTokenT< std::vector< reco::Vertex > >	vertices_

Additional Inherited Members
Public Types inherited from edm::one::EDProducerBase
typedef EDProducerBase	ModuleType

Public Types inherited from edm::ProducerBase
template<typename T >
using	BranchAliasSetterT = ProductRegistryHelper::BranchAliasSetterT< T >

using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex > >

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Protected Member Functions inherited from edm::ProducerBase
template<Transition Tr = Transition::Event>
auto	produces (std::string instanceName) noexcept
	declare what type of product will make and with which optional label More...

template<Transition B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<BranchType B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<class ProductType >
BranchAliasSetterT< ProductType >	produces ()

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces ()

template<class ProductType >
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces ()

template<Transition Tr = Transition::Event>
auto	produces () noexcept

ProducesCollector	producesCollector ()

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<Transition Tr = Transition::Event>
constexpr auto	esConsumes ()

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag)

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

void	resetItemsToGetFrom (BranchType iType)

Detailed Description

Description: [one line class summary] Implementation: [Notes on implementation]

Definition at line 77 of file JetCoreMCtruthSeedGenerator.cc.

Constructor & Destructor Documentation

◆ JetCoreMCtruthSeedGenerator()

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

explicit

Definition at line 159 of file JetCoreMCtruthSeedGenerator.cc.

     : geomEsToken_(esConsumes()),
       pixelCPEEsToken_(esConsumes(edm::ESInputTag("", iConfig.getParameter<std::string>("pixelCPE")))),
       tTopoEsToken_(esConsumes()),
       vertices_(consumes<reco::VertexCollection>(iConfig.getParameter<edm::InputTag>("vertices"))),
       pixelClusters_(
           consumes<edmNew::DetSetVector<SiPixelCluster>>(iConfig.getParameter<edm::InputTag>("pixelClusters"))),
       cores_(consumes<edm::View<reco::Candidate>>(iConfig.getParameter<edm::InputTag>("cores"))),
       simtracksToken_(consumes<std::vector<SimTrack>>(iConfig.getParameter<edm::InputTag>("simTracks"))),
       simvertexToken_(consumes<std::vector<SimVertex>>(iConfig.getParameter<edm::InputTag>("simVertex"))),
       PSimHitToken_(consumes<std::vector<PSimHit>>(iConfig.getParameter<edm::InputTag>("simHit"))),
       ptMin_(iConfig.getParameter<double>("ptMin")),
       deltaR_(iConfig.getParameter<double>("deltaR")),
       chargeFracMin_(iConfig.getParameter<double>("chargeFractionMin")),
       centralMIPCharge_(iConfig.getParameter<double>("centralMIPCharge")) {
   produces<TrajectorySeedCollection>();
   produces<reco::TrackCollection>();
 }

◆ ~JetCoreMCtruthSeedGenerator()

JetCoreMCtruthSeedGenerator::~JetCoreMCtruthSeedGenerator ( )

override

Definition at line 178 of file JetCoreMCtruthSeedGenerator.cc.

178 {}

Member Function Documentation

◆ beginJob()

void JetCoreMCtruthSeedGenerator::beginJob ( void )

overrideprivatevirtual

Reimplemented from edm::one::EDProducerBase.

Definition at line 495 of file JetCoreMCtruthSeedGenerator.cc.

495 {}

◆ coreHitsFilling()

std::vector< PSimHit > JetCoreMCtruthSeedGenerator::coreHitsFilling	(	std::vector< PSimHit >	simhits,
		const GeomDet *	globDet,
		GlobalVector	bigClustDir,
		const reco::Vertex &	jetVertex
	)

private

Definition at line 380 of file JetCoreMCtruthSeedGenerator.cc.

References funct::abs(), findIntersection(), geometry_, GlobalTrackingGeometry::idToDet(), jetDimX, jetDimY, pitchX_, pitchY_, reco::Vertex::position(), HLTBitAnalyser_cfi::simhits, GeomDet::specificSurface(), GloballyPositioned< T >::toLocal(), x, and y.

Referenced by produce().

                                                                                                {
   std::vector<PSimHit> goodSimHit;
   for (const auto& sh : simhits) {
     const GeomDet* det = geometry_->idToDet(sh.detUnitId());
     if (det != globDet)
       continue;
     std::pair<bool, Basic3DVector<float>> interPair =
         findIntersection(bigClustDir, (reco::Candidate::Point)jetVertex.position(), det);
     if (interPair.first == false)
       continue;
     Basic3DVector<float> inter = interPair.second;
     auto localInter = det->specificSurface().toLocal((GlobalPoint)inter);
 
     if (std::abs((sh.localPosition()).x() - localInter.x()) / pitchX_ <= jetDimX / 2 &&
         std::abs((sh.localPosition()).y() - localInter.y()) / pitchY_ <= jetDimY / 2) {
       goodSimHit.emplace_back(sh);
     }
   }
   return goodSimHit;
 }

◆ coreTracksFilling()

std::pair< std::vector< SimTrack >, std::vector< SimVertex > > JetCoreMCtruthSeedGenerator::coreTracksFilling	(	std::vector< PSimHit >	goodSimHit,
		const std::vector< SimTrack >	simtracksVector,
		const std::vector< SimVertex >	simvertexVector
	)

private

Definition at line 404 of file JetCoreMCtruthSeedGenerator.cc.

References createfilelist::int, dqmiolumiharvest::j, convertSQLitetoXML_cfg::output, pfDeepBoostedJetPreprocessParams_cfi::sv, CoreSimTrack::trackId(), parallelization::uint, findQualityFiles::v, and SimTrack::vertIndex().

Referenced by produce().

                                                 {
   std::vector<SimTrack> goodSimTrk;
   std::vector<SimVertex> goodSimVtx;
 
   for (uint j = 0; j < simtracksVector.size(); j++) {
     for (std::vector<PSimHit>::const_iterator it = goodSimHit.begin(); it != goodSimHit.end(); ++it) {
       SimTrack st = simtracksVector[j];
       if (st.trackId() == (*it).trackId()) {
         for (uint v = 0; v < simvertexVector.size(); v++) {
           SimVertex sv = simvertexVector[v];
           if ((int)sv.vertexId() == (int)st.vertIndex()) {
             goodSimTrk.emplace_back(st);
             goodSimVtx.emplace_back(sv);
           }
         }
       }
     }
   }
   std::pair<std::vector<SimTrack>, std::vector<SimVertex>> output(goodSimTrk, goodSimVtx);
   return output;
 }

◆ coreTracksFillingDeltaR()

std::pair< std::vector< SimTrack >, std::vector< SimVertex > > JetCoreMCtruthSeedGenerator::coreTracksFillingDeltaR	(	const std::vector< SimTrack >	simtracksVector,
		const std::vector< SimVertex >	simvertexVector,
		const GeomDet *	globDet,
		const reco::Candidate &	jet,
		const reco::Vertex &	jetVertex
	)

private

Definition at line 429 of file JetCoreMCtruthSeedGenerator.cc.

References CoreSimTrack::charge(), PbPb_ZMuSkimMuonDPG_cff::deltaR, deltaR_, createfilelist::int, dqmiolumiharvest::j, metsig::jet, CoreSimTrack::momentum(), convertSQLitetoXML_cfg::output, pfDeepBoostedJetPreprocessParams_cfi::sv, parallelization::uint, findQualityFiles::v, and SimTrack::vertIndex().

Referenced by produce().

                                  {
   std::vector<SimTrack> goodSimTrk;
   std::vector<SimVertex> goodSimVtx;
 
   GlobalVector jetDir(jet.px(), jet.py(), jet.pz());
 
   for (uint j = 0; j < simtracksVector.size(); j++) {
     SimTrack st = simtracksVector[j];
     GlobalVector trkDir(st.momentum().Px(), st.momentum().Py(), st.momentum().Pz());
     if (st.charge() == 0)
       continue;
     if (Geom::deltaR(jetDir, trkDir) < deltaR_) {
       for (uint v = 0; v < simvertexVector.size(); v++) {
         SimVertex sv = simvertexVector[v];
         if ((int)sv.vertexId() == (int)st.vertIndex()) {
           goodSimTrk.emplace_back(st);
           goodSimVtx.emplace_back(sv);
         }
       }
     }
   }
   std::pair<std::vector<SimTrack>, std::vector<SimVertex>> output(goodSimTrk, goodSimVtx);
   return output;
 }

◆ DetectorSelector()

const GeomDet * JetCoreMCtruthSeedGenerator::DetectorSelector	(	int	llay,
		const reco::Candidate &	jet,
		GlobalVector	jetDir,
		const reco::Vertex &	jetVertex,
		const TrackerTopology * const	tTopo,
		const edmNew::DetSetVector< SiPixelCluster > &	clusters
	)

private

Definition at line 316 of file JetCoreMCtruthSeedGenerator.cc.

References funct::abs(), bsc_activity_cfg::clusters, findIntersection(), GeomDet::geographicalId(), geometry_, GlobalTrackingGeometry::idToDet(), TrackerTopology::layer(), convertSQLitetoXML_cfg::output, reco::Vertex::position(), GeomDet::specificSurface(), GloballyPositioned< T >::toLocal(), x, and y.

Referenced by produce().

                                                                                                                  {
   struct trkNumCompare {
     bool operator()(std::pair<int, const GeomDet*> x, std::pair<int, const GeomDet*> y) const {
       return x.first > y.first;
     }
   };
   std::set<std::pair<int, const GeomDet*>, trkNumCompare> track4detSet;
 
   double minDist = 0.0;
   const GeomDet* output = nullptr;
   for (const auto& detset : clusters) {
     auto aClusterID = detset.id();
     if (DetId(aClusterID).subdetId() != 1)
       continue;
     const GeomDet* det = geometry_->idToDet(aClusterID);
     int lay = tTopo->layer(det->geographicalId());
     if (lay != llay)
       continue;
     std::pair<bool, Basic3DVector<float>> interPair =
         findIntersection(jetDir, (reco::Candidate::Point)jetVertex.position(), det);
     if (interPair.first == false)
       continue;
     Basic3DVector<float> inter = interPair.second;
     auto localInter = det->specificSurface().toLocal((GlobalPoint)inter);
     if ((minDist == 0.0 || std::abs(localInter.x()) < minDist) && std::abs(localInter.y()) < 3.35) {
       minDist = std::abs(localInter.x());
       output = det;
     }
   }  //detset
   return output;
 }

◆ endJob()

void JetCoreMCtruthSeedGenerator::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::one::EDProducerBase.

Definition at line 498 of file JetCoreMCtruthSeedGenerator.cc.

498 {}

◆ fillDescriptions()

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

static

Definition at line 501 of file JetCoreMCtruthSeedGenerator.cc.

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

                                                                                              {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("vertices", edm::InputTag("offlinePrimaryVertices"));
   desc.add<edm::InputTag>("pixelClusters", edm::InputTag("siPixelClustersPreSplitting"));
   desc.add<edm::InputTag>("cores", edm::InputTag("jetsForCoreTracking"));
   desc.add<double>("ptMin", 300);
   desc.add<double>("deltaR", 0.3);
   desc.add<double>("chargeFractionMin", 18000.0);
   desc.add<edm::InputTag>("simTracks", edm::InputTag("g4SimHits"));
   desc.add<edm::InputTag>("simVertex", edm::InputTag("g4SimHits"));
   desc.add<edm::InputTag>("simHit", edm::InputTag("g4SimHits", "TrackerHitsPixelBarrelLowTof"));
   desc.add<double>("centralMIPCharge", 2.);
   desc.add<std::string>("pixelCPE", "PixelCPEGeneric");
   descriptions.add("JetCoreMCtruthSeedGenerator", desc);
 }

◆ findIntersection()

std::pair< bool, Basic3DVector< float > > JetCoreMCtruthSeedGenerator::findIntersection	(	const GlobalVector &	dir,
		const reco::Candidate::Point &	vertex,
		const GeomDet *	det
	)

private

Definition at line 306 of file JetCoreMCtruthSeedGenerator.cc.

References DeadROC_duringRun::dir, StraightLinePlaneCrossing::position(), GeomDet::specificSurface(), and bphysicsOniaDQM_cfi::vertex.

Referenced by coreHitsFilling(), DetectorSelector(), and seedParFilling().

                                                                                    {
   StraightLinePlaneCrossing vertexPlane(Basic3DVector<float>(vertex.x(), vertex.y(), vertex.z()),
                                         Basic3DVector<float>(dir.x(), dir.y(), dir.z()));
 
   std::pair<bool, Basic3DVector<float>> pos = vertexPlane.position(det->specificSurface());
 
   return pos;
 }

◆ produce()

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

overrideprivatevirtual

Implements edm::one::EDProducerBase.

Definition at line 180 of file JetCoreMCtruthSeedGenerator.cc.

References alongMomentum, gpuPixelDoublets::cc, coreHitsFilling(), HLT_FULL_cff::cores, cores_, coreTracksFilling(), coreTracksFillingDeltaR(), DetectorSelector(), MillePedeFileConverter_cfg::e, PV3DBase< T, PVType, FrameType >::eta(), JetChargeProducer_cfi::exp, GeomDet::geographicalId(), geomEsToken_, geometry_, edm::EventSetup::getData(), edm::EventSetup::getHandle(), iEvent, inclusiveConeSeed_, inputPixelClusters_, createfilelist::int, metsig::jet, jetEta_, jetPt_, eostools::move(), convertSQLitetoXML_cfg::output, PV3DBase< T, PVType, FrameType >::phi(), pixelClusters_, HLT_2023v12_cff::pixelCPE, pixelCPEEsToken_, createTree::pp, PSimHitToken_, DiDispStaMuonMonitor_cfi::pt, ptMin_, mps_fire::result, seedParFilling(), simhits_, simtracksToken_, simvertexToken_, funct::sin(), splittedClusterDirections(), GeomDet::surface(), Surface::toGlobal(), GloballyPositioned< T >::toLocal(), tTopoEsToken_, parallelization::uint, AlignmentTracksFromVertexSelector_cfi::vertices, vertices_, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

                                                                                        {
   auto result = std::make_unique<TrajectorySeedCollection>();
   auto resultTracks = std::make_unique<reco::TrackCollection>();
 
   using namespace edm;
   using namespace reco;
 
   geometry_ = iSetup.getHandle(geomEsToken_);
 
   const auto& inputPixelClusters_ = iEvent.get(pixelClusters_);
   const auto& simtracksVector = iEvent.get(simtracksToken_);
   const auto& simvertexVector = iEvent.get(simvertexToken_);
   const auto& simhits_ = iEvent.get(PSimHitToken_);
   const auto& vertices = iEvent.get(vertices_);
   const auto& cores = iEvent.get(cores_);
 
   const PixelClusterParameterEstimator* pixelCPE = &iSetup.getData(pixelCPEEsToken_);
   const TrackerTopology* const tTopo = &iSetup.getData(tTopoEsToken_);
 
   auto output = std::make_unique<edmNew::DetSetVector<SiPixelCluster>>();
 
   for (const auto& jet : cores) {  //jet loop
 
     if (jet.pt() > ptMin_) {
       std::set<long long int> ids;
       const reco::Vertex& jetVertex = vertices[0];
 
       std::vector<GlobalVector> splitClustDirSet =
           splittedClusterDirections(jet, tTopo, pixelCPE, jetVertex, 1, inputPixelClusters_);
       if (splitClustDirSet.empty()) {  //if layer 1 is broken find direcitons on layer 2
         splitClustDirSet = splittedClusterDirections(jet, tTopo, pixelCPE, jetVertex, 2, inputPixelClusters_);
       }
       if (inclusiveConeSeed_)
         splitClustDirSet.clear();
       splitClustDirSet.emplace_back(GlobalVector(jet.px(), jet.py(), jet.pz()));
 
       for (int cc = 0; cc < (int)splitClustDirSet.size(); cc++) {
         GlobalVector bigClustDir = splitClustDirSet[cc];
 
         jetEta_ = jet.eta();
         jetPt_ = jet.pt();
 
         const auto& jetVert = jetVertex;  //trackInfo filling
 
         std::vector<PSimHit> goodSimHit;
 
         const GeomDet* globDet = DetectorSelector(
             2, jet, bigClustDir, jetVertex, tTopo, inputPixelClusters_);  //select detector mostly hitten by the jet
 
         if (globDet == nullptr)
           continue;
 
         std::pair<std::vector<SimTrack>, std::vector<SimVertex>> goodSimTkVx;
 
         if (inclusiveConeSeed_) {
           goodSimTkVx = JetCoreMCtruthSeedGenerator::coreTracksFillingDeltaR(
               simtracksVector, simvertexVector, globDet, jet, jetVert);
         } else {
           std::vector<PSimHit> goodSimHit =
               JetCoreMCtruthSeedGenerator::coreHitsFilling(simhits_, globDet, bigClustDir, jetVertex);
           goodSimTkVx = JetCoreMCtruthSeedGenerator::coreTracksFilling(goodSimHit, simtracksVector, simvertexVector);
         }
         edm::LogInfo("PerfectSeeder") << "seed number in deltaR cone =" << goodSimTkVx.first.size();
 
         std::vector<std::array<double, 5>> seedVector =
             JetCoreMCtruthSeedGenerator::seedParFilling(goodSimTkVx, globDet, jet);
         edm::LogInfo("PerfectSeeder") << "seedVector.size()=" << seedVector.size();
 
         for (uint tk = 0; tk < seedVector.size(); tk++) {
           for (int pp = 0; pp < 5; pp++) {
             edm::LogInfo("PerfectSeeder")
                 << "seed " << tk << ", int par " << pp << "=" << seedVector[tk][pp] << std::endl;
           }
           LocalPoint localSeedPoint = LocalPoint(seedVector[tk][0], seedVector[tk][1], 0);
           double track_theta = 2 * std::atan(std::exp(-seedVector[tk][2]));
           double track_phi = seedVector[tk][3];
           double pt = 1. / seedVector[tk][4];
 
           double normdirR = pt / sin(track_theta);
           const GlobalVector globSeedDir(
               GlobalVector::Polar(Geom::Theta<double>(track_theta), Geom::Phi<double>(track_phi), normdirR));
           LocalVector localSeedDir = globDet->surface().toLocal(globSeedDir);
 
           int64_t seedid = (int64_t(localSeedPoint.x() * 200.) << 0) + (int64_t(localSeedPoint.y() * 200.) << 16) +
                            (int64_t(seedVector[tk][2] * 400.) << 32) + (int64_t(track_phi * 400.) << 48);
           if (ids.count(seedid) != 0) {
             edm::LogInfo("PerfectSeeder") << "seed not removed with DeepCore cleaner";
           }
           ids.insert(seedid);
 
           //Covariance matrix, currently the hadrcoded variances = NN residuals width (see documentation of DeepCore)
           //in general: if are not compared with DeepCore but another algo-->to state-of-the art errors
           //The "perfect seeds" has no intrinsic error, but the CTF needs errors to propagate...
           float em[15] = {
               0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};  // (see LocalTrajectoryError for details), order as follow:
           em[0] = 0.15 * 0.15;                               // q/pt
           em[2] = 0.5e-5;                                    // dxdz
           em[5] = 0.5e-5;                                    // dydz
           em[9] = 2e-5;                                      // x
           em[14] = 2e-5;                                     // y
           long int detId = globDet->geographicalId();
           LocalTrajectoryParameters localParam(localSeedPoint, localSeedDir, TrackCharge(1));
           result->emplace_back(TrajectorySeed(PTrajectoryStateOnDet(localParam, pt, em, detId, /*surfaceSide*/ 0),
                                               edm::OwnVector<TrackingRecHit>(),
                                               PropagationDirection::alongMomentum));
 
           GlobalPoint globalSeedPoint = globDet->surface().toGlobal(localSeedPoint);
           reco::Track::CovarianceMatrix mm;
           resultTracks->emplace_back(
               reco::Track(1,
                           1,
                           reco::Track::Point(globalSeedPoint.x(), globalSeedPoint.y(), globalSeedPoint.z()),
                           reco::Track::Vector(globSeedDir.x(), globSeedDir.y(), globSeedDir.z()),
                           1,
                           mm));
           edm::LogInfo("PerfectSeeder") << "seed " << tk << ", out,  pt=" << pt << ", eta=" << globSeedDir.eta()
                                         << ", phi=" << globSeedDir.phi() << std::endl;
         }
 
       }  //bigcluster
     }    //jet > pt
   }      //jet
   iEvent.put(std::move(result));
   iEvent.put(std::move(resultTracks));
 }

◆ seedParFilling()

std::vector< std::array< double, 5 > > JetCoreMCtruthSeedGenerator::seedParFilling	(	std::pair< std::vector< SimTrack >, std::vector< SimVertex >>	goodSimTkVx,
		const GeomDet *	globDet,
		const reco::Candidate &	jet
	)

private

Definition at line 459 of file JetCoreMCtruthSeedGenerator.cc.

References findIntersection(), dqmiolumiharvest::j, metsig::jet, CoreSimTrack::momentum(), convertSQLitetoXML_cfg::output, GeomDet::specificSurface(), pfDeepBoostedJetPreprocessParams_cfi::sv, GloballyPositioned< T >::toLocal(), parallelization::uint, and PV3DBase< T, PVType, FrameType >::x().

Referenced by produce().

                               {
   std::vector<std::array<double, 5>> output;
   std::vector<SimTrack> goodSimTrk = goodSimTkVx.first;
   std::vector<SimVertex> goodSimVtx = goodSimTkVx.second;
 
   edm::LogInfo("PerfectSeeder") << "goodSimTrk size" << goodSimTrk.size();
   for (uint j = 0; j < goodSimTrk.size(); j++) {
     SimTrack st = goodSimTrk[j];
     SimVertex sv = goodSimVtx[j];
     GlobalVector trkMom(st.momentum().x(), st.momentum().y(), st.momentum().z());
     GlobalPoint trkPos(sv.position().x(), sv.position().y(), sv.position().z());
     edm::LogInfo("PerfectSeeder") << "seed " << j << ", very int pt" << st.momentum().Pt()
                                   << ", eta=" << st.momentum().Eta() << ", phi=" << st.momentum().Phi()
                                   << "------ internal point=" << trkMom.x() << "," << trkMom.y() << "," << trkMom.z()
                                   << "," << trkPos.x() << "," << trkPos.y() << "," << trkPos.z() << std::endl;
 
     std::pair<bool, Basic3DVector<float>> trkInterPair;
     trkInterPair = findIntersection(trkMom, (reco::Candidate::Point)trkPos, globDet);
     if (trkInterPair.first == false) {
       GlobalVector jetDir(jet.px(), jet.py(), jet.pz());
       continue;
     }
     Basic3DVector<float> trkInter = trkInterPair.second;
 
     auto localTrkInter = globDet->specificSurface().toLocal((GlobalPoint)trkInter);  //trkInter->trkPos if par at vertex
     std::array<double, 5> tkPar{
         {localTrkInter.x(), localTrkInter.y(), st.momentum().Eta(), st.momentum().Phi(), 1 / st.momentum().Pt()}};
     output.emplace_back(tkPar);
   }
   return output;
 }

◆ splittedClusterDirections()

std::vector< GlobalVector > JetCoreMCtruthSeedGenerator::splittedClusterDirections	(	const reco::Candidate &	jet,
		const TrackerTopology * const	tTopo,
		const PixelClusterParameterEstimator *	pixelCPE,
		const reco::Vertex &	jetVertex,
		int	layer,
		const edmNew::DetSetVector< SiPixelCluster > &	clusters
	)

private

Definition at line 353 of file JetCoreMCtruthSeedGenerator.cc.

References bsc_activity_cfg::clusters, PbPb_ZMuSkimMuonDPG_cff::deltaR, deltaR_, GeomDet::geographicalId(), geometry_, GlobalTrackingGeometry::idToDet(), GlobalTrackingGeometry::idToDetUnit(), metsig::jet, pixelTopology::layer, TrackerTopology::layer(), HLT_2023v12_cff::pixelCPE, reco::Vertex::position(), GeomDet::surface(), and Surface::toGlobal().

Referenced by produce().

                                                         {
   std::vector<GlobalVector> clustDirs;
   for (const auto& detset_int : clusters) {
     const GeomDet* det_int = geometry_->idToDet(detset_int.id());
     int lay = tTopo->layer(det_int->geographicalId());
     if (lay != layer)
       continue;  //NB: saved bigclusetr on all the layers!!
     auto detUnit = *geometry_->idToDetUnit(detset_int.id());
     for (const auto& aCluster : detset_int) {
       GlobalPoint clustPos = det_int->surface().toGlobal(pixelCPE->localParametersV(aCluster, detUnit)[0].first);
       GlobalPoint vertexPos(jetVertex.position().x(), jetVertex.position().y(), jetVertex.position().z());
       GlobalVector clusterDir = clustPos - vertexPos;
       GlobalVector jetDir(jet.px(), jet.py(), jet.pz());
       if (Geom::deltaR(jetDir, clusterDir) < deltaR_) {
         clustDirs.emplace_back(clusterDir);
       }
     }
   }
   return clustDirs;
 }