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)
const EtaPhiCenterGrid &	etaCenter () const
EtaPhiCenterGrid &	etaCenter ()
std::unique_ptr< l1t::PFClusterCollection >	fetch (float ptMin=0.) const
std::unique_ptr< l1t::PFClusterCollection >	fetch (const edm::OrphanHandle< l1t::PFClusterCollection > &cells, 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
const EtaPhiCenterGrid &	phiCenter () const
EtaPhiCenterGrid &	phiCenter ()
const EtGrid &	raw () const
EtGrid &	raw ()
	non-const access to the energy: be careful to use it only before 'run()' More...
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_
EtaPhiCenterGrid	eta_center_
std::vector< double >	etaBounds_
const Grid *	grid_
std::vector< unsigned int >	maxClustersEtaPhi_
float	minClusterEt_
float	minEtToGrow_
std::vector< int >	neighborCells_
const Cluster	nullCluster_
EtaPhiCenterGrid	phi_center_
std::vector< double >	phiBounds_
bool	preciseEtaPhi_
PreClusterGrid	precluster_
EtGrid	rawet_
float	seedEt_
EtGrid	unclustered_
float	zsEt_

Detailed Description

Definition at line 186 of file CaloClusterer.h.

Member Enumeration Documentation

EnergyShareAlgo

enum l1tpf_calo::SingleCaloClusterer::EnergyShareAlgo

strongprivate

Enumerator
Fractions
None
Greedy
Crude

Definition at line 237 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 166 of file CaloClusterer.cc.

References Crude, pfClustersFromCombinedCaloHF_cfi::energyShareAlgo, energyShareAlgo_, etaBounds_, Exception, Fractions, Greedy, maxClustersEtaPhi_, neighborCells_, None, phiBounds_, muonDTDigis_cfi::pset, and AlCaHLTBitMon_QueryRunRegistry::string.

    : grid_(getGrid(pset.getParameter<std::string>("grid"))),
      rawet_(*grid_),
      unclustered_(*grid_),
      eta_center_(*grid_),
      phi_center_(*grid_),
      precluster_(*grid_),
      clusterIndex_(*grid_),
      cellKey_(*grid_),
      preciseEtaPhi_(pset.existsAs<bool>("usePreciseEtaPhi") ? pset.getParameter<bool>("usePreciseEtaPhi") : false),
      etaBounds_(pset.getParameter<std::vector<double>>("etaBounds")),
      phiBounds_(pset.getParameter<std::vector<double>>("phiBounds")),
      maxClustersEtaPhi_(pset.getParameter<std::vector<unsigned int>>("maxClustersEtaPhi")),
      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";
  if (pset.existsAs<std::vector<int>>("neighborCells")) {
    neighborCells_ = pset.getParameter<std::vector<int>>(
        "neighborCells");  //anything other than 3x3 is incompatible with grow() I think...
  } else {
    neighborCells_ = std::vector<int>({0, 1, 2, 3, 4, 5, 6, 7});  //default to 3x3
    //  in relative eta,phi: 5 = (+1, 0), 6 = (+1, 0), 7 = (+1,+1)
    //                       3 = ( 0,-1),              4 = ( 0,+1),
    //                       0 = (-1,-1), 1 = (-1, 0), 2 = (-1,+1),
  }
  if ((etaBounds_.size() - 1) * (phiBounds_.size() - 1) != maxClustersEtaPhi_.size()) {
    throw cms::Exception("Configuration")
        << "Size mismatch between eta/phi bounds and max clusters: " << (etaBounds_.size() - 1) << " x "
        << (phiBounds_.size() - 1) << " != " << maxClustersEtaPhi_.size() << "\n";
  }
  if (!std::is_sorted(etaBounds_.begin(), etaBounds_.end())) {
    throw cms::Exception("Configuration") << "etaBounds is not sorted\n";
  }
  if (!std::is_sorted(phiBounds_.begin(), phiBounds_.end())) {
    throw cms::Exception("Configuration") << "phiBounds is not sorted\n";
  }
}

~SingleCaloClusterer()

l1tpf_calo::SingleCaloClusterer::~SingleCaloClusterer

(

)

Definition at line 219 of file CaloClusterer.cc.

{}

Member Function Documentation

add() [1/2]

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

inline

Definition at line 191 of file CaloClusterer.h.

References add(), and HltBtagPostValidation_cff::c.

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

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

add() [2/2]

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

inline

Definition at line 192 of file CaloClusterer.h.

References PVValHelper::eta, eta_center_, phi_center_, preciseEtaPhi_, DiDispStaMuonMonitor_cfi::pt, and rawet_.

