l1tpf_calo::SingleCaloClusterer Class Reference

#include <CaloClusterer.h>

Public Member Functions
void	add (const reco::Candidate &c)
void	add (float pt, float eta, float phi)
void	clear ()
const Cluster &	cluster (int i) const
const std::vector< Cluster > &	clusters () const
template<typename Corrector >
void	correct (const Corrector &corrector)
std::unique_ptr< l1t::PFClusterCollection >	fetch (const edm::OrphanHandle< l1t::PFClusterCollection > &cells, float ptMin=0.) const
std::unique_ptr< l1t::PFClusterCollection >	fetch (float ptMin=0.) const
std::unique_ptr< l1t::PFClusterCollection >	fetchCells (bool unclusteredOnly=false, float ptMin=0.) const
void	grow ()
	possibly grow clusters by adding unclustered energy on the sides More...
const IndexGrid &	indexGrid () const
EtGrid &	raw ()
	non-const access to the energy: be careful to use it only before 'run()' More...
const EtGrid &	raw () const
void	run ()
	SingleCaloClusterer (const edm::ParameterSet &pset)
	~SingleCaloClusterer ()

Private Types
enum	EnergyShareAlgo { EnergyShareAlgo::Fractions, EnergyShareAlgo::None, EnergyShareAlgo::Greedy, EnergyShareAlgo::Crude }

Private Attributes
IndexGrid	cellKey_
IndexGrid	clusterIndex_
std::vector< Cluster >	clusters_
EnergyShareAlgo	energyShareAlgo_
bool	energyWeightedPosition_
const Grid *	grid_
float	minClusterEt_
float	minEtToGrow_
const Cluster	nullCluster_
PreClusterGrid	precluster_
EtGrid	rawet_
float	seedEt_
EtGrid	unclustered_
float	zsEt_

Detailed Description

Definition at line 180 of file CaloClusterer.h.

Member Enumeration Documentation

EnergyShareAlgo

enum l1tpf_calo::SingleCaloClusterer::EnergyShareAlgo

strongprivate

Enumerator
Fractions
None
Greedy
Crude

Definition at line 218 of file CaloClusterer.h.

                               {
      Fractions, /* each local maximum neighbour takes a share proportional to its value */
      None,      /* each local maximum neighbour takes all the value (double counting!) */
      Greedy,    /* assing cell to the highest local maximum neighbour */
      Crude
    }; /* if there's more than one local maximum neighbour, they all take half of the value (no fp division) */

Constructor & Destructor Documentation

SingleCaloClusterer()

l1tpf_calo::SingleCaloClusterer::SingleCaloClusterer

(

const edm::ParameterSet &

pset

)

Definition at line 164 of file CaloClusterer.cc.

    : grid_(getGrid(pset.getParameter<std::string>("grid"))),
      rawet_(*grid_),
      unclustered_(*grid_),
      precluster_(*grid_),
      clusterIndex_(*grid_),
      cellKey_(*grid_),
      clusters_(),
      nullCluster_(),
      zsEt_(pset.getParameter<double>("zsEt")),
      seedEt_(pset.getParameter<double>("seedEt")),
      minClusterEt_(pset.getParameter<double>("minClusterEt")),
      minEtToGrow_(pset.existsAs<double>("minEtToGrow") ? pset.getParameter<double>("minEtToGrow") : -1),
      energyWeightedPosition_(pset.getParameter<bool>("energyWeightedPosition")) {
  std::string energyShareAlgo = pset.getParameter<std::string>("energyShareAlgo");
  if (energyShareAlgo == "fractions")
    energyShareAlgo_ = EnergyShareAlgo::Fractions;
  else if (energyShareAlgo == "none")
    energyShareAlgo_ = EnergyShareAlgo::None;
  else if (energyShareAlgo == "greedy")
    energyShareAlgo_ = EnergyShareAlgo::Greedy;
  else if (energyShareAlgo == "crude")
    energyShareAlgo_ = EnergyShareAlgo::Crude;
  else
    throw cms::Exception("Configuration") << "Unsupported energyShareAlgo '" << energyShareAlgo << "'\n";
}

