Skip to content

Commit 4302286

Browse files
thomreisthomreis
committed
Make EcalUncalibRecHitSoAToLegacy a global module.
1 parent 1ac1ab8 commit 4302286

File tree

2 files changed

+67
-50
lines changed

2 files changed

+67
-50
lines changed

‎HLTrigger/Configuration/python/customizeHLTforCMSSW.py‎

Lines changed: 19 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -48,12 +48,31 @@ def customiseForOffline(process):
4848

4949
return process
5050

51+
def customizeHLTfor46935(process):
52+
"""Changes parameter names of EcalUncalibRecHitSoAToLegacy producer"""
53+
for prod in producers_by_type(process, 'EcalUncalibRecHitSoAToLegacy'):
54+
if hasattr(prod, 'uncalibRecHitsPortableEB'):
55+
prod.inputCollectionEB = prod.uncalibRecHitsPortableEB
56+
delattr(prod, 'uncalibRecHitsPortableEB')
57+
if hasattr(prod, 'uncalibRecHitsPortableEE'):
58+
prod.inputCollectionEE = prod.uncalibRecHitsPortableEE
59+
delattr(prod, 'uncalibRecHitsPortableEE')
60+
if hasattr(prod, 'recHitsLabelCPUEB'):
61+
prod.outputLabelEB = prod.recHitsLabelCPUEB
62+
delattr(prod, 'recHitsLabelCPUEB')
63+
if hasattr(prod, 'recHitsLabelCPUEE'):
64+
prod.outputLabelEE = prod.recHitsLabelCPUEE
65+
delattr(prod, 'recHitsLabelCPUEE')
66+
return process
67+
5168
# CMSSW version specific customizations
5269
def customizeHLTforCMSSW(process, menuType="GRun"):
5370

5471
process = customiseForOffline(process)
5572

5673
# add call to action function in proper order: newest last!
5774
# process = customiseFor12718(process)
75+
76+
process = customizeHLTfor46935(process)
5877

5978
return process

‎RecoLocalCalo/EcalRecProducers/plugins/EcalUncalibRecHitSoAToLegacy.cc‎

Lines changed: 48 additions & 50 deletions
Original file line numberDiff line numberDiff line change
@@ -4,101 +4,99 @@
44
#include "FWCore/Framework/interface/Event.h"
55
#include "FWCore/Framework/interface/EventSetup.h"
66
#include "FWCore/Framework/interface/MakerMacros.h"
7-
#include "FWCore/Framework/interface/stream/EDProducer.h"
7+
#include "FWCore/Framework/interface/global/EDProducer.h"
88
#include "FWCore/ParameterSet/interface/ParameterSet.h"
99
#include "FWCore/ParameterSet/interface/EmptyGroupDescription.h"
1010
#include "FWCore/Utilities/interface/EDGetToken.h"
1111
#include "FWCore/Utilities/interface/EDPutToken.h"
1212
#include "DataFormats/EcalRecHit/interface/EcalUncalibratedRecHitHostCollection.h"
1313