Referenced by counter.Counter::register().

                                             {
      rawet_(eta, phi) += pt;
      if (preciseEtaPhi_) {
        float newet = rawet_(eta, phi);
        float prevw = (newet - pt) / newet;
        float nextw = pt / newet;
        eta_center_(eta, phi) = eta_center_(eta, phi) * prevw + eta * nextw;
        phi_center_(eta, phi) = phi_center_(eta, phi) * prevw + phi * nextw;
      }
    }

clear()

void l1tpf_calo::SingleCaloClusterer::clear

(

void

)

Definition at line 221 of file CaloClusterer.cc.

Referenced by L1TPFCaloProducer::produce().

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

cluster()

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

inline

Definition at line 213 of file CaloClusterer.h.

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

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

clusters()

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

inline

Definition at line 212 of file CaloClusterer.h.

References clusters_.

{ return clusters_; }

correct()

template<typename Corrector >

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

inline

Definition at line 224 of file CaloClusterer.h.

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

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

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

etaCenter() [1/2]

const EtaPhiCenterGrid& l1tpf_calo::SingleCaloClusterer::etaCenter ( ) const

inline

Definition at line 209 of file CaloClusterer.h.

References eta_center_.

{ return eta_center_; }

etaCenter() [2/2]

EtaPhiCenterGrid& l1tpf_calo::SingleCaloClusterer::etaCenter ( )

inline

Definition at line 219 of file CaloClusterer.h.

References eta_center_.

{ return eta_center_; }

fetch() [1/2]

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

(

float

ptMin = 0.

)

const

Definition at line 428 of file CaloClusterer.cc.

References ptMin, and runTheMatrix::ret.

Referenced by L1TPFCaloProducer::produce().

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

fetch() [2/2]

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

Definition at line 438 of file CaloClusterer.cc.

References hgcalTBTopologyTester_cfi::cells, ptMin, and runTheMatrix::ret.

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

fetchCells()

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

Definition at line 400 of file CaloClusterer.cc.

References cms::cuda::assert(), mps_fire::i, cuy::ii, dqmdumpme::indices, l1tpf_calo::GridData< T >::phi(), ptMin, runTheMatrix::ret, collectionMerger::selector, and TrackRefitter_38T_cff::src.

Referenced by L1TPFCaloProducer::produce().

                                                                                                         {
  auto ret = std::make_unique<l1t::PFClusterCollection>();
  const EtGrid &src = (unclusteredOnly ? unclustered_ : rawet_);
  const EtaPhiCenterGrid &eta_shift = eta_center_;
  const EtaPhiCenterGrid &phi_shift = phi_center_;
  l1tpf_calo::GridSelector selector = l1tpf_calo::GridSelector(etaBounds_, phiBounds_, maxClustersEtaPhi_);
  int totalClusters = 0;
  for (unsigned int i = 0, ncells = grid_->size(); i < ncells; ++i) {
    if (src[i] <= ptMin)
      continue;
    if ((unclusteredOnly == false) && (ptMin == 0)) {
      assert(cellKey_[i] == totalClusters);
    }
    totalClusters++;
    selector.fill(src[i], grid_->eta(i), grid_->phi(i), i);
  }
  std::vector<unsigned int> indices = selector.returnSorted();
  for (unsigned int ii = 0; ii < indices.size(); ii++) {
    unsigned int theIndex = indices[ii];
    ret->emplace_back(
        src[theIndex], grid_->eta(theIndex) + eta_shift[theIndex], grid_->phi(theIndex) + phi_shift[theIndex]);
    ret->back().setHwEta(grid_->ieta(theIndex));
    ret->back().setHwPhi(grid_->iphi(theIndex));
  }
  return ret;
}

grow()

void l1tpf_calo::SingleCaloClusterer::grow

(

)

possibly grow clusters by adding unclustered energy on the sides

Definition at line 373 of file CaloClusterer.cc.

References mps_fire::i, recoMuon::in, and ALPAKA_ACCELERATOR_NAMESPACE::ecal::reconstruction::internal::barrel::side().

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

indexGrid()

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

inline

Definition at line 211 of file CaloClusterer.h.

References clusterIndex_.

{ return clusterIndex_; }

phiCenter() [1/2]

const EtaPhiCenterGrid& l1tpf_calo::SingleCaloClusterer::phiCenter ( ) const

inline

Definition at line 210 of file CaloClusterer.h.

References phi_center_.

{ return phi_center_; }

phiCenter() [2/2]

EtaPhiCenterGrid& l1tpf_calo::SingleCaloClusterer::phiCenter ( )

inline

Definition at line 220 of file CaloClusterer.h.

References phi_center_.

{ return phi_center_; }

raw() [1/2]

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

inline

Definition at line 208 of file CaloClusterer.h.

References rawet_.

{ return rawet_; }

raw() [2/2]

EtGrid& l1tpf_calo::SingleCaloClusterer::raw ( )

