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

Inheritance diagram for DeepCoreSeedGenerator:

Public Member Functions
	DeepCoreSeedGenerator (const edm::ParameterSet &, const tensorflow::SessionCache *)

	~DeepCoreSeedGenerator () override

Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< tensorflow::SessionCache > >
	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)

static void	globalEndJob (tensorflow::SessionCache *)

static std::unique_ptr< tensorflow::SessionCache >	initializeGlobalCache (const edm::ParameterSet &)

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

static constexpr int	Nlayer = 4

static constexpr int	Nover = 3

static constexpr int	Npar = 5

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

void	fillPixelMatrix (const SiPixelCluster &, int, Point3DBase< float, LocalTag >, const GeomDet *, tensorflow::NamedTensorList)

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

std::pair< int, int >	local2Pixel (double, double, const GeomDet *)

LocalPoint	pixel2Local (int, int, const GeomDet *)

int	pixelFlipper (const GeomDet *)

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

std::pair< double[jetDimX][jetDimY][Nover][Npar], double[jetDimX][jetDimY][Nover]>	SeedEvaluation (tensorflow::NamedTensorList, std::vector< std::string >)

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 GlobalTrackingGeometry *	geometry_ = nullptr

const edm::ESGetToken< GlobalTrackingGeometry, GlobalTrackingGeometryRecord >	geometryToken_

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

std::vector< std::string >	inputTensorName_

std::vector< std::string >	outputTensorName_

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

const edm::ESGetToken< PixelClusterParameterEstimator, TkPixelCPERecord >	pixelCPEToken_

double	probThr_

std::string	propagatorName_

double	ptMin_

const tensorflow::Session *	session_

const edm::ESGetToken< TrackerTopology, TrackerTopologyRcd >	topoToken_

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

std::string	weightfilename_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< tensorflow::SessionCache > >
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 76 of file DeepCoreSeedGenerator.cc.

Constructor & Destructor Documentation

◆ DeepCoreSeedGenerator()

DeepCoreSeedGenerator::DeepCoreSeedGenerator	(	const edm::ParameterSet &	iConfig,
		const tensorflow::SessionCache *	cache
	)

explicit

Definition at line 158 of file DeepCoreSeedGenerator.cc.

     : 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"))),
       geometryToken_(esConsumes()),
       pixelCPEToken_(esConsumes(edm::ESInputTag("", iConfig.getParameter<std::string>("pixelCPE")))),
       topoToken_(esConsumes<TrackerTopology, TrackerTopologyRcd>()),
       ptMin_(iConfig.getParameter<double>("ptMin")),
       deltaR_(iConfig.getParameter<double>("deltaR")),
       chargeFracMin_(iConfig.getParameter<double>("chargeFractionMin")),
       centralMIPCharge_(iConfig.getParameter<double>("centralMIPCharge")),
       weightfilename_(iConfig.getParameter<edm::FileInPath>("weightFile").fullPath()),
       inputTensorName_(iConfig.getParameter<std::vector<std::string>>("inputTensorName")),
       outputTensorName_(iConfig.getParameter<std::vector<std::string>>("outputTensorName")),
       probThr_(iConfig.getParameter<double>("probThr")),
       session_(cache->getSession())
 
 {
   produces<TrajectorySeedCollection>();
   produces<reco::TrackCollection>();
 }

◆ ~DeepCoreSeedGenerator()

DeepCoreSeedGenerator::~DeepCoreSeedGenerator ( )

override

Definition at line 181 of file DeepCoreSeedGenerator.cc.

181 {}

Member Function Documentation

◆ DetectorSelector()

const GeomDet * DeepCoreSeedGenerator::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 475 of file DeepCoreSeedGenerator.cc.

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

Referenced by produce().

                                                                                                            {
   double minDist = 0.0;
   GeomDet* output = (GeomDet*)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 = (GeomDet*)det;
     }
   }  //detset
   return output;
 }

◆ fillDescriptions()

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

static

