Inheritance diagram for JetCoreClusterSplitter:

Public Member Functions
	JetCoreClusterSplitter (const edm::ParameterSet &iConfig)

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

	~JetCoreClusterSplitter () override

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

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

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

Private Member Functions
std::pair< float, float >	closestClusters (const std::vector< float > &distanceMap)

std::multimap< float, int >	distScore (const std::vector< std::vector< float >> &distanceMap)

std::vector< SiPixelCluster >	fittingSplit (const SiPixelCluster &aCluster, float expectedADC, int sizeY, int sizeX, float jetZOverRho, unsigned int nSplitted)

std::multimap< float, int >	secondDistDiffScore (const std::vector< std::vector< float >> &distanceMap)

std::multimap< float, int >	secondDistScore (const std::vector< std::vector< float >> &distanceMap)

bool	split (const SiPixelCluster &aCluster, edmNew::DetSetVector< SiPixelCluster >::FastFiller &filler, float expectedADC, int sizeY, int sizeX, float jetZOverRho)

Private Attributes
double	centralMIPCharge_

double	chargeFracMin_

double	chargePerUnit_

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

double	deltaR_

float	expSizeXAtLorentzAngleIncidence_

float	expSizeXDeltaPerTanAlpha_

float	expSizeYAtNormalIncidence_

double	forceXError_

double	forceYError_

double	fractionalWidth_

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

double	ptMin_

float	tanLorentzAngle_

float	tanLorentzAngleBarrelLayer1_

edm::ESGetToken< PixelClusterParameterEstimator, TkPixelCPERecord > const	tCPE_

edm::ESGetToken< TrackerTopology, TrackerTopologyRcd > const	tTrackerTopo_

edm::ESGetToken< GlobalTrackingGeometry, GlobalTrackingGeometryRecord > const	tTrackingGeom_

bool	verbose

edm::EDGetTokenT< reco::VertexCollection >	vertices_

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

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Definition at line 31 of file JetCoreClusterSplitter.cc.

Constructor & Destructor Documentation

◆ JetCoreClusterSplitter()

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

Definition at line 105 of file JetCoreClusterSplitter.cc.

     : tTrackingGeom_(esConsumes()),
       tCPE_(esConsumes(edm::ESInputTag("", iConfig.getParameter<std::string>("pixelCPE")))),
       tTrackerTopo_(esConsumes()),
       verbose(iConfig.getParameter<bool>("verbose")),
       ptMin_(iConfig.getParameter<double>("ptMin")),
       deltaR_(iConfig.getParameter<double>("deltaRmax")),
       chargeFracMin_(iConfig.getParameter<double>("chargeFractionMin")),
       expSizeXAtLorentzAngleIncidence_(iConfig.getParameter<double>("expSizeXAtLorentzAngleIncidence")),
       expSizeXDeltaPerTanAlpha_(iConfig.getParameter<double>("expSizeXDeltaPerTanAlpha")),
       expSizeYAtNormalIncidence_(iConfig.getParameter<double>("expSizeYAtNormalIncidence")),
       tanLorentzAngle_(iConfig.getParameter<double>("tanLorentzAngle")),
       tanLorentzAngleBarrelLayer1_(iConfig.getParameter<double>("tanLorentzAngleBarrelLayer1")),
       pixelClusters_(
           consumes<edmNew::DetSetVector<SiPixelCluster>>(iConfig.getParameter<edm::InputTag>("pixelClusters"))),
       vertices_(consumes<reco::VertexCollection>(iConfig.getParameter<edm::InputTag>("vertices"))),
       cores_(consumes<edm::View<reco::Candidate>>(iConfig.getParameter<edm::InputTag>("cores"))),
       forceXError_(iConfig.getParameter<double>("forceXError")),
       forceYError_(iConfig.getParameter<double>("forceYError")),
       fractionalWidth_(iConfig.getParameter<double>("fractionalWidth")),
       chargePerUnit_(iConfig.getParameter<double>("chargePerUnit")),
       centralMIPCharge_(iConfig.getParameter<double>("centralMIPCharge"))
 
 {
   produces<edmNew::DetSetVector<SiPixelCluster>>();
 }

◆ ~JetCoreClusterSplitter()

JetCoreClusterSplitter::~JetCoreClusterSplitter ( )

override

Definition at line 132 of file JetCoreClusterSplitter.cc.

132 {}

Member Function Documentation

◆ closestClusters()

