CaloTruthCellsProducer Class Reference

Inheritance diagram for CaloTruthCellsProducer:

Public Member Functions
	CaloTruthCellsProducer (edm::ParameterSet const &)
	~CaloTruthCellsProducer () 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 Types
typedef edm::AssociationMap < edm::OneToMany < CaloParticleCollection, l1t::HGCalTriggerCellBxCollection > >	CaloToCellsMap

Private Member Functions
void	beginRun (const edm::Run &, const edm::EventSetup &) override
std::unordered_map< uint32_t, double >	makeHitMap (edm::Event const &, edm::EventSetup const &, HGCalTriggerGeometryBase const &) const
void	produce (edm::Event &, edm::EventSetup const &) override

Private Attributes
edm::EDGetTokenT < CaloParticleCollection >	caloParticlesToken_
HGCalClusteringDummyImpl	dummyClustering_
bool	makeCellsCollection_
HGCalShowerShape	showerShape_
edm::EDGetTokenT< std::vector < PCaloHit > >	simHitsTokenEE_
edm::EDGetTokenT< std::vector < PCaloHit > >	simHitsTokenHEback_
edm::EDGetTokenT< std::vector < PCaloHit > >	simHitsTokenHEfront_
edm::EDGetTokenT < l1t::HGCalTriggerCellBxCollection >	triggerCellsToken_
edm::ESHandle < HGCalTriggerGeometryBase >	triggerGeomHandle_
edm::ESGetToken < HGCalTriggerGeometryBase, CaloGeometryRecord >	triggerGeomToken_
HGCalTriggerTools	triggerTools_

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 26 of file CaloTruthCellsProducer.cc.

Member Typedef Documentation

typedef edm::AssociationMap<edm::OneToMany<CaloParticleCollection, l1t::HGCalTriggerCellBxCollection> > CaloTruthCellsProducer::CaloToCellsMap

private

Definition at line 41 of file CaloTruthCellsProducer.cc.

Constructor & Destructor Documentation

CaloTruthCellsProducer::CaloTruthCellsProducer ( edm::ParameterSet const &  config )

explicit

Definition at line 58 of file CaloTruthCellsProducer.cc.

References makeCellsCollection_.

    : makeCellsCollection_(config.getParameter<bool>("makeCellsCollection")),
      caloParticlesToken_(consumes<CaloParticleCollection>(config.getParameter<edm::InputTag>("caloParticles"))),
      triggerCellsToken_(
          consumes<l1t::HGCalTriggerCellBxCollection>(config.getParameter<edm::InputTag>("triggerCells"))),
      simHitsTokenEE_(consumes<std::vector<PCaloHit>>(config.getParameter<edm::InputTag>("simHitsEE"))),
      simHitsTokenHEfront_(consumes<std::vector<PCaloHit>>(config.getParameter<edm::InputTag>("simHitsHEfront"))),
      simHitsTokenHEback_(consumes<std::vector<PCaloHit>>(config.getParameter<edm::InputTag>("simHitsHEback"))),
      triggerGeomToken_(esConsumes<HGCalTriggerGeometryBase, CaloGeometryRecord, edm::Transition::BeginRun>()),
      dummyClustering_(config.getParameterSet("dummyClustering")) {
  produces<CaloToCellsMap>();
  produces<l1t::HGCalClusterBxCollection>();
  produces<l1t::HGCalMulticlusterBxCollection>();
  if (makeCellsCollection_)
    produces<l1t::HGCalTriggerCellBxCollection>();
}

CaloTruthCellsProducer::~CaloTruthCellsProducer ( )

override

Definition at line 75 of file CaloTruthCellsProducer.cc.

{}

Member Function Documentation

void CaloTruthCellsProducer::beginRun ( const edm::Run &  , const edm::EventSetup &  es  )

overrideprivate

Definition at line 77 of file CaloTruthCellsProducer.cc.

References edm::EventSetup::getHandle(), triggerGeomHandle_, and triggerGeomToken_.

                                                                              {
  triggerGeomHandle_ = es.getHandle(triggerGeomToken_);
}

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

static

Definition at line 271 of file CaloTruthCellsProducer.cc.

