Payload generator 7 6 x

CondFormats/PhysicsToolsObjects/test/TFormulaWriter.cc

@@ -0,0 +1,66 @@
+#include "CondFormats/PhysicsToolsObjects/test/TFormulaWriter.h"
+
+#include "FWCore/Utilities/interface/Exception.h"
+
+#include "FWCore/ServiceRegistry/interface/Service.h"
+#include "CondCore/DBOutputService/interface/PoolDBOutputService.h"
+
+#include "CondFormats/PhysicsToolsObjects/interface/PhysicsTFormulaPayload.h"
+
+#include <TFile.h>
+#include <TFormula.h>
+
+TFormulaWriter::TFormulaWriter(const edm::ParameterSet& cfg)
+  : moduleLabel_(cfg.getParameter<std::string>("@module_label"))
+{
+  edm::VParameterSet cfgJobs = cfg.getParameter<edm::VParameterSet>("jobs");
+  for ( edm::VParameterSet::const_iterator cfgJob = cfgJobs.begin();
+	cfgJob != cfgJobs.end(); ++cfgJob ) {
+    jobEntryType* job = new jobEntryType(*cfgJob);
+    jobs_.push_back(job);
+  }
+}
+
+TFormulaWriter::~TFormulaWriter()
+{
+  for ( std::vector<jobEntryType*>::iterator it = jobs_.begin();
+	it != jobs_.end(); ++it ) {
+    delete (*it);
+  }
+}
+
+void TFormulaWriter::analyze(const edm::Event&, const edm::EventSetup&)
+{
+  std::cout << "<TFormulaWriter::analyze (moduleLabel = " << moduleLabel_ << ")>:" << std::endl;
+
+  for ( std::vector<jobEntryType*>::iterator job = jobs_.begin();
+	job != jobs_.end(); ++job ) {   
+    TFile* inputFile = new TFile((*job)->inputFileName_.data());
+    std::cout << "reading TFormula = " << (*job)->formulaName_ << " from ROOT file = " << (*job)->inputFileName_ << "." << std::endl;
+    const TFormula* formula = dynamic_cast<TFormula*>(inputFile->Get((*job)->formulaName_.data()));
+    std::cout << "the formula is " << formula->GetExpFormula("p") << std::endl;
+    delete inputFile;
+    if ( !formula ) 
+      throw cms::Exception("TFormulaWriter") 
+	<< " Failed to load TFormula = " << (*job)->formulaName_.data() << " from file = " << (*job)->inputFileName_ << " !!\n";
+    edm::Service<cond::service::PoolDBOutputService> dbService;
+    if ( !dbService.isAvailable() ) 
+      throw cms::Exception("TFormulaWriter") 
+	<< " Failed to access PoolDBOutputService !!\n";
+    std::cout << " writing TFormula = " << (*job)->formulaName_ << " to SQLlite file, record = " << (*job)->outputRecord_ << "." << std::endl;
+    typedef std::pair<float, float> vfloat;
+    std::vector<vfloat> limits;
+    limits.push_back(vfloat(0., 1.e+6));
+    std::vector<std::string> formulas;
+    formulas.push_back((formula->GetExpFormula("p")).Data());
+    PhysicsTFormulaPayload* formulaPayload = new PhysicsTFormulaPayload(limits, formulas);
+    delete formula;
+    dbService->writeOne(formulaPayload, dbService->beginOfTime(), (*job)->outputRecord_);
+  }
+
+  std::cout << "done." << std::endl;
+}
+
+#include "FWCore/Framework/interface/MakerMacros.h"
+
+DEFINE_FWK_MODULE(TFormulaWriter);

CondFormats/PhysicsToolsObjects/test/TFormulaWriter.h

