#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

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

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 &&)=default

	EDConsumerBase (EDConsumerBase const &)=delete

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 &	operator= (EDConsumerBase &&)=default

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

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

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
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<class ProductType >
BranchAliasSetterT< ProductType >	produces ()
	declare what type of product will make and with which optional label More...

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

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

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)

template<Transition B>
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 (std::string instanceName)

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

ProducesCollector	producesCollector ()

Protected Member Functions inherited from edm::EDConsumerBase
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

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

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

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<Transition Tr = Transition::Event>
constexpr auto	esConsumes () noexcept

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

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

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

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

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

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

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.

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

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

Referenced by produce().

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

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

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

Referenced by produce().

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

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

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().

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

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

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

Referenced by produce().

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

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

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

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

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

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

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

◆ produce()

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

overrideprivatevirtual

Implements edm::one::EDProducerBase.

Definition at line 180 of file JetCoreMCtruthSeedGenerator.cc.

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

References alongMomentum, 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_FULL_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, pwdgSkimBPark_cfi::vertices, vertices_, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

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

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

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().

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

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