References edm::ConfigurationDescriptions::addDefault(), submitPVResolutionJobs::desc, and edm::ParameterSetDescription::setUnknown().

                                                                                        {
  //The following says we do not know what parameters are allowed so do no validation
  // Please change this to state exactly what you do use, even if it is no parameters
  edm::ParameterSetDescription desc;
  desc.setUnknown();
  descriptions.addDefault(desc);
}

std::unordered_map< uint32_t, double > CaloTruthCellsProducer::makeHitMap ( edm::Event const &  event, edm::EventSetup const &  setup, HGCalTriggerGeometryBase const &  geometry  ) const

private

Definition at line 240 of file CaloTruthCellsProducer.cc.

References HGCalTriggerGeometryBase::eeTopology(), HGCalTriggerGeometryBase::fhTopology(), relativeConstraints::geometry, patZpeak::handle, HGCalTriggerGeometryBase::hscTopology(), simHitsTokenEE_, simHitsTokenHEback_, simHitsTokenHEfront_, HGCalTriggerTools::simToReco(), triggerTools_, and groupFilesInBlocks::tt.

Referenced by produce().

                                                                                                       {
  std::unordered_map<uint32_t, double> hitMap;  // cellId -> sim energy

  typedef std::function<DetId(DetId const&)> DetIdMapper;
  typedef std::pair<edm::EDGetTokenT<std::vector<PCaloHit>> const*, DetIdMapper> SimHitSpec;

  SimHitSpec specs[3] = {{&simHitsTokenEE_,
                          [this, &geometry](DetId const& simId) -> DetId {
                            return this->triggerTools_.simToReco(simId, geometry.eeTopology());
                          }},
                         {&simHitsTokenHEfront_,
                          [this, &geometry](DetId const& simId) -> DetId {
                            return this->triggerTools_.simToReco(simId, geometry.fhTopology());
                          }},
                         {&simHitsTokenHEback_, [this, &geometry](DetId const& simId) -> DetId {
                            return this->triggerTools_.simToReco(simId, geometry.hscTopology());
                          }}};

  for (auto const& tt : specs) {
    edm::Handle<std::vector<PCaloHit>> handle;
    event.getByToken(*tt.first, handle);
    auto const& simhits(*handle);

    for (auto const& simhit : simhits)
      hitMap.emplace(tt.second(simhit.id()), simhit.energy());
  }

  return hitMap;
}

void CaloTruthCellsProducer::produce ( edm::Event &  event, edm::EventSetup const &  setup  )

overrideprivate

Definition at line 81 of file CaloTruthCellsProducer.cc.

