JetCoreClusterSplitter Class Reference

Inheritance diagram for JetCoreClusterSplitter:

Public Member Functions
	JetCoreClusterSplitter (const edm::ParameterSet &iConfig)
void	produce (edm::Event &iEvent, const edm::EventSetup &iSetup)
	~JetCoreClusterSplitter ()
Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default
Public Member Functions inherited from edm::stream::EDProducerBase
	EDProducerBase ()
ModuleDescription const &	moduleDescription () const
virtual	~EDProducerBase ()
Public Member Functions inherited from edm::ProducerBase
	ProducerBase ()
void	registerProducts (ProducerBase *, ProductRegistry *, ModuleDescription const &)
std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...
virtual	~ProducerBase ()
Public Member Functions inherited from edm::EDConsumerBase
	EDConsumerBase ()
ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const
void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const
void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const
std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const
void	labelsForToken (EDGetToken iToken, Labels &oLabels) const
void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const
bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const
bool	registeredToConsumeMany (TypeID const &, BranchType) const
void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)
virtual	~EDConsumerBase ()

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_
double	forceXError_
double	forceYError_
double	fractionalWidth_
edm::EDGetTokenT < edmNew::DetSetVector < SiPixelCluster > >	pixelClusters_
std::string	pixelCPE_
double	ptMin_
bool	verbose
edm::EDGetTokenT < reco::VertexCollection >	vertices_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T...>	CacheTypes
typedef CacheTypes::GlobalCache	GlobalCache
typedef AbilityChecker< T...>	HasAbility
typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache
typedef LuminosityBlockContextT < LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext
typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache
typedef CacheTypes::RunCache	RunCache
typedef RunContextT< RunCache, GlobalCache >	RunContext
typedef CacheTypes::RunSummaryCache	RunSummaryCache
Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType
Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList
Static Public Member Functions inherited from edm::stream::EDProducerBase
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &descriptions)
Protected Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)
ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...
template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()
void	consumesMany (const TypeToGet &id)
template<BranchType B>
void	consumesMany (const TypeToGet &id)
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Definition at line 32 of file JetCoreClusterSplitter.cc.

Constructor & Destructor Documentation

JetCoreClusterSplitter::JetCoreClusterSplitter

(

const edm::ParameterSet &

iConfig

)

Definition at line 63 of file JetCoreClusterSplitter.cc.

                                                                            :
    verbose(iConfig.getParameter<bool>("verbose")),
    pixelCPE_(iConfig.getParameter<std::string>("pixelCPE")),
    ptMin_(iConfig.getParameter<double>("ptMin")),
    deltaR_(iConfig.getParameter<double>("deltaRmax")),
    chargeFracMin_(iConfig.getParameter<double>("chargeFractionMin")),
    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

(

)

Definition at line 84 of file JetCoreClusterSplitter.cc.

{
}

Member Function Documentation

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

private

Definition at line 196 of file JetCoreClusterSplitter.cc.

References i.

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

{
 
    float minDist=9e99;
    float secondMinDist=9e99;
    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);
}

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

private

Definition at line 236 of file JetCoreClusterSplitter.cc.

References closestClusters(), and 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;
}

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

private

Definition at line 247 of file JetCoreClusterSplitter.cc.