@@ -0,0 +1,59 @@
+#ifndef RecoTauTag_TauTagTools_TFormulaWriter_h
+#define RecoTauTag_TauTagTools_TFormulaWriter_h
+
+/** \class TgraphWriter
+ *
+ * Read TFormula objects from ROOT file input
+ * and store it in SQL-lite output file
+ *
+ * \author Christian Veelken, LLR
+ *
+ */
+
+#include "FWCore/Framework/interface/Frameworkfwd.h"
+#include "FWCore/Framework/interface/EDAnalyzer.h"
+#include "FWCore/Framework/interface/Event.h"
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+
+#include <vector>
+#include <string>
+
+class TFormulaWriter : public edm::EDAnalyzer 
+{
+ public:
+  TFormulaWriter(const edm::ParameterSet&);
+  ~TFormulaWriter();
+
+ private:
+  virtual void analyze(const edm::Event&, const edm::EventSetup&);
+
+  std::string moduleLabel_;
+
+  bool hasRun_;
+
+  struct jobEntryType
+  {
+    jobEntryType(const edm::ParameterSet& cfg)
+    {
+      if ( cfg.existsAs<edm::FileInPath>("inputFileName") ) {
+	edm::FileInPath inputFileName_fip = cfg.getParameter<edm::FileInPath>("inputFileName");
+	if ( inputFileName_fip.location() == edm::FileInPath::Unknown ) 
+	  throw cms::Exception("TFormulaWriter") 
+	    << " Failed to find File = " << inputFileName_fip << " !!\n";
+	inputFileName_ = inputFileName_fip.fullPath();
+      } else if ( cfg.existsAs<std::string>("inputFileName") ) {
+	inputFileName_ = cfg.getParameter<std::string>("inputFileName");
+      } else throw cms::Exception("TFormulaWriter") 
+	       << " Undefined Configuration Parameter 'inputFileName !!\n";
+      formulaName_ = cfg.getParameter<std::string>("formulaName");
+      outputRecord_ = cfg.getParameter<std::string>("outputRecord");
+    }
+    ~jobEntryType() {}
+    std::string inputFileName_;
+    std::string formulaName_;
+    std::string outputRecord_;
+  };
+  std::vector<jobEntryType*> jobs_;
+};
+
+#endif

CondFormats/PhysicsToolsObjects/test/TGraphWriter.cc

@@ -0,0 +1,60 @@
+#include "CondFormats/PhysicsToolsObjects/test/TGraphWriter.h"
+
+#include "FWCore/Utilities/interface/Exception.h"
+
+#include "FWCore/ServiceRegistry/interface/Service.h"
+#include "CondCore/DBOutputService/interface/PoolDBOutputService.h"
+
+#include "CondFormats/PhysicsToolsObjects/interface/PhysicsTGraphPayload.h"
+
+#include <TFile.h>
+#include <TGraph.h>
+
+TGraphWriter::TGraphWriter(const edm::ParameterSet& cfg)
+  : moduleLabel_(cfg.getParameter<std::string>("@module_label"))
+{
+  edm::VParameterSet cfgJobs = cfg.getParameter<edm::VParameterSet>("jobs");
+  for ( edm::VParameterSet::const_iterator cfgJob = cfgJobs.begin();
+	cfgJob != cfgJobs.end(); ++cfgJob ) {
+    jobEntryType* job = new jobEntryType(*cfgJob);
+    jobs_.push_back(job);
+  }
+}
+
+TGraphWriter::~TGraphWriter()
+{
+  for ( std::vector<jobEntryType*>::iterator it = jobs_.begin();
+	it != jobs_.end(); ++it ) {
+    delete (*it);
+  }
+}
+
+void TGraphWriter::analyze(const edm::Event&, const edm::EventSetup&)
+{
+  std::cout << "<TGraphWriter::analyze (moduleLabel = " << moduleLabel_ << ")>:" << std::endl;
+
+  for ( std::vector<jobEntryType*>::iterator job = jobs_.begin();
+	job != jobs_.end(); ++job ) {   
+    TFile* inputFile = new TFile((*job)->inputFileName_.data());
+    std::cout << "reading TGraph = " << (*job)->graphName_ << " from ROOT file = " << (*job)->inputFileName_ << "." << std::endl;
+    const TGraph* graph = dynamic_cast<TGraph*>(inputFile->Get((*job)->graphName_.data()));
+    delete inputFile;
+    if ( !graph ) 
+      throw cms::Exception("TGraphWriter") 
+	<< " Failed to load TGraph = " << (*job)->graphName_.data() << " from file = " << (*job)->inputFileName_ << " !!\n";
+    edm::Service<cond::service::PoolDBOutputService> dbService;
+    if ( !dbService.isAvailable() ) 
+      throw cms::Exception("TGraphWriter") 
+	<< " Failed to access PoolDBOutputService !!\n";
+    std::cout << " writing TGraph = " << (*job)->graphName_ << " to SQLlite file, record = " << (*job)->outputRecord_ << "." << std::endl;
+    PhysicsTGraphPayload* graphPayload = new PhysicsTGraphPayload(*graph);
+    delete graph;
+    dbService->writeOne(graphPayload, dbService->beginOfTime(), (*job)->outputRecord_);
+  }
+
+  std::cout << "done." << std::endl;
+}
+
+#include "FWCore/Framework/interface/MakerMacros.h"
+
+DEFINE_FWK_MODULE(TGraphWriter);

CondFormats/PhysicsToolsObjects/test/TGraphWriter.h

