File indexing completed on 2024-04-06 12:05:11
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() != 33) {
0122 throwWithMessage("electronsFloatingPointValues must have 33 elements and it does not");
0123 }
0124 if (electronsIntegralValues_.size() != 8) {
0125 throwWithMessage("electronsIntegralValues must have 8 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() != 17) {
0146 throwWithMessage("photonsFloatingPointValues must have 17 elements and it does not");
0147 }
0148 if (photonsIntegralValues_.size() != 5) {
0149 throwWithMessage("photonsIntegralValues must have 5 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() != 10) {
0158 throwWithMessage("vertexesFloatingPointValues must have 10 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> trkpMode;
0248 std::vector<float> trketaMode;
0249 std::vector<float> trkphiMode;
0250 std::vector<float> trkqoverpModeError;
0251 std::vector<float> trkchi2overndf;
0252 std::vector<int> trkcharge;
0253 std::vector<float> energyMatrix;
0254 std::vector<unsigned int> detIds;
0255 std::vector<float> timingMatrix;
0256 trkd0.reserve(vectorSize);
0257 trkdz.reserve(vectorSize);
0258 trkpt.reserve(vectorSize);
0259 trketa.reserve(vectorSize);
0260 trkphi.reserve(vectorSize);
0261 trkpMode.reserve(vectorSize);
0262 trketaMode.reserve(vectorSize);
0263 trkphiMode.reserve(vectorSize);
0264 trkqoverpModeError.reserve(vectorSize);
0265 trkchi2overndf.reserve(vectorSize);
0266 trkcharge.reserve(vectorSize);
0267 energyMatrix.reserve(vectorSize);
0268 detIds.reserve(vectorSize);
0269 timingMatrix.reserve(vectorSize);
0270 for (unsigned int j = 0; j < vectorSize; ++j) {
0271 trkd0.push_back(static_cast<float>(electronsFloatingPointValues_[19] + offset + j * 10));
0272 trkdz.push_back(static_cast<float>(electronsFloatingPointValues_[20] + offset + j * 10));
0273 trkpt.push_back(static_cast<float>(electronsFloatingPointValues_[21] + offset + j * 10));
0274 trketa.push_back(static_cast<float>(electronsFloatingPointValues_[22] + offset + j * 10));
0275 trkphi.push_back(static_cast<float>(electronsFloatingPointValues_[23] + offset + j * 10));
0276 trkpMode.push_back(static_cast<float>(electronsFloatingPointValues_[28] + offset + j * 10));
0277 trketaMode.push_back(static_cast<float>(electronsFloatingPointValues_[29] + offset + j * 10));
0278 trkphiMode.push_back(static_cast<float>(electronsFloatingPointValues_[30] + offset + j * 10));
0279 trkqoverpModeError.push_back(static_cast<float>(electronsFloatingPointValues_[31] + offset + j * 10));
0280 trkchi2overndf.push_back(static_cast<float>(electronsFloatingPointValues_[24] + offset + j * 10));
0281 trkcharge.push_back(static_cast<int>(electronsIntegralValues_[5] + offset + j * 10));
0282 energyMatrix.push_back(static_cast<float>(electronsFloatingPointValues_[17] + offset + j * 10));
0283 detIds.push_back(static_cast<uint32_t>(electronsIntegralValues_[3] + iOffset + j * 10));
0284 timingMatrix.push_back(static_cast<float>(electronsFloatingPointValues_[18] + offset + j * 10));
0285 }
0286 run3ScoutingElectrons->emplace_back(static_cast<float>(electronsFloatingPointValues_[0] + offset),
0287 static_cast<float>(electronsFloatingPointValues_[1] + offset),
0288 static_cast<float>(electronsFloatingPointValues_[2] + offset),
0289 static_cast<float>(electronsFloatingPointValues_[3] + offset),
0290 static_cast<float>(electronsFloatingPointValues_[25] + offset),
0291 static_cast<float>(electronsFloatingPointValues_[26] + offset),
0292 static_cast<float>(electronsFloatingPointValues_[27] + offset),
0293 std::move(trkd0),
0294 std::move(trkdz),
0295 std::move(trkpt),
0296 std::move(trketa),
0297 std::move(trkphi),
0298 std::move(trkpMode),
0299 std::move(trketaMode),
0300 std::move(trkphiMode),
0301 std::move(trkqoverpModeError),
0302 std::move(trkchi2overndf),
0303 static_cast<float>(electronsFloatingPointValues_[6] + offset),
0304 static_cast<float>(electronsFloatingPointValues_[7] + offset),
0305 static_cast<float>(electronsFloatingPointValues_[8] + offset),
0306 static_cast<float>(electronsFloatingPointValues_[9] + offset),
0307 static_cast<float>(electronsFloatingPointValues_[10] + offset),
0308 electronsIntegralValues_[0] + iOffset,
0309 std::move(trkcharge),
0310 static_cast<float>(electronsFloatingPointValues_[32] + offset),
0311 static_cast<float>(electronsFloatingPointValues_[11] + offset),
0312 static_cast<float>(electronsFloatingPointValues_[12] + offset),
0313 static_cast<float>(electronsFloatingPointValues_[13] + offset),
0314 static_cast<float>(electronsFloatingPointValues_[14] + offset),
0315 static_cast<float>(electronsFloatingPointValues_[15] + offset),
0316 static_cast<float>(electronsFloatingPointValues_[16] + offset),
0317 static_cast<uint32_t>(electronsIntegralValues_[2] + iOffset),
0318 static_cast<uint32_t>(electronsIntegralValues_[6] + iOffset),
0319 static_cast<uint32_t>(electronsIntegralValues_[7] + iOffset),
0320 std::move(energyMatrix),
0321 std::move(detIds),
0322 std::move(timingMatrix),
0323 static_cast<bool>((electronsIntegralValues_[4] + iOffset) % 2));
0324 }
0325 iEvent.put(electronsPutToken_, std::move(run3ScoutingElectrons));
0326 }
0327
0328 void TestWriteRun3Scouting::produceMuons(edm::Event& iEvent) const {
0329 auto run3ScoutingMuons = std::make_unique<std::vector<Run3ScoutingMuon>>();
0330 unsigned int vectorSize = 2 + iEvent.id().event() % 4;
0331 run3ScoutingMuons->reserve(vectorSize);
0332 for (unsigned int i = 0; i < vectorSize; ++i) {
0333 double offset = static_cast<double>(iEvent.id().event() + i);
0334 int iOffset = static_cast<int>(iEvent.id().event() + i);
0335
0336 std::vector<int> vtxIndx;
0337 std::vector<uint16_t> hitPattern;
0338 vtxIndx.reserve(vectorSize);
0339 hitPattern.reserve(vectorSize);
0340 for (unsigned int j = 0; j < vectorSize; ++j) {
0341 vtxIndx.push_back(static_cast<int>(muonsIntegralValues_[17] + iOffset + j * 10));
0342 hitPattern.push_back(static_cast<uint16_t>(muonsIntegralValues_[25] + iOffset + j * 10));
0343 }
0344
0345 Run3ScoutingHitPatternPOD run3ScoutingHitPatternPOD;
0346 run3ScoutingHitPatternPOD.hitCount = static_cast<uint8_t>(muonsIntegralValues_[18] + iOffset);
0347 run3ScoutingHitPatternPOD.beginTrackHits = static_cast<uint8_t>(muonsIntegralValues_[19] + iOffset);
0348 run3ScoutingHitPatternPOD.endTrackHits = static_cast<uint8_t>(muonsIntegralValues_[20] + iOffset);
0349 run3ScoutingHitPatternPOD.beginInner = static_cast<uint8_t>(muonsIntegralValues_[21] + iOffset);
0350 run3ScoutingHitPatternPOD.endInner = static_cast<uint8_t>(muonsIntegralValues_[22] + iOffset);
0351 run3ScoutingHitPatternPOD.beginOuter = static_cast<uint8_t>(muonsIntegralValues_[23] + iOffset);
0352 run3ScoutingHitPatternPOD.endOuter = static_cast<uint8_t>(muonsIntegralValues_[24] + iOffset);
0353 run3ScoutingHitPatternPOD.hitPattern = std::move(hitPattern);
0354
0355 run3ScoutingMuons->emplace_back(static_cast<float>(muonsFloatingPointValues_[0] + offset),
0356 static_cast<float>(muonsFloatingPointValues_[1] + offset),
0357 static_cast<float>(muonsFloatingPointValues_[2] + offset),
0358 static_cast<float>(muonsFloatingPointValues_[3] + offset),
0359 static_cast<unsigned int>(muonsIntegralValues_[0] + iOffset),
0360 muonsIntegralValues_[1] + iOffset,
0361 static_cast<float>(muonsFloatingPointValues_[4] + offset),
0362 static_cast<float>(muonsFloatingPointValues_[5] + offset),
0363 static_cast<float>(muonsFloatingPointValues_[6] + offset),
0364 static_cast<float>(muonsFloatingPointValues_[7] + offset),
0365 muonsIntegralValues_[2] + iOffset,
0366 muonsIntegralValues_[3] + iOffset,
0367 muonsIntegralValues_[4] + iOffset,
0368 muonsIntegralValues_[5] + iOffset,
0369 muonsIntegralValues_[6] + iOffset,
0370 muonsIntegralValues_[7] + iOffset,
0371 muonsIntegralValues_[8] + iOffset,
0372 static_cast<unsigned int>(muonsIntegralValues_[9] + iOffset),
0373 static_cast<unsigned int>(muonsIntegralValues_[10] + iOffset),
0374 muonsIntegralValues_[11] + iOffset,
0375 static_cast<unsigned int>(muonsIntegralValues_[12] + iOffset),
0376 muonsIntegralValues_[13] + iOffset,
0377 muonsIntegralValues_[14] + iOffset,
0378 muonsIntegralValues_[15] + iOffset,
0379 muonsIntegralValues_[16] + iOffset,
0380 static_cast<float>(muonsFloatingPointValues_[8] + offset),
0381 static_cast<float>(muonsFloatingPointValues_[9] + offset),
0382 static_cast<float>(muonsFloatingPointValues_[10] + offset),
0383 static_cast<float>(muonsFloatingPointValues_[11] + offset),
0384 static_cast<float>(muonsFloatingPointValues_[12] + offset),
0385 static_cast<float>(muonsFloatingPointValues_[13] + offset),
0386 static_cast<float>(muonsFloatingPointValues_[14] + offset),
0387 static_cast<float>(muonsFloatingPointValues_[15] + offset),
0388 static_cast<float>(muonsFloatingPointValues_[16] + offset),
0389 static_cast<float>(muonsFloatingPointValues_[17] + offset),
0390 static_cast<float>(muonsFloatingPointValues_[18] + offset),
0391 static_cast<float>(muonsFloatingPointValues_[19] + offset),
0392 static_cast<float>(muonsFloatingPointValues_[20] + offset),
0393 static_cast<float>(muonsFloatingPointValues_[21] + offset),
0394 static_cast<float>(muonsFloatingPointValues_[22] + offset),
0395 static_cast<float>(muonsFloatingPointValues_[23] + offset),
0396 static_cast<float>(muonsFloatingPointValues_[24] + offset),
0397 static_cast<float>(muonsFloatingPointValues_[25] + offset),
0398 static_cast<float>(muonsFloatingPointValues_[26] + offset),
0399 static_cast<float>(muonsFloatingPointValues_[27] + offset),
0400 static_cast<float>(muonsFloatingPointValues_[28] + offset),
0401 static_cast<float>(muonsFloatingPointValues_[29] + offset),
0402 static_cast<float>(muonsFloatingPointValues_[30] + offset),
0403 static_cast<float>(muonsFloatingPointValues_[31] + offset),
0404 static_cast<float>(muonsFloatingPointValues_[32] + offset),
0405 static_cast<float>(muonsFloatingPointValues_[33] + offset),
0406 static_cast<float>(muonsFloatingPointValues_[34] + offset),
0407 static_cast<float>(muonsFloatingPointValues_[35] + offset),
0408 static_cast<float>(muonsFloatingPointValues_[36] + offset),
0409 std::move(vtxIndx),
0410 std::move(run3ScoutingHitPatternPOD));
0411 }
0412 iEvent.put(muonsPutToken_, std::move(run3ScoutingMuons));
0413 }
0414
0415 void TestWriteRun3Scouting::produceParticles(edm::Event& iEvent) const {
0416 auto run3ScoutingParticles = std::make_unique<std::vector<Run3ScoutingParticle>>();
0417 unsigned int vectorSize = 2 + iEvent.id().event() % 4;
0418 run3ScoutingParticles->reserve(vectorSize);
0419 for (unsigned int i = 0; i < vectorSize; ++i) {
0420 double offset = static_cast<double>(iEvent.id().event() + i);
0421 int iOffset = static_cast<int>(iEvent.id().event() + i);
0422 run3ScoutingParticles->emplace_back(static_cast<float>(particlesFloatingPointValues_[0] + offset),
0423 static_cast<float>(particlesFloatingPointValues_[1] + offset),
0424 static_cast<float>(particlesFloatingPointValues_[2] + offset),
0425 particlesIntegralValues_[0] + iOffset,
0426 particlesIntegralValues_[1] + iOffset,
0427 static_cast<float>(particlesFloatingPointValues_[3] + offset),
0428 static_cast<float>(particlesFloatingPointValues_[4] + offset),
0429 static_cast<float>(particlesFloatingPointValues_[5] + offset),
0430 static_cast<float>(particlesFloatingPointValues_[6] + offset),
0431 static_cast<float>(particlesFloatingPointValues_[7] + offset),
0432 static_cast<uint8_t>(particlesIntegralValues_[2] + iOffset),
0433 static_cast<uint8_t>(particlesIntegralValues_[3] + iOffset),
0434 static_cast<float>(particlesFloatingPointValues_[8] + offset),
0435 static_cast<float>(particlesFloatingPointValues_[9] + offset),
0436 static_cast<float>(particlesFloatingPointValues_[10] + offset),
0437 static_cast<bool>((particlesIntegralValues_[4] + iOffset) % 2));
0438 }
0439 iEvent.put(particlesPutToken_, std::move(run3ScoutingParticles));
0440 }
0441
0442 void TestWriteRun3Scouting::producePFJets(edm::Event& iEvent) const {
0443 auto run3ScoutingPFJets = std::make_unique<std::vector<Run3ScoutingPFJet>>();
0444 unsigned int vectorSize = 2 + iEvent.id().event() % 4;
0445 run3ScoutingPFJets->reserve(vectorSize);
0446
0447 for (unsigned int i = 0; i < vectorSize; ++i) {
0448 double offset = static_cast<double>(iEvent.id().event() + i);
0449 int iOffset = static_cast<int>(iEvent.id().event() + i);
0450
0451 std::vector<int> constituents;
0452 constituents.reserve(vectorSize);
0453 for (unsigned int j = 0; j < vectorSize; ++j) {
0454 constituents.push_back(static_cast<int>(pfJetsIntegralValues_[7] + iOffset + j * 10));
0455 }
0456
0457 run3ScoutingPFJets->emplace_back(static_cast<float>(pfJetsFloatingPointValues_[0] + offset),
0458 static_cast<float>(pfJetsFloatingPointValues_[1] + offset),
0459 static_cast<float>(pfJetsFloatingPointValues_[2] + offset),
0460 static_cast<float>(pfJetsFloatingPointValues_[3] + offset),
0461 static_cast<float>(pfJetsFloatingPointValues_[4] + offset),
0462 static_cast<float>(pfJetsFloatingPointValues_[5] + offset),
0463 static_cast<float>(pfJetsFloatingPointValues_[6] + offset),
0464 static_cast<float>(pfJetsFloatingPointValues_[7] + offset),
0465 static_cast<float>(pfJetsFloatingPointValues_[8] + offset),
0466 static_cast<float>(pfJetsFloatingPointValues_[9] + offset),
0467 static_cast<float>(pfJetsFloatingPointValues_[10] + offset),
0468 static_cast<float>(pfJetsFloatingPointValues_[11] + offset),
0469 pfJetsIntegralValues_[0] + iOffset,
0470 pfJetsIntegralValues_[1] + iOffset,
0471 pfJetsIntegralValues_[2] + iOffset,
0472 pfJetsIntegralValues_[3] + iOffset,
0473 pfJetsIntegralValues_[4] + iOffset,
0474 pfJetsIntegralValues_[5] + iOffset,
0475 pfJetsIntegralValues_[6] + iOffset,
0476 static_cast<float>(pfJetsFloatingPointValues_[12] + offset),
0477 static_cast<float>(pfJetsFloatingPointValues_[13] + offset),
0478 static_cast<float>(pfJetsFloatingPointValues_[14] + offset),
0479 std::move(constituents));
0480 }
0481 iEvent.put(pfJetsPutToken_, std::move(run3ScoutingPFJets));
0482 }
0483
0484 void TestWriteRun3Scouting::producePhotons(edm::Event& iEvent) const {
0485 auto run3ScoutingPhotons = std::make_unique<std::vector<Run3ScoutingPhoton>>();
0486 unsigned int vectorSize = 2 + iEvent.id().event() % 4;
0487 run3ScoutingPhotons->reserve(vectorSize);
0488 for (unsigned int i = 0; i < vectorSize; ++i) {
0489 double offset = static_cast<double>(iEvent.id().event() + i);
0490 int iOffset = static_cast<int>(iEvent.id().event() + i);
0491
0492 std::vector<float> energyMatrix;
0493 std::vector<uint32_t> detIds;
0494 std::vector<float> timingMatrix;
0495 energyMatrix.reserve(vectorSize);
0496 detIds.reserve(vectorSize);
0497 timingMatrix.reserve(vectorSize);
0498 for (unsigned int j = 0; j < vectorSize; ++j) {
0499 energyMatrix.push_back(static_cast<float>(photonsFloatingPointValues_[12] + offset + j * 10));
0500 detIds.push_back(static_cast<uint32_t>(photonsIntegralValues_[1] + iOffset + j * 10));
0501 timingMatrix.push_back(static_cast<float>(photonsFloatingPointValues_[13] + offset + j * 10));
0502 }
0503 run3ScoutingPhotons->emplace_back(static_cast<float>(photonsFloatingPointValues_[0] + offset),
0504 static_cast<float>(photonsFloatingPointValues_[1] + offset),
0505 static_cast<float>(photonsFloatingPointValues_[2] + offset),
0506 static_cast<float>(photonsFloatingPointValues_[3] + offset),
0507 static_cast<float>(photonsFloatingPointValues_[14] + offset),
0508 static_cast<float>(photonsFloatingPointValues_[15] + offset),
0509 static_cast<float>(photonsFloatingPointValues_[16] + offset),
0510 static_cast<float>(photonsFloatingPointValues_[4] + offset),
0511 static_cast<float>(photonsFloatingPointValues_[5] + offset),
0512 static_cast<float>(photonsFloatingPointValues_[6] + offset),
0513 static_cast<float>(photonsFloatingPointValues_[7] + offset),
0514 static_cast<float>(photonsFloatingPointValues_[8] + offset),
0515 static_cast<float>(photonsFloatingPointValues_[9] + offset),
0516 static_cast<float>(photonsFloatingPointValues_[10] + offset),
0517 static_cast<float>(photonsFloatingPointValues_[11] + offset),
0518 static_cast<uint32_t>(photonsIntegralValues_[0] + iOffset),
0519 static_cast<uint32_t>(photonsIntegralValues_[3] + iOffset),
0520 static_cast<uint32_t>(photonsIntegralValues_[4] + iOffset),
0521 std::move(energyMatrix),
0522 std::move(detIds),
0523 std::move(timingMatrix),
0524 static_cast<bool>((photonsIntegralValues_[2] + iOffset) % 2));
0525 }
0526 iEvent.put(photonsPutToken_, std::move(run3ScoutingPhotons));
0527 }
0528
0529 void TestWriteRun3Scouting::produceTracks(edm::Event& iEvent) const {
0530 auto run3ScoutingTracks = std::make_unique<std::vector<Run3ScoutingTrack>>();
0531 unsigned int vectorSize = 2 + iEvent.id().event() % 4;
0532 run3ScoutingTracks->reserve(vectorSize);
0533
0534 for (unsigned int i = 0; i < vectorSize; ++i) {
0535 double offset = static_cast<double>(iEvent.id().event() + i);
0536 int iOffset = static_cast<int>(iEvent.id().event() + i);
0537
0538 run3ScoutingTracks->emplace_back(static_cast<float>(tracksFloatingPointValues_[0] + offset),
0539 static_cast<float>(tracksFloatingPointValues_[1] + offset),
0540 static_cast<float>(tracksFloatingPointValues_[2] + offset),
0541 static_cast<float>(tracksFloatingPointValues_[3] + offset),
0542 static_cast<float>(tracksFloatingPointValues_[4] + offset),
0543 tracksIntegralValues_[0] + iOffset,
0544 static_cast<float>(tracksFloatingPointValues_[5] + offset),
0545 static_cast<float>(tracksFloatingPointValues_[6] + offset),
0546 tracksIntegralValues_[1] + iOffset,
0547 tracksIntegralValues_[2] + iOffset,
0548 tracksIntegralValues_[3] + iOffset,
0549 static_cast<float>(tracksFloatingPointValues_[7] + offset),
0550 static_cast<float>(tracksFloatingPointValues_[8] + offset),
0551 static_cast<float>(tracksFloatingPointValues_[9] + offset),
0552 static_cast<float>(tracksFloatingPointValues_[10] + offset),
0553 static_cast<float>(tracksFloatingPointValues_[11] + offset),
0554 static_cast<float>(tracksFloatingPointValues_[12] + offset),
0555 static_cast<float>(tracksFloatingPointValues_[13] + offset),
0556 static_cast<float>(tracksFloatingPointValues_[14] + offset),
0557 static_cast<float>(tracksFloatingPointValues_[15] + offset),
0558 static_cast<float>(tracksFloatingPointValues_[16] + offset),
0559 static_cast<float>(tracksFloatingPointValues_[17] + offset),
0560 static_cast<float>(tracksFloatingPointValues_[18] + offset),
0561 static_cast<float>(tracksFloatingPointValues_[19] + offset),
0562 static_cast<float>(tracksFloatingPointValues_[20] + offset),
0563 static_cast<float>(tracksFloatingPointValues_[21] + offset),
0564 static_cast<float>(tracksFloatingPointValues_[22] + offset),
0565 static_cast<float>(tracksFloatingPointValues_[23] + offset),
0566 static_cast<float>(tracksFloatingPointValues_[24] + offset),
0567 static_cast<float>(tracksFloatingPointValues_[25] + offset),
0568 tracksIntegralValues_[4] + iOffset,
0569 static_cast<float>(tracksFloatingPointValues_[26] + offset),
0570 static_cast<float>(tracksFloatingPointValues_[27] + offset),
0571 static_cast<float>(tracksFloatingPointValues_[28] + offset));
0572 }
0573 iEvent.put(tracksPutToken_, std::move(run3ScoutingTracks));
0574 }
0575
0576 void TestWriteRun3Scouting::produceVertexes(edm::Event& iEvent) const {
0577 auto run3ScoutingVertexes = std::make_unique<std::vector<Run3ScoutingVertex>>();
0578 unsigned int vectorSize = 2 + iEvent.id().event() % 4;
0579 run3ScoutingVertexes->reserve(vectorSize);
0580
0581 for (unsigned int i = 0; i < vectorSize; ++i) {
0582 double offset = static_cast<double>(iEvent.id().event() + i);
0583 int iOffset = static_cast<int>(iEvent.id().event() + i);
0584
0585 run3ScoutingVertexes->emplace_back(static_cast<float>(vertexesFloatingPointValues_[0] + offset),
0586 static_cast<float>(vertexesFloatingPointValues_[1] + offset),
0587 static_cast<float>(vertexesFloatingPointValues_[2] + offset),
0588 static_cast<float>(vertexesFloatingPointValues_[3] + offset),
0589 static_cast<float>(vertexesFloatingPointValues_[4] + offset),
0590 static_cast<float>(vertexesFloatingPointValues_[5] + offset),
0591 vertexesIntegralValues_[0] + iOffset,
0592 static_cast<float>(vertexesFloatingPointValues_[6] + offset),
0593 vertexesIntegralValues_[1] + iOffset,
0594 static_cast<bool>((vertexesIntegralValues_[2] + iOffset) % 2),
0595 static_cast<float>(vertexesFloatingPointValues_[7] + offset),
0596 static_cast<float>(vertexesFloatingPointValues_[8] + offset),
0597 static_cast<float>(vertexesFloatingPointValues_[9] + offset));
0598 }
0599 iEvent.put(vertexesPutToken_, std::move(run3ScoutingVertexes));
0600 }
0601
0602 void TestWriteRun3Scouting::throwWithMessage(const char* msg) const {
0603 throw cms::Exception("TestFailure") << "TestWriteRun3Scouting constructor, test configuration error, " << msg;
0604 }
0605
0606 }
0607
0608 using edmtest::TestWriteRun3Scouting;
0609 DEFINE_FWK_MODULE(TestWriteRun3Scouting);