References funct::abs(), ecalMGPA::adc(), SiPixelCluster::add(), centralMIPCharge_, chargePerUnit_, GetRecoTauVFromDQM_MC_cff::cl, gather_cfg::cout, alignCSCRings::e, create_public_lumi_plots::exp, forceXError_, forceYError_, fractionalWidth_, i, j, roll_playback::k, convertSQLitetoXML_cfg::output, SiPixelCluster::pixels(), secondDistScore(), SiPixelCluster::setSplitClusterErrorX(), SiPixelCluster::setSplitClusterErrorY(), mathSSE::sqrt(), x, and detailsBasic3DVector::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<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 << " ] "<< std::endl;
        for(int k=0;k<sub;k++)
        {
            if(k==sub-1) perDiv = originalpixels[j].adc - perDiv*k;
            pixels.push_back(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( pixels.size(), std::vector<float>(meanExp));
        std::vector<std::vector<float> > distanceMapY( pixels.size(), std::vector<float>(meanExp));
        std::vector<std::vector<float> > distanceMap( pixels.size(), std::vector<float>(meanExp));
        for(unsigned int j = 0; j < pixels.size(); j++)
        {
            if(verbose) std::cout << "pixel pos " << j << " " << pixels[j].x << " " << pixels[j].y << std::endl;
            for(unsigned int i = 0; i < meanExp; i++)
            {
                distanceMapX[j][i]=1.*pixels[j].x-clx[i];
                distanceMapY[j][i]=1.*pixels[j].y-cly[i];
                float dist=0;
                //              float sizeX=2;
                if(std::abs(distanceMapX[j][i])>sizeX/2.)
                {
                    dist+=(std::abs(distanceMapX[j][i])-sizeX/2.+1)*(std::abs(distanceMapX[j][i])-sizeX/2.+1);
                } else {
                    dist+=distanceMapX[j][i]/sizeX*2*distanceMapX[j][i]/sizeX*2;
                }
                //              dist+=1.*distanceMapX[j][i]*distanceMapX[j][i];

                if(std::abs(distanceMapY[j][i])>sizeY/2.)
                {
                    dist+=1.*(std::abs(distanceMapY[j][i])-sizeY/2.+1.)*(std::abs(distanceMapY[j][i])-sizeY/2.+1.);
                } else {
                    dist+=1.*distanceMapY[j][i]/sizeY*2.*distanceMapY[j][i]/sizeY*2.;
                }
                distanceMap[j][i]=sqrt(dist);
                if(verbose) std::cout << "Cluster " << i << " Pixel " << j << " distances: " << distanceMapX[j][i] << " " << distanceMapY[j][i]  << " " << distanceMap[j][i] << std::endl;

            }

        }
        //Compute scores for sequential addition
        std::multimap<float,int> scores;
        //Using different rankings to improve convergence (as Giulio proposed)  
//      if(remainingSteps > 70){
            scores=secondDistScore(distanceMap);
//      } else { //if(remainingSteps > 40 ) {
//          scores=secondDistDiffScore(distanceMap);
//      } else {
//          scores = distScore(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 j=it->second;
            if(verbose) std::cout << "Pixel " << j << " with score " << it->first << std::endl;
            //find cluster that is both close and has some charge still to assign
            float maxEst=0;
            int cl=-1;
            for(unsigned int i = 0; i < meanExp; i++)
            {
//              float nsig=(cls[i]*cls[i]-expectedADC*expectedADC)/2./(expectedADC*0.2); //20% uncertainty? realistic from Landau?
                float nsig=(cls[i]-expectedADC)/(expectedADC*fractionalWidth_); //20% uncertainty? realistic from Landau?
                float clQest=1./(1.+exp(nsig))+1e-6; //1./(1.+exp(x*x-3*3)) 
                float clDest=1./(distanceMap[j][i]+0.05);

                if(verbose)  std::cout <<" Q: " <<  clQest << " D: " << clDest << " " << distanceMap[j][i] <<  std::endl;
                float est=clQest*clDest;
                if(est> maxEst) {
                    cl=i;
                    maxEst=est;
                }   
            }
            cls[cl]+=pixels[j].adc;
            clusterForPixel[j]=cl;
            weightOfPixel[j]=maxEst;
            if(verbose) std::cout << "Pixel j weight " << weightOfPixel[j] << " " << j << std::endl;
        }
        //Recompute cluster centers
        stop=true;
        for(unsigned int i = 0; i < meanExp; i++){
            if(std::abs(clx[i]-oldclx[i]) > 0.01) stop = false; //still moving
            if(std::abs(cly[i]-oldcly[i]) > 0.01) stop = false;
            oldclx[i]=clx[i]; oldcly[i]=cly[i]; clx[i]=0; cly[i]=0; cls[i]=1e-99; 
        }
        for(unsigned int j = 0; j < pixels.size(); j++)
        {
            if(clusterForPixel[j]<0) continue;
            if(verbose)             std::cout << "x " << pixels[j].x <<" * " << pixels[j].adc << " * " << weightOfPixel[j]<<std::endl;
            clx[clusterForPixel[j]]+=pixels[j].x*pixels[j].adc;
            cly[clusterForPixel[j]]+=pixels[j].y*pixels[j].adc;
            cls[clusterForPixel[j]]+=pixels[j].adc;
            //          std::cout << "update cluster " << clusterForPixel[j] << " x,y " << clx[clusterForPixel[j]] << " " << cly[clusterForPixel[j]] <<  "weight x,y " << cls[clusterForPixel[j]] <<  " " << clx[clusterForPixel[j]]/cls[clusterForPixel[j]] << " " << cly[clusterForPixel[j]]/cls[clusterForPixel[j]] <<std::endl;

        }
        for(unsigned int i = 0; i < meanExp; i++){
            if(cls[i]!=0){
                clx[i]/=cls[i];
                cly[i]/=cls[i];
            }
            if(verbose)             std::cout << "Center for cluster " << i << " x,y " << clx[i] << " " << cly[i] << std::endl;
            cls[i]=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].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].adc!=0 and pixels[k].x==pixels[j].x and pixels[k].y==pixels[j].y)
                    {
                        pixels[j].adc+=pixels[k].adc;
                        pixels[k].adc=0;
                    }
                }
                pixelsForCl[cl].push_back(pixels[j]);
            }
        }
    }

    //  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++){
        SiPixelCluster * cluster=0;
        if(verbose) std::cout << "Pixels of cl " << cl << " " ;
        for(unsigned int j = 0; j < pixelsForCl[cl].size(); j++) {
            if(verbose) std::cout << pixelsForCl[cl][j].x<<","<<pixelsForCl[cl][j].y<<"|";
            if(cluster){

                SiPixelCluster::PixelPos newpix(pixelsForCl[cl][j].x,pixelsForCl[cl][j].y);
                cluster->add( newpix, pixelsForCl[cl][j].adc);
            }
            else
            {
                SiPixelCluster::PixelPos newpix(pixelsForCl[cl][j].x,pixelsForCl[cl][j].y);
                cluster = new  SiPixelCluster( newpix,pixelsForCl[cl][j].adc ); // create protocluster
            }
        }
        if(verbose) std::cout << std::endl;
        if(cluster){ 
            if(forceXError_ > 0)cluster->setSplitClusterErrorX(forceXError_);
            if(forceYError_ > 0)cluster->setSplitClusterErrorY(forceYError_);
            output.push_back(*cluster);
            delete cluster;
        }
    }
    //  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;
}

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