@@ -0,0 +1,59 @@
+#ifndef RecoTauTag_TauTagTools_TGraphWriter_h
+#define RecoTauTag_TauTagTools_TGraphWriter_h
+
+/** \class TGraphWriter
+ *
+ * Read TGraph objects from ROOT file input
+ * and store it in SQL-lite output file
+ *
+ * \author Christian Veelken, LLR
+ *
+ */
+
+#include "FWCore/Framework/interface/Frameworkfwd.h"
+#include "FWCore/Framework/interface/EDAnalyzer.h"
+#include "FWCore/Framework/interface/Event.h"
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+
+#include <vector>
+#include <string>
+
+class TGraphWriter : public edm::EDAnalyzer 
+{
+ public:
+  TGraphWriter(const edm::ParameterSet&);
+  ~TGraphWriter();
+
+ private:
+  virtual void analyze(const edm::Event&, const edm::EventSetup&);
+
+  std::string moduleLabel_;
+
+  bool hasRun_;
+
+  struct jobEntryType
+  {
+    jobEntryType(const edm::ParameterSet& cfg)
+    {
+      if ( cfg.existsAs<edm::FileInPath>("inputFileName") ) {
+	edm::FileInPath inputFileName_fip = cfg.getParameter<edm::FileInPath>("inputFileName");
+	if ( inputFileName_fip.location() == edm::FileInPath::Unknown) 
+	  throw cms::Exception("TGraphWriter") 
+	    << " Failed to find File = " << inputFileName_fip << " !!\n";
+	inputFileName_ = inputFileName_fip.fullPath();
+      } else if ( cfg.existsAs<std::string>("inputFileName") ) {
+	inputFileName_ = cfg.getParameter<std::string>("inputFileName");
+      } else throw cms::Exception("TGraphWriter") 
+	       << " Undefined Configuration Parameter 'inputFileName !!\n";
+      graphName_ = cfg.getParameter<std::string>("graphName");
+      outputRecord_ = cfg.getParameter<std::string>("outputRecord");
+    }
+    ~jobEntryType() {}
+    std::string inputFileName_;
+    std::string graphName_;
+    std::string outputRecord_;
+  };
+  std::vector<jobEntryType*> jobs_;
+};
+
+#endif

RecoMET/METPUSubtraction/plugins/GBRForestWriter.cc

@@ -67,7 +67,7 @@ void GBRForestWriter::analyze(const edm::Event&, const edm::EventSetup&)
 	gbrForest = new GBRForest(bdt);  
 	delete mvaReader;
 	TMVA::Tools::DestroyInstance();