std::pair< float, float > JetCoreClusterSplitter::closestClusters ( const std::vector< float > & distanceMap )

private

Definition at line 261 of file JetCoreClusterSplitter.cc.

References mps_fire::i, and WZElectronSkims53X_cff::max.

Referenced by distScore(), secondDistDiffScore(), and secondDistScore().

                                                                                                  {
   float minDist = std::numeric_limits<float>::max();
   float secondMinDist = std::numeric_limits<float>::max();
   for (unsigned int i = 0; i < distanceMap.size(); i++) {
     float dist = distanceMap[i];
     if (dist < minDist) {
       secondMinDist = minDist;
       minDist = dist;
     } else if (dist < secondMinDist) {
       secondMinDist = dist;
     }
   }
   return std::pair<float, float>(minDist, secondMinDist);
 }

◆ distScore()

std::multimap< float, int > JetCoreClusterSplitter::distScore ( const std::vector< std::vector< float >> & distanceMap )

private

Definition at line 295 of file JetCoreClusterSplitter.cc.

References closestClusters(), ztail::d, and dqmiolumiharvest::j.

                                                                                                         {
   std::multimap<float, int> scores;
   for (unsigned int j = 0; j < distanceMap.size(); j++) {
     std::pair<float, float> d = closestClusters(distanceMap[j]);
     scores.insert(std::pair<float, int>(-d.first, j));
   }
   return scores;
 }

◆ fillDescriptions()

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

static

Definition at line 79 of file JetCoreClusterSplitter.cc.

References edm::ConfigurationDescriptions::addWithDefaultLabel(), submitPVResolutionJobs::desc, SiPixelPhase1Clusters_cfi::e3, ProducerED_cfi::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                         {
   edm::ParameterSetDescription desc;
 
   desc.add<std::string>("pixelCPE", "PixelCPEGeneric");
   desc.add<bool>("verbose", false);
   desc.add<double>("ptMin", 200.0);
   desc.add<double>("deltaRmax", 0.05);
   desc.add<double>("chargeFractionMin", 2.0);
   desc.add<edm::InputTag>("pixelClusters", edm::InputTag("siPixelCluster"));
   desc.add<edm::InputTag>("vertices", edm::InputTag("offlinePrimaryVertices"));
   desc.add<edm::InputTag>("cores", edm::InputTag("ak5CaloJets"));
   desc.add<double>("forceXError", 100.0);
   desc.add<double>("forceYError", 150.0);
   desc.add<double>("fractionalWidth", 0.4);
   desc.add<double>("chargePerUnit", 2000.0);
   desc.add<double>("centralMIPCharge", 26e3);
 
   desc.add<double>("expSizeXAtLorentzAngleIncidence", 1.5);
   desc.add<double>("expSizeXDeltaPerTanAlpha", 0.0);
   desc.add<double>("expSizeYAtNormalIncidence", 1.3);
   desc.add<double>("tanLorentzAngle", 0.0);
   desc.add<double>("tanLorentzAngleBarrelLayer1", 0.0);
 
   descriptions.addWithDefaultLabel(desc);
 }

◆ fittingSplit()

std::vector< SiPixelCluster > JetCoreClusterSplitter::fittingSplit	(	const SiPixelCluster &	aCluster,
		float	expectedADC,
		int	sizeY,
		int	sizeX,
		float	jetZOverRho,
		unsigned int	nSplitted
	)

private

Definition at line 304 of file JetCoreClusterSplitter.cc.

References funct::abs(), gpuClustering::adc, centralMIPCharge_, chargePerUnit_, haddnano::cl, gather_cfg::cout, MillePedeFileConverter_cfg::e, relativeConstraints::empty, JetChargeProducer_cfi::exp, f, forceXError_, forceYError_, fractionalWidth_, mps_fire::i, createfilelist::int, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, dqmiolumiharvest::j, isotrackApplyRegressor::k, convertSQLitetoXML_cfg::output, AlCaHLTBitMon_ParallelJobs::p, SiPixelCluster::pixels(), Hcal_Conditions_forGlobalTag_cff::pixels, edm::second(), secondDistScore(), RecoTauValidation_cfi::sizeX, RecoTauValidation_cfi::sizeY, mathSSE::sqrt(), isotrackNtupler::stop, verbose, x, and y.