inline

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

Definition at line 218 of file CaloClusterer.h.

References rawet_.

{ return rawet_; }

run()

void l1tpf_calo::SingleCaloClusterer::run

(

)

Definition at line 229 of file CaloClusterer.cc.

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

Referenced by L1TPFCaloProducer::produce().

                                        {
  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 (const auto &ineigh : neighborCells_) {
        if (ineigh >= 4)
          continue;
        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 (const auto &ineigh : neighborCells_) {
        if (ineigh < 4)
          continue;
        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 (const auto &ineigh : neighborCells_) {
            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 (const auto &ineigh : neighborCells_) {
            maxet = std::max(maxet, precluster_.neigh(i, ineigh).ptLocalMax);
          }
          precluster_[i].ptOverNeighLocalMaxSum = maxet;
        } break;
        case EnergyShareAlgo::Crude: {
          int number = 0;
          for (const auto &ineigh : neighborCells_) {
            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 (const auto &ineigh : neighborCells_) {
        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 (const auto &ineigh : neighborCells_) {
          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();
}

Member Data Documentation

cellKey_

IndexGrid l1tpf_calo::SingleCaloClusterer::cellKey_

private

Definition at line 248 of file CaloClusterer.h.

clusterIndex_

IndexGrid l1tpf_calo::SingleCaloClusterer::clusterIndex_

private

Definition at line 248 of file CaloClusterer.h.

Referenced by cluster(), and indexGrid().

clusters_

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

private

Definition at line 253 of file CaloClusterer.h.

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

energyShareAlgo_

EnergyShareAlgo l1tpf_calo::SingleCaloClusterer::energyShareAlgo_

private

Definition at line 256 of file CaloClusterer.h.

Referenced by SingleCaloClusterer().

energyWeightedPosition_

bool l1tpf_calo::SingleCaloClusterer::energyWeightedPosition_

private

Definition at line 257 of file CaloClusterer.h.

eta_center_

EtaPhiCenterGrid l1tpf_calo::SingleCaloClusterer::eta_center_

private

Definition at line 245 of file CaloClusterer.h.

Referenced by add(), and etaCenter().

etaBounds_

std::vector<double> l1tpf_calo::SingleCaloClusterer::etaBounds_

private

Definition at line 250 of file CaloClusterer.h.

Referenced by SingleCaloClusterer().

grid_

const Grid* l1tpf_calo::SingleCaloClusterer::grid_

private

Definition at line 243 of file CaloClusterer.h.

maxClustersEtaPhi_

std::vector<unsigned int> l1tpf_calo::SingleCaloClusterer::maxClustersEtaPhi_

private

Definition at line 252 of file CaloClusterer.h.

Referenced by SingleCaloClusterer().

minClusterEt_

float l1tpf_calo::SingleCaloClusterer::minClusterEt_

private

Definition at line 255 of file CaloClusterer.h.

minEtToGrow_

float l1tpf_calo::SingleCaloClusterer::minEtToGrow_

private

Definition at line 255 of file CaloClusterer.h.

neighborCells_

std::vector<int> l1tpf_calo::SingleCaloClusterer::neighborCells_

private

Definition at line 258 of file CaloClusterer.h.

Referenced by SingleCaloClusterer().

nullCluster_

const Cluster l1tpf_calo::SingleCaloClusterer::nullCluster_

private

Definition at line 254 of file CaloClusterer.h.

Referenced by cluster().

phi_center_

EtaPhiCenterGrid l1tpf_calo::SingleCaloClusterer::phi_center_

private

Definition at line 246 of file CaloClusterer.h.

Referenced by add(), and phiCenter().

phiBounds_

std::vector<double> l1tpf_calo::SingleCaloClusterer::phiBounds_

private

Definition at line 251 of file CaloClusterer.h.

Referenced by SingleCaloClusterer().

preciseEtaPhi_

bool l1tpf_calo::SingleCaloClusterer::preciseEtaPhi_

private

Definition at line 249 of file CaloClusterer.h.

Referenced by add().

precluster_

PreClusterGrid l1tpf_calo::SingleCaloClusterer::precluster_

private

Definition at line 247 of file CaloClusterer.h.

rawet_

EtGrid l1tpf_calo::SingleCaloClusterer::rawet_

private

Definition at line 244 of file CaloClusterer.h.

Referenced by add(), and raw().

seedEt_

float l1tpf_calo::SingleCaloClusterer::seedEt_

private

Definition at line 255 of file CaloClusterer.h.

unclustered_

EtGrid l1tpf_calo::SingleCaloClusterer::unclustered_

private

Definition at line 244 of file CaloClusterer.h.

zsEt_

float l1tpf_calo::SingleCaloClusterer::zsEt_

private

Definition at line 255 of file CaloClusterer.h.