Definition at line 543 of file DeepCoreSeedGenerator.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", 100);
   desc.add<double>("deltaR", 0.25);  // the current training makes use of 0.1
   desc.add<double>("chargeFractionMin", 18000.0);
   desc.add<double>("centralMIPCharge", 2);
   desc.add<std::string>("pixelCPE", "PixelCPEGeneric");
   desc.add<edm::FileInPath>(
       "weightFile",
       edm::FileInPath("RecoTracker/TkSeedGenerator/data/DeepCore/DeepCoreSeedGenerator_TrainedModel_barrel_2017.pb"));
   desc.add<std::vector<std::string>>("inputTensorName", {"input_1", "input_2", "input_3"});
   desc.add<std::vector<std::string>>("outputTensorName", {"output_node0", "output_node1"});
   desc.add<double>("probThr", 0.85);
   descriptions.add("deepCoreSeedGenerator", desc);
 }

◆ fillPixelMatrix()

void DeepCoreSeedGenerator::fillPixelMatrix	(	const SiPixelCluster &	cluster,
		int	layer,
		Point3DBase< float, LocalTag >	inter,
		const GeomDet *	det,
		tensorflow::NamedTensorList	input_tensors
	)

private

Definition at line 424 of file DeepCoreSeedGenerator.cc.

References funct::abs(), SiPixelCluster::Pixel::adc, f, HLT_2023v12_cff::flip, dqmMemoryStats::float, mps_fire::i, jetDimX, jetDimY, pixelTopology::layer, local2Pixel(), SiPixelCluster::pixel(), pixelFlipper(), SiPixelCluster::size(), SiPixelCluster::Pixel::x, PV3DBase< T, PVType, FrameType >::x(), SiPixelCluster::Pixel::y, and PV3DBase< T, PVType, FrameType >::y().

Referenced by produce().

                                                                                      {
   int flip = pixelFlipper(det);  // 1=not flip, -1=flip
 
   for (int i = 0; i < cluster.size(); i++) {
     SiPixelCluster::Pixel pix = cluster.pixel(i);
     std::pair<int, int> pixInter = local2Pixel(inter.x(), inter.y(), det);
     int nx = pix.x - pixInter.first;
     int ny = pix.y - pixInter.second;
     nx = flip * nx;
 
     if (abs(nx) < jetDimX / 2 && abs(ny) < jetDimY / 2) {
       nx = nx + jetDimX / 2;
       ny = ny + jetDimY / 2;
       //14000 = normalization of ACD counts used in the NN
       input_tensors[2].second.tensor<float, 4>()(0, nx, ny, layer - 1) += (pix.adc) / (14000.f);
     }
   }
 }

◆ findIntersection()

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

private

Definition at line 386 of file DeepCoreSeedGenerator.cc.

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

Referenced by DetectorSelector(), and produce().

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

◆ globalEndJob()

void DeepCoreSeedGenerator::globalEndJob ( tensorflow::SessionCache * cache )

static

Definition at line 540 of file DeepCoreSeedGenerator.cc.

540 {}

◆ initializeGlobalCache()

std::unique_ptr< tensorflow::SessionCache > DeepCoreSeedGenerator::initializeGlobalCache ( const edm::ParameterSet & iConfig )

static

Definition at line 532 of file DeepCoreSeedGenerator.cc.

References utilities::cache(), contentValuesFiles::fullPath, edm::ParameterSet::getParameter(), HLT_2023v12_cff::graphPath, and AlCaHLTBitMon_QueryRunRegistry::string.

                                     {
   // this method is supposed to create, initialize and return a Tensorflow:SessionCache instance
   std::string graphPath = iConfig.getParameter<edm::FileInPath>("weightFile").fullPath();
   std::unique_ptr<tensorflow::SessionCache> cache = std::make_unique<tensorflow::SessionCache>(graphPath);
   return cache;
 }

◆ local2Pixel()

std::pair< int, int > DeepCoreSeedGenerator::local2Pixel	(	double	locX,
		double	locY,
		const GeomDet *	det
	)

private

Definition at line 397 of file DeepCoreSeedGenerator.cc.

References MillePedeFileConverter_cfg::out.