References l1t::HGCalClusterT< C >::addConstituent(), makePileupJSON::bx, caloTruthProducer_cfi::caloParticles, caloParticlesToken_, l1t::HGCalClusterT< C >::centre(), HGCalClusteringDummyImpl::clusterizeDummy(), dummyClustering_, HGCalShowerShape::fillShapes(), relativeConstraints::geometry, hcalSimParameters_cfi::he, makeCellsCollection_, makeHitMap(), eostools::move(), edm::ESHandle< class >::product(), edm::Event::put(), l1t::HGCalMulticluster::saveHOverE(), l1t::HGCalClusterT< C >::setDetId(), HGCalClusteringDummyImpl::setGeometry(), HGCalShowerShape::setGeometry(), HGCalTriggerTools::setGeometry(), reco::LeafCandidate::setP4(), showerShape_, l1t::HGCalClusterT< C >::sumPt(), triggerCellsToken_, triggerGeomHandle_, triggerTools_, and cms::Exception::what().

                                                                                {
  edm::Handle<CaloParticleCollection> caloParticlesHandle;
  event.getByToken(caloParticlesToken_, caloParticlesHandle);
  auto const& caloParticles(*caloParticlesHandle);

  edm::Handle<l1t::HGCalTriggerCellBxCollection> triggerCellsHandle;
  event.getByToken(triggerCellsToken_, triggerCellsHandle);
  auto const& triggerCells(*triggerCellsHandle);

  auto const& geometry(*triggerGeomHandle_);

  dummyClustering_.setGeometry(triggerGeomHandle_.product());
  showerShape_.setGeometry(triggerGeomHandle_.product());
  triggerTools_.setGeometry(triggerGeomHandle_.product());

  std::unordered_map<uint32_t, CaloParticleRef> tcToCalo;

  std::unordered_map<uint32_t, double> hitToEnergy(makeHitMap(event, setup, geometry));  // cellId -> sim energy
  std::unordered_map<uint32_t, std::pair<double, double>>
      tcToEnergies;  // tcId -> {total sim energy, fractioned sim energy}

  for (auto const& he : hitToEnergy) {
    DetId hitId(he.first);
    // this line will throw if (for whatever reason) hitId is not mapped to a trigger cell id
    uint32_t tcId(geometry.getTriggerCellFromCell(hitId));
    tcToEnergies[tcId].first += he.second;
  }

  // used later to order multiclusters
  std::map<int, CaloParticleRef> orderedCaloRefs;

  for (unsigned iP(0); iP != caloParticles.size(); ++iP) {
    auto const& caloParticle(caloParticles.at(iP));
    if (caloParticle.g4Tracks().at(0).eventId().event() != 0)  // pileup
      continue;

    CaloParticleRef ref(caloParticlesHandle, iP);

    SimClusterRefVector const& simClusters(caloParticle.simClusters());
    for (auto const& simCluster : simClusters) {
      for (auto const& hAndF : simCluster->hits_and_fractions()) {
        DetId hitId(hAndF.first);
        uint32_t tcId;
        try {
          tcId = geometry.getTriggerCellFromCell(hitId);
        } catch (cms::Exception const& ex) {
          edm::LogError("CaloTruthCellsProducer") << ex.what();
          continue;
        }

        tcToCalo.emplace(tcId, ref);
        tcToEnergies[tcId].second += hitToEnergy[hAndF.first] * hAndF.second;
      }
    }

    // ordered by the gen particle index
    int genIndex(caloParticle.g4Tracks().at(0).genpartIndex() - 1);
    orderedCaloRefs[genIndex] = ref;
  }

  auto outMap(std::make_unique<CaloToCellsMap>(caloParticlesHandle, triggerCellsHandle));
  std::unique_ptr<l1t::HGCalTriggerCellBxCollection> outCollection;
  if (makeCellsCollection_)
    outCollection = std::make_unique<l1t::HGCalTriggerCellBxCollection>();

  typedef edm::Ptr<l1t::HGCalTriggerCell> TriggerCellPtr;
  typedef edm::Ptr<l1t::HGCalCluster> ClusterPtr;

  // ClusteringDummyImpl only considers BX 0, so we dump all cells to one vector
  std::vector<TriggerCellPtr> triggerCellPtrs;

  // loop through all bunch crossings
  for (int bx(triggerCells.getFirstBX()); bx <= triggerCells.getLastBX(); ++bx) {
    for (auto cItr(triggerCells.begin(bx)); cItr != triggerCells.end(bx); ++cItr) {
      auto const& cell(*cItr);

      auto mapElem(tcToCalo.find(cell.detId()));
      if (mapElem == tcToCalo.end())
        continue;

      outMap->insert(mapElem->second,
                     edm::Ref<l1t::HGCalTriggerCellBxCollection>(triggerCellsHandle, triggerCells.key(cItr)));

      if (makeCellsCollection_) {
        auto const& simEnergies(tcToEnergies.at(cell.detId()));
        if (simEnergies.first > 0.) {
          double eFraction(simEnergies.second / simEnergies.first);

          outCollection->push_back(bx, cell);
          auto& newCell((*outCollection)[outCollection->size() - 1]);

          newCell.setMipPt(cell.mipPt() * eFraction);
          newCell.setP4(cell.p4() * eFraction);
        }
      }

      triggerCellPtrs.emplace_back(triggerCellsHandle, triggerCells.key(cItr));
    }
  }

  event.put(std::move(outMap));
  if (makeCellsCollection_)
    event.put(std::move(outCollection));

  auto outClusters(std::make_unique<l1t::HGCalClusterBxCollection>());

  auto sortCellPtrs(
      [](TriggerCellPtr const& lhs, TriggerCellPtr const& rhs) -> bool { return lhs->mipPt() > rhs->mipPt(); });

  std::sort(triggerCellPtrs.begin(), triggerCellPtrs.end(), sortCellPtrs);
  dummyClustering_.clusterizeDummy(triggerCellPtrs, *outClusters);

  std::unordered_map<unsigned, std::vector<unsigned>> caloToClusterIndices;
  for (unsigned iC(0); iC != outClusters->size(); ++iC) {
    auto const& cluster((*outClusters)[iC]);
    // cluster detId and cell detId are identical
    auto caloRef(tcToCalo.at(cluster.detId()));
    caloToClusterIndices[caloRef.key()].push_back(iC);
  }

  auto clustersHandle(event.put(std::move(outClusters)));

  auto outMulticlusters(std::make_unique<l1t::HGCalMulticlusterBxCollection>());

  for (auto const& ocr : orderedCaloRefs) {
    auto const& ref(ocr.second);

    if (ref.isNull())  // shouldn't happen
      continue;

    auto const& caloParticle(*ref);

    l1t::HGCalMulticluster multicluster;

    for (unsigned iC : caloToClusterIndices[ref.key()]) {
      ClusterPtr clPtr(clustersHandle, iC);
      multicluster.addConstituent(clPtr, true, 1.);
    }

    // Set the gen particle index as the DetId
    multicluster.setDetId(caloParticle.g4Tracks().at(0).genpartIndex() - 1);

    auto const& centre(multicluster.centre());
    math::PtEtaPhiMLorentzVector multiclusterP4(multicluster.sumPt(), centre.eta(), centre.phi(), 0.);
    multicluster.setP4(multiclusterP4);

    showerShape_.fillShapes(multicluster, geometry);

    // not setting the quality flag
    // multicluster.setHwQual(id_->decision(multicluster));
    // fill H/E
    multicluster.saveHOverE();

    outMulticlusters->push_back(0, multicluster);
  }

  event.put(std::move(outMulticlusters));
}