Referenced by split().

                                                                                          {
   std::vector<SiPixelCluster> output;
 
   unsigned int meanExp = nSplitted;
   if (meanExp <= 1) {
     output.push_back(aCluster);
     return output;
   }
 
   std::vector<float> clx(meanExp);
   std::vector<float> cly(meanExp);
   std::vector<float> cls(meanExp);
   std::vector<float> oldclx(meanExp);
   std::vector<float> oldcly(meanExp);
   std::vector<SiPixelCluster::Pixel> originalpixels = aCluster.pixels();
   std::vector<std::pair<int, SiPixelCluster::Pixel>> pixels;
   for (unsigned int j = 0; j < originalpixels.size(); j++) {
     int sub = originalpixels[j].adc / chargePerUnit_ * expectedADC / centralMIPCharge_;
     if (sub < 1)
       sub = 1;
     int perDiv = originalpixels[j].adc / sub;
     if (verbose)
       std::cout << "Splitting  " << j << "  in [ " << pixels.size() << " , " << pixels.size() + sub
                 << " ], expected numb of clusters: " << meanExp << " original pixel (x,y) " << originalpixels[j].x
                 << " " << originalpixels[j].y << " sub " << sub << std::endl;
     for (int k = 0; k < sub; k++) {
       if (k == sub - 1)
         perDiv = originalpixels[j].adc - perDiv * k;
       pixels.push_back(std::make_pair(j, SiPixelCluster::Pixel(originalpixels[j].x, originalpixels[j].y, perDiv)));
     }
   }
   std::vector<int> clusterForPixel(pixels.size());
   // initial values
   for (unsigned int j = 0; j < meanExp; j++) {
     oldclx[j] = -999;
     oldcly[j] = -999;
     clx[j] = originalpixels[0].x + j;
     cly[j] = originalpixels[0].y + j;
     cls[j] = 0;
   }
   bool stop = false;
   int remainingSteps = 100;
   while (!stop && remainingSteps > 0) {
     remainingSteps--;
     // Compute all distances
     std::vector<std::vector<float>> distanceMapX(originalpixels.size(), std::vector<float>(meanExp));
     std::vector<std::vector<float>> distanceMapY(originalpixels.size(), std::vector<float>(meanExp));
     std::vector<std::vector<float>> distanceMap(originalpixels.size(), std::vector<float>(meanExp));
     for (unsigned int j = 0; j < originalpixels.size(); j++) {
       if (verbose)
         std::cout << "Original Pixel pos " << j << " " << pixels[j].second.x << " " << pixels[j].second.y << std::endl;
       for (unsigned int i = 0; i < meanExp; i++) {
         distanceMapX[j][i] = 1.f * originalpixels[j].x - clx[i];
         distanceMapY[j][i] = 1.f * originalpixels[j].y - cly[i];
         float dist = 0;
         //              float sizeX=2;
         if (std::abs(distanceMapX[j][i]) > sizeX / 2.f) {
           dist +=
               (std::abs(distanceMapX[j][i]) - sizeX / 2.f + 1.f) * (std::abs(distanceMapX[j][i]) - sizeX / 2.f + 1.f);
         } else {
           dist += (2.f * distanceMapX[j][i] / sizeX) * (2.f * distanceMapX[j][i] / sizeX);
         }
 
         if (std::abs(distanceMapY[j][i]) > sizeY / 2.f) {
           dist += 1.f * (std::abs(distanceMapY[j][i]) - sizeY / 2.f + 1.f) *
                   (std::abs(distanceMapY[j][i]) - sizeY / 2.f + 1.f);
         } else {
           dist += 1.f * (2.f * distanceMapY[j][i] / sizeY) * (2.f * distanceMapY[j][i] / sizeY);
         }
         distanceMap[j][i] = sqrt(dist);
         if (verbose)
           std::cout << "Cluster " << i << " Original Pixel " << j << " distances: " << distanceMapX[j][i] << " "
                     << distanceMapY[j][i] << " " << distanceMap[j][i] << std::endl;
       }
     }
     // Compute scores for sequential addition. The first index is the
     // distance, in whatever metrics we use, while the second is the
     // pixel index w.r.t which the distance is computed.
     std::multimap<float, int> scores;
 
     // Using different rankings to improve convergence (as Giulio proposed)
     scores = secondDistScore(distanceMap);
 
     // Iterate starting from the ones with furthest second best clusters, i.e.
     // easy choices
     std::vector<float> weightOfPixel(pixels.size());
     for (std::multimap<float, int>::iterator it = scores.begin(); it != scores.end(); it++) {
       int pixel_index = it->second;
       if (verbose)
         std::cout << "Original Pixel " << pixel_index << " with score " << it->first << std::endl;
       // find cluster that is both close and has some charge still to assign
       int subpixel_counter = 0;
       for (auto subpixel = pixels.begin(); subpixel != pixels.end(); ++subpixel, ++subpixel_counter) {
         if (subpixel->first > pixel_index) {
           break;
         } else if (subpixel->first != pixel_index) {
           continue;
         } else {
           float maxEst = 0;
           int cl = -1;
           for (unsigned int subcluster_index = 0; subcluster_index < meanExp; subcluster_index++) {
             float nsig = (cls[subcluster_index] - expectedADC) /
                          (expectedADC * fractionalWidth_);        // 20% uncertainty? realistic from Landau?
             float clQest = 1.f / (1.f + std::exp(nsig)) + 1e-6f;  // 1./(1.+exp(x*x-3*3))
             float clDest = 1.f / (distanceMap[pixel_index][subcluster_index] + 0.05f);
 
             if (verbose)
               std::cout << " Q: " << clQest << " D: " << clDest << " " << distanceMap[pixel_index][subcluster_index]
                         << std::endl;
             float est = clQest * clDest;
             if (est > maxEst) {
               cl = subcluster_index;
               maxEst = est;
             }
           }
           cls[cl] += subpixel->second.adc;
           clusterForPixel[subpixel_counter] = cl;
           weightOfPixel[subpixel_counter] = maxEst;
           if (verbose)
             std::cout << "Pixel weight j cl " << weightOfPixel[subpixel_counter] << " " << subpixel_counter << " " << cl
                       << std::endl;
         }
       }
     }
     // Recompute cluster centers
     stop = true;
     for (unsigned int subcluster_index = 0; subcluster_index < meanExp; subcluster_index++) {
       if (std::abs(clx[subcluster_index] - oldclx[subcluster_index]) > 0.01f)
         stop = false;  // still moving
       if (std::abs(cly[subcluster_index] - oldcly[subcluster_index]) > 0.01f)
         stop = false;
       oldclx[subcluster_index] = clx[subcluster_index];
       oldcly[subcluster_index] = cly[subcluster_index];
       clx[subcluster_index] = 0;
       cly[subcluster_index] = 0;
       cls[subcluster_index] = 1e-99;
     }
     for (unsigned int pixel_index = 0; pixel_index < pixels.size(); pixel_index++) {
       if (clusterForPixel[pixel_index] < 0)
         continue;
       if (verbose)
         std::cout << "j " << pixel_index << " x " << pixels[pixel_index].second.x << " * y "
                   << pixels[pixel_index].second.y << " * ADC " << pixels[pixel_index].second.adc << " * W "
                   << weightOfPixel[pixel_index] << std::endl;
       clx[clusterForPixel[pixel_index]] += pixels[pixel_index].second.x * pixels[pixel_index].second.adc;
       cly[clusterForPixel[pixel_index]] += pixels[pixel_index].second.y * pixels[pixel_index].second.adc;
       cls[clusterForPixel[pixel_index]] += pixels[pixel_index].second.adc;
     }
     for (unsigned int subcluster_index = 0; subcluster_index < meanExp; subcluster_index++) {
       if (cls[subcluster_index] != 0) {
         clx[subcluster_index] /= cls[subcluster_index];
         cly[subcluster_index] /= cls[subcluster_index];
       }
       if (verbose)
         std::cout << "Center for cluster " << subcluster_index << " x,y " << clx[subcluster_index] << " "
                   << cly[subcluster_index] << std::endl;
       cls[subcluster_index] = 0;
     }
   }
   if (verbose)
     std::cout << "maxstep " << remainingSteps << std::endl;
   // accumulate pixel with same cl
   std::vector<std::vector<SiPixelCluster::Pixel>> pixelsForCl(meanExp);
   for (int cl = 0; cl < (int)meanExp; cl++) {
     for (unsigned int j = 0; j < pixels.size(); j++) {
       if (clusterForPixel[j] == cl and pixels[j].second.adc != 0) {  // for each pixel of cluster
                                                                      // cl find the other pixels
                                                                      // with same x,y and
                                                                      // accumulate+reset their adc
         for (unsigned int k = j + 1; k < pixels.size(); k++) {
           if (pixels[k].second.adc != 0 and pixels[k].second.x == pixels[j].second.x and
               pixels[k].second.y == pixels[j].second.y and clusterForPixel[k] == cl) {
             if (verbose)
               std::cout << "Resetting all sub-pixel for location " << pixels[k].second.x << ", " << pixels[k].second.y
                         << " at index " << k << " associated to cl " << clusterForPixel[k] << std::endl;
             pixels[j].second.adc += pixels[k].second.adc;
             pixels[k].second.adc = 0;
           }
         }
         for (unsigned int p = 0; p < pixels.size(); ++p)
           if (verbose)
             std::cout << "index, x, y, ADC: " << p << ", " << pixels[p].second.x << ", " << pixels[p].second.y << ", "
                       << pixels[p].second.adc << " associated to cl " << clusterForPixel[p] << std::endl
                       << "Adding pixel " << pixels[j].second.x << ", " << pixels[j].second.y << " to cluster " << cl
                       << std::endl;
         pixelsForCl[cl].push_back(pixels[j].second);
       }
     }
   }
 
   //    std::vector<std::vector<std::vector<SiPixelCluster::PixelPos *> > >
   //pixelMap(meanExp,std::vector<std::vector<SiPixelCluster::PixelPos *>
   //>(512,std::vector<SiPixelCluster::Pixel *>(512,0)));
 
   for (int cl = 0; cl < (int)meanExp; cl++) {
     if (verbose)
       std::cout << "Pixels of cl " << cl << " ";
     for (unsigned int j = 0; j < pixelsForCl[cl].size(); j++) {
       SiPixelCluster::PixelPos newpix(pixelsForCl[cl][j].x, pixelsForCl[cl][j].y);
       if (verbose)
         std::cout << pixelsForCl[cl][j].x << "," << pixelsForCl[cl][j].y << "|";
       if (j == 0) {
         output.emplace_back(newpix, pixelsForCl[cl][j].adc);
       } else {
         output.back().add(newpix, pixelsForCl[cl][j].adc);
       }
     }
     if (verbose)
       std::cout << std::endl;
     if (!pixelsForCl[cl].empty()) {
       if (forceXError_ > 0)
         output.back().setSplitClusterErrorX(forceXError_);
       if (forceYError_ > 0)
         output.back().setSplitClusterErrorY(forceYError_);
     }
   }
   //    if(verbose) std::cout << "Weights" << std::endl;
   //    if(verbose) print(theWeights,aCluster,1);
   //    if(verbose) std::cout << "Unused charge" << std::endl;
   //    if(verbose) print(theBufferResidual,aCluster);
 
   return output;
 }