Referenced by fillPixelMatrix(), and produce().

                                                                                                  {
   LocalPoint locXY(locX, locY);
   float pixX = (dynamic_cast<const PixelGeomDetUnit*>(det))->specificTopology().pixel(locXY).first;
   float pixY = (dynamic_cast<const PixelGeomDetUnit*>(det))->specificTopology().pixel(locXY).second;
   std::pair<int, int> out(pixX, pixY);
   return out;
 }

◆ pixel2Local()

LocalPoint DeepCoreSeedGenerator::pixel2Local	(	int	pixX,
		int	pixY,
		const GeomDet *	det
	)

private

Definition at line 405 of file DeepCoreSeedGenerator.cc.

Referenced by produce().

                                                                                     {
   float locX = (dynamic_cast<const PixelGeomDetUnit*>(det))->specificTopology().localX(pixX);
   float locY = (dynamic_cast<const PixelGeomDetUnit*>(det))->specificTopology().localY(pixY);
   LocalPoint locXY(locX, locY);
   return locXY;
 }

◆ pixelFlipper()

int DeepCoreSeedGenerator::pixelFlipper ( const GeomDet * det )

private

Definition at line 412 of file DeepCoreSeedGenerator.cc.

References MillePedeFileConverter_cfg::out, GeomDet::position(), GeomDet::specificSurface(), Surface::toGlobal(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by fillPixelMatrix(), and produce().

                                                           {
   int out = 1;
   LocalVector locZdir(0, 0, 1);
   GlobalVector globZdir = det->specificSurface().toGlobal(locZdir);
   const GlobalPoint& globDetCenter = det->position();
   float direction =
       globZdir.x() * globDetCenter.x() + globZdir.y() * globDetCenter.y() + globZdir.z() * globDetCenter.z();
   if (direction < 0)
     out = -1;
   return out;
 }

◆ produce()

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

overrideprivate

Definition at line 183 of file DeepCoreSeedGenerator.cc.

References funct::abs(), alongMomentum, gpuPixelDoublets::cc, HLT_FULL_cff::cores, cores_, DetectorSelector(), MillePedeFileConverter_cfg::e, PV3DBase< T, PVType, FrameType >::eta(), JetChargeProducer_cfi::exp, fillPixelMatrix(), findIntersection(), dqmdumpme::first, HLT_2023v12_cff::flip, dqmMemoryStats::float, GeomDet::geographicalId(), geometry_, geometryToken_, edm::EventSetup::getData(), mps_fire::i, GlobalTrackingGeometry::idToDet(), GlobalTrackingGeometry::idToDetUnit(), iEvent, inputPixelClusters_, inputTensorName_, createfilelist::int, dqmiolumiharvest::j, metsig::jet, jetDimX, jetDimY, jetEta_, jetPt_, MainPageGenerator::l, TrackerTopology::layer(), local2Pixel(), eostools::move(), Nlayer, Nover, EcalTangentSkim_cfg::o, HLT_2023v12_cff::output_names, outputTensorName_, PV3DBase< T, PVType, FrameType >::phi(), pitchX_, pitchY_, pixel2Local(), PixelSubdetector::PixelBarrel, pixelClusters_, HLT_2023v12_cff::pixelCPE, pixelCPEToken_, pixelFlipper(), reco::Vertex::position(), probThr_, DiDispStaMuonMonitor_cfi::pt, ptMin_, mps_fire::result, SeedEvaluation(), funct::sin(), GeomDet::specificSurface(), splittedClusterDirections(), GeomDet::surface(), Surface::toGlobal(), GloballyPositioned< T >::toLocal(), topoToken_, AlignmentTracksFromVertexSelector_cfi::vertices, vertices_, x, PV3DBase< T, PVType, FrameType >::x(), geometryCSVtoXML::xx, y, PV3DBase< T, PVType, FrameType >::y(), geometryCSVtoXML::yy, and PV3DBase< T, PVType, FrameType >::z().

                                                                                  {
   auto result = std::make_unique<TrajectorySeedCollection>();
   auto resultTracks = std::make_unique<reco::TrackCollection>();
 
   const tensorflow::TensorShape input_size_eta({1, 1});
   const tensorflow::TensorShape input_size_pt({1, 1});
   const tensorflow::TensorShape input_size_cluster({1, jetDimX, jetDimY, Nlayer});
   std::vector<std::string> output_names;
   output_names.push_back(outputTensorName_[0]);
   output_names.push_back(outputTensorName_[1]);
 
   using namespace edm;
   using namespace reco;
 
   geometry_ = &iSetup.getData(geometryToken_);
 
   const auto& inputPixelClusters_ = iEvent.get(pixelClusters_);
   const auto& vertices = iEvent.get(vertices_);
   const auto& cores = iEvent.get(cores_);
 
   const PixelClusterParameterEstimator* pixelCPE = &iSetup.getData(pixelCPEToken_);
 
   const TrackerTopology* const tTopo = &iSetup.getData(topoToken_);
   auto output = std::make_unique<edmNew::DetSetVector<SiPixelCluster>>();
 
   for (const auto& jet : cores) {  // jet loop
 
     if (jet.pt() > ptMin_) {
       std::set<unsigned long long int> ids;
       const reco::Vertex& jetVertex = vertices[0];
 
       std::vector<GlobalVector> splitClustDirSet =
           splittedClusterDirections(jet, tTopo, pixelCPE, jetVertex, 1, inputPixelClusters_);
       bool l2off = (splitClustDirSet.empty());
       if (splitClustDirSet.empty()) {  //if layer 1 is broken find direcitons on layer 2
         splitClustDirSet = splittedClusterDirections(jet, tTopo, pixelCPE, jetVertex, 2, inputPixelClusters_);
       }
       splitClustDirSet.emplace_back(GlobalVector(jet.px(), jet.py(), jet.pz()));
       for (int cc = 0; cc < (int)splitClustDirSet.size(); cc++) {
         tensorflow::NamedTensorList input_tensors;  //TensorFlow tensors init
         input_tensors.resize(3);
         input_tensors[0] =
             tensorflow::NamedTensor(inputTensorName_[0], tensorflow::Tensor(tensorflow::DT_FLOAT, input_size_eta));
         input_tensors[1] =
             tensorflow::NamedTensor(inputTensorName_[1], tensorflow::Tensor(tensorflow::DT_FLOAT, input_size_pt));
         input_tensors[2] = tensorflow::NamedTensor(inputTensorName_[2],
                                                    tensorflow::Tensor(tensorflow::DT_FLOAT, {input_size_cluster}));
 
         //put all the input tensor to 0
         input_tensors[0].second.matrix<float>()(0, 0) = 0.0;
         input_tensors[1].second.matrix<float>()(0, 0) = 0.0;
         for (int x = 0; x < jetDimX; x++) {
           for (int y = 0; y < jetDimY; y++) {
             for (int l = 0; l < Nlayer; l++) {
               input_tensors[2].second.tensor<float, 4>()(0, x, y, l) = 0.0;
             }
           }
         }  //end of TensorFlow tensors init
 
         GlobalVector bigClustDir = splitClustDirSet[cc];
 
         jetEta_ = jet.eta();
         jetPt_ = jet.pt();
         input_tensors[0].second.matrix<float>()(0, 0) = jet.eta();
         input_tensors[1].second.matrix<float>()(0, 0) = jet.pt();
 
         const GeomDet* globDet = DetectorSelector(
             2, jet, bigClustDir, jetVertex, tTopo, inputPixelClusters_);  //det. aligned to bigClustDir on L2
 
         if (globDet == nullptr)  //no intersection between bigClustDir and pixel detector modules found
           continue;
 
         const GeomDet* goodDet1 = DetectorSelector(1, jet, bigClustDir, jetVertex, tTopo, inputPixelClusters_);
         const GeomDet* goodDet3 = DetectorSelector(3, jet, bigClustDir, jetVertex, tTopo, inputPixelClusters_);
         const GeomDet* goodDet4 = DetectorSelector(4, jet, bigClustDir, jetVertex, tTopo, inputPixelClusters_);
 
         for (const auto& detset : inputPixelClusters_) {
           const GeomDet* det = geometry_->idToDet(detset.id());
 
           for (const auto& aCluster : detset) {
             det_id_type aClusterID = detset.id();
             if (DetId(aClusterID).subdetId() != PixelSubdetector::PixelBarrel)
               continue;
 
             int lay = tTopo->layer(det->geographicalId());
 
             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);
 
             GlobalPoint pointVertex(jetVertex.position().x(), jetVertex.position().y(), jetVertex.position().z());
 
             LocalPoint clustPos_local =
                 pixelCPE->localParametersV(aCluster, (*geometry_->idToDetUnit(detset.id())))[0].first;
 
             if (std::abs(clustPos_local.x() - localInter.x()) / pitchX_ <= jetDimX / 2 &&
                 std::abs(clustPos_local.y() - localInter.y()) / pitchY_ <=
                     jetDimY / 2) {  //used the baricenter, better description maybe useful
 
               if (det == goodDet1 || det == goodDet3 || det == goodDet4 || det == globDet) {
                 fillPixelMatrix(aCluster, lay, localInter, det, input_tensors);
               }
             }  //cluster in ROI
           }    //cluster
         }      //detset
 
         //here the NN produce the seed from the filled input
         std::pair<double[jetDimX][jetDimY][Nover][Npar], double[jetDimX][jetDimY][Nover]> seedParamNN =
             DeepCoreSeedGenerator::SeedEvaluation(input_tensors, output_names);
 
         for (int i = 0; i < jetDimX; i++) {
           for (int j = 0; j < jetDimY; j++) {
             for (int o = 0; o < Nover; o++) {
               if (seedParamNN.second[i][j][o] > (probThr_ - o * 0.1 - (l2off ? 0.35 : 0))) {
                 std::pair<bool, Basic3DVector<float>> interPair =
                     findIntersection(bigClustDir, (reco::Candidate::Point)jetVertex.position(), globDet);
                 auto localInter = globDet->specificSurface().toLocal((GlobalPoint)interPair.second);
 
                 int flip = pixelFlipper(globDet);  // 1=not flip, -1=flip
                 int nx = i - jetDimX / 2;
                 int ny = j - jetDimY / 2;
                 nx = flip * nx;
                 std::pair<int, int> pixInter = local2Pixel(localInter.x(), localInter.y(), globDet);
                 nx = nx + pixInter.first;
                 ny = ny + pixInter.second;
                 LocalPoint xyLocal = pixel2Local(nx, ny, globDet);
 
                 double xx = xyLocal.x() + seedParamNN.first[i][j][o][0] * 0.01;  //0.01=internal normalization of NN
                 double yy = xyLocal.y() + seedParamNN.first[i][j][o][1] * 0.01;  //0.01=internal normalization of NN
                 LocalPoint localSeedPoint = LocalPoint(xx, yy, 0);
 
                 double track_eta =
                     seedParamNN.first[i][j][o][2] * 0.01 + bigClustDir.eta();  //pay attention to this 0.01
                 double track_theta = 2 * std::atan(std::exp(-track_eta));
                 double track_phi =
                     seedParamNN.first[i][j][o][3] * 0.01 + bigClustDir.phi();  //pay attention to this 0.01
 
                 double pt = 1. / seedParamNN.first[i][j][o][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);
                 uint64_t seedid = (uint64_t(xx * 200.) << 0) + (uint64_t(yy * 200.) << 16) +
                                   (uint64_t(track_eta * 400.) << 32) + (uint64_t(track_phi * 400.) << 48);
                 if (ids.count(seedid) != 0) {
                   continue;
                 }
                 //to disable jetcore iteration comment from here to probability block end--->
                 //seeing iteration skipped, useful to total eff and FakeRate comparison
                 ids.insert(seedid);
 
                 //Covariance matrix, the hadrcoded variances = NN residuals width
                 //(see https://twiki.cern.ch/twiki/bin/view/CMSPublic/NNJetCoreAtCtD2019)
                 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));
               }  //probability
             }
           }
         }
       }  //bigcluster
     }    //jet > pt
   }      //jet
   iEvent.put(std::move(result));
   iEvent.put(std::move(resultTracks));
 }