Member Data Documentation

edm::EDGetTokenT<CaloParticleCollection> CaloTruthCellsProducer::caloParticlesToken_

private

Definition at line 44 of file CaloTruthCellsProducer.cc.

Referenced by produce().

HGCalClusteringDummyImpl CaloTruthCellsProducer::dummyClustering_

private

Definition at line 52 of file CaloTruthCellsProducer.cc.

Referenced by produce().

bool CaloTruthCellsProducer::makeCellsCollection_

private

Definition at line 43 of file CaloTruthCellsProducer.cc.

Referenced by CaloTruthCellsProducer(), and produce().

HGCalShowerShape CaloTruthCellsProducer::showerShape_

private

Definition at line 53 of file CaloTruthCellsProducer.cc.

Referenced by produce().

edm::EDGetTokenT<std::vector<PCaloHit> > CaloTruthCellsProducer::simHitsTokenEE_

private

Definition at line 46 of file CaloTruthCellsProducer.cc.

Referenced by makeHitMap().

edm::EDGetTokenT<std::vector<PCaloHit> > CaloTruthCellsProducer::simHitsTokenHEback_

private

Definition at line 48 of file CaloTruthCellsProducer.cc.

Referenced by makeHitMap().

edm::EDGetTokenT<std::vector<PCaloHit> > CaloTruthCellsProducer::simHitsTokenHEfront_

private

Definition at line 47 of file CaloTruthCellsProducer.cc.

Referenced by makeHitMap().

edm::EDGetTokenT<l1t::HGCalTriggerCellBxCollection> CaloTruthCellsProducer::triggerCellsToken_

private

Definition at line 45 of file CaloTruthCellsProducer.cc.

Referenced by produce().

edm::ESHandle<HGCalTriggerGeometryBase> CaloTruthCellsProducer::triggerGeomHandle_

private

Definition at line 50 of file CaloTruthCellsProducer.cc.

Referenced by beginRun(), and produce().

edm::ESGetToken<HGCalTriggerGeometryBase, CaloGeometryRecord> CaloTruthCellsProducer::triggerGeomToken_

private

Definition at line 49 of file CaloTruthCellsProducer.cc.

Referenced by beginRun().

HGCalTriggerTools CaloTruthCellsProducer::triggerTools_

private

Definition at line 55 of file CaloTruthCellsProducer.cc.

Referenced by makeHitMap(), and produce().