◆ produce()

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

override

Definition at line 136 of file JetCoreClusterSplitter.cc.

References funct::abs(), edmNew::DetSetVector< T >::begin(), Surface::bounds(), DummyCfis::c, centralMIPCharge_, SiPixelCluster::charge(), chargeFracMin_, GetRecoTauVFromDQM_MC_cff::cl2, HLT_FULL_cff::cores, cores_, gather_cfg::cout, eleIsoSequence_cff::deltaR, deltaR_, vertexPlots::e4, edmNew::DetSetVector< T >::end(), expSizeXAtLorentzAngleIncidence_, expSizeXDeltaPerTanAlpha_, expSizeYAtNormalIncidence_, f, trigObjTnPSource_cfi::filler, dqmdumpme::first, edm::EventSetup::getData(), edmNew::DetSetVector< T >::id(), iEvent, metsig::jet, SiPixelCluster::minPixelRow(), eostools::move(), pixelClusters_, createTree::pp, ptMin_, SiPixelCluster::sizeX(), SiPixelCluster::sizeY(), split(), mathSSE::sqrt(), GeomDet::surface(), jetCoreClusterSplitter_cfi::tanLorentzAngle, tanLorentzAngle_, tanLorentzAngleBarrelLayer1_, tCPE_, ppsPixelTopologyESSourceRun2_cfi::thickness, Bounds::thickness(), Surface::toGlobal(), GloballyPositioned< T >::toLocal(), GeomDet::topology(), HLT_2024v14_cff::topology, tTrackerTopo_, tTrackingGeom_, verbose, AlignmentTracksFromVertexSelector_cfi::vertices, vertices_, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

                                                                                   {
   using namespace edm;
   const auto& geometry = &iSetup.getData(tTrackingGeom_);
   const auto& topology = &iSetup.getData(tTrackerTopo_);
 
   Handle<edmNew::DetSetVector<SiPixelCluster>> inputPixelClusters;
   iEvent.getByToken(pixelClusters_, inputPixelClusters);
 
   Handle<std::vector<reco::Vertex>> vertices;
   iEvent.getByToken(vertices_, vertices);
   const reco::Vertex& pv = (*vertices)[0];
 
   Handle<edm::View<reco::Candidate>> cores;
   iEvent.getByToken(cores_, cores);
 
   const PixelClusterParameterEstimator* pp = &iSetup.getData(tCPE_);
   auto output = std::make_unique<edmNew::DetSetVector<SiPixelCluster>>();
 
   edmNew::DetSetVector<SiPixelCluster>::const_iterator detIt = inputPixelClusters->begin();
   for (; detIt != inputPixelClusters->end(); detIt++) {
     edmNew::DetSetVector<SiPixelCluster>::FastFiller filler(*output, detIt->id());
     const edmNew::DetSet<SiPixelCluster>& detset = *detIt;
     const GeomDet* det = geometry->idToDet(detset.id());
     float pitchX, pitchY;
     std::tie(pitchX, pitchY) = static_cast<const PixelTopology&>(det->topology()).pitch();
     float thickness = det->surface().bounds().thickness();
     float tanLorentzAngle = tanLorentzAngle_;
     if (DetId(detset.id()).subdetId() == 1 /* px barrel */ && topology->pxbLayer(detset.id()) == 1) {
       tanLorentzAngle = tanLorentzAngleBarrelLayer1_;
     }
     for (auto cluster = detset.begin(); cluster != detset.end(); cluster++) {
       const SiPixelCluster& aCluster = *cluster;
       bool hasBeenSplit = false;
       bool shouldBeSplit = false;
       GlobalPoint cPos =
           det->surface().toGlobal(pp->localParametersV(aCluster, (*geometry->idToDetUnit(detIt->id())))[0].first);
       GlobalPoint ppv(pv.position().x(), pv.position().y(), pv.position().z());
       GlobalVector clusterDir = cPos - ppv;
       for (unsigned int ji = 0; ji < cores->size(); ji++) {
         if ((*cores)[ji].pt() > ptMin_) {
           const reco::Candidate& jet = (*cores)[ji];
           GlobalVector jetDir(jet.px(), jet.py(), jet.pz());
           if (Geom::deltaR(jetDir, clusterDir) < deltaR_) {
             // check if the cluster has to be splitted
 
             LocalVector jetDirLocal = det->surface().toLocal(jetDir);
             float jetTanAlpha = jetDirLocal.x() / jetDirLocal.z();
             float jetTanBeta = jetDirLocal.y() / jetDirLocal.z();
             float jetZOverRho = std::sqrt(jetTanAlpha * jetTanAlpha + jetTanBeta * jetTanBeta);
             float expSizeX = expSizeXAtLorentzAngleIncidence_ +
                              std::abs(expSizeXDeltaPerTanAlpha_ * (jetTanAlpha - tanLorentzAngle));
             float expSizeY = std::sqrt((expSizeYAtNormalIncidence_ * expSizeYAtNormalIncidence_) +
                                        thickness * thickness / (pitchY * pitchY) * jetTanBeta * jetTanBeta);
             if (expSizeX < 1.f)
               expSizeX = 1.f;
             if (expSizeY < 1.f)
               expSizeY = 1.f;
             float expCharge = std::sqrt(1.08f + jetZOverRho * jetZOverRho) * centralMIPCharge_;
 
             if (aCluster.charge() > expCharge * chargeFracMin_ &&
                 (aCluster.sizeX() > expSizeX + 1 || aCluster.sizeY() > expSizeY + 1)) {
               shouldBeSplit = true;
               if (verbose)
                 std::cout << "Trying to split: charge and deltaR " << aCluster.charge() << " "
                           << Geom::deltaR(jetDir, clusterDir) << " size x y " << aCluster.sizeX() << " "
                           << aCluster.sizeY() << " exp. size (x,y) " << expSizeX << " " << expSizeY << " detid "
                           << detIt->id() << std::endl;
               if (verbose)
                 std::cout << "jetZOverRho=" << jetZOverRho << std::endl;
 
               if (split(aCluster, filler, expCharge, expSizeY, expSizeX, jetZOverRho)) {
                 hasBeenSplit = true;
               }
             }
           }
         }
       }
       if (!hasBeenSplit) {
         SiPixelCluster c = aCluster;
         if (shouldBeSplit) {
           // blowup the error if we failed to split a splittable cluster (does
           // it ever happen)
           const float fromCentiToMicro = 1e4;
           c.setSplitClusterErrorX(c.sizeX() *
                                   (pitchX * fromCentiToMicro / 3.f));  // this is not really blowing up .. TODO: tune
           c.setSplitClusterErrorY(c.sizeY() * (pitchY * fromCentiToMicro / 3.f));
         }
         filler.push_back(c);
         std::push_heap(filler.begin(), filler.end(), [](SiPixelCluster const& cl1, SiPixelCluster const& cl2) {
           return cl1.minPixelRow() < cl2.minPixelRow();
         });
       }
     }  // loop over clusters
     std::sort_heap(filler.begin(), filler.end(), [](SiPixelCluster const& cl1, SiPixelCluster const& cl2) {
       return cl1.minPixelRow() < cl2.minPixelRow();
     });
 
   }  // loop over det
   iEvent.put(std::move(output));
 }