◆ SeedEvaluation()

std::pair< double[DeepCoreSeedGenerator::jetDimX][DeepCoreSeedGenerator::jetDimY][DeepCoreSeedGenerator::Nover] [DeepCoreSeedGenerator::Npar], double[DeepCoreSeedGenerator::jetDimX][DeepCoreSeedGenerator::jetDimY][DeepCoreSeedGenerator::Nover]> DeepCoreSeedGenerator::SeedEvaluation	(	tensorflow::NamedTensorList	input_tensors,
		std::vector< std::string >	output_names
	)

private

Definition at line 450 of file DeepCoreSeedGenerator.cc.

References dqmMemoryStats::float, jetDimX, jetDimY, Nover, Npar, HLT_2023v12_cff::output_names, PatBasicFWLiteJetAnalyzer_Selector_cfg::outputs, AlCaHLTBitMon_ParallelJobs::p, tensorflow::run(), session_, x, and y.

Referenced by produce().

                                                                          {
   std::vector<tensorflow::Tensor> outputs;
   tensorflow::run(session_, input_tensors, output_names, &outputs);
   auto matrix_output_par = outputs.at(0).tensor<float, 5>();
   auto matrix_output_prob = outputs.at(1).tensor<float, 5>();
 
   std::pair<double[jetDimX][jetDimY][Nover][Npar], double[jetDimX][jetDimY][Nover]> output_combined;
 
   for (int x = 0; x < jetDimX; x++) {
     for (int y = 0; y < jetDimY; y++) {
       for (int trk = 0; trk < Nover; trk++) {
         output_combined.second[x][y][trk] =
             matrix_output_prob(0, x, y, trk, 0);  //outputs.at(1).matrix<double>()(0,x,y,trk);
 
         for (int p = 0; p < Npar; p++) {
           output_combined.first[x][y][trk][p] =
               matrix_output_par(0, x, y, trk, p);  //outputs.at(0).matrix<double>()(0,x,y,trk,p);
         }
       }
     }
   }
   return output_combined;
 }

