From 5334ab1798f158100d1654f73b878c35b296a719 Mon Sep 17 00:00:00 2001 From: AJ Johnson Date: Fri, 26 Jun 2015 15:55:42 +0200 Subject: [PATCH 1/2] Pavel's tool for writing tau MVA payloads --- .../plugins/GBRForestWriter.cc | 2 +- .../TauTagTools/plugins/TFormulaWriter.cc | 66 ++++++++++ .../TauTagTools/plugins/TFormulaWriter.h | 59 +++++++++ .../TauTagTools/plugins/TGraphWriter.cc | 60 ++++++++++ RecoTauTag/TauTagTools/plugins/TGraphWriter.h | 59 +++++++++ .../python/writeAntiElectronDiscrMVA_cfi.py | 59 +++++++++ .../python/writeAntiMuonDiscrMVA_cfi.py | 57 +++++++++ .../python/writeTauIdDiscrMVA_cfi.py | 111 +++++++++++++++++ RecoTauTag/TauTagTools/test/writeMVAs_cfg.py | 113 ++++++++++++++++++ 9 files changed, 585 insertions(+), 1 deletion(-) create mode 100644 RecoTauTag/TauTagTools/plugins/TFormulaWriter.cc create mode 100644 RecoTauTag/TauTagTools/plugins/TFormulaWriter.h create mode 100644 RecoTauTag/TauTagTools/plugins/TGraphWriter.cc create mode 100644 RecoTauTag/TauTagTools/plugins/TGraphWriter.h create mode 100644 RecoTauTag/TauTagTools/python/writeAntiElectronDiscrMVA_cfi.py create mode 100644 RecoTauTag/TauTagTools/python/writeAntiMuonDiscrMVA_cfi.py create mode 100644 RecoTauTag/TauTagTools/python/writeTauIdDiscrMVA_cfi.py create mode 100644 RecoTauTag/TauTagTools/test/writeMVAs_cfg.py diff --git a/RecoMET/METPUSubtraction/plugins/GBRForestWriter.cc b/RecoMET/METPUSubtraction/plugins/GBRForestWriter.cc index 3e0ea80f4d55b..7233eedc2e047 100644 --- a/RecoMET/METPUSubtraction/plugins/GBRForestWriter.cc +++ b/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(inputFile->Get((*category)->gbrForestName_.data())); // CV: dynamic_cast fails for some reason ?! gbrForest = (GBRForest*)inputFile->Get((*category)->gbrForestName_.data()); diff --git a/RecoTauTag/TauTagTools/plugins/TFormulaWriter.cc b/RecoTauTag/TauTagTools/plugins/TFormulaWriter.cc new file mode 100644 index 0000000000000..8473841b1b504 --- /dev/null +++ b/RecoTauTag/TauTagTools/plugins/TFormulaWriter.cc @@ -0,0 +1,66 @@ +#include "RecoTauTag/TauTagTools/plugins/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 +#include + +TFormulaWriter::TFormulaWriter(const edm::ParameterSet& cfg) + : moduleLabel_(cfg.getParameter("@module_label")) +{ + edm::VParameterSet cfgJobs = cfg.getParameter("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::iterator it = jobs_.begin(); + it != jobs_.end(); ++it ) { + delete (*it); + } +} + +void TFormulaWriter::analyze(const edm::Event&, const edm::EventSetup&) +{ + std::cout << ":" << std::endl; + + for ( std::vector::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(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 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 vfloat; + std::vector limits; + limits.push_back(vfloat(0., 1.e+6)); + std::vector 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); diff --git a/RecoTauTag/TauTagTools/plugins/TFormulaWriter.h b/RecoTauTag/TauTagTools/plugins/TFormulaWriter.h new file mode 100644 index 0000000000000..8e05260c50443 --- /dev/null +++ b/RecoTauTag/TauTagTools/plugins/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 +#include + +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("inputFileName") ) { + edm::FileInPath inputFileName_fip = cfg.getParameter("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("inputFileName") ) { + inputFileName_ = cfg.getParameter("inputFileName"); + } else throw cms::Exception("TFormulaWriter") + << " Undefined Configuration Parameter 'inputFileName !!\n"; + formulaName_ = cfg.getParameter("formulaName"); + outputRecord_ = cfg.getParameter("outputRecord"); + } + ~jobEntryType() {} + std::string inputFileName_; + std::string formulaName_; + std::string outputRecord_; + }; + std::vector jobs_; +}; + +#endif diff --git a/RecoTauTag/TauTagTools/plugins/TGraphWriter.cc b/RecoTauTag/TauTagTools/plugins/TGraphWriter.cc new file mode 100644 index 0000000000000..edada9d8e8cc1 --- /dev/null +++ b/RecoTauTag/TauTagTools/plugins/TGraphWriter.cc @@ -0,0 +1,60 @@ +#include "RecoTauTag/TauTagTools/plugins/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 +#include + +TGraphWriter::TGraphWriter(const edm::ParameterSet& cfg) + : moduleLabel_(cfg.getParameter("@module_label")) +{ + edm::VParameterSet cfgJobs = cfg.getParameter("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::iterator it = jobs_.begin(); + it != jobs_.end(); ++it ) { + delete (*it); + } +} + +void TGraphWriter::analyze(const edm::Event&, const edm::EventSetup&) +{ + std::cout << ":" << std::endl; + + for ( std::vector::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(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 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); diff --git a/RecoTauTag/TauTagTools/plugins/TGraphWriter.h b/RecoTauTag/TauTagTools/plugins/TGraphWriter.h new file mode 100644 index 0000000000000..36ef4c552d748 --- /dev/null +++ b/RecoTauTag/TauTagTools/plugins/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 +#include + +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("inputFileName") ) { + edm::FileInPath inputFileName_fip = cfg.getParameter("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("inputFileName") ) { + inputFileName_ = cfg.getParameter("inputFileName"); + } else throw cms::Exception("TGraphWriter") + << " Undefined Configuration Parameter 'inputFileName !!\n"; + graphName_ = cfg.getParameter("graphName"); + outputRecord_ = cfg.getParameter("outputRecord"); + } + ~jobEntryType() {} + std::string inputFileName_; + std::string graphName_; + std::string outputRecord_; + }; + std::vector jobs_; +}; + +#endif diff --git a/RecoTauTag/TauTagTools/python/writeAntiElectronDiscrMVA_cfi.py b/RecoTauTag/TauTagTools/python/writeAntiElectronDiscrMVA_cfi.py new file mode 100644 index 0000000000000..3ae9a5c67fc19 --- /dev/null +++ b/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) diff --git a/RecoTauTag/TauTagTools/python/writeAntiMuonDiscrMVA_cfi.py b/RecoTauTag/TauTagTools/python/writeAntiMuonDiscrMVA_cfi.py new file mode 100644 index 0000000000000..47851a9b92413 --- /dev/null +++ b/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) diff --git a/RecoTauTag/TauTagTools/python/writeTauIdDiscrMVA_cfi.py b/RecoTauTag/TauTagTools/python/writeTauIdDiscrMVA_cfi.py new file mode 100644 index 0000000000000..82139e53a7510 --- /dev/null +++ b/RecoTauTag/TauTagTools/python/writeTauIdDiscrMVA_cfi.py @@ -0,0 +1,111 @@ +import FWCore.ParameterSet.Config as cms + +tauIdDiscrMVA_trainings = { + 'tauIdMVAoldDMwoLT' : "tauIdMVAoldDMwoLT", + 'tauIdMVAoldDMwLT' : "tauIdMVAoldDMwLT", + 'tauIdMVAnewDMwoLT' : "tauIdMVAnewDMwoLT", + 'tauIdMVAnewDMwLT' : "tauIdMVAnewDMwLT" +} + +tauIdDiscrMVA_WPs = { + 'tauIdMVAoldDMwoLT' : { + 'Eff90' : "oldDMwoLTEff90", + 'Eff80' : "oldDMwoLTEff80", + 'Eff70' : "oldDMwoLTEff70", + 'Eff60' : "oldDMwoLTEff60", + 'Eff50' : "oldDMwoLTEff50", + 'Eff40' : "oldDMwoLTEff40" + }, + 'tauIdMVAoldDMwLT' : { + 'Eff90' : "oldDMwLTEff90", + 'Eff80' : "oldDMwLTEff80", + 'Eff70' : "oldDMwLTEff70", + 'Eff60' : "oldDMwLTEff60", + 'Eff50' : "oldDMwLTEff50", + 'Eff40' : "oldDMwLTEff40" + }, + 'tauIdMVAnewDMwoLT' : { + 'Eff90' : "newDMwoLTEff90", + 'Eff80' : "newDMwoLTEff80", + 'Eff70' : "newDMwoLTEff70", + 'Eff60' : "newDMwoLTEff60", + 'Eff50' : "newDMwoLTEff50", + 'Eff40' : "newDMwoLTEff40" + }, + 'tauIdMVAnewDMwLT' : { + 'Eff90' : "newDMwLTEff90", + 'Eff80' : "newDMwLTEff80", + 'Eff70' : "newDMwLTEff70", + 'Eff60' : "newDMwLTEff60", + 'Eff50' : "newDMwLTEff50", + 'Eff40' : "newDMwLTEff40" + } +} + +tauIdDiscrMVA_mvaOutput_normalizations = { + 'tauIdMVAoldDMwoLT' : "mvaOutput_normalization_oldDMwoLT", + 'tauIdMVAoldDMwLT' : "mvaOutput_normalization_oldDMwLT", + 'tauIdMVAnewDMwoLT' : "mvaOutput_normalization_newDMwoLT", + 'tauIdMVAnewDMwLT' : "mvaOutput_normalization_newDMwLT" +} + + +tauIdDiscrMVA_inputFileNames = { + 'tauIdMVAoldDMwoLT' : { + 'GBRForest' : "RecoTauTag/RecoTau/data/gbrDiscriminationByIsolationMVA3_oldDMwoLT.root", + 'TGraph' : "RecoTauTag/RecoTau/data/wpDiscriminationByIsolationMVA3_oldDMwoLT.root" + }, + + 'tauIdMVAoldDMwLT' : { + 'GBRForest' : "RecoTauTag/RecoTau/data/gbrDiscriminationByIsolationMVA3_oldDMwLT.root", + 'TGraph' : "RecoTauTag/RecoTau/data/wpDiscriminationByIsolationMVA3_oldDMwLT.root" + }, + 'tauIdMVAnewDMwoLT' : { + 'GBRForest' : "RecoTauTag/RecoTau/data/gbrDiscriminationByIsolationMVA3_newDMwoLT.root", + 'TGraph' : "RecoTauTag/RecoTau/data/wpDiscriminationByIsolationMVA3_newDMwoLT.root" + }, + 'tauIdMVAnewDMwLT' : { + 'GBRForest' : "RecoTauTag/RecoTau/data/gbrDiscriminationByIsolationMVA3_newDMwLT.root", + 'TGraph' : "RecoTauTag/RecoTau/data/wpDiscriminationByIsolationMVA3_newDMwLT.root" + } +} + +tauIdDiscrMVA_version = "v1" + +writeTauIdDiscrMVAs = cms.EDAnalyzer("GBRForestWriter", + jobs = cms.VPSet() +) +writeTauIdDiscrWPs = cms.EDAnalyzer("TGraphWriter", + jobs = cms.VPSet() +) +writeTauIdDiscrMVAoutputNormalizations = cms.EDAnalyzer("TFormulaWriter", + jobs = cms.VPSet() +) + +for training, gbrForestName in tauIdDiscrMVA_trainings.items(): + writeTauIdDiscrMVAs.jobs.append( + cms.PSet( + inputFileName = cms.FileInPath(tauIdDiscrMVA_inputFileNames[training]['GBRForest']), + inputFileType = cms.string("GBRForest"), + gbrForestName = cms.string(gbrForestName), + outputFileType = cms.string("SQLLite"), + outputRecord = cms.string("RecoTauTag_%s%s" % (gbrForestName, tauIdDiscrMVA_version)) + ) + ) + for WP in tauIdDiscrMVA_WPs[training].keys(): + writeTauIdDiscrWPs.jobs.append( + cms.PSet( + inputFileName = cms.FileInPath(tauIdDiscrMVA_inputFileNames[training]['TGraph']), + graphName = cms.string(tauIdDiscrMVA_WPs[training][WP]), + outputRecord = cms.string("RecoTauTag_%s%s_WP%s" % (gbrForestName, tauIdDiscrMVA_version, WP)) + ) + ) + writeTauIdDiscrMVAoutputNormalizations.jobs.append( + cms.PSet( + inputFileName = cms.FileInPath(tauIdDiscrMVA_inputFileNames[training]['TGraph']), + formulaName = cms.string(tauIdDiscrMVA_mvaOutput_normalizations[training]), + outputRecord = cms.string("RecoTauTag_%s%s_mvaOutput_normalization" % (gbrForestName, tauIdDiscrMVA_version)) + ) + ) + +writeTauIdDiscrSequence = cms.Sequence(writeTauIdDiscrMVAs + writeTauIdDiscrWPs + writeTauIdDiscrMVAoutputNormalizations) diff --git a/RecoTauTag/TauTagTools/test/writeMVAs_cfg.py b/RecoTauTag/TauTagTools/test/writeMVAs_cfg.py new file mode 100644 index 0000000000000..82f9595baf223 --- /dev/null +++ b/RecoTauTag/TauTagTools/test/writeMVAs_cfg.py @@ -0,0 +1,113 @@ + +import FWCore.ParameterSet.Config as cms + +from datetime import date + +processName = "writeMVAs" +print "<%s>:" % processName +today = date.today() +today_string = "%s%s%s" % (today.strftime("%Y"), today.strftime("%B")[0:3], today.strftime("%d")) +print " date = %s" % today_string + +process = cms.Process(processName) + +process.maxEvents = cms.untracked.PSet( + input = cms.untracked.int32(1) # CV: needs to be set to 1 so that GBRForestWriter::analyze method gets called exactly once +) + +process.source = cms.Source("EmptySource") + +process.load('Configuration/StandardSequences/Services_cff') + +#-------------------------------------------------------------------------------- +# enable/disable update of anti-electron discriminator MVA training +updateAntiElectronDiscrMVA = False + +# enable/disable update of anti-muon discriminator MVA training +updateAntiMuonDiscrMVA = True + +# enable/disable update of tau ID (= isolation+lifetime) discriminator MVA training +updateTauIdDiscrMVA = True +#-------------------------------------------------------------------------------- + +process.load("CondCore.DBCommon.CondDBCommon_cfi") +process.CondDBCommon.connect = 'sqlite_file:RecoTauTag_MVAs_%s.db' % today_string + +process.PoolDBOutputService = cms.Service("PoolDBOutputService", + process.CondDBCommon, + timetype = cms.untracked.string('runnumber'), + toPut = cms.VPSet() +) + +process.writeMVAsSequence = cms.Sequence() + +if updateAntiElectronDiscrMVA: + process.load('RecoTauTag/TauTagTools/writeAntiElectronDiscrMVA_cfi') + for category in process.writeAntiElectronDiscrMVAs.jobs: + process.PoolDBOutputService.toPut.append( + cms.PSet( + record = category.outputRecord, + tag = category.outputRecord + ) + ) + for WP in process.writeAntiElectronDiscrWPs.jobs: + process.PoolDBOutputService.toPut.append( + cms.PSet( + record = WP.outputRecord, + tag = WP.outputRecord + ) + ) + process.writeMVAsSequence += process.writeAntiElectronDiscrSequence +if updateAntiMuonDiscrMVA: + process.load('RecoTauTag/TauTagTools/writeAntiMuonDiscrMVA_cfi') + for training in process.writeAntiMuonDiscrMVAs.jobs: + process.PoolDBOutputService.toPut.append( + cms.PSet( + record = training.outputRecord, + tag = training.outputRecord + ) + ) + for WP in process.writeAntiMuonDiscrWPs.jobs: + process.PoolDBOutputService.toPut.append( + cms.PSet( + record = WP.outputRecord, + tag = WP.outputRecord + ) + ) + for WP in process.writeAntiMuonDiscrMVAoutputNormalizations.jobs: + process.PoolDBOutputService.toPut.append( + cms.PSet( + record = WP.outputRecord, + tag = WP.outputRecord + ) + ) + process.writeMVAsSequence += process.writeAntiMuonDiscrSequence +if updateTauIdDiscrMVA: + process.load('RecoTauTag/TauTagTools/writeTauIdDiscrMVA_cfi') + for training in process.writeTauIdDiscrMVAs.jobs: + process.PoolDBOutputService.toPut.append( + cms.PSet( + record = training.outputRecord, + tag = training.outputRecord + ) + ) + for WP in process.writeTauIdDiscrWPs.jobs: + process.PoolDBOutputService.toPut.append( + cms.PSet( + record = WP.outputRecord, + tag = WP.outputRecord + ) + ) + for WP in process.writeTauIdDiscrMVAoutputNormalizations.jobs: + process.PoolDBOutputService.toPut.append( + cms.PSet( + record = WP.outputRecord, + tag = WP.outputRecord + ) + ) + process.writeMVAsSequence += process.writeTauIdDiscrSequence + +##print "PoolDBOutputService:" +##print process.PoolDBOutputService + +process.p = cms.Path(process.writeMVAsSequence) From cf2e03413121f6db90bc7c15ded83382575eed55 Mon Sep 17 00:00:00 2001 From: AJ Johnson Date: Sun, 28 Jun 2015 20:25:23 +0200 Subject: [PATCH 2/2] Removed RecoTauTag/RecoTau/data folder containing rootfiles, moved non-production code to CondFormats/PhysicsToolsObjects/test --- .../PhysicsToolsObjects/test}/TFormulaWriter.cc | 2 +- .../PhysicsToolsObjects/test}/TFormulaWriter.h | 0 .../PhysicsToolsObjects/test}/TGraphWriter.cc | 2 +- .../PhysicsToolsObjects/test}/TGraphWriter.h | 0 4 files changed, 2 insertions(+), 2 deletions(-) rename {RecoTauTag/TauTagTools/plugins => CondFormats/PhysicsToolsObjects/test}/TFormulaWriter.cc (97%) rename {RecoTauTag/TauTagTools/plugins => CondFormats/PhysicsToolsObjects/test}/TFormulaWriter.h (100%) rename {RecoTauTag/TauTagTools/plugins => CondFormats/PhysicsToolsObjects/test}/TGraphWriter.cc (97%) rename {RecoTauTag/TauTagTools/plugins => CondFormats/PhysicsToolsObjects/test}/TGraphWriter.h (100%) diff --git a/RecoTauTag/TauTagTools/plugins/TFormulaWriter.cc b/CondFormats/PhysicsToolsObjects/test/TFormulaWriter.cc similarity index 97% rename from RecoTauTag/TauTagTools/plugins/TFormulaWriter.cc rename to CondFormats/PhysicsToolsObjects/test/TFormulaWriter.cc index 8473841b1b504..c161f6f2f67c5 100644 --- a/RecoTauTag/TauTagTools/plugins/TFormulaWriter.cc +++ b/CondFormats/PhysicsToolsObjects/test/TFormulaWriter.cc @@ -1,4 +1,4 @@ -#include "RecoTauTag/TauTagTools/plugins/TFormulaWriter.h" +#include "CondFormats/PhysicsToolsObjects/test/TFormulaWriter.h" #include "FWCore/Utilities/interface/Exception.h" diff --git a/RecoTauTag/TauTagTools/plugins/TFormulaWriter.h b/CondFormats/PhysicsToolsObjects/test/TFormulaWriter.h similarity index 100% rename from RecoTauTag/TauTagTools/plugins/TFormulaWriter.h rename to CondFormats/PhysicsToolsObjects/test/TFormulaWriter.h diff --git a/RecoTauTag/TauTagTools/plugins/TGraphWriter.cc b/CondFormats/PhysicsToolsObjects/test/TGraphWriter.cc similarity index 97% rename from RecoTauTag/TauTagTools/plugins/TGraphWriter.cc rename to CondFormats/PhysicsToolsObjects/test/TGraphWriter.cc index edada9d8e8cc1..ac1a4db2cb50d 100644 --- a/RecoTauTag/TauTagTools/plugins/TGraphWriter.cc +++ b/CondFormats/PhysicsToolsObjects/test/TGraphWriter.cc @@ -1,4 +1,4 @@ -#include "RecoTauTag/TauTagTools/plugins/TGraphWriter.h" +#include "CondFormats/PhysicsToolsObjects/test/TGraphWriter.h" #include "FWCore/Utilities/interface/Exception.h" diff --git a/RecoTauTag/TauTagTools/plugins/TGraphWriter.h b/CondFormats/PhysicsToolsObjects/test/TGraphWriter.h similarity index 100% rename from RecoTauTag/TauTagTools/plugins/TGraphWriter.h rename to CondFormats/PhysicsToolsObjects/test/TGraphWriter.h