◆ secondDistDiffScore()

std::multimap< float, int > JetCoreClusterSplitter::secondDistDiffScore ( const std::vector< std::vector< float >> & distanceMap )

private

Definition at line 276 of file JetCoreClusterSplitter.cc.

References closestClusters(), ztail::d, and dqmiolumiharvest::j.

                                                     {
   std::multimap<float, int> scores;
   for (unsigned int j = 0; j < distanceMap.size(); j++) {
     std::pair<float, float> d = closestClusters(distanceMap[j]);
     scores.insert(std::pair<float, int>(d.second - d.first, j));
   }
   return scores;
 }

◆ secondDistScore()

std::multimap< float, int > JetCoreClusterSplitter::secondDistScore ( const std::vector< std::vector< float >> & distanceMap )

private

Definition at line 286 of file JetCoreClusterSplitter.cc.

References closestClusters(), ztail::d, and dqmiolumiharvest::j.

Referenced by fittingSplit().

                                                                                                               {
   std::multimap<float, int> scores;
   for (unsigned int j = 0; j < distanceMap.size(); j++) {
     std::pair<float, float> d = closestClusters(distanceMap[j]);
     scores.insert(std::pair<float, int>(-d.second, j));
   }
   return scores;
 }

◆ split()

bool JetCoreClusterSplitter::split	(	const SiPixelCluster &	aCluster,
		edmNew::DetSetVector< SiPixelCluster >::FastFiller &	filler,
		float	expectedADC,
		int	sizeY,
		int	sizeX,
		float	jetZOverRho
	)