◆ splittedClusterDirections()

std::vector< GlobalVector > DeepCoreSeedGenerator::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 505 of file DeepCoreSeedGenerator.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 bigClusters 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;
 }

Member Data Documentation

◆ centralMIPCharge_

double DeepCoreSeedGenerator::centralMIPCharge_

private

Definition at line 116 of file DeepCoreSeedGenerator.cc.

◆ chargeFracMin_

double DeepCoreSeedGenerator::chargeFracMin_

private

Definition at line 115 of file DeepCoreSeedGenerator.cc.

◆ cores_

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

private

Definition at line 108 of file DeepCoreSeedGenerator.cc.

Referenced by produce().

◆ deltaR_

double DeepCoreSeedGenerator::deltaR_

private

Definition at line 114 of file DeepCoreSeedGenerator.cc.

Referenced by splittedClusterDirections().

◆ geometry_

const GlobalTrackingGeometry* DeepCoreSeedGenerator::geometry_ = nullptr

private

Definition at line 103 of file DeepCoreSeedGenerator.cc.

Referenced by DetectorSelector(), produce(), and splittedClusterDirections().

◆ geometryToken_

const edm::ESGetToken<GlobalTrackingGeometry, GlobalTrackingGeometryRecord> DeepCoreSeedGenerator::geometryToken_

