Integration/plugins/TestLimitedOutput.cc

0001
0002 #include "FWCore/Framework/interface/limited/OutputModule.h"
0003 #include "FWCore/Framework/interface/MakerMacros.h"
0004 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
0005 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0006 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
0007 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0008 #include "FWCore/Framework/interface/RunForOutput.h"
0009
0010 #include <memory>
0011 #include <string>
0012 #include <vector>
0013
0014 namespace edm {
0015
0016   class TestLimitedOutput : public limited::OutputModule<WatchInputFiles, RunCache<int>, LuminosityBlockCache<int>> {
0017   public:
0018     explicit TestLimitedOutput(ParameterSet const& pset);
0019     ~TestLimitedOutput() override;
0020     static void fillDescriptions(ConfigurationDescriptions& descriptions);
0021
0022   private:
0023     void write(EventForOutput const& e) override;
0024     void writeLuminosityBlock(LuminosityBlockForOutput const&) override;
0025     void writeRun(RunForOutput const&) override;
0026     void writeProcessBlock(ProcessBlockForOutput const&) override;
0027
0028     void respondToOpenInputFile(FileBlock const&) override;
0029     void respondToCloseInputFile(FileBlock const&) override;
0030
0031     std::shared_ptr<int> globalBeginRun(RunForOutput const&) const override;
0032     void globalEndRun(RunForOutput const&) const override;
0033
0034     std::shared_ptr<int> globalBeginLuminosityBlock(LuminosityBlockForOutput const&) const override;
0035     void globalEndLuminosityBlock(LuminosityBlockForOutput const&) const override;
0036
0037     void endJob() override;
0038
0039     bool verbose_;
0040     std::vector<std::string> expectedProcessesWithProcessBlockProducts_;
0041     int expectedWriteProcessBlockTransitions_;
0042     int countWriteProcessBlockTransitions_ = 0;
0043   };
0044
0045   TestLimitedOutput::TestLimitedOutput(ParameterSet const& pset)
0046       : limited::OutputModuleBase(pset),
0047         limited::OutputModule<WatchInputFiles, RunCache<int>, LuminosityBlockCache<int>>(pset),
0048         verbose_(pset.getUntrackedParameter<bool>("verbose")),
0049         expectedProcessesWithProcessBlockProducts_(
0050             pset.getUntrackedParameter<std::vector<std::string>>("expectedProcessesWithProcessBlockProducts")),
0051         expectedWriteProcessBlockTransitions_(pset.getUntrackedParameter<int>("expectedWriteProcessBlockTransitions")) {
0052   }
0053
0054   TestLimitedOutput::~TestLimitedOutput() {}
0055
0056   void TestLimitedOutput::write(EventForOutput const& e) {
0057     if (verbose_) {
0058       LogAbsolute("TestLimitedOutput") << "limited write event";
0059     }
0060   }
0061
0062   void TestLimitedOutput::writeLuminosityBlock(LuminosityBlockForOutput const&) {
0063     if (verbose_) {
0064       LogAbsolute("TestLimitedOutput") << "limited writeLuminosityBlock";
0065     }
0066   }
0067
0068   void TestLimitedOutput::writeRun(RunForOutput const&) { LogAbsolute("TestLimitedOutput") << "limited writeRun"; }
0069
0070   void TestLimitedOutput::writeProcessBlock(ProcessBlockForOutput const&) {
0071     LogAbsolute("TestLimitedOutput") << "limited writeProcessBlock";
0072     ++countWriteProcessBlockTransitions_;
0073     if (!expectedProcessesWithProcessBlockProducts_.empty()) {
0074       for (auto const& process : outputProcessBlockHelper().processesWithProcessBlockProducts()) {
0075         LogAbsolute("TestLimitedOutput") << "    " << process;
0076       }
0077       if (expectedProcessesWithProcessBlockProducts_ !=
0078           outputProcessBlockHelper().processesWithProcessBlockProducts()) {
0079         throw cms::Exception("TestFailure") << "TestLimitedOutput::writeProcessBlock unexpected process name list";
0080       }
0081     }
0082   }
0083
0084   void TestLimitedOutput::respondToOpenInputFile(FileBlock const&) {
0085     if (verbose_) {
0086       LogAbsolute("TestLimitedOutput") << "limited respondToOpenInputFile";
0087     }
0088   }
0089
0090   void TestLimitedOutput::respondToCloseInputFile(FileBlock const&) {
0091     if (verbose_) {
0092       LogAbsolute("TestLimitedOutput") << "limited respondToCloseInputFile";
0093     }
0094   }
0095
0096   std::shared_ptr<int> TestLimitedOutput::globalBeginRun(RunForOutput const& iRun) const {
0097     LogAbsolute("TestLimitedOutput") << "limited globalBeginRun";
0098     if (verbose_) {
0099       BranchIDLists const* theBranchIDLists = branchIDLists();
0100       for (auto const& branchIDList : *theBranchIDLists) {
0101         LogAbsolute("TestLimitedOutput") << "A branchID list";
0102         for (auto const& branchID : branchIDList) {
0103           LogAbsolute("TestLimitedOutput") << "  limited branchID " << branchID;
0104         }
0105       }
0106       for (auto const& it : iRun.productRegistry().productList()) {
0107         LogAbsolute("TestLimitedOutput") << it.second;
0108       }
0109     }
0110     return std::make_shared<int>(0);
0111   }
0112
0113   void TestLimitedOutput::globalEndRun(RunForOutput const&) const {
0114     LogAbsolute("TestLimitedOutput") << "limited globalEndRun";
0115   }
0116
0117   std::shared_ptr<int> TestLimitedOutput::globalBeginLuminosityBlock(LuminosityBlockForOutput const&) const {
0118     if (verbose_) {
0119       LogAbsolute("TestLimitedOutput") << "limited globalBeginLuminosityBlock";
0120     }
0121     return std::make_shared<int>(0);
0122   }
0123
0124   void TestLimitedOutput::globalEndLuminosityBlock(LuminosityBlockForOutput const&) const {
0125     if (verbose_) {
0126       LogAbsolute("TestLimitedOutput") << "limited globalEndLuminosityBlock";
0127     }
0128   }
0129
0130   void TestLimitedOutput::endJob() {
0131     if (expectedWriteProcessBlockTransitions_ >= 0) {
0132       if (expectedWriteProcessBlockTransitions_ != countWriteProcessBlockTransitions_) {
0133         throw cms::Exception("TestFailure")
0134             << "TestLimitedOutput::writeProcessBlock unexpected number of writeProcessBlock transitions";
0135       }
0136     }
0137   }
0138
0139   void TestLimitedOutput::fillDescriptions(ConfigurationDescriptions& descriptions) {
0140     ParameterSetDescription desc;
0141     OutputModule::fillDescription(desc);
0142     desc.addUntracked<bool>("verbose", true);
0143     desc.addUntracked<std::vector<std::string>>("expectedProcessesWithProcessBlockProducts",
0144                                                 std::vector<std::string>());
0145     desc.addUntracked<int>("expectedWriteProcessBlockTransitions", -1);
0146     descriptions.addDefault(desc);
0147   }
0148 }  // namespace edm
0149
0150 using edm::TestLimitedOutput;
0151 DEFINE_FWK_MODULE(TestLimitedOutput);