private

Definition at line 237 of file JetCoreClusterSplitter.cc.

References SiPixelCluster::charge(), GetRecoTauVFromDQM_MC_cff::cl2, trigObjTnPSource_cfi::filler, fittingSplit(), mps_fire::i, SiPixelCluster::minPixelRow(), RecoTauValidation_cfi::sizeX, and RecoTauValidation_cfi::sizeY.

Referenced by produce().

                                                       {
   // This function should test several configuration of splitting, and then
   // return the one with best chi2
 
   std::vector<SiPixelCluster> sp = fittingSplit(
       aCluster, expectedADC, sizeY, sizeX, jetZOverRho, std::floor(aCluster.charge() / expectedADC + 0.5f));
 
   // for the config with best chi2
   for (unsigned int i = 0; i < sp.size(); i++) {
     filler.push_back(sp[i]);
     std::push_heap(filler.begin(), filler.end(), [](SiPixelCluster const& cl1, SiPixelCluster const& cl2) {
       return cl1.minPixelRow() < cl2.minPixelRow();
     });
   }
 
   return (!sp.empty());
 }

Member Data Documentation

◆ centralMIPCharge_

double JetCoreClusterSplitter::centralMIPCharge_

private

Definition at line 76 of file JetCoreClusterSplitter.cc.