private

Definition at line 109 of file DeepCoreSeedGenerator.cc.

Referenced by produce().

◆ inputPixelClusters_

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

private

Definition at line 107 of file DeepCoreSeedGenerator.cc.

Referenced by produce().

◆ inputTensorName_

std::vector<std::string> DeepCoreSeedGenerator::inputTensorName_

private

Definition at line 118 of file DeepCoreSeedGenerator.cc.

Referenced by produce().

◆ jetDimX

constexpr int DeepCoreSeedGenerator::jetDimX = 30

static

Definition at line 92 of file DeepCoreSeedGenerator.cc.

Referenced by fillPixelMatrix(), produce(), and SeedEvaluation().

◆ jetDimY

constexpr int DeepCoreSeedGenerator::jetDimY = 30

static

Definition at line 93 of file DeepCoreSeedGenerator.cc.

Referenced by fillPixelMatrix(), produce(), and SeedEvaluation().

◆ jetEta_

double DeepCoreSeedGenerator::jetEta_

Definition at line 89 of file DeepCoreSeedGenerator.cc.

Referenced by produce().

◆ jetPt_

double DeepCoreSeedGenerator::jetPt_

Definition at line 88 of file DeepCoreSeedGenerator.cc.

Referenced by produce().

◆ Nlayer

