File indexing completed on 2023-06-05 01:26:12
0001
0002
0003
0004
0005
0006
0007
0008
0009
0010
0011
0012
0013
0014
0015
0016
0017
0018 #include "DataFormats/Scouting/interface/Run3ScoutingCaloJet.h"
0019 #include "DataFormats/Scouting/interface/Run3ScoutingElectron.h"
0020 #include "DataFormats/Scouting/interface/Run3ScoutingHitPatternPOD.h"
0021 #include "DataFormats/Scouting/interface/Run3ScoutingMuon.h"
0022 #include "DataFormats/Scouting/interface/Run3ScoutingParticle.h"
0023 #include "DataFormats/Scouting/interface/Run3ScoutingPFJet.h"
0024 #include "DataFormats/Scouting/interface/Run3ScoutingPhoton.h"
0025 #include "DataFormats/Scouting/interface/Run3ScoutingTrack.h"
0026 #include "DataFormats/Scouting/interface/Run3ScoutingVertex.h"
0027 #include "FWCore/Framework/interface/Event.h"
0028 #include "FWCore/Framework/interface/Frameworkfwd.h"
0029 #include "FWCore/Framework/interface/global/EDProducer.h"
0030 #include "FWCore/Framework/interface/MakerMacros.h"
0031 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
0032 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0033 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
0034 #include "FWCore/Utilities/interface/EDPutToken.h"
0035 #include "FWCore/Utilities/interface/Exception.h"
0036 #include "FWCore/Utilities/interface/StreamID.h"
0037
0038 #include <memory>
0039 #include <utility>
0040 #include <vector>
0041
0042 namespace edmtest {
0043
0044 class TestWriteRun3Scouting : public edm::global::EDProducer<> {
0045 public:
0046 TestWriteRun3Scouting(edm::ParameterSet const&);
0047 void produce(edm::StreamID, edm::Event&, edm::EventSetup const&) const override;
0048 static void fillDescriptions(edm::ConfigurationDescriptions&);
0049
0050 private:
0051 void produceCaloJets(edm::Event&) const;
0052 void produceElectrons(edm::Event&) const;
0053 void produceMuons(edm::Event&) const;
0054 void produceParticles(edm::Event&) const;
0055 void producePFJets(edm::Event&) const;
0056 void producePhotons(edm::Event&) const;
0057 void produceTracks(edm::Event&) const;
0058 void produceVertexes(edm::Event&) const;
0059
0060 void throwWithMessage(const char*) const;
0061
0062 const std::vector<double> caloJetsValues_;
0063 const edm::EDPutTokenT<std::vector<Run3ScoutingCaloJet>> caloJetsPutToken_;
0064
0065 const std::vector<double> electronsFloatingPointValues_;
0066 const std::vector<int> electronsIntegralValues_;
0067 const edm::EDPutTokenT<std::vector<Run3ScoutingElectron>> electronsPutToken_;
0068
0069 const std::vector<double> muonsFloatingPointValues_;
0070 const std::vector<int> muonsIntegralValues_;
0071 const edm::EDPutTokenT<std::vector<Run3ScoutingMuon>> muonsPutToken_;
0072
0073 const std::vector<double> particlesFloatingPointValues_;
0074 const std::vector<int> particlesIntegralValues_;
0075 const edm::EDPutTokenT<std::vector<Run3ScoutingParticle>> particlesPutToken_;
0076
0077 const std::vector<double> pfJetsFloatingPointValues_;
0078 const std::vector<int> pfJetsIntegralValues_;
0079 const edm::EDPutTokenT<std::vector<Run3ScoutingPFJet>> pfJetsPutToken_;
0080
0081 const std::vector<double> photonsFloatingPointValues_;
0082 const std::vector<int> photonsIntegralValues_;
0083 const edm::EDPutTokenT<std::vector<Run3ScoutingPhoton>> photonsPutToken_;
0084
0085 const std::vector<double> tracksFloatingPointValues_;
0086 const std::vector<int> tracksIntegralValues_;
0087 const edm::EDPutTokenT<std::vector<Run3ScoutingTrack>> tracksPutToken_;
0088
0089 const std::vector<double> vertexesFloatingPointValues_;
0090 const std::vector<int> vertexesIntegralValues_;
0091 const edm::EDPutTokenT<std::vector<Run3ScoutingVertex>> vertexesPutToken_;
0092 };
0093
0094 TestWriteRun3Scouting::TestWriteRun3Scouting(edm::ParameterSet const& iPSet)
0095 : caloJetsValues_(iPSet.getParameter<std::vector<double>>("caloJetsValues")),
0096 caloJetsPutToken_(produces()),
0097 electronsFloatingPointValues_(iPSet.getParameter<std::vector<double>>("electronsFloatingPointValues")),
0098 electronsIntegralValues_(iPSet.getParameter<std::vector<int>>("electronsIntegralValues")),
0099 electronsPutToken_(produces()),
0100 muonsFloatingPointValues_(iPSet.getParameter<std::vector<double>>("muonsFloatingPointValues")),
0101 muonsIntegralValues_(iPSet.getParameter<std::vector<int>>("muonsIntegralValues")),
0102 muonsPutToken_(produces()),
0103 particlesFloatingPointValues_(iPSet.getParameter<std::vector<double>>("particlesFloatingPointValues")),
0104 particlesIntegralValues_(iPSet.getParameter<std::vector<int>>("particlesIntegralValues")),
0105 particlesPutToken_(produces()),
0106 pfJetsFloatingPointValues_(iPSet.getParameter<std::vector<double>>("pfJetsFloatingPointValues")),
0107 pfJetsIntegralValues_(iPSet.getParameter<std::vector<int>>("pfJetsIntegralValues")),
0108 pfJetsPutToken_(produces()),
0109 photonsFloatingPointValues_(iPSet.getParameter<std::vector<double>>("photonsFloatingPointValues")),
0110 photonsIntegralValues_(iPSet.getParameter<std::vector<int>>("photonsIntegralValues")),
0111 photonsPutToken_(produces()),
0112 tracksFloatingPointValues_(iPSet.getParameter<std::vector<double>>("tracksFloatingPointValues")),
0113 tracksIntegralValues_(iPSet.getParameter<std::vector<int>>("tracksIntegralValues")),
0114 tracksPutToken_(produces()),
0115 vertexesFloatingPointValues_(iPSet.getParameter<std::vector<double>>("vertexesFloatingPointValues")),
0116 vertexesIntegralValues_(iPSet.getParameter<std::vector<int>>("vertexesIntegralValues")),
0117 vertexesPutToken_(produces()) {
0118 if (caloJetsValues_.size() != 16) {
0119 throwWithMessage("caloJetsValues must have 16 elements and it does not");
0120 }
0121 if (electronsFloatingPointValues_.size() != 25) {
0122 throwWithMessage("electronsFloatingPointValues must have 25 elements and it does not");
0123 }
0124 if (electronsIntegralValues_.size() != 6) {
0125 throwWithMessage("electronsIntegralValues must have 6 elements and it does not");
0126 }
0127 if (muonsFloatingPointValues_.size() != 37) {
0128 throwWithMessage("muonsFloatingPointValues must have 37 elements and it does not");
0129 }
0130 if (muonsIntegralValues_.size() != 26) {
0131 throwWithMessage("muonsIntegralValues must have 26 elements and it does not");
0132 }
0133 if (particlesFloatingPointValues_.size() != 11) {
0134 throwWithMessage("particlesFloatingPointValues must have 11 elements and it does not");
0135 }
0136 if (particlesIntegralValues_.size() != 5) {
0137 throwWithMessage("particlesIntegralValues must have 5 elements and it does not");
0138 }
0139 if (pfJetsFloatingPointValues_.size() != 15) {
0140 throwWithMessage("pfJetsFloatingPointValues must have 15 elements and it does not");
0141 }
0142 if (pfJetsIntegralValues_.size() != 8) {
0143 throwWithMessage("pfJetsIntegralValues must have 8 elements and it does not");
0144 }
0145 if (photonsFloatingPointValues_.size() != 14) {
0146 throwWithMessage("photonsFloatingPointValues must have 14 elements and it does not");
0147 }
0148 if (photonsIntegralValues_.size() != 3) {
0149 throwWithMessage("photonsIntegralValues must have 3 elements and it does not");
0150 }
0151 if (tracksFloatingPointValues_.size() != 29) {
0152 throwWithMessage("tracksFloatingPointValues must have 29 elements and it does not");
0153 }
0154 if (tracksIntegralValues_.size() != 5) {
0155 throwWithMessage("tracksIntegralValues must have 5 elements and it does not");
0156 }
0157 if (vertexesFloatingPointValues_.size() != 7) {
0158 throwWithMessage("vertexesFloatingPointValues must have 7 elements and it does not");
0159 }
0160 if (vertexesIntegralValues_.size() != 3) {
0161 throwWithMessage("vertexesIntegralValues must have 3 elements and it does not");
0162 }
0163 }
0164
0165 void TestWriteRun3Scouting::produce(edm::StreamID, edm::Event& iEvent, edm::EventSetup const&) const {
0166
0167
0168
0169
0170
0171
0172 produceCaloJets(iEvent);
0173 produceElectrons(iEvent);
0174 produceMuons(iEvent);
0175 produceParticles(iEvent);
0176 producePFJets(iEvent);
0177 producePhotons(iEvent);
0178 produceTracks(iEvent);
0179 produceVertexes(iEvent);
0180 }
0181
0182 void TestWriteRun3Scouting::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0183 edm::ParameterSetDescription desc;
0184 desc.add<std::vector<double>>("caloJetsValues");
0185 desc.add<std::vector<double>>("electronsFloatingPointValues");
0186 desc.add<std::vector<int>>("electronsIntegralValues");
0187 desc.add<std::vector<double>>("muonsFloatingPointValues");
0188 desc.add<std::vector<int>>("muonsIntegralValues");
0189 desc.add<std::vector<double>>("particlesFloatingPointValues");
0190 desc.add<std::vector<int>>("particlesIntegralValues");
0191 desc.add<std::vector<double>>("pfJetsFloatingPointValues");
0192 desc.add<std::vector<int>>("pfJetsIntegralValues");
0193 desc.add<std::vector<double>>("photonsFloatingPointValues");
0194 desc.add<std::vector<int>>("photonsIntegralValues");
0195 desc.add<std::vector<double>>("tracksFloatingPointValues");
0196 desc.add<std::vector<int>>("tracksIntegralValues");
0197 desc.add<std::vector<double>>("vertexesFloatingPointValues");
0198 desc.add<std::vector<int>>("vertexesIntegralValues");
0199 descriptions.addDefault(desc);
0200 }
0201
0202 void TestWriteRun3Scouting::produceCaloJets(edm::Event& iEvent) const {
0203 auto run3ScoutingCaloJets = std::make_unique<std::vector<Run3ScoutingCaloJet>>();
0204 unsigned int vectorSize = 2 + iEvent.id().event() % 4;
0205 run3ScoutingCaloJets->reserve(vectorSize);
0206 for (unsigned int i = 0; i < vectorSize; ++i) {
0207 double offset = static_cast<double>(iEvent.id().event() + i);
0208 run3ScoutingCaloJets->emplace_back(static_cast<float>(caloJetsValues_[0] + offset),
0209 static_cast<float>(caloJetsValues_[1] + offset),
0210 static_cast<float>(caloJetsValues_[2] + offset),
0211 static_cast<float>(caloJetsValues_[3] + offset),
0212 static_cast<float>(caloJetsValues_[4] + offset),
0213 static_cast<float>(caloJetsValues_[5] + offset),
0214 static_cast<float>(caloJetsValues_[6] + offset),
0215 static_cast<float>(caloJetsValues_[7] + offset),
0216 static_cast<float>(caloJetsValues_[8] + offset),
0217 static_cast<float>(caloJetsValues_[9] + offset),
0218 static_cast<float>(caloJetsValues_[10] + offset),
0219 static_cast<float>(caloJetsValues_[11] + offset),
0220 static_cast<float>(caloJetsValues_[12] + offset),
0221 static_cast<float>(caloJetsValues_[13] + offset),
0222 static_cast<float>(caloJetsValues_[14] + offset),
0223 static_cast<float>(caloJetsValues_[15] + offset));
0224 }
0225 iEvent.put(caloJetsPutToken_, std::move(run3ScoutingCaloJets));
0226 }
0227
0228 void TestWriteRun3Scouting::produceElectrons(edm::Event& iEvent) const {
0229 auto run3ScoutingElectrons = std::make_unique<std::vector<Run3ScoutingElectron>>();
0230 unsigned int vectorSize = 2 + iEvent.id().event() % 4;
0231 run3ScoutingElectrons->reserve(vectorSize);
0232 for (unsigned int i = 0; i < vectorSize; ++i) {
0233 double offset = static_cast<double>(iEvent.id().event() + i);
0234 int iOffset = static_cast<int>(iEvent.id().event() + i);
0235
0236
0237
0238
0239
0240
0241
0242 std::vector<float> trkd0;
0243 std::vector<float> trkdz;
0244 std::vector<float> trkpt;
0245 std::vector<float> trketa;
0246 std::vector<float> trkphi;
0247 std::vector<float> trkchi2overndf;
0248 std::vector<int> trkcharge;
0249 std::vector<float> energyMatrix;
0250 std::vector<unsigned int> detIds;
0251 std::vector<float> timingMatrix;
0252 trkd0.reserve(vectorSize);
0253 trkdz.reserve(vectorSize);
0254 trkpt.reserve(vectorSize);
0255 trketa.reserve(vectorSize);
0256 trkphi.reserve(vectorSize);
0257 trkchi2overndf.reserve(vectorSize);
0258 trkcharge.reserve(vectorSize);
0259 energyMatrix.reserve(vectorSize);
0260 detIds.reserve(vectorSize);
0261 timingMatrix.reserve(vectorSize);
0262 for (unsigned int j = 0; j < vectorSize; ++j) {
0263 trkd0.push_back(static_cast<float>(electronsFloatingPointValues_[19] + offset + j * 10));
0264 trkdz.push_back(static_cast<float>(electronsFloatingPointValues_[20] + offset + j * 10));
0265 trkpt.push_back(static_cast<float>(electronsFloatingPointValues_[21] + offset + j * 10));
0266 trketa.push_back(static_cast<float>(electronsFloatingPointValues_[22] + offset + j * 10));
0267 trkphi.push_back(static_cast<float>(electronsFloatingPointValues_[23] + offset + j * 10));
0268 trkchi2overndf.push_back(static_cast<float>(electronsFloatingPointValues_[24] + offset + j * 10));
0269 trkcharge.push_back(static_cast<int>(electronsIntegralValues_[5] + offset + j * 10));
0270 energyMatrix.push_back(static_cast<float>(electronsFloatingPointValues_[17] + offset + j * 10));
0271 detIds.push_back(static_cast<uint32_t>(electronsIntegralValues_[3] + iOffset + j * 10));
0272 timingMatrix.push_back(static_cast<float>(electronsFloatingPointValues_[18] + offset + j * 10));
0273 }
0274 run3ScoutingElectrons->emplace_back(static_cast<float>(electronsFloatingPointValues_[0] + offset),
0275 static_cast<float>(electronsFloatingPointValues_[1] + offset),
0276 static_cast<float>(electronsFloatingPointValues_[2] + offset),
0277 static_cast<float>(electronsFloatingPointValues_[3] + offset),
0278 std::move(trkd0),
0279 std::move(trkdz),
0280 std::move(trkpt),
0281 std::move(trketa),
0282 std::move(trkphi),
0283 std::move(trkchi2overndf),
0284 static_cast<float>(electronsFloatingPointValues_[6] + offset),
0285 static_cast<float>(electronsFloatingPointValues_[7] + offset),
0286 static_cast<float>(electronsFloatingPointValues_[8] + offset),
0287 static_cast<float>(electronsFloatingPointValues_[9] + offset),
0288 static_cast<float>(electronsFloatingPointValues_[10] + offset),
0289 electronsIntegralValues_[0] + iOffset,
0290 std::move(trkcharge),
0291 static_cast<float>(electronsFloatingPointValues_[11] + offset),
0292 static_cast<float>(electronsFloatingPointValues_[12] + offset),
0293 static_cast<float>(electronsFloatingPointValues_[13] + offset),
0294 static_cast<float>(electronsFloatingPointValues_[14] + offset),
0295 static_cast<float>(electronsFloatingPointValues_[15] + offset),
0296 static_cast<float>(electronsFloatingPointValues_[16] + offset),
0297 static_cast<uint32_t>(electronsIntegralValues_[2] + iOffset),
0298 std::move(energyMatrix),
0299 std::move(detIds),
0300 std::move(timingMatrix),
0301 static_cast<bool>((electronsIntegralValues_[4] + iOffset) % 2));
0302 }
0303 iEvent.put(electronsPutToken_, std::move(run3ScoutingElectrons));
0304 }
0305
0306 void TestWriteRun3Scouting::produceMuons(edm::Event& iEvent) const {
0307 auto run3ScoutingMuons = std::make_unique<std::vector<Run3ScoutingMuon>>();
0308 unsigned int vectorSize = 2 + iEvent.id().event() % 4;
0309 run3ScoutingMuons->reserve(vectorSize);
0310 for (unsigned int i = 0; i < vectorSize; ++i) {
0311 double offset = static_cast<double>(iEvent.id().event() + i);
0312 int iOffset = static_cast<int>(iEvent.id().event() + i);
0313
0314 std::vector<int> vtxIndx;
0315 std::vector<uint16_t> hitPattern;
0316 vtxIndx.reserve(vectorSize);
0317 hitPattern.reserve(vectorSize);
0318 for (unsigned int j = 0; j < vectorSize; ++j) {
0319 vtxIndx.push_back(static_cast<int>(muonsIntegralValues_[17] + iOffset + j * 10));
0320 hitPattern.push_back(static_cast<uint16_t>(muonsIntegralValues_[25] + iOffset + j * 10));
0321 }
0322
0323 Run3ScoutingHitPatternPOD run3ScoutingHitPatternPOD;
0324 run3ScoutingHitPatternPOD.hitCount = static_cast<uint8_t>(muonsIntegralValues_[18] + iOffset);
0325 run3ScoutingHitPatternPOD.beginTrackHits = static_cast<uint8_t>(muonsIntegralValues_[19] + iOffset);
0326 run3ScoutingHitPatternPOD.endTrackHits = static_cast<uint8_t>(muonsIntegralValues_[20] + iOffset);
0327 run3ScoutingHitPatternPOD.beginInner = static_cast<uint8_t>(muonsIntegralValues_[21] + iOffset);
0328 run3ScoutingHitPatternPOD.endInner = static_cast<uint8_t>(muonsIntegralValues_[22] + iOffset);
0329 run3ScoutingHitPatternPOD.beginOuter = static_cast<uint8_t>(muonsIntegralValues_[23] + iOffset);
0330 run3ScoutingHitPatternPOD.endOuter = static_cast<uint8_t>(muonsIntegralValues_[24] + iOffset);
0331 run3ScoutingHitPatternPOD.hitPattern = std::move(hitPattern);
0332
0333 run3ScoutingMuons->emplace_back(static_cast<float>(muonsFloatingPointValues_[0] + offset),
0334 static_cast<float>(muonsFloatingPointValues_[1] + offset),
0335 static_cast<float>(muonsFloatingPointValues_[2] + offset),
0336 static_cast<float>(muonsFloatingPointValues_[3] + offset),
0337 static_cast<unsigned int>(muonsIntegralValues_[0] + iOffset),
0338 muonsIntegralValues_[1] + iOffset,
0339 static_cast<float>(muonsFloatingPointValues_[4] + offset),
0340 static_cast<float>(muonsFloatingPointValues_[5] + offset),
0341 static_cast<float>(muonsFloatingPointValues_[6] + offset),
0342 static_cast<float>(muonsFloatingPointValues_[7] + offset),
0343 muonsIntegralValues_[2] + iOffset,
0344 muonsIntegralValues_[3] + iOffset,
0345 muonsIntegralValues_[4] + iOffset,
0346 muonsIntegralValues_[5] + iOffset,
0347 muonsIntegralValues_[6] + iOffset,
0348 muonsIntegralValues_[7] + iOffset,
0349 muonsIntegralValues_[8] + iOffset,
0350 static_cast<unsigned int>(muonsIntegralValues_[9] + iOffset),
0351 static_cast<unsigned int>(muonsIntegralValues_[10] + iOffset),
0352 muonsIntegralValues_[11] + iOffset,
0353 static_cast<unsigned int>(muonsIntegralValues_[12] + iOffset),
0354 muonsIntegralValues_[13] + iOffset,
0355 muonsIntegralValues_[14] + iOffset,
0356 muonsIntegralValues_[15] + iOffset,
0357 muonsIntegralValues_[16] + iOffset,
0358 static_cast<float>(muonsFloatingPointValues_[8] + offset),
0359 static_cast<float>(muonsFloatingPointValues_[9] + offset),
0360 static_cast<float>(muonsFloatingPointValues_[10] + offset),
0361 static_cast<float>(muonsFloatingPointValues_[11] + offset),
0362 static_cast<float>(muonsFloatingPointValues_[12] + offset),
0363 static_cast<float>(muonsFloatingPointValues_[13] + offset),
0364 static_cast<float>(muonsFloatingPointValues_[14] + offset),
0365 static_cast<float>(muonsFloatingPointValues_[15] + offset),
0366 static_cast<float>(muonsFloatingPointValues_[16] + offset),
0367 static_cast<float>(muonsFloatingPointValues_[17] + offset),
0368 static_cast<float>(muonsFloatingPointValues_[18] + offset),
0369 static_cast<float>(muonsFloatingPointValues_[19] + offset),
0370 static_cast<float>(muonsFloatingPointValues_[20] + offset),
0371 static_cast<float>(muonsFloatingPointValues_[21] + offset),
0372 static_cast<float>(muonsFloatingPointValues_[22] + offset),
0373 static_cast<float>(muonsFloatingPointValues_[23] + offset),
0374 static_cast<float>(muonsFloatingPointValues_[24] + offset),
0375 static_cast<float>(muonsFloatingPointValues_[25] + offset),
0376 static_cast<float>(muonsFloatingPointValues_[26] + offset),
0377 static_cast<float>(muonsFloatingPointValues_[27] + offset),
0378 static_cast<float>(muonsFloatingPointValues_[28] + offset),
0379 static_cast<float>(muonsFloatingPointValues_[29] + offset),
0380 static_cast<float>(muonsFloatingPointValues_[30] + offset),
0381 static_cast<float>(muonsFloatingPointValues_[31] + offset),
0382 static_cast<float>(muonsFloatingPointValues_[32] + offset),
0383 static_cast<float>(muonsFloatingPointValues_[33] + offset),
0384 static_cast<float>(muonsFloatingPointValues_[34] + offset),
0385 static_cast<float>(muonsFloatingPointValues_[35] + offset),
0386 static_cast<float>(muonsFloatingPointValues_[36] + offset),
0387 std::move(vtxIndx),
0388 std::move(run3ScoutingHitPatternPOD));
0389 }
0390 iEvent.put(muonsPutToken_, std::move(run3ScoutingMuons));
0391 }
0392
0393 void TestWriteRun3Scouting::produceParticles(edm::Event& iEvent) const {
0394 auto run3ScoutingParticles = std::make_unique<std::vector<Run3ScoutingParticle>>();
0395 unsigned int vectorSize = 2 + iEvent.id().event() % 4;
0396 run3ScoutingParticles->reserve(vectorSize);
0397 for (unsigned int i = 0; i < vectorSize; ++i) {
0398 double offset = static_cast<double>(iEvent.id().event() + i);
0399 int iOffset = static_cast<int>(iEvent.id().event() + i);
0400 run3ScoutingParticles->emplace_back(static_cast<float>(particlesFloatingPointValues_[0] + offset),
0401 static_cast<float>(particlesFloatingPointValues_[1] + offset),
0402 static_cast<float>(particlesFloatingPointValues_[2] + offset),
0403 particlesIntegralValues_[0] + iOffset,
0404 particlesIntegralValues_[1] + iOffset,
0405 static_cast<float>(particlesFloatingPointValues_[3] + offset),
0406 static_cast<float>(particlesFloatingPointValues_[4] + offset),
0407 static_cast<float>(particlesFloatingPointValues_[5] + offset),
0408 static_cast<float>(particlesFloatingPointValues_[6] + offset),
0409 static_cast<float>(particlesFloatingPointValues_[7] + offset),
0410 static_cast<uint8_t>(particlesIntegralValues_[2] + iOffset),
0411 static_cast<uint8_t>(particlesIntegralValues_[3] + iOffset),
0412 static_cast<float>(particlesFloatingPointValues_[8] + offset),
0413 static_cast<float>(particlesFloatingPointValues_[9] + offset),
0414 static_cast<float>(particlesFloatingPointValues_[10] + offset),
0415 static_cast<bool>((particlesIntegralValues_[4] + iOffset) % 2));
0416 }
0417 iEvent.put(particlesPutToken_, std::move(run3ScoutingParticles));
0418 }
0419
0420 void TestWriteRun3Scouting::producePFJets(edm::Event& iEvent) const {
0421 auto run3ScoutingPFJets = std::make_unique<std::vector<Run3ScoutingPFJet>>();
0422 unsigned int vectorSize = 2 + iEvent.id().event() % 4;
0423 run3ScoutingPFJets->reserve(vectorSize);
0424
0425 for (unsigned int i = 0; i < vectorSize; ++i) {
0426 double offset = static_cast<double>(iEvent.id().event() + i);
0427 int iOffset = static_cast<int>(iEvent.id().event() + i);
0428
0429 std::vector<int> constituents;
0430 constituents.reserve(vectorSize);
0431 for (unsigned int j = 0; j < vectorSize; ++j) {
0432 constituents.push_back(static_cast<int>(pfJetsIntegralValues_[7] + iOffset + j * 10));
0433 }
0434
0435 run3ScoutingPFJets->emplace_back(static_cast<float>(pfJetsFloatingPointValues_[0] + offset),
0436 static_cast<float>(pfJetsFloatingPointValues_[1] + offset),
0437 static_cast<float>(pfJetsFloatingPointValues_[2] + offset),
0438 static_cast<float>(pfJetsFloatingPointValues_[3] + offset),
0439 static_cast<float>(pfJetsFloatingPointValues_[4] + offset),
0440 static_cast<float>(pfJetsFloatingPointValues_[5] + offset),
0441 static_cast<float>(pfJetsFloatingPointValues_[6] + offset),
0442 static_cast<float>(pfJetsFloatingPointValues_[7] + offset),
0443 static_cast<float>(pfJetsFloatingPointValues_[8] + offset),
0444 static_cast<float>(pfJetsFloatingPointValues_[9] + offset),
0445 static_cast<float>(pfJetsFloatingPointValues_[10] + offset),
0446 static_cast<float>(pfJetsFloatingPointValues_[11] + offset),
0447 pfJetsIntegralValues_[0] + iOffset,
0448 pfJetsIntegralValues_[1] + iOffset,
0449 pfJetsIntegralValues_[2] + iOffset,
0450 pfJetsIntegralValues_[3] + iOffset,
0451 pfJetsIntegralValues_[4] + iOffset,
0452 pfJetsIntegralValues_[5] + iOffset,
0453 pfJetsIntegralValues_[6] + iOffset,
0454 static_cast<float>(pfJetsFloatingPointValues_[12] + offset),
0455 static_cast<float>(pfJetsFloatingPointValues_[13] + offset),
0456 static_cast<float>(pfJetsFloatingPointValues_[14] + offset),
0457 std::move(constituents));
0458 }
0459 iEvent.put(pfJetsPutToken_, std::move(run3ScoutingPFJets));
0460 }
0461
0462 void TestWriteRun3Scouting::producePhotons(edm::Event& iEvent) const {
0463 auto run3ScoutingPhotons = std::make_unique<std::vector<Run3ScoutingPhoton>>();
0464 unsigned int vectorSize = 2 + iEvent.id().event() % 4;
0465 run3ScoutingPhotons->reserve(vectorSize);
0466 for (unsigned int i = 0; i < vectorSize; ++i) {
0467 double offset = static_cast<double>(iEvent.id().event() + i);
0468 int iOffset = static_cast<int>(iEvent.id().event() + i);
0469
0470 std::vector<float> energyMatrix;
0471 std::vector<uint32_t> detIds;
0472 std::vector<float> timingMatrix;
0473 energyMatrix.reserve(vectorSize);
0474 detIds.reserve(vectorSize);
0475 timingMatrix.reserve(vectorSize);
0476 for (unsigned int j = 0; j < vectorSize; ++j) {
0477 energyMatrix.push_back(static_cast<float>(photonsFloatingPointValues_[12] + offset + j * 10));
0478 detIds.push_back(static_cast<uint32_t>(photonsIntegralValues_[1] + iOffset + j * 10));
0479 timingMatrix.push_back(static_cast<float>(photonsFloatingPointValues_[13] + offset + j * 10));
0480 }
0481 run3ScoutingPhotons->emplace_back(static_cast<float>(photonsFloatingPointValues_[0] + offset),
0482 static_cast<float>(photonsFloatingPointValues_[1] + offset),
0483 static_cast<float>(photonsFloatingPointValues_[2] + offset),
0484 static_cast<float>(photonsFloatingPointValues_[3] + offset),
0485 static_cast<float>(photonsFloatingPointValues_[4] + offset),
0486 static_cast<float>(photonsFloatingPointValues_[5] + offset),
0487 static_cast<float>(photonsFloatingPointValues_[6] + offset),
0488 static_cast<float>(photonsFloatingPointValues_[7] + offset),
0489 static_cast<float>(photonsFloatingPointValues_[8] + offset),
0490 static_cast<float>(photonsFloatingPointValues_[9] + offset),
0491 static_cast<float>(photonsFloatingPointValues_[10] + offset),
0492 static_cast<float>(photonsFloatingPointValues_[11] + offset),
0493 static_cast<uint32_t>(photonsIntegralValues_[0] + iOffset),
0494 std::move(energyMatrix),
0495 std::move(detIds),
0496 std::move(timingMatrix),
0497 static_cast<bool>((photonsIntegralValues_[2] + iOffset) % 2));
0498 }
0499 iEvent.put(photonsPutToken_, std::move(run3ScoutingPhotons));
0500 }
0501
0502 void TestWriteRun3Scouting::produceTracks(edm::Event& iEvent) const {
0503 auto run3ScoutingTracks = std::make_unique<std::vector<Run3ScoutingTrack>>();
0504 unsigned int vectorSize = 2 + iEvent.id().event() % 4;
0505 run3ScoutingTracks->reserve(vectorSize);
0506
0507 for (unsigned int i = 0; i < vectorSize; ++i) {
0508 double offset = static_cast<double>(iEvent.id().event() + i);
0509 int iOffset = static_cast<int>(iEvent.id().event() + i);
0510
0511 run3ScoutingTracks->emplace_back(static_cast<float>(tracksFloatingPointValues_[0] + offset),
0512 static_cast<float>(tracksFloatingPointValues_[1] + offset),
0513 static_cast<float>(tracksFloatingPointValues_[2] + offset),
0514 static_cast<float>(tracksFloatingPointValues_[3] + offset),
0515 static_cast<float>(tracksFloatingPointValues_[4] + offset),
0516 tracksIntegralValues_[0] + iOffset,
0517 static_cast<float>(tracksFloatingPointValues_[5] + offset),
0518 static_cast<float>(tracksFloatingPointValues_[6] + offset),
0519 tracksIntegralValues_[1] + iOffset,
0520 tracksIntegralValues_[2] + iOffset,
0521 tracksIntegralValues_[3] + iOffset,
0522 static_cast<float>(tracksFloatingPointValues_[7] + offset),
0523 static_cast<float>(tracksFloatingPointValues_[8] + offset),
0524 static_cast<float>(tracksFloatingPointValues_[9] + offset),
0525 static_cast<float>(tracksFloatingPointValues_[10] + offset),
0526 static_cast<float>(tracksFloatingPointValues_[11] + offset),
0527 static_cast<float>(tracksFloatingPointValues_[12] + offset),
0528 static_cast<float>(tracksFloatingPointValues_[13] + offset),
0529 static_cast<float>(tracksFloatingPointValues_[14] + offset),
0530 static_cast<float>(tracksFloatingPointValues_[15] + offset),
0531 static_cast<float>(tracksFloatingPointValues_[16] + offset),
0532 static_cast<float>(tracksFloatingPointValues_[17] + offset),
0533 static_cast<float>(tracksFloatingPointValues_[18] + offset),
0534 static_cast<float>(tracksFloatingPointValues_[19] + offset),
0535 static_cast<float>(tracksFloatingPointValues_[20] + offset),
0536 static_cast<float>(tracksFloatingPointValues_[21] + offset),
0537 static_cast<float>(tracksFloatingPointValues_[22] + offset),
0538 static_cast<float>(tracksFloatingPointValues_[23] + offset),
0539 static_cast<float>(tracksFloatingPointValues_[24] + offset),
0540 static_cast<float>(tracksFloatingPointValues_[25] + offset),
0541 tracksIntegralValues_[4] + iOffset,
0542 static_cast<float>(tracksFloatingPointValues_[26] + offset),
0543 static_cast<float>(tracksFloatingPointValues_[27] + offset),
0544 static_cast<float>(tracksFloatingPointValues_[28] + offset));
0545 }
0546 iEvent.put(tracksPutToken_, std::move(run3ScoutingTracks));
0547 }
0548
0549 void TestWriteRun3Scouting::produceVertexes(edm::Event& iEvent) const {
0550 auto run3ScoutingVertexes = std::make_unique<std::vector<Run3ScoutingVertex>>();
0551 unsigned int vectorSize = 2 + iEvent.id().event() % 4;
0552 run3ScoutingVertexes->reserve(vectorSize);
0553
0554 for (unsigned int i = 0; i < vectorSize; ++i) {
0555 double offset = static_cast<double>(iEvent.id().event() + i);
0556 int iOffset = static_cast<int>(iEvent.id().event() + i);
0557
0558 run3ScoutingVertexes->emplace_back(static_cast<float>(vertexesFloatingPointValues_[0] + offset),
0559 static_cast<float>(vertexesFloatingPointValues_[1] + offset),
0560 static_cast<float>(vertexesFloatingPointValues_[2] + offset),
0561 static_cast<float>(vertexesFloatingPointValues_[3] + offset),
0562 static_cast<float>(vertexesFloatingPointValues_[4] + offset),
0563 static_cast<float>(vertexesFloatingPointValues_[5] + offset),
0564 vertexesIntegralValues_[0] + iOffset,
0565 static_cast<float>(vertexesFloatingPointValues_[6] + offset),
0566 vertexesIntegralValues_[1] + iOffset,
0567 static_cast<bool>((vertexesIntegralValues_[2] + iOffset) % 2));
0568 }
0569 iEvent.put(vertexesPutToken_, std::move(run3ScoutingVertexes));
0570 }
0571
0572 void TestWriteRun3Scouting::throwWithMessage(const char* msg) const {
0573 throw cms::Exception("TestFailure") << "TestWriteRun3Scouting constructor, test configuration error, " << msg;
0574 }
0575
0576 }
0577
0578 using edmtest::TestWriteRun3Scouting;
0579 DEFINE_FWK_MODULE(TestWriteRun3Scouting);