14-
class EcalUncalibRecHitSoAToLegacy : public edm::stream::EDProducer<> {
14+
class EcalUncalibRecHitSoAToLegacy : public edm::global::EDProducer<> {
1515
public:
1616
explicit EcalUncalibRecHitSoAToLegacy(edm::ParameterSet const &ps);
1717
~EcalUncalibRecHitSoAToLegacy() override = default;
1818
static void fillDescriptions(edm::ConfigurationDescriptions &);
1919

2020
private:
2121
using InputProduct = EcalUncalibratedRecHitHostCollection;
22-
void produce(edm::Event &, edm::EventSetup const &) override;
22+
void produce(edm::StreamID, edm::Event &, edm::EventSetup const &) const override;
2323

2424
private:
2525
const bool isPhase2_;
26-
const edm::EDGetTokenT<InputProduct> uncalibRecHitsPortableEB_;
27-
const edm::EDGetTokenT<InputProduct> uncalibRecHitsPortableEE_;
28-
const edm::EDPutTokenT<EBUncalibratedRecHitCollection> uncalibRecHitsCPUEBToken_;
29-
const edm::EDPutTokenT<EEUncalibratedRecHitCollection> uncalibRecHitsCPUEEToken_;
26+
const edm::EDGetTokenT<InputProduct> inputTokenEB_;
27+
const edm::EDGetTokenT<InputProduct> inputTokenEE_;
28+
const edm::EDPutTokenT<EBUncalibratedRecHitCollection> outputTokenEB_;
29+
const edm::EDPutTokenT<EEUncalibratedRecHitCollection> outputTokenEE_;
3030
};
3131

3232
void EcalUncalibRecHitSoAToLegacy::fillDescriptions(edm::ConfigurationDescriptions &confDesc) {
3333
edm::ParameterSetDescription desc;
3434

35-
desc.add<edm::InputTag>("uncalibRecHitsPortableEB",
35+
desc.add<edm::InputTag>("inputCollectionEB",
3636
edm::InputTag("ecalMultiFitUncalibRecHitPortable", "EcalUncalibRecHitsEB"));
37-
desc.add<std::string>("recHitsLabelCPUEB", "EcalUncalibRecHitsEB");
37+
desc.add<std::string>("outputLabelEB", "EcalUncalibRecHitsEB");
3838
desc.ifValue(edm::ParameterDescription<bool>("isPhase2", false, true),
3939
false >> (edm::ParameterDescription<edm::InputTag>(
40-
"uncalibRecHitsPortableEE",
40+
"inputCollectionEE",
4141
edm::InputTag("ecalMultiFitUncalibRecHitPortable", "EcalUncalibRecHitsEE"),
4242
true) and
43-
edm::ParameterDescription<std::string>("recHitsLabelCPUEE", "EcalUncalibRecHitsEE", true)) or
43+
edm::ParameterDescription<std::string>("outputLabelEE", "EcalUncalibRecHitsEE", true)) or
4444
true >> edm::EmptyGroupDescription());
4545
confDesc.add("ecalUncalibRecHitSoAToLegacy", desc);
4646
}
4747

4848
EcalUncalibRecHitSoAToLegacy::EcalUncalibRecHitSoAToLegacy(edm::ParameterSet const &ps)
4949
: isPhase2_{ps.getParameter<bool>("isPhase2")},
50-
uncalibRecHitsPortableEB_{consumes<InputProduct>(ps.getParameter<edm::InputTag>("uncalibRecHitsPortableEB"))},
51-
uncalibRecHitsPortableEE_{
52-
isPhase2_ ? edm::EDGetTokenT<InputProduct>{}
53-
: consumes<InputProduct>(ps.getParameter<edm::InputTag>("uncalibRecHitsPortableEE"))},
54-
uncalibRecHitsCPUEBToken_{
55-
produces<EBUncalibratedRecHitCollection>(ps.getParameter<std::string>("recHitsLabelCPUEB"))},
56-
uncalibRecHitsCPUEEToken_{
57-
isPhase2_ ? edm::EDPutTokenT<EEUncalibratedRecHitCollection>{}
58-
: produces<EEUncalibratedRecHitCollection>(ps.getParameter<std::string>("recHitsLabelCPUEE"))} {}
50+
inputTokenEB_{consumes<InputProduct>(ps.getParameter<edm::InputTag>("inputCollectionEB"))},
51+
inputTokenEE_{isPhase2_ ? edm::EDGetTokenT<InputProduct>{}
52+
: consumes<InputProduct>(ps.getParameter<edm::InputTag>("inputCollectionEE"))},
53+
outputTokenEB_{produces<EBUncalibratedRecHitCollection>(ps.getParameter<std::string>("outputLabelEB"))},
54+
outputTokenEE_{isPhase2_
55+
? edm::EDPutTokenT<EEUncalibratedRecHitCollection>{}
56+
: produces<EEUncalibratedRecHitCollection>(ps.getParameter<std::string>("outputLabelEE"))} {}
5957

60-
void EcalUncalibRecHitSoAToLegacy::produce(edm::Event &event, edm::EventSetup const &setup) {
61-
auto const &uncalRecHitsEBColl = event.get(uncalibRecHitsPortableEB_);
62-
auto const &uncalRecHitsEBCollView = uncalRecHitsEBColl.const_view();
63-
auto recHitsCPUEB = std::make_unique<EBUncalibratedRecHitCollection>();
64-
recHitsCPUEB->reserve(uncalRecHitsEBCollView.size());
58+
void EcalUncalibRecHitSoAToLegacy::produce(edm::StreamID sid, edm::Event &event, edm::EventSetup const &setup) const {
59+
auto const &inputCollEB = event.get(inputTokenEB_);
60+
auto const &inputCollEBView = inputCollEB.const_view();
61+
auto outputCollEB = std::make_unique<EBUncalibratedRecHitCollection>();
62+
outputCollEB->reserve(inputCollEBView.size());
6563

66-
for (uint32_t i = 0; i < uncalRecHitsEBCollView.size(); ++i) {
67-
recHitsCPUEB->emplace_back(DetId{uncalRecHitsEBCollView.id()[i]},
68-
uncalRecHitsEBCollView.amplitude()[i],
69-
uncalRecHitsEBCollView.pedestal()[i],
70-
uncalRecHitsEBCollView.jitter()[i],
71-
uncalRecHitsEBCollView.chi2()[i],
72-
uncalRecHitsEBCollView.flags()[i]);
64+
for (uint32_t i = 0; i < inputCollEBView.size(); ++i) {
65+
outputCollEB->emplace_back(DetId{inputCollEBView.id()[i]},
66+
inputCollEBView.amplitude()[i],
67+
inputCollEBView.pedestal()[i],
68+
inputCollEBView.jitter()[i],
69+
inputCollEBView.chi2()[i],
70+
inputCollEBView.flags()[i]);
7371
if (isPhase2_) {
74-
(*recHitsCPUEB)[i].setAmplitudeError(uncalRecHitsEBCollView.amplitudeError()[i]);
72+
(*outputCollEB)[i].setAmplitudeError(inputCollEBView.amplitudeError()[i]);
7573
}
76-
(*recHitsCPUEB)[i].setJitterError(uncalRecHitsEBCollView.jitterError()[i]);
74+
(*outputCollEB)[i].setJitterError(inputCollEBView.jitterError()[i]);
7775
for (uint32_t sample = 0; sample < EcalDataFrame::MAXSAMPLES; ++sample) {
78-
(*recHitsCPUEB)[i].setOutOfTimeAmplitude(sample, uncalRecHitsEBCollView.outOfTimeAmplitudes()[i][sample]);
76+
(*outputCollEB)[i].setOutOfTimeAmplitude(sample, inputCollEBView.outOfTimeAmplitudes()[i][sample]);
7977
}
8078
}
81-
event.put(uncalibRecHitsCPUEBToken_, std::move(recHitsCPUEB));
79+
event.put(outputTokenEB_, std::move(outputCollEB));
8280

8381
if (!isPhase2_) {
84-
auto const &uncalRecHitsEEColl = event.get(uncalibRecHitsPortableEE_);
85-
auto const &uncalRecHitsEECollView = uncalRecHitsEEColl.const_view();
86-
auto recHitsCPUEE = std::make_unique<EEUncalibratedRecHitCollection>();
87-
recHitsCPUEE->reserve(uncalRecHitsEECollView.size());
82+
auto const &inputCollEE = event.get(inputTokenEE_);
83+
auto const &inputCollEEView = inputCollEE.const_view();
84+
auto outputCollEE = std::make_unique<EEUncalibratedRecHitCollection>();
85+
outputCollEE->reserve(inputCollEEView.size());
8886

89-
for (uint32_t i = 0; i < uncalRecHitsEECollView.size(); ++i) {
90-
recHitsCPUEE->emplace_back(DetId{uncalRecHitsEECollView.id()[i]},
91-
uncalRecHitsEECollView.amplitude()[i],
92-
uncalRecHitsEECollView.pedestal()[i],
93-
uncalRecHitsEECollView.jitter()[i],
94-
uncalRecHitsEECollView.chi2()[i],
95-
uncalRecHitsEECollView.flags()[i]);
96-
(*recHitsCPUEE)[i].setJitterError(uncalRecHitsEECollView.jitterError()[i]);
87+
for (uint32_t i = 0; i < inputCollEEView.size(); ++i) {
88+
outputCollEE->emplace_back(DetId{inputCollEEView.id()[i]},
89+
inputCollEEView.amplitude()[i],
90+
inputCollEEView.pedestal()[i],
91+
inputCollEEView.jitter()[i],
92+
inputCollEEView.chi2()[i],
93+
inputCollEEView.flags()[i]);
94+
(*outputCollEE)[i].setJitterError(inputCollEEView.jitterError()[i]);
9795
for (uint32_t sample = 0; sample < EcalDataFrame::MAXSAMPLES; ++sample) {
98-
(*recHitsCPUEE)[i].setOutOfTimeAmplitude(sample, uncalRecHitsEECollView.outOfTimeAmplitudes()[i][sample]);
96+
(*outputCollEE)[i].setOutOfTimeAmplitude(sample, inputCollEEView.outOfTimeAmplitudes()[i][sample]);
9997
}
10098
}
101-
event.put(uncalibRecHitsCPUEEToken_, std::move(recHitsCPUEE));
99+
event.put(outputTokenEE_, std::move(outputCollEE));
102100
}
103101
}
104102

0 commit comments

Comments
 (0)