Referenced by fittingSplit(), and produce().

◆ chargeFracMin_

double JetCoreClusterSplitter::chargeFracMin_

private

Definition at line 63 of file JetCoreClusterSplitter.cc.

Referenced by produce().

◆ chargePerUnit_

double JetCoreClusterSplitter::chargePerUnit_

private

Definition at line 75 of file JetCoreClusterSplitter.cc.

Referenced by fittingSplit().

◆ cores_

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

private

Definition at line 71 of file JetCoreClusterSplitter.cc.

Referenced by produce().

◆ deltaR_

double JetCoreClusterSplitter::deltaR_

private

Definition at line 62 of file JetCoreClusterSplitter.cc.

Referenced by produce().

◆ expSizeXAtLorentzAngleIncidence_

float JetCoreClusterSplitter::expSizeXAtLorentzAngleIncidence_

private

Definition at line 64 of file JetCoreClusterSplitter.cc.

Referenced by produce().

◆ expSizeXDeltaPerTanAlpha_

float JetCoreClusterSplitter::expSizeXDeltaPerTanAlpha_

private

Definition at line 65 of file JetCoreClusterSplitter.cc.

Referenced by produce().

◆ expSizeYAtNormalIncidence_

float JetCoreClusterSplitter::expSizeYAtNormalIncidence_

