L1TGlobal/test/TestReadGlobalObjectMapRecord.cc

0001 // -*- C++ -*-
0002 //
0003 // Package:    DataFormats/L1TGlobal
0004 // Class:      TestReadGlobalObjectMapRecord
0005 //
0006 /**\class edmtest::TestReadGlobalObjectMapRecord
0007   Description: Used as part of tests that ensure the GlobalObjectMapRecord
0008   data format can be persistently written and in a subsequent process
0009   read. First, this is done using the current release version for writing
0010   and reading. In addition, the output file of the write process should
0011   be saved permanently each time the GlobalObjectMapRecord persistent data
0012   format changes. In unit tests, we read each of those saved files to verify
0013   that the current releases can read older versions of the data format.
0014 */
0015 // Original Author:  W. David Dagenhart
0016 //         Created:  3 May 2023
0017
0018 #include "DataFormats/L1TGlobal/interface/GlobalObject.h"
0019 #include "DataFormats/L1TGlobal/interface/GlobalObjectMapFwd.h"
0020 #include "DataFormats/L1TGlobal/interface/GlobalObjectMapRecord.h"
0021 #include "FWCore/Framework/interface/Event.h"
0022 #include "FWCore/Framework/interface/Frameworkfwd.h"
0023 #include "FWCore/Framework/interface/global/EDAnalyzer.h"
0024 #include "FWCore/Framework/interface/MakerMacros.h"
0025 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
0026 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0027 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
0028 #include "FWCore/Utilities/interface/EDGetToken.h"
0029 #include "FWCore/Utilities/interface/Exception.h"
0030 #include "FWCore/Utilities/interface/InputTag.h"
0031 #include "FWCore/Utilities/interface/StreamID.h"
0032
0033 #include <string>
0034 #include <vector>
0035
0036 namespace edmtest {
0037
0038   class TestReadGlobalObjectMapRecord : public edm::global::EDAnalyzer<> {
0039   public:
0040     TestReadGlobalObjectMapRecord(edm::ParameterSet const&);
0041     void analyze(edm::StreamID, edm::Event const&, edm::EventSetup const&) const override;
0042     void throwWithMessage(const char*) const;
0043     static void fillDescriptions(edm::ConfigurationDescriptions&);
0044
0045   private:
0046     // These expected values are meaningless other than we use them
0047     // to check that values read from persistent storage match the values
0048     // we know were written.
0049     std::vector<std::string> expectedAlgoNames_;
0050     std::vector<int> expectedAlgoBitNumbers_;
0051     std::vector<int> expectedAlgoGtlResults_;
0052     std::vector<std::string> expectedTokenNames0_;
0053     std::vector<int> expectedTokenNumbers0_;
0054     std::vector<int> expectedTokenResults0_;
0055     std::vector<std::string> expectedTokenNames3_;
0056     std::vector<int> expectedTokenNumbers3_;
0057     std::vector<int> expectedTokenResults3_;
0058     int expectedFirstElement_;
0059     int expectedElementDelta_;
0060     int expectedFinalValue_;
0061     uint expectedBxIndexModulus_;
0062
0063     edm::EDGetTokenT<GlobalObjectMapRecord> globalObjectMapRecordToken_;
0064     uint globalObjectMapClassVersion_;
0065   };
0066
0067   TestReadGlobalObjectMapRecord::TestReadGlobalObjectMapRecord(edm::ParameterSet const& iPSet)
0068       : expectedAlgoNames_(iPSet.getParameter<std::vector<std::string>>("expectedAlgoNames")),
0069         expectedAlgoBitNumbers_(iPSet.getParameter<std::vector<int>>("expectedAlgoBitNumbers")),
0070         expectedAlgoGtlResults_(iPSet.getParameter<std::vector<int>>("expectedAlgoGtlResults")),
0071         expectedTokenNames0_(iPSet.getParameter<std::vector<std::string>>("expectedTokenNames0")),
0072         expectedTokenNumbers0_(iPSet.getParameter<std::vector<int>>("expectedTokenNumbers0")),
0073         expectedTokenResults0_(iPSet.getParameter<std::vector<int>>("expectedTokenResults0")),
0074         expectedTokenNames3_(iPSet.getParameter<std::vector<std::string>>("expectedTokenNames3")),
0075         expectedTokenNumbers3_(iPSet.getParameter<std::vector<int>>("expectedTokenNumbers3")),
0076         expectedTokenResults3_(iPSet.getParameter<std::vector<int>>("expectedTokenResults3")),
0077         expectedFirstElement_(iPSet.getParameter<int>("expectedFirstElement")),
0078         expectedElementDelta_(iPSet.getParameter<int>("expectedElementDelta")),
0079         expectedFinalValue_(iPSet.getParameter<int>("expectedFinalValue")),
0080         expectedBxIndexModulus_(iPSet.getParameter<uint>("expectedBxIndexModulus")),
0081         globalObjectMapRecordToken_(consumes(iPSet.getParameter<edm::InputTag>("globalObjectMapRecordTag"))),
0082         globalObjectMapClassVersion_(iPSet.getParameter<uint>("globalObjectMapClassVersion")) {
0083     if (expectedAlgoNames_.size() != expectedAlgoBitNumbers_.size() ||
0084         expectedAlgoNames_.size() != expectedAlgoGtlResults_.size() ||
0085         expectedAlgoNames_.size() != expectedTokenNames0_.size() ||
0086         expectedAlgoNames_.size() != expectedTokenNumbers0_.size() ||
0087         expectedAlgoNames_.size() != expectedTokenResults0_.size() ||
0088         expectedAlgoNames_.size() != expectedTokenNames3_.size() ||
0089         expectedAlgoNames_.size() != expectedTokenNumbers3_.size() ||
0090         expectedAlgoNames_.size() != expectedTokenResults3_.size()) {
0091       throw cms::Exception("TestFailure") << "TestWriteGlobalObjectMapRecord, test configuration error: "
0092                                              "expectedAlgoNames, expectedAlgoBitNumbers, expectedAlgoGtlResults, "
0093                                              "expectedTokenNames0_, expectedTokenNumbers0_, expectedTokenResults0_, "
0094                                              "expectedTokenNames3_, expectedTokenNumbers3_, and expectedTokenResults3_ "
0095                                              "should have the same size.";
0096     }
0097   }
0098
0099   void TestReadGlobalObjectMapRecord::analyze(edm::StreamID, edm::Event const& iEvent, edm::EventSetup const&) const {
0100     auto const& globalObjectMapRecord = iEvent.get(globalObjectMapRecordToken_);
0101
0102     std::vector<GlobalObjectMap> const& globalObjectMaps = globalObjectMapRecord.gtObjectMap();
0103
0104     if (expectedAlgoNames_.size() != globalObjectMaps.size()) {
0105       throwWithMessage("globalObjectMaps does not have expected size");
0106     }
0107
0108     unsigned int index = 0;
0109     for (auto const& globalObjectMap : globalObjectMaps) {
0110       if (globalObjectMap.algoName() != expectedAlgoNames_[index]) {
0111         throwWithMessage("algoName does not have expected value");
0112       }
0113       if (globalObjectMap.algoBitNumber() != expectedAlgoBitNumbers_[index]) {
0114         throwWithMessage("algoBitNumber does not have expected value");
0115       }
0116       if (globalObjectMap.algoGtlResult() != static_cast<bool>(expectedAlgoGtlResults_[index])) {
0117         throwWithMessage("algoGtlResult does not have expected value");
0118       }
0119
0120       std::vector<GlobalLogicParser::OperandToken> const& operandTokens = globalObjectMap.operandTokenVector();
0121       if (operandTokens[0].tokenName != expectedTokenNames0_[index]) {
0122         throwWithMessage("tokenName0 does not have expected value");
0123       }
0124       if (operandTokens[0].tokenNumber != expectedTokenNumbers0_[index]) {
0125         throwWithMessage("tokenNumber0 does not have expected value");
0126       }
0127       if (operandTokens[0].tokenResult != static_cast<bool>(expectedTokenResults0_[index])) {
0128         throwWithMessage("tokenResult0 does not have expected value");
0129       }
0130       if (operandTokens[3].tokenName != expectedTokenNames3_[index]) {
0131         throwWithMessage("tokenName3 does not have expected value");
0132       }
0133       if (operandTokens[3].tokenNumber != expectedTokenNumbers3_[index]) {
0134         throwWithMessage("tokenNumber3 does not have expected value");
0135       }
0136       if (operandTokens[3].tokenResult != static_cast<bool>(expectedTokenResults3_[index])) {
0137         throwWithMessage("tokenResult3 does not have expected value");
0138       }
0139
0140       uint bxCounter = 0;
0141       int expectedValue = expectedFirstElement_;
0142       for (auto const& combinationsInCond : globalObjectMap.combinationVector()) {
0143         for (auto const& singleCombInCond : combinationsInCond) {
0144           for (auto const& value : singleCombInCond) {
0145             L1TObjBxIndexType const expectedBxValue =
0146                 globalObjectMapClassVersion_ > 10 ? bxCounter % expectedBxIndexModulus_ : 0;
0147             if (value.first != expectedBxValue) {
0148               throwWithMessage("BX in combinationVector does not have expected value");
0149             }
0150             ++bxCounter;
0151
0152             if (value.second != expectedValue) {
0153               throwWithMessage("index in combinationVector does not have expected value");
0154             }
0155             expectedValue += expectedElementDelta_;
0156           }
0157         }
0158       }
0159
0160       for (auto const& l1tObjectTypeInCond : globalObjectMap.objectTypeVector()) {
0161         for (auto const& globalObject : l1tObjectTypeInCond) {
0162           if (static_cast<int>(globalObject) != (expectedValue % 28)) {
0163             throwWithMessage("globalObject does not have expected value");
0164           }
0165           expectedValue += expectedElementDelta_;
0166         }
0167       }
0168       if (expectedValue != expectedFinalValue_) {
0169         throw cms::Exception("TestFailure")
0170             << "final value = " << expectedValue << " which does not match the expected value of "
0171             << expectedFinalValue_ << " this might mean the vectors did not contain the expected number of elements";
0172       }
0173       ++index;
0174     }
0175   }
0176
0177   void TestReadGlobalObjectMapRecord::throwWithMessage(const char* msg) const {
0178     throw cms::Exception("TestFailure") << "TestReadGlobalObjectMapRecord::analyze, " << msg;
0179   }
0180
0181   void TestReadGlobalObjectMapRecord::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0182     edm::ParameterSetDescription desc;
0183     desc.add<std::vector<std::string>>("expectedAlgoNames");
0184     desc.add<std::vector<int>>("expectedAlgoBitNumbers");
0185     desc.add<std::vector<int>>("expectedAlgoGtlResults");
0186     desc.add<std::vector<std::string>>("expectedTokenNames0");
0187     desc.add<std::vector<int>>("expectedTokenNumbers0");
0188     desc.add<std::vector<int>>("expectedTokenResults0");
0189     desc.add<std::vector<std::string>>("expectedTokenNames3");
0190     desc.add<std::vector<int>>("expectedTokenNumbers3");
0191     desc.add<std::vector<int>>("expectedTokenResults3");
0192     desc.add<int>("expectedFirstElement");
0193     desc.add<int>("expectedElementDelta");
0194     desc.add<int>("expectedFinalValue");
0195     desc.add<uint>("expectedBxIndexModulus");
0196     desc.add<edm::InputTag>("globalObjectMapRecordTag");
0197     desc.add<uint>("globalObjectMapClassVersion");
0198     descriptions.addDefault(desc);
0199   }
0200 }  // namespace edmtest
0201
0202 using edmtest::TestReadGlobalObjectMapRecord;
0203 DEFINE_FWK_MODULE(TestReadGlobalObjectMapRecord);