constexpr int DeepCoreSeedGenerator::Nlayer = 4

static

Definition at line 94 of file DeepCoreSeedGenerator.cc.

Referenced by produce().

◆ Nover

constexpr int DeepCoreSeedGenerator::Nover = 3

static

Definition at line 95 of file DeepCoreSeedGenerator.cc.

Referenced by produce(), and SeedEvaluation().

◆ Npar

constexpr int DeepCoreSeedGenerator::Npar = 5

static

Definition at line 96 of file DeepCoreSeedGenerator.cc.

Referenced by SeedEvaluation().

◆ outputTensorName_

std::vector<std::string> DeepCoreSeedGenerator::outputTensorName_

private

Definition at line 119 of file DeepCoreSeedGenerator.cc.

Referenced by produce().

◆ pitchX_

double DeepCoreSeedGenerator::pitchX_ = 0.01

Definition at line 90 of file DeepCoreSeedGenerator.cc.

Referenced by produce().

◆ pitchY_

double DeepCoreSeedGenerator::pitchY_ = 0.015

Definition at line 91 of file DeepCoreSeedGenerator.cc.

Referenced by produce().

◆ pixelClusters_

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

private

Definition at line 106 of file DeepCoreSeedGenerator.cc.

Referenced by produce().

◆ pixelCPEToken_

const edm::ESGetToken<PixelClusterParameterEstimator, TkPixelCPERecord> DeepCoreSeedGenerator::pixelCPEToken_

private

Definition at line 110 of file DeepCoreSeedGenerator.cc.

Referenced by produce().

◆ probThr_

double DeepCoreSeedGenerator::probThr_

private

Definition at line 120 of file DeepCoreSeedGenerator.cc.

Referenced by produce().

◆ propagatorName_

std::string DeepCoreSeedGenerator::propagatorName_

private

Definition at line 102 of file DeepCoreSeedGenerator.cc.

◆ ptMin_

double DeepCoreSeedGenerator::ptMin_

private

Definition at line 113 of file DeepCoreSeedGenerator.cc.

Referenced by produce().

◆ session_

const tensorflow::Session* DeepCoreSeedGenerator::session_

private

Definition at line 121 of file DeepCoreSeedGenerator.cc.

Referenced by SeedEvaluation().

◆ topoToken_

const edm::ESGetToken<TrackerTopology, TrackerTopologyRcd> DeepCoreSeedGenerator::topoToken_

private

Definition at line 111 of file DeepCoreSeedGenerator.cc.

Referenced by produce().

◆ vertices_

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

private

Definition at line 105 of file DeepCoreSeedGenerator.cc.

Referenced by produce().

◆ weightfilename_

std::string DeepCoreSeedGenerator::weightfilename_

private

Definition at line 117 of file DeepCoreSeedGenerator.cc.

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ DeepCoreSeedGenerator()

◆ ~DeepCoreSeedGenerator()

Member Function Documentation

◆ DetectorSelector()

◆ fillDescriptions()

◆ fillPixelMatrix()

◆ findIntersection()

◆ globalEndJob()

◆ initializeGlobalCache()

◆ local2Pixel()

◆ pixel2Local()

◆ pixelFlipper()

◆ produce()

◆ SeedEvaluation()

◆ splittedClusterDirections()

Member Data Documentation

◆ centralMIPCharge_

◆ chargeFracMin_

◆ cores_

◆ deltaR_

◆ geometry_

◆ geometryToken_

◆ inputPixelClusters_

◆ inputTensorName_

◆ jetDimX

◆ jetDimY

◆ jetEta_

◆ jetPt_

◆ Nlayer

◆ Nover

◆ Npar

◆ outputTensorName_

◆ pitchX_

◆ pitchY_

◆ pixelClusters_

◆ pixelCPEToken_

◆ probThr_

◆ propagatorName_

◆ ptMin_

◆ session_

◆ topoToken_

◆ vertices_

◆ weightfilename_