-      } else if ( (*category)->inputFileType_ == jobEntryType::kGBRForest ) {
+      } else if ( (*category)->inputFileType_ == categoryEntryType::kGBRForest ) {
 	TFile* inputFile = new TFile((*category)->inputFileName_.data());
 	//gbrForest = dynamic_cast<GBRForest*>(inputFile->Get((*category)->gbrForestName_.data())); // CV: dynamic_cast<GBRForest*> fails for some reason ?!
 	gbrForest = (GBRForest*)inputFile->Get((*category)->gbrForestName_.data());

RecoTauTag/TauTagTools/python/writeAntiElectronDiscrMVA_cfi.py

@@ -0,0 +1,59 @@
+import FWCore.ParameterSet.Config as cms
+
+# CV: The different categories of the anti-electron MVA discriminator are documented in CMS AN-2012/417.
+#     Also see RecoTauTag/RecoTau/plugins/PFRecoTauDiscriminationAgainstElectronMVA5GBR.cc .
+antiElectronDiscrMVA_categories = {
+     '0' : "gbr_NoEleMatch_woGwoGSF_BL",
+     '1' : "gbr_NoEleMatch_woGwGSF_BL",
+     '2' : "gbr_NoEleMatch_wGwoGSF_BL",
+     '3' : "gbr_NoEleMatch_wGwGSF_BL",
+     '4' : "gbr_woGwoGSF_BL",
+     '5' : "gbr_woGwGSF_BL",
+     '6' : "gbr_wGwoGSF_BL",
+     '7' : "gbr_wGwGSF_BL",
+     '8' : "gbr_NoEleMatch_woGwoGSF_EC",
+     '9' : "gbr_NoEleMatch_woGwGSF_EC",
+    '10' : "gbr_NoEleMatch_wGwoGSF_EC",
+    '11' : "gbr_NoEleMatch_wGwGSF_EC",
+    '12' : "gbr_woGwoGSF_EC",
+    '13' : "gbr_woGwGSF_EC",
+    '14' : "gbr_wGwoGSF_EC",
+    '15' : "gbr_wGwGSF_EC"
+}
+
+antiElectronDiscrMVA_inputFileName = {
+    'GBRForest' : "RecoTauTag/RecoTau/data/gbrDiscriminationAgainstElectronMVA5.root",
+    'TGraph'    : "RecoTauTag/RecoTau/data/wpDiscriminationAgainstElectronMVA5.root"
+}
+
+antiElectronDiscrMVA_WPs = [ "eff99", "eff96", "eff91", "eff85", "eff79" ]
+
+antiElectronDiscrMVA_version = "v1"
+
+writeAntiElectronDiscrMVAs = cms.EDAnalyzer("GBRForestWriter",
+    jobs = cms.VPSet()
+)
+writeAntiElectronDiscrWPs = cms.EDAnalyzer("TGraphWriter",
+    jobs = cms.VPSet()
+)
+
+for category, gbrForestName in antiElectronDiscrMVA_categories.items():
+    writeAntiElectronDiscrMVAs.jobs.append(
+        cms.PSet(
+            inputFileName = cms.FileInPath(antiElectronDiscrMVA_inputFileName['GBRForest']),
+            inputFileType = cms.string("GBRForest"),
+            gbrForestName = cms.string(gbrForestName),
+            outputFileType = cms.string("SQLLite"),                                      
+            outputRecord = cms.string("RecoTauTag_antiElectronMVA5%s_%s" % (antiElectronDiscrMVA_version, gbrForestName))
+        )
+    )
+    for WP in antiElectronDiscrMVA_WPs:
+        writeAntiElectronDiscrWPs.jobs.append(
+            cms.PSet(
+                inputFileName = cms.FileInPath(antiElectronDiscrMVA_inputFileName['TGraph']),
+                graphName = cms.string("%scat%s" % (WP, category)), 
+                outputRecord = cms.string("RecoTauTag_antiElectronMVA5%s_%s_WP%s" % (antiElectronDiscrMVA_version, gbrForestName, WP))
+            )
+        )
+
+writeAntiElectronDiscrSequence = cms.Sequence(writeAntiElectronDiscrMVAs + writeAntiElectronDiscrWPs)

RecoTauTag/TauTagTools/python/writeAntiMuonDiscrMVA_cfi.py

@@ -0,0 +1,57 @@
+import FWCore.ParameterSet.Config as cms
+
+antiMuonDiscrMVA_inputFileName = "RecoTauTag/RecoTau/data/gbrDiscriminationAgainstMuonMVA.root"
+
+antiMuonDiscrMVA_version = "v1"
+
+writeAntiMuonDiscrMVAs = cms.EDAnalyzer("GBRForestWriter",
+    jobs = cms.VPSet()
+)
+
+antiMuonDiscrMVA_inputFileName = {
+    'GBRForest' : "RecoTauTag/RecoTau/data/gbrDiscriminationAgainstMuonMVA.root",
+    'TGraph'    : "RecoTauTag/RecoTau/data/wpDiscriminationByMVAMuonRejection.root"
+}
+
+antiMuonDiscrMVA_WPs = [ "eff99_5", "eff99_0", "eff98_0" ]
+
+antiMuonDiscrMVA_version = "v1"
+
+writeAntiMuonDiscrMVAs = cms.EDAnalyzer("GBRForestWriter",
+    jobs = cms.VPSet()
+)
+writeAntiMuonDiscrWPs = cms.EDAnalyzer("TGraphWriter",
+    jobs = cms.VPSet()
+)
+writeAntiMuonDiscrMVAoutputNormalizations = cms.EDAnalyzer("TFormulaWriter",
+    jobs = cms.VPSet()
+)
+
+gbrForestName = "againstMuonMVA"
+
+writeAntiMuonDiscrMVAs.jobs.append(
+    cms.PSet(
+        inputFileName = cms.FileInPath(antiMuonDiscrMVA_inputFileName['GBRForest']),
+        inputFileType = cms.string("GBRForest"),
+        gbrForestName = cms.string(gbrForestName),
+        outputFileType = cms.string("SQLLite"),                                      
+        outputRecord = cms.string("RecoTauTag_%s%s" % (gbrForestName, antiMuonDiscrMVA_version))
+    )
+)
+for WP in antiMuonDiscrMVA_WPs:
+    writeAntiMuonDiscrWPs.jobs.append(
+        cms.PSet(
+            inputFileName = cms.FileInPath(antiMuonDiscrMVA_inputFileName['TGraph']),
+            graphName = cms.string("opt2%s" % WP), 
+            outputRecord = cms.string("RecoTauTag_%s%s_WP%s" % (gbrForestName, antiMuonDiscrMVA_version, WP))
+        )
+    )
+writeAntiMuonDiscrMVAoutputNormalizations.jobs.append(
+    cms.PSet(
+        inputFileName = cms.FileInPath(antiMuonDiscrMVA_inputFileName['TGraph']),
+        formulaName = cms.string("mvaOutput_normalization_opt2"),
+        outputRecord = cms.string("RecoTauTag_%s%s_mvaOutput_normalization" % (gbrForestName, antiMuonDiscrMVA_version))
+    )
+)
+
+writeAntiMuonDiscrSequence = cms.Sequence(writeAntiMuonDiscrMVAs + writeAntiMuonDiscrWPs + writeAntiMuonDiscrMVAoutputNormalizations)