virtual

Implements edm::stream::EDProducerBase.

Definition at line 90 of file JetCoreClusterSplitter.cc.

References edmNew::DetSetVector< T >::begin(), EnergyCorrector::c, centralMIPCharge_, SiPixelCluster::charge(), chargeFracMin_, cores_, gather_cfg::cout, deltaR(), deltaR_, edmNew::DetSetVector< T >::end(), first, geometry, edm::EventSetup::get(), edm::Event::getByToken(), edmNew::DetSetVector< T >::id(), metsig::jet, reco::Candidate::momentum(), convertSQLitetoXML_cfg::output, pixelClusters_, pixelCPE_, createTree::pp, ptMin_, edm::Event::put(), MetAnalyzer::pv(), reco::Candidate::px(), reco::Candidate::py(), reco::Candidate::pz(), SiPixelCluster::setSplitClusterErrorX(), SiPixelCluster::setSplitClusterErrorY(), SiPixelCluster::sizeX(), SiPixelCluster::sizeY(), split(), mathSSE::sqrt(), GeomDet::surface(), Surface::toGlobal(), vertices_, and PV3DBase< T, PVType, FrameType >::z().

{
    using namespace edm;
    edm::ESHandle<GlobalTrackingGeometry> geometry;
    iSetup.get<GlobalTrackingGeometryRecord>().get(geometry);

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

    edm::ESHandle<PixelClusterParameterEstimator> pe; 
    const PixelClusterParameterEstimator * pp ;
    iSetup.get<TkPixelCPERecord>().get(pixelCPE_ , pe );  
    pp = pe.product();

    std::auto_ptr<edmNew::DetSetVector<SiPixelCluster> > output(new 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() );
        for(edmNew::DetSet<SiPixelCluster>::const_iterator 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

                        bool isEndCap = (fabs(cPos.z())>30); //FIXME: check detID instead!
                        float jetZOverRho = jet.momentum().Z()/jet.momentum().Rho();
                        if(isEndCap) jetZOverRho=jet.momentum().Rho()/jet.momentum().Z();
                        float expSizeY=fabs(sqrt(1.3*1.3+1.9*1.9*jetZOverRho*jetZOverRho)); 
                        if(expSizeY<1) expSizeY=1.; 
                        float expSizeX=1.5;
                        if(isEndCap) {expSizeX=expSizeY; expSizeY = 1.5;} // in endcap col/rows are switched
                        float expCharge=sqrt(1.08+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()<< " 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)
                    c.setSplitClusterErrorX(c.sizeX()*100./3.); //this is not really blowing up .. TODO: tune
                    c.setSplitClusterErrorY(c.sizeY()*150./3.);
                }
                filler.push_back(c);    
            }

        }
    }
    iEvent.put(output);
}

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

private

Definition at line 214 of file JetCoreClusterSplitter.cc.

References closestClusters(), and 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;
}

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

private

Definition at line 225 of file JetCoreClusterSplitter.cc.

References closestClusters(), and 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;
}

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

private

Definition at line 181 of file JetCoreClusterSplitter.cc.

References SiPixelCluster::charge(), fittingSplit(), i, and edmNew::DetSetVector< T >::FastFiller::push_back().

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,floor(aCluster.charge() / expectedADC +0.5));

    //for the config with best chi2
    for(unsigned int i = 0; i < sp.size();i++ )
    {
        filler.push_back(sp[i]);
    }

    return (sp.size() > 0);
}

Member Data Documentation

double JetCoreClusterSplitter::centralMIPCharge_

private

Definition at line 59 of file JetCoreClusterSplitter.cc.

Referenced by fittingSplit(), and produce().

double JetCoreClusterSplitter::chargeFracMin_

private

Definition at line 51 of file JetCoreClusterSplitter.cc.

Referenced by produce().

double JetCoreClusterSplitter::chargePerUnit_

private

Definition at line 58 of file JetCoreClusterSplitter.cc.

Referenced by fittingSplit().

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

private

Definition at line 54 of file JetCoreClusterSplitter.cc.

Referenced by produce().

double JetCoreClusterSplitter::deltaR_

private

Definition at line 50 of file JetCoreClusterSplitter.cc.

Referenced by produce().

double JetCoreClusterSplitter::forceXError_

private

Definition at line 55 of file JetCoreClusterSplitter.cc.

Referenced by fittingSplit().

double JetCoreClusterSplitter::forceYError_

private

Definition at line 56 of file JetCoreClusterSplitter.cc.

Referenced by fittingSplit().

double JetCoreClusterSplitter::fractionalWidth_

private

Definition at line 57 of file JetCoreClusterSplitter.cc.

Referenced by fittingSplit().

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

private

Definition at line 52 of file JetCoreClusterSplitter.cc.

Referenced by produce().

std::string JetCoreClusterSplitter::pixelCPE_

private

Definition at line 48 of file JetCoreClusterSplitter.cc.

Referenced by produce().

double JetCoreClusterSplitter::ptMin_

private

Definition at line 49 of file JetCoreClusterSplitter.cc.

Referenced by produce().

bool JetCoreClusterSplitter::verbose

private

Definition at line 47 of file JetCoreClusterSplitter.cc.

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

private

Definition at line 53 of file JetCoreClusterSplitter.cc.

Referenced by produce().