private

Definition at line 66 of file JetCoreClusterSplitter.cc.

Referenced by produce().

◆ forceXError_

double JetCoreClusterSplitter::forceXError_

private

Definition at line 72 of file JetCoreClusterSplitter.cc.

Referenced by fittingSplit().

◆ forceYError_

double JetCoreClusterSplitter::forceYError_

private

Definition at line 73 of file JetCoreClusterSplitter.cc.

Referenced by fittingSplit().

◆ fractionalWidth_

double JetCoreClusterSplitter::fractionalWidth_

private

Definition at line 74 of file JetCoreClusterSplitter.cc.

Referenced by fittingSplit().

◆ pixelClusters_

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

private

Definition at line 69 of file JetCoreClusterSplitter.cc.

Referenced by produce().

◆ ptMin_

double JetCoreClusterSplitter::ptMin_

private

Definition at line 61 of file JetCoreClusterSplitter.cc.

Referenced by produce().

◆ tanLorentzAngle_

float JetCoreClusterSplitter::tanLorentzAngle_

private

Definition at line 67 of file JetCoreClusterSplitter.cc.

Referenced by produce().

◆ tanLorentzAngleBarrelLayer1_

float JetCoreClusterSplitter::tanLorentzAngleBarrelLayer1_

private

Definition at line 68 of file JetCoreClusterSplitter.cc.

Referenced by produce().

◆ tCPE_

edm::ESGetToken<PixelClusterParameterEstimator, TkPixelCPERecord> const JetCoreClusterSplitter::tCPE_

private

Definition at line 57 of file JetCoreClusterSplitter.cc.

Referenced by produce().

◆ tTrackerTopo_

edm::ESGetToken<TrackerTopology, TrackerTopologyRcd> const JetCoreClusterSplitter::tTrackerTopo_

private

Definition at line 58 of file JetCoreClusterSplitter.cc.

Referenced by produce().

◆ tTrackingGeom_

edm::ESGetToken<GlobalTrackingGeometry, GlobalTrackingGeometryRecord> const JetCoreClusterSplitter::tTrackingGeom_

private

Definition at line 56 of file JetCoreClusterSplitter.cc.

Referenced by produce().

◆ verbose

bool JetCoreClusterSplitter::verbose

private

Definition at line 60 of file JetCoreClusterSplitter.cc.

Referenced by fittingSplit(), and produce().

◆ vertices_

edm::EDGetTokenT<reco::VertexCollection> JetCoreClusterSplitter::vertices_

private

Definition at line 70 of file JetCoreClusterSplitter.cc.

Referenced by produce().

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ JetCoreClusterSplitter()

◆ ~JetCoreClusterSplitter()

Member Function Documentation

◆ closestClusters()

◆ distScore()

◆ fillDescriptions()

◆ fittingSplit()

◆ produce()

◆ secondDistDiffScore()

◆ secondDistScore()

◆ split()

Member Data Documentation

◆ centralMIPCharge_

◆ chargeFracMin_

◆ chargePerUnit_

◆ cores_

◆ deltaR_

◆ expSizeXAtLorentzAngleIncidence_

◆ expSizeXDeltaPerTanAlpha_

◆ expSizeYAtNormalIncidence_

◆ forceXError_

◆ forceYError_

◆ fractionalWidth_

◆ pixelClusters_

◆ ptMin_

◆ tanLorentzAngle_

◆ tanLorentzAngleBarrelLayer1_

◆ tCPE_

◆ tTrackerTopo_

◆ tTrackingGeom_

◆ verbose

◆ vertices_