References Crude, pfClustersFromCombinedCalo_cfi::energyShareAlgo, energyShareAlgo_, Exception, Fractions, Greedy, None, muonDTDigis_cfi::pset, and AlCaHLTBitMon_QueryRunRegistry::string.

~SingleCaloClusterer()

l1tpf_calo::SingleCaloClusterer::~SingleCaloClusterer

(

)

Definition at line 191 of file CaloClusterer.cc.

{}

Member Function Documentation

add() [1/2]

void l1tpf_calo::SingleCaloClusterer::add ( const reco::Candidate &  c )

inline

Definition at line 185 of file CaloClusterer.h.

{ add(c.pt(), c.eta(), c.phi()); }

References add(), and HltBtagPostValidation_cff::c.

Referenced by add(), L1TPFCaloProducer::produce(), L1TPFCaloProducer::readHcalDigis_(), L1TPFCaloProducer::readHcalHGCTowers_(), L1TPFCaloProducer::readPhase2BarrelCaloTowers_(), and counter.Counter::register().

add() [2/2]

void l1tpf_calo::SingleCaloClusterer::add ( float  pt, float  eta, float  phi  )

inline

Definition at line 186 of file CaloClusterer.h.

{ rawet_(eta, phi) += pt; }

References PVValHelper::eta, DiDispStaMuonMonitor_cfi::pt, and rawet_.

Referenced by counter.Counter::register().

clear()

void l1tpf_calo::SingleCaloClusterer::clear

(

void

)

Definition at line 193 of file CaloClusterer.cc.

                                          {
  rawet_.zero();
  clusters_.clear();
  clusterIndex_.fill(-1);
}

Referenced by L1TPFCaloProducer::produce().

cluster()

const Cluster& l1tpf_calo::SingleCaloClusterer::cluster ( int  i ) const

inline

Definition at line 196 of file CaloClusterer.h.

                                        {
      return (i == -1 || clusterIndex_[i] == -1) ? nullCluster_ : clusters_[clusterIndex_[i]];
    }

References clusterIndex_, clusters_, mps_fire::i, and nullCluster_.

clusters()

const std::vector<Cluster>& l1tpf_calo::SingleCaloClusterer::clusters ( ) const

inline

Definition at line 195 of file CaloClusterer.h.

{ return clusters_; }

References clusters_.

correct()

template<typename Corrector >

void l1tpf_calo::SingleCaloClusterer::correct ( const Corrector &  corrector )

inline

Definition at line 205 of file CaloClusterer.h.

                                             {
      for (Cluster &c : clusters_) {
        c.et = corrector(c);
      }
    }

References HltBtagPostValidation_cff::c, clusters_, and pfClustersFromHGC3DClusters_cfi::corrector.

Referenced by KalmanMuonCorrector.KalmanMuonCorrector::correct_all(), JetReCalibrator.JetReCalibrator::correctAll(), and L1TPFCaloProducer::produce().

fetch() [1/2]

std::unique_ptr< l1t::PFClusterCollection > l1tpf_calo::SingleCaloClusterer::fetch	(	const edm::OrphanHandle< l1t::PFClusterCollection > &	cells,
		float	ptMin = 0.
	)		const

Definition at line 393 of file CaloClusterer.cc.

                                                                             {
  auto ret = std::make_unique<l1t::PFClusterCollection>();
  for (const Cluster &cluster : clusters_) {
    if (cluster.et > ptMin) {
      ret->emplace_back(cluster.et, cluster.eta, cluster.phi);
      for (const auto &pair : cluster.constituents) {
        edm::Ptr<l1t::PFCluster> ref(cells, cellKey_[pair.first]);
        ret->back().addConstituent(ref, pair.second);
      }
    }
  }
  return ret;
}

References postprocess-scan-build::cells, ptMin, and runTheMatrix::ret.

fetch() [2/2]

std::unique_ptr< l1t::PFClusterCollection > l1tpf_calo::SingleCaloClusterer::fetch

(

float

ptMin = 0.

)

const

Definition at line 383 of file CaloClusterer.cc.

                                                                                            {
  auto ret = std::make_unique<l1t::PFClusterCollection>();
  for (const Cluster &cluster : clusters_) {
    if (cluster.et > ptMin) {
      ret->emplace_back(cluster.et, cluster.eta, cluster.phi);
    }
  }
  return ret;
}

References ptMin, and runTheMatrix::ret.

Referenced by L1TPFCaloProducer::produce().

fetchCells()

std::unique_ptr< l1t::PFClusterCollection > l1tpf_calo::SingleCaloClusterer::fetchCells	(	bool	unclusteredOnly = false,
		float	ptMin = 0.
	)		const

Definition at line 366 of file CaloClusterer.cc.

                                                                                                         {
  auto ret = std::make_unique<l1t::PFClusterCollection>();
  const EtGrid &src = (unclusteredOnly ? unclustered_ : rawet_);
  for (unsigned int i = 0, ncells = grid_->size(); i < ncells; ++i) {
    if (src[i] <= ptMin)
      continue;
    if ((unclusteredOnly == false) && (ptMin == 0)) {
      assert(cellKey_[i] == int(ret->size()));
    }
    ret->emplace_back(src[i], grid_->eta(i), grid_->phi(i));
    ret->back().setHwEta(grid_->ieta(i));
    ret->back().setHwPhi(grid_->iphi(i));
  }
  return ret;
}

References cms::cuda::assert(), mps_fire::i, ptMin, runTheMatrix::ret, and TrackRefitter_38T_cff::src.

Referenced by L1TPFCaloProducer::produce().

grow()

void l1tpf_calo::SingleCaloClusterer::grow

(

)

possibly grow clusters by adding unclustered energy on the sides

Definition at line 339 of file CaloClusterer.cc.

                                         {
  int selneighs[4] = {1, 3, 4, 6};  // -eta, -phi, +phi, +eta
  std::vector<int> toreset;
  for (Cluster &cluster : clusters_) {
    if (cluster.et > minEtToGrow_) {
      int i = cluster.constituents.front().first;
      for (int side = 0; side < 4; ++side) {
        int neigh = grid_->neighbour(i, selneighs[side]);
        if (neigh == -1)
          continue;
        for (int in = 0; in < 8; ++in) {
          int n2 = grid_->neighbour(neigh, in);
          if (n2 == -1)
            continue;
          cluster.et += unclustered_[n2];
          if (unclustered_[n2]) {
            cluster.constituents.emplace_back(n2, 1.0);
            toreset.push_back(n2);
          }
        }
      }
    }
  }
  for (int i : toreset)
    unclustered_[i] = 0;
}

References mps_fire::i, and recoMuon::in.

indexGrid()

const IndexGrid& l1tpf_calo::SingleCaloClusterer::indexGrid ( ) const

inline

Definition at line 194 of file CaloClusterer.h.

{ return clusterIndex_; }

References clusterIndex_.

raw() [1/2]

EtGrid& l1tpf_calo::SingleCaloClusterer::raw ( )

inline

non-const access to the energy: be careful to use it only before 'run()'

Definition at line 201 of file CaloClusterer.h.

{ return rawet_; }

References rawet_.

raw() [2/2]

const EtGrid& l1tpf_calo::SingleCaloClusterer::raw ( ) const

inline

Definition at line 193 of file CaloClusterer.h.

{ return rawet_; }

References rawet_.

run()

void l1tpf_calo::SingleCaloClusterer::run

(

)

Definition at line 199 of file CaloClusterer.cc.

                                        {
  unsigned int i, ncells = grid_->size();
 
  // kill zeros. count non-zeros, for linking later
  cellKey_.fill(-1);
  int key = 0;
  for (i = 0; i < ncells; ++i) {
    if (rawet_[i] < zsEt_) {
      rawet_[i] = 0;
    } else {
      cellKey_[i] = key++;
    }
  }
 
  precluster_.clear();
  // pre-cluster step 1: at each cell, set the value equal to itself if it's a local maxima, zero otherwise
  // can be done in parallel on all cells
  for (i = 0; i < ncells; ++i) {
    if (rawet_[i] > seedEt_) {
      precluster_[i].ptLocalMax = rawet_[i];
      //printf("   candidate precluster pt %7.2f at %4d (ieta %+3d iphi %2d)\n",  rawet_[i], i, grid_->ieta(i), grid_->iphi(i));
      for (int ineigh = 0; ineigh <= 3; ++ineigh) {
        if (rawet_.neigh(i, ineigh) > rawet_[i])
          precluster_[i].ptLocalMax = 0;
        //int ncell = grid_->neighbour(i,ineigh);
        //if (ncell == -1) printf("   \t neigh %d is null\n", ineigh);
        //else printf("   \t neigh %d at %4d (ieta %+3d iphi %2d) has pt %7.2f: comparison %1d \n", ineigh, ncell, grid_->ieta(ncell), grid_->iphi(ncell), rawet_[ncell], precluster_[i].ptLocalMax > 0);
      }
      for (int ineigh = 4; ineigh < 8; ++ineigh) {
        if (rawet_.neigh(i, ineigh) >= rawet_[i])
          precluster_[i].ptLocalMax = 0;
        //int ncell = grid_->neighbour(i,ineigh);
        //if (ncell == -1) printf("   \t neigh %d is null\n", ineigh);
        //else printf("   \t neigh %d at %4d (ieta %+3d iphi %2d) has pt %7.2f: comparison %1d \n", ineigh, ncell, grid_->ieta(ncell), grid_->iphi(ncell), rawet_[ncell], precluster_[i].ptLocalMax > 0);
      }
    }
  }
  // pre-cluster step 2: compute information from neighbouring local max, for energy sharing purposes
  for (i = 0; i < ncells; ++i) {
    if (precluster_[i].ptLocalMax == 0) {
      switch (energyShareAlgo_) {
        case EnergyShareAlgo::Fractions: {
          float tot = 0;
          for (int ineigh = 0; ineigh < 8; ++ineigh) {
            tot += precluster_.neigh(i, ineigh).ptLocalMax;
          }
          precluster_[i].ptOverNeighLocalMaxSum = tot ? rawet_[i] / tot : 0;
        } break;
        case EnergyShareAlgo::None:
          precluster_[i].ptOverNeighLocalMaxSum = rawet_[i];
          break;
        case EnergyShareAlgo::Greedy: {
          float maxet = 0;
          for (int ineigh = 0; ineigh < 8; ++ineigh) {
            maxet = std::max(maxet, precluster_.neigh(i, ineigh).ptLocalMax);
          }
          precluster_[i].ptOverNeighLocalMaxSum = maxet;
        } break;
        case EnergyShareAlgo::Crude: {
          int number = 0;
          for (int ineigh = 0; ineigh < 8; ++ineigh) {
            number += (precluster_.neigh(i, ineigh).ptLocalMax > 0);
          }
          precluster_[i].ptOverNeighLocalMaxSum = (number > 1 ? 0.5 : 1.0) * rawet_[i];
        } break;
      }
    }
  }
 
  clusterIndex_.fill(-1);
  clusters_.clear();
  unclustered_ = rawet_;
  // cluster: at each localMax cell, take itself plus the weighted contributions of the neighbours
  Cluster cluster;
  for (i = 0; i < ncells; ++i) {
    if (precluster_[i].ptLocalMax > 0) {
      float myet = rawet_[i];
      float tot = myet;
      float avg_eta = 0;
      float avg_phi = 0;
      cluster.clear();
      cluster.constituents.emplace_back(i, 1.0);
      for (int ineigh = 0; ineigh < 8; ++ineigh) {
        int ineighcell = grid_->neighbour(i, ineigh);
        if (ineighcell == -1)
          continue;  // skip dummy cells
        float fracet = 0;
        switch (energyShareAlgo_) {
          case EnergyShareAlgo::Fractions:
            fracet = myet * precluster_.neigh(i, ineigh).ptOverNeighLocalMaxSum;
            break;
          case EnergyShareAlgo::None:
            fracet = precluster_.neigh(i, ineigh).ptOverNeighLocalMaxSum;
            break;
          case EnergyShareAlgo::Greedy:
            fracet = (myet == precluster_.neigh(i, ineigh).ptOverNeighLocalMaxSum ? rawet_.neigh(i, ineigh) : 0);
            break;
          case EnergyShareAlgo::Crude:
            fracet = precluster_.neigh(i, ineigh).ptOverNeighLocalMaxSum;
            break;
        }
        if (fracet == 0)
          continue;
        tot += fracet;
        cluster.constituents.emplace_back(ineighcell, fracet / rawet_.neigh(i, ineigh));
        if (energyWeightedPosition_) {
          avg_eta += fracet * (grid_->eta(ineighcell) - grid_->eta(i));
          avg_phi += fracet * deltaPhi(grid_->phi(ineighcell), grid_->phi(i));
        }
      }
      if (tot > minClusterEt_) {
        cluster.et = tot;
        unclustered_[i] = 0;
        for (int ineigh = 0; ineigh < 8; ++ineigh) {
          int ineighcell = grid_->neighbour(i, ineigh);
          if (ineighcell == -1)
            continue;  // skip dummy cells
          unclustered_[ineighcell] = 0;
        }
        if (energyWeightedPosition_) {
          cluster.eta = grid_->eta(i) + avg_eta / tot;
          cluster.phi = grid_->phi(i) + avg_phi / tot;
          // wrap around phi
          cluster.phi = reco::reduceRange(cluster.phi);
        } else {
          cluster.eta = grid_->eta(i);
          cluster.phi = grid_->phi(i);
        }
        clusterIndex_[i] = clusters_.size();
        clusters_.push_back(cluster);
      }
    }
  }
  if (minEtToGrow_ > 0)
    grow();
}

References l1tpf_calo::Cluster::clear(), l1tpf_calo::Cluster::constituents, SiPixelRawToDigiRegional_cfi::deltaPhi, l1tpf_calo::Cluster::et, l1tpf_calo::Cluster::eta, mps_fire::i, crabWrapper::key, SiStripPI::max, HiEvtPlane_cfi::maxet, None, contentValuesFiles::number, l1tpf_calo::Cluster::phi, and reco::reduceRange().

Referenced by L1TPFCaloProducer::produce().

Member Data Documentation

cellKey_

IndexGrid l1tpf_calo::SingleCaloClusterer::cellKey_

private

Definition at line 227 of file CaloClusterer.h.

clusterIndex_

IndexGrid l1tpf_calo::SingleCaloClusterer::clusterIndex_

private

Definition at line 227 of file CaloClusterer.h.

Referenced by cluster(), and indexGrid().

clusters_

std::vector<Cluster> l1tpf_calo::SingleCaloClusterer::clusters_

private

Definition at line 228 of file CaloClusterer.h.

Referenced by cluster(), clusters(), and correct().

energyShareAlgo_

EnergyShareAlgo l1tpf_calo::SingleCaloClusterer::energyShareAlgo_

private

Definition at line 231 of file CaloClusterer.h.

Referenced by SingleCaloClusterer().

energyWeightedPosition_

bool l1tpf_calo::SingleCaloClusterer::energyWeightedPosition_

private

Definition at line 232 of file CaloClusterer.h.

grid_

const Grid* l1tpf_calo::SingleCaloClusterer::grid_

private

Definition at line 224 of file CaloClusterer.h.

minClusterEt_

float l1tpf_calo::SingleCaloClusterer::minClusterEt_

private

Definition at line 230 of file CaloClusterer.h.

minEtToGrow_

float l1tpf_calo::SingleCaloClusterer::minEtToGrow_

private

Definition at line 230 of file CaloClusterer.h.

nullCluster_

const Cluster l1tpf_calo::SingleCaloClusterer::nullCluster_

private

Definition at line 229 of file CaloClusterer.h.

Referenced by cluster().

precluster_

PreClusterGrid l1tpf_calo::SingleCaloClusterer::precluster_

private

Definition at line 226 of file CaloClusterer.h.

rawet_

EtGrid l1tpf_calo::SingleCaloClusterer::rawet_

private

Definition at line 225 of file CaloClusterer.h.

Referenced by add(), and raw().

seedEt_

float l1tpf_calo::SingleCaloClusterer::seedEt_

private

Definition at line 230 of file CaloClusterer.h.

unclustered_

EtGrid l1tpf_calo::SingleCaloClusterer::unclustered_

private

Definition at line 225 of file CaloClusterer.h.

zsEt_

float l1tpf_calo::SingleCaloClusterer::zsEt_

private

Definition at line 230 of file CaloClusterer.h.