From b7d9c56956a79405541d3bbaace17d566f74d093 Mon Sep 17 00:00:00 2001 From: Georgios Krintiras Date: Wed, 8 Feb 2017 13:14:05 +0100 Subject: [PATCH 1/2] small update --- DataFormats/interface/THQLeptonicTag.h | 59 ++- MetaData/data/cross_sections.json | 1 + .../SystematicDumperDefaultVariables.py | 20 +- Systematics/test/bkg_jobs_forthq.sh | 4 +- Systematics/test/bkg_jobs_forthq_ZG.json | 6 + Systematics/test/workspaceStd_testThq.py | 22 +- .../test/workspaceStd_testThq_Georgios.py | 457 ++++++++++++++++++ Taggers/plugins/THQLeptonicTagProducer.cc | 8 +- Taggers/python/THQLeptonicTagVariables.py | 209 ++++++++ 9 files changed, 756 insertions(+), 30 deletions(-) create mode 100644 Systematics/test/bkg_jobs_forthq_ZG.json create mode 100644 Systematics/test/workspaceStd_testThq_Georgios.py create mode 100644 Taggers/python/THQLeptonicTagVariables.py diff --git a/DataFormats/interface/THQLeptonicTag.h b/DataFormats/interface/THQLeptonicTag.h index 3f80836d432..9f2a70496c9 100644 --- a/DataFormats/interface/THQLeptonicTag.h +++ b/DataFormats/interface/THQLeptonicTag.h @@ -28,7 +28,38 @@ namespace flashgg { const std::vector > bJets() const { return BJets_;} const std::vector > nonbJets() const { return nonBJets_;} float thqleptonicMvaRes() const {return thqleptonicMvaRes_;} + + float getElecAlpha(int eleIndex) const{ + float eleta = electrons()[eleIndex]->eta(); + + //for isolation recalculation + float Aeff = 0; + //cmssw/RecoEgamma/ElectronIdentification/data/Summer16/effAreaElectrons_cone03_pfNeuHadronsAndPhotons_80X.txt + if( fabs(eleta) <= 1.0000 ){ + Aeff = 0.1703; + } else if( fabs(eleta) <= 1.4790 ){ + Aeff = 0.1715; + } else if( fabs(eleta) <= 2.0000 ){ + Aeff = 0.1213; + } else if( fabs(eleta) <= 2.2000 ){ + Aeff = 0.1230; + } else if( fabs(eleta) <= 2.3000 ){ + Aeff = 0.1635; + } else if( fabs(eleta) <= 2.4000 ){ + Aeff = 0.1937; + } else if( fabs(eleta) <= 5.0000 ){ + Aeff = 0.2393; + } + + return Aeff; + + }; + /* + float getMuoDz(int muIndex) const{ + mouons()[muIndex]->muonBestTrack()->dz( diPhoton()->vtx()->position() ) ; + } + */ // const reco::LeafCandidate getLepton() const{ // if( electrons().size() == 1 && muons().size() == 0 ){ // return ( *(electrons()[0]) ); @@ -95,21 +126,41 @@ namespace flashgg { return TopMass; } + float getMET() const{ + return MET; + } + float getMET_Phi() const{ + return MET_Phi; + } + void setJets( std::vector > Jets ) { Jets_ = Jets; } void setBJets( std::vector > BJets ) { BJets_ = BJets;} void setLightJets( std::vector > Jets ) { nonBJets_ = Jets;} - void setMuons( std::vector > Muons ) {Muons_ = Muons;} - void setElectrons( std::vector > Electrons ) {Electrons_ = Electrons;} + void setMuons( std::vector > Muons ) { + Muons_ = Muons; + + if( Muons.size() == 1 ) + includeWeights( *Muons_[0] ); + } + void setElectrons( std::vector > Electrons ) { + Electrons_ = Electrons; + if( Electrons_.size() == 1 ) + includeWeights( *Electrons_[0] ); + } + void setMVAres(float val) {thqleptonicMvaRes_ = val;} void setFwdJet( Ptr fwd ) { fwdJet.clear() ; fwdJet.push_back( fwd ) ;} void setbJet( Ptr bj ) { bJet.clear() ; bJet.push_back( bj ) ;} - void setValues( float fox , float aplan , float topMass ){ + void setValues( float fox , float aplan , float topMass, float met, float metPhi ){ FoxWolframMoment_ONE = fox ; Aplanarity = aplan; TopMass = topMass; + + MET = met ; + MET_Phi = metPhi ; } //void setTHQLeptonicMVA( THQLeptonicMVAResult THQLeptonicMVA ) {THQLeptonicMVA_ = THQLeptonicMVA;} void setLeptonType(int val){ LeptonType_ = val; } @@ -127,6 +178,8 @@ namespace flashgg { float FoxWolframMoment_ONE; float Aplanarity; float TopMass; + float MET; + float MET_Phi; }; } diff --git a/MetaData/data/cross_sections.json b/MetaData/data/cross_sections.json index 8133d08793a..a82354d19b2 100644 --- a/MetaData/data/cross_sections.json +++ b/MetaData/data/cross_sections.json @@ -70,6 +70,7 @@ "TTGG_0Jets_TuneCUETP8M1_13TeV_amcatnlo_madspin_pythia8" : { "xs" : 0.017, "br" : 1.0, "kf" : 1.0, "itype":1 }, "TTGJets_TuneCUETP8M1_13TeV-amcatnloFXFX-madspin-pythia8" : { "xs" : 3.697, "br" : 1.0, "kf" : 1.0, "itype":1 }, "TGJets_TuneCUETP8M1_13TeV_amcatnlo_madspin_pythia8" : { "xs" : 2.967, "br" : 1.0, "kf" : 1.0, "itype":1 }, + "ZGTo2LG_TuneCUETP8M1_13TeV-amcatnloFXFX-pythia8" : { "xs" : 117.864, "br" : 1.0, "kf" : 1.0, "itype":1 }, "VHToGG_M120_13TeV_amcatnloFXFX_madspin_pythia8" : { "xs" : 2.559, "br" : 0.00222, "itype":-120400 }, "VHToGG_M121_13TeV_amcatnloFXFX_madspin_pythia8" : { "xs" : 2.495, "br" : 0.00223, "itype":-121400 }, "VHToGG_M122_13TeV_amcatnloFXFX_madspin_pythia8" : { "xs" : 2.433, "br" : 0.00225, "itype":-122400 }, diff --git a/Systematics/python/SystematicDumperDefaultVariables.py b/Systematics/python/SystematicDumperDefaultVariables.py index 4300c7057d7..162b19e3dc0 100644 --- a/Systematics/python/SystematicDumperDefaultVariables.py +++ b/Systematics/python/SystematicDumperDefaultVariables.py @@ -18,24 +18,8 @@ "leadIDMVA :=leadingView.phoIdMvaWrtChosenVtx", "subleadIDMVA :=subLeadingView.phoIdMvaWrtChosenVtx", "maxEta :=max(abs(diPhoton().leadingPhoton.superCluster.eta),abs(diPhoton().leadingPhoton.superCluster.eta))", - "vtxZ :=diPhoton().vtx().z", - "bjet1_pt := ?bJets.size>0? bJets.at(0).pt : -1", - "bjet2_pt := ?bJets.size>1? bJets.at(1).pt : -1", - "bjet1_eta:= ?bJets.size>0? bJets.at(0).eta: -1", - "bjet2_eta:= ?bJets.size>1? bJets.at(1).eta:-1", - "bjet1_abseta := ?bJets.size>0? abs(bJets.at(0).eta): -1", - "bjet2_abseta := ?bJets.size>1? abs(bJets.at(1).eta): -1", - "jet1_pt := ?(jets.size>0)? jets.at(0).pt : -1", - "jet2_pt := ?(jets.size>1)? jets.at(1).pt : -1", - "jet1_eta := ?(jets.size>0)? jets.at(0).eta : -1", - "jet2_eta := ?(jets.size>1)? jets.at(1).eta: -1", - "jet1_abseta := ?(jets.size>0)? abs(jets.at(0).eta): -1", - "jet2_abseta := ?(jets.size>1)? abs(jets.at(1).eta): -1", - "electronjet1deta := ?(electrons.size>0)? abs(electrons.at(0).eta - jets.at(0).eta) : -1", - "electronjet2deta := ?(electrons.size>0)? abs(electrons.at(0).eta - jets.at(1).eta) : -1", - "muonjet1deta := ?(muons.size>0)? abs(muons.at(0).eta - jets.at(0).eta) : -1", -"muonjet2deta := ?(muons.size>0)? abs(muons.at(0).eta - jets.at(1).eta) : -1", - ] + "vtxZ :=diPhoton().vtx().z" + ] defaultHistograms=["CMS_hgg_mass>>mass(160,100,180)", diff --git a/Systematics/test/bkg_jobs_forthq.sh b/Systematics/test/bkg_jobs_forthq.sh index f91edfc7b3a..695ea3d54f1 100755 --- a/Systematics/test/bkg_jobs_forthq.sh +++ b/Systematics/test/bkg_jobs_forthq.sh @@ -3,5 +3,5 @@ outdir="/eos/user/g/gkrintir/test/" queue="1nd" useAAA=1 -version="0" -fggRunJobs.py --load bkg_jobs_forthq.json -d $outdir/bkg_jobs_$version -x cmsRun workspaceStd_testThq.py maxEvents=-1 -n 500 -q 1nd -D -P useAAA=1 --no-use-tarball puTarget=2.51e+05,1.15e+06,2.47e+06,3.72e+06,5.19e+06,6.79e+06,8.67e+06,2.31e+07,5.89e+07,1.38e+08,3.12e+08,5.71e+08,8.76e+08,1.21e+09,1.56e+09,1.87e+09,2.08e+09,2.19e+09,2.24e+09,2.28e+09,2.29e+09,2.24e+09,2.15e+09,2.03e+09,1.88e+09,1.71e+09,1.54e+09,1.36e+09,1.19e+09,1.01e+09,8.48e+08,6.94e+08,5.57e+08,4.38e+08,3.37e+08,2.53e+08,1.85e+08,1.31e+08,8.96e+07,5.87e+07,3.68e+07,2.2e+07,1.25e+07,6.75e+06,3.46e+06,1.68e+06,7.79e+05,3.44e+05,1.46e+05,6.13e+04,2.68e+04,1.33e+04,8.25e+03,6.3e+03,5.45e+03,4.97e+03,4.59e+03,4.25e+03,3.92e+03,3.58e+03,3.25e+03,2.93e+03,2.62e+03,2.33e+03,2.05e+03,1.79e+03,1.56e+03,1.34e+03,1.14e+03,969,815,680,563,463,378 \ No newline at end of file +version="ZG" +fggRunJobs.py --load bkg_jobs_forthq_ZG.json -d $outdir/bkg_jobs_$version -x cmsRun workspaceStd_testThq.py maxEvents=-1 -n 500 -q 1nd -D -P useAAA=1 --no-use-tarball puTarget=2.51e+05,1.15e+06,2.47e+06,3.72e+06,5.19e+06,6.79e+06,8.67e+06,2.31e+07,5.89e+07,1.38e+08,3.12e+08,5.71e+08,8.76e+08,1.21e+09,1.56e+09,1.87e+09,2.08e+09,2.19e+09,2.24e+09,2.28e+09,2.29e+09,2.24e+09,2.15e+09,2.03e+09,1.88e+09,1.71e+09,1.54e+09,1.36e+09,1.19e+09,1.01e+09,8.48e+08,6.94e+08,5.57e+08,4.38e+08,3.37e+08,2.53e+08,1.85e+08,1.31e+08,8.96e+07,5.87e+07,3.68e+07,2.2e+07,1.25e+07,6.75e+06,3.46e+06,1.68e+06,7.79e+05,3.44e+05,1.46e+05,6.13e+04,2.68e+04,1.33e+04,8.25e+03,6.3e+03,5.45e+03,4.97e+03,4.59e+03,4.25e+03,3.92e+03,3.58e+03,3.25e+03,2.93e+03,2.62e+03,2.33e+03,2.05e+03,1.79e+03,1.56e+03,1.34e+03,1.14e+03,969,815,680,563,463,378 \ No newline at end of file diff --git a/Systematics/test/bkg_jobs_forthq_ZG.json b/Systematics/test/bkg_jobs_forthq_ZG.json new file mode 100644 index 00000000000..c127259c5fc --- /dev/null +++ b/Systematics/test/bkg_jobs_forthq_ZG.json @@ -0,0 +1,6 @@ +{ + "processes" : { + "DY" : [ "/ZGTo2LG_TuneCUETP8M1_13TeV-amcatnloFXFX-pythia8"] + }, + "cmdLine" : "campaign=RunIISummer16-2_4_1-25ns_Moriond17" +} \ No newline at end of file diff --git a/Systematics/test/workspaceStd_testThq.py b/Systematics/test/workspaceStd_testThq.py index de6def881d3..22ffa1f7e3c 100644 --- a/Systematics/test/workspaceStd_testThq.py +++ b/Systematics/test/workspaceStd_testThq.py @@ -147,8 +147,10 @@ # Or use the official tool instead useEGMTools(process) - +import flashgg.Taggers.THQLeptonicTagVariables as var +''' variablesToUse = defaultVariables + variablesToUse.append("topMass :=getTopMass()") variablesToUse.append("fwdJetEta :=getFwdJet().eta") @@ -165,6 +167,15 @@ variablesToUse.append("MVA :=thqleptonicMvaRes()") +variablesToUse.append("MET :=getMET()") +variablesToUse.append("METPhi :=getMET_Phi()") + +variablesToUse.append("prompt_pho_1 := diPhoton.leadingPhoton.genMatchType()") +variablesToUse.append("prompt_pho_2 := diPhoton.subLeadingPhoton.genMatchType()") + +variablesToUse.append("MuonsPt := getMuonsPt()" ) +''' +variablesToUse = defaultVariables + var.vtx_variables + var.dipho_variables + var.photon_variables + var.lepton_variables + var.jet_variables print "-------------------------------------------------" print "--- Variables to be dumped, including systematic weights ---" print variablesToUse @@ -185,12 +196,13 @@ process.extraDumpers = cms.Sequence() from flashgg.Taggers.tagsDumpers_cfi import * +#process.load("flashgg.Taggers.globalVariables_cff") process.thqLeptonicTagDumper = createTagDumper("THQLeptonicTag") process.thqLeptonicTagDumper.dumpTrees = customize.dumpTrees process.thqLeptonicTagDumper.dumpWorkspace = customize.dumpWorkspace process.thqLeptonicTagDumper.nameTemplate ="$PROCESS_$SQRTS_$LABEL_$SUBCAT" - +#process.thqLeptonicTagDumper.globalVariables = process.globalVariables import flashgg.Taggers.dumperConfigTools as cfgTools cfgTools.addCategories(process.thqLeptonicTagDumper, @@ -225,9 +237,11 @@ if( not hasattr(process,"options") ): process.options = cms.untracked.PSet() -process.options.allowUnscheduled = cms.untracked.bool(False) +process.options.allowUnscheduled = cms.untracked.bool(True) + process.flashggTHQLeptonicTag.ElectronTag = "flashggElectronSystematics" +process.flashggTHQLeptonicTag.MuonTag = "flashggMuonSystematics" process.p = cms.Path(process.dataRequirements* process.genFilter* process.flashggUpdatedIdMVADiPhotons* @@ -308,7 +322,7 @@ #print >> processDumpFile, process.dumpPython() # set default options if needed -customize.setDefault("maxEvents",-1) +customize.setDefault("maxEvents",2000) customize.setDefault("targetLumi",1.00e+3) # call the customization customize(process) diff --git a/Systematics/test/workspaceStd_testThq_Georgios.py b/Systematics/test/workspaceStd_testThq_Georgios.py new file mode 100644 index 00000000000..8dadc74e39e --- /dev/null +++ b/Systematics/test/workspaceStd_testThq_Georgios.py @@ -0,0 +1,457 @@ +#!/usr/bin/env cmsRun + +import FWCore.ParameterSet.Config as cms +import FWCore.Utilities.FileUtils as FileUtils +import FWCore.ParameterSet.VarParsing as VarParsing +from flashgg.Systematics.SystematicDumperDefaultVariables import defaultVariables,minimalVariables,minimalHistograms,minimalNonSignalVariables,systematicVariables +import os + +process = cms.Process("FLASHggTHQ") + +process.load("FWCore.MessageService.MessageLogger_cfi") +process.load("Configuration.StandardSequences.GeometryDB_cff") +process.load("Configuration.StandardSequences.MagneticField_cff") +process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_condDBv2_cff") +from Configuration.AlCa.GlobalTag import GlobalTag +if os.environ["CMSSW_VERSION"].count("CMSSW_7_6"): + process.GlobalTag.globaltag = '76X_mcRun2_asymptotic_v12' +elif os.environ["CMSSW_VERSION"].count("CMSSW_7_4"): + process.GlobalTag.globaltag = '74X_mcRun2_asymptotic_v4' +elif os.environ["CMSSW_VERSION"].count("CMSSW_8_0"): + process.GlobalTag.globaltag = '80X_mcRun2_asymptotic_2016_miniAODv2' +else: + raise Exception,"Could not find a sensible CMSSW_VERSION for default globaltag" + +process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(2000) ) +process.MessageLogger.cerr.FwkReport.reportEvery = cms.untracked.int32( 100 ) + + + +from flashgg.Systematics.SystematicsCustomize import * +jetSystematicsInputTags = createStandardSystematicsProducers(process) +modifyTagSequenceForSystematics(process,jetSystematicsInputTags) + +systlabels = [""] +phosystlabels = [] +metsystlabels = [] +jetsystlabels = [] +elesystlabels = [] +musystlabels = [] + +from flashgg.MetaData.JobConfig import customize +customize.options.register('doFiducial', + False, + VarParsing.VarParsing.multiplicity.singleton, + VarParsing.VarParsing.varType.bool, + 'doFiducial' + ) +customize.options.register('acceptance', + 'NONE', + VarParsing.VarParsing.multiplicity.singleton, + VarParsing.VarParsing.varType.string, + 'acceptance' + ) +customize.options.register('doSystematics', + True, + VarParsing.VarParsing.multiplicity.singleton, + VarParsing.VarParsing.varType.bool, + 'doSystematics' + ) +customize.options.register('doPdfWeights', + True, + VarParsing.VarParsing.multiplicity.singleton, + VarParsing.VarParsing.varType.bool, + 'doPdfWeights' + ) +customize.options.register('dumpTrees', + True, + VarParsing.VarParsing.multiplicity.singleton, + VarParsing.VarParsing.varType.bool, + 'dumpTrees' + ) +customize.options.register('dumpWorkspace', + True, + VarParsing.VarParsing.multiplicity.singleton, + VarParsing.VarParsing.varType.bool, + 'dumpWorkspace' + ) +customize.options.register('doMuFilter', + True, + VarParsing.VarParsing.multiplicity.singleton, + VarParsing.VarParsing.varType.bool, + 'doMuFilter' + ) + + +print "Printing defaults" +print 'doFiducial '+str(customize.doFiducial) +print 'acceptance '+str(customize.acceptance) +# import flashgg customization to check if we have signal or background +from flashgg.MetaData.JobConfig import customize +customize.parse() +print "Printing options" +print 'doFiducial '+str(customize.doFiducial) +print 'acceptance '+str(customize.acceptance) + +if customize.doFiducial: + import flashgg.Systematics.fiducialCrossSectionsCustomize as fc + fc.leadCut = 1./3. + fc.subLeadCut = 1./4. + fc.isoCut = 10. + fc.etaCut = 2.5 + matchCut = "leadingPhoton.hasMatchedGenPhoton() && subLeadingPhoton.hasMatchedGenPhoton()" + phoIDcut = '(leadingView().phoIdMvaWrtChosenVtx() >0.320 && subLeadingView().phoIdMvaWrtChosenVtx() >0.320)' + accCut = fc.getAccRecoCut() + + print process.flashggPreselectedDiPhotons.cut + + if customize.acceptance == 'IN': + process.flashggPreselectedDiPhotons.cut = cms.string(str(process.flashggPreselectedDiPhotons.cut)[12:-2] +' && '+ str(matchCut)+ ' && '+ str(phoIDcut) +' && ' + str(accCut)) + + if customize.acceptance == 'OUT': + process.flashggPreselectedDiPhotons.cut = cms.string(str(process.flashggPreselectedDiPhotons.cut)[12:-2] +' && '+ str(matchCut)+ ' && '+ str(phoIDcut) +' && !' + str(accCut)) + + if customize.acceptance == 'NONE': + process.flashggPreselectedDiPhotons.cut = cms.string(str(process.flashggPreselectedDiPhotons.cut)[12:-2] +' && '+ str(phoIDcut)) + print "Here we print the preslection cut" + print process.flashggPreselectedDiPhotons.cut + +process.load("flashgg/Taggers/flashggTagSequence_cfi") +print 'here we print the tag sequence before' +print process.flashggTagSequence +if customize.doFiducial: + from PhysicsTools.PatAlgos.tools.helpers import cloneProcessingSnippet,massSearchReplaceAnyInputTag + process.flashggTagSequence.remove(process.flashggVBFTag) + process.flashggTagSequence.remove(process.flashggTTHLeptonicTag) + process.flashggTagSequence.remove(process.flashggTTHHadronicTag) + #haven't tested VH tags with fiducial cross-section measurement yet + process.flashggTagSequence.remove(process.flashggVHEtTag) + process.flashggTagSequence.remove(process.flashggVHLooseTag) + process.flashggTagSequence.remove(process.flashggVHTightTag) + process.flashggTagSequence.remove(process.flashggVHMetTag) + process.flashggTagSequence.remove(process.flashggWHLeptonicTag) + process.flashggTagSequence.remove(process.flashggZHLeptonicTag) + process.flashggTagSequence.remove(process.flashggVHLeptonicLooseTag) + process.flashggTagSequence.remove(process.flashggVHHadronicTag) + process.flashggTagSequence.replace(process.flashggUntagged, process.flashggSigmaMoMpToMTag) + + +print 'here we print the tag sequence after' +print process.flashggTagSequence + +if customize.doFiducial: + print 'we do fiducial and we change tagsorter' + process.flashggTagSorter.TagPriorityRanges = cms.VPSet( cms.PSet(TagName = cms.InputTag('flashggSigmaMoMpToMTag')) ) + + + +print "customize.processId:",customize.processId +# load appropriate scale and smearing bins here +# systematics customization scripts will take care of adjusting flashggDiPhotonSystematics +#process.load("flashgg.Systematics.escales.escale76X_16DecRereco_2015") + +# Or use the official tool instead +useEGMTools(process) + +variablesToUse = defaultVariables +variablesToUse.append("topMass :=getTopMass()") + +variablesToUse.append("fwdJetEta :=getFwdJet().eta") + +variablesToUse.append("LeptonPt :=getLeptonP4().pt") +variablesToUse.append("LeptonType :=getLeptonType()") +variablesToUse.append("LeptonCharge :=getLeptonCharge()") + +variablesToUse.append("nJets :=jets().size()") +variablesToUse.append("nBJets :=bJets().size()") + +variablesToUse.append("FoxWolf :=getFoxWolframMoment_ONE()") +variablesToUse.append("Aplanarity :=getAplanarity()") + +variablesToUse.append("MVA :=thqleptonicMvaRes()") + +# Only run systematics for signal events +print 'customize!!!!!!!!!!!!!!!!!!!!!!!!!!',customize.processId.count("h_") +if customize.processId.count("h_") or customize.processId.count("vbf_") or customize.processId.count("Acceptance") or True: # convention: ggh vbf wzh (wh zh) tth + print "Signal MC, so adding systematics and dZ" + #variablesToUse = minimalVariables + if customize.doFiducial: + variablesToUse.extend(fc.getGenVariables(True)) + variablesToUse.extend(fc.getRecoVariables(True)) + variablesToUse.append("genLeadGenIso := ? diPhoton().leadingPhoton().hasMatchedGenPhoton() ? diPhoton().leadingPhoton().userFloat(\"genIso\") : -99") + variablesToUse.append("decorrSigmarv := diPhotonMVA().decorrSigmarv") + variablesToUse.append("leadmva := diPhotonMVA().leadmva") + variablesToUse.append("subleadmva := diPhotonMVA().subleadmva") + + if customize.doSystematics: + for direction in ["Up","Down"]: + phosystlabels.append("MvaShift%s01sigma" % direction) +# phosystlabels.append("MvaLinearSyst%s01sigma" % direction) + phosystlabels.append("SigmaEOverEShift%s01sigma" % direction) + phosystlabels.append("MaterialCentral%s01sigma" % direction) + phosystlabels.append("MaterialForward%s01sigma" % direction) + phosystlabels.append("FNUFEB%s01sigma" % direction) + phosystlabels.append("FNUFEE%s01sigma" % direction) + jetsystlabels.append("JEC%s01sigma" % direction) + jetsystlabels.append("JER%s01sigma" % direction) + jetsystlabels.append("RMSShift%s01sigma" % direction) + #metsystlabels.append("metUncertainty%s01sigma" % direction) + variablesToUse.append("UnmatchedPUWeight%s01sigma[1,-999999.,999999.] := weight(\"UnmatchedPUWeight%s01sigma\")" % (direction,direction)) + variablesToUse.append("MvaLinearSyst%s01sigma[1,-999999.,999999.] := weight(\"MvaLinearSyst%s01sigma\")" % (direction,direction)) + variablesToUse.append("LooseMvaSF%s01sigma[1,-999999.,999999.] := weight(\"LooseMvaSF%s01sigma\")" % (direction,direction)) + variablesToUse.append("PreselSF%s01sigma[1,-999999.,999999.] := weight(\"PreselSF%s01sigma\")" % (direction,direction)) + variablesToUse.append("electronVetoSF%s01sigma[1,-999999.,999999.] := weight(\"electronVetoSF%s01sigma\")" % (direction,direction)) + variablesToUse.append("TriggerWeight%s01sigma[1,-999999.,999999.] := weight(\"TriggerWeight%s01sigma\")" % (direction,direction)) + variablesToUse.append("FracRVWeight%s01sigma[1,-999999.,999999.] := weight(\"FracRVWeight%s01sigma\")" % (direction,direction)) + variablesToUse.append("ElectronWeight%s01sigma[1,-999999.,999999.] := weight(\"ElectronWeight%s01sigma\")" % (direction,direction)) + variablesToUse.append("MuonWeight%s01sigma[1,-999999.,999999.] := weight(\"MuonWeight%s01sigma\")" % (direction,direction)) + variablesToUse.append("JetBTagCutWeight%s01sigma[1,-999999.,999999.] := weight(\"JetBTagCutWeight%s01sigma\")" % (direction,direction)) + for r9 in ["HighR9","LowR9"]: + for region in ["EB","EE"]: + phosystlabels.append("ShowerShape%s%s%s01sigma"%(r9,region,direction)) +# phosystlabels.append("MCSmear%s%s%s01sigma" % (r9,region,direction)) + phosystlabels.append("MCScale%s%s%s01sigma" % (r9,region,direction)) + for var in ["Rho","Phi"]: + phosystlabels.append("MCSmear%s%s%s%s01sigma" % (r9,region,var,direction)) + systlabels += phosystlabels + systlabels += jetsystlabels + #systlabels += metsystlabels + customizeSystematicsForSignal(process) +elif customize.processId == "Data": + print "Data, so turn off all shifts and systematics, with some exceptions" + variablesToUse = minimalNonSignalVariables + if customize.doFiducial: + variablesToUse.extend(fc.getRecoVariables(True)) + customizeSystematicsForData(process) +else: + print "Background MC, so store mgg and central only" + variablesToUse = minimalNonSignalVariables + customizeSystematicsForBackground(process) + + +#from flashgg.Taggers.globalVariables_cff import globalVariables +#globalVariables.extraFloats.rho = cms.InputTag("rhoFixedGridAll") + +#cloneTagSequenceForEachSystematic(process,systlabels,phosystlabels,jetsystlabels,jetSystematicsInputTags) +cloneTagSequenceForEachSystematic(process,systlabels,phosystlabels,metsystlabels,jetsystlabels,jetSystematicsInputTags) + +print "--- Systematics with independent collections ---" +print systlabels +print "-------------------------------------------------" +print "--- Variables to be dumped, including systematic weights ---" +print variablesToUse +print "------------------------------------------------------------" + + +###### Dumper section + +from flashgg.MetaData.samples_utils import SamplesManager + +process.source = cms.Source ("PoolSource", + fileNames = cms.untracked.vstring("root://eoscms.cern.ch//eos/cms/store/group/phys_higgs/cmshgg/sethzenz/flashgg/RunIISummer16-2_4_1-25ns_Moriond17/2_4_1/THQ_HToGG_13TeV-madgraph-pythia8_TuneCUETP8M1/RunIISummer16-2_4_1-25ns_Moriond17-2_4_1-v0-RunIISummer16MiniAODv2-PUMoriond17_80X_mcRun2_asymptotic_2016_TrancheIV_v6-v1/170114_100016/0000/myMicroAODOutputFile_2.root" + ) + ) + +process.TFileService = cms.Service("TFileService", + fileName = cms.string("test.root")) + +process.extraDumpers = cms.Sequence() +from flashgg.Taggers.tagsDumpers_cfi import * + +process.thqLeptonicTagDumper = createTagDumper("THQLeptonicTag") +process.thqLeptonicTagDumper.src = "flashggSystTagMerger" +process.thqLeptonicTagDumper.dumpTrees = customize.dumpTrees +process.thqLeptonicTagDumper.dumpWorkspace = customize.dumpWorkspace +process.thqLeptonicTagDumper.nameTemplate ="$PROCESS_$SQRTS_$LABEL_$SUBCAT" + + +import flashgg.Taggers.dumperConfigTools as cfgTools +#nominal +#cfgTools.addCategories(process.thqLeptonicTagDumper, + ## categories definition +# [("all","1",0) +# ], + ## variables to be dumped in trees/datasets. Same variables for all categories +# variables=variablesToUse, +# histograms=[] +# ) + + +tagList=[ + ["THQLeptonicTag",0] +] + +definedSysts=set() +process.thqLeptonicTagDumper.classifierCfg.remap=cms.untracked.VPSet() +for tag in tagList: + tagName=tag[0] + tagCats=tag[1] + # remap return value of class-based classifier + process.thqLeptonicTagDumper.classifierCfg.remap.append( cms.untracked.PSet( src=cms.untracked.string("flashgg%s"%tagName), dst=cms.untracked.string(tagName) ) ) + for systlabel in systlabels: + if not systlabel in definedSysts: + # the cut corresponding to the systematics can be defined just once + cutstring = "hasSyst(\"%s\") "%(systlabel) + definedSysts.add(systlabel) + else: + cutstring = None + if systlabel == "": + currentVariables = variablesToUse + else: + currentVariables = systematicVariables + + isBinnedOnly = (systlabel != "") + if ( customize.doPdfWeights or customize.doSystematics ) and ( (customize.datasetName() and customize.datasetName().count("HToGG")) or customize.processId.count("h_") or customize.processId.count("vbf_") ) and (systlabel == ""): + print "Signal MC central value, so dumping PDF weights" + dumpPdfWeights = True + nPdfWeights = 60 + nAlphaSWeights = 2 + nScaleWeights = 9 + else: + print "Data, background MC, or non-central value, or no systematics: no PDF weights" + dumpPdfWeights = False + nPdfWeights = -1 + nAlphaSWeights = -1 + nScaleWeights = -1 + + cfgTools.addCategory(process.thqLeptonicTagDumper, + systlabel, + classname=tagName, + cutbased=cutstring, + subcats=tagCats, + variables=currentVariables, + histograms=minimalHistograms, + binnedOnly=isBinnedOnly, + dumpPdfWeights=dumpPdfWeights, + nPdfWeights=nPdfWeights, + nAlphaSWeights=nAlphaSWeights, + nScaleWeights=nScaleWeights + ) + +# Require standard diphoton trigger +from HLTrigger.HLTfilters.hltHighLevel_cfi import hltHighLevel +process.hltHighLevel= hltHighLevel.clone(HLTPaths = cms.vstring("HLT_Diphoton30_18_R9Id_OR_IsoCaloId_AND_HE_R9Id_Mass90_v*", +# "HLT_Diphoton30PV_18PV_R9Id_AND_IsoCaloId_AND_HE_R9Id_DoublePixelVeto_Mass55_v1", +# "HLT_Diphoton30EB_18EB_R9Id_OR_IsoCaloId_AND_HE_R9Id_DoublePixelVeto_Mass55_v1" + )) + +process.options = cms.untracked.PSet( wantSummary = cms.untracked.bool(True) ) + +# ee bad supercluster filter on data +process.load('RecoMET.METFilters.eeBadScFilter_cfi') +process.eeBadScFilter.EERecHitSource = cms.InputTag("reducedEgamma","reducedEERecHits") # Saved MicroAOD Collection (data only) +# Bad Muon filter +process.load('RecoMET.METFilters.badGlobalMuonTaggersMiniAOD_cff') +process.badGlobalMuonTagger.muons = cms.InputTag("flashggSelectedMuons") +process.cloneGlobalMuonTagger.muons = cms.InputTag("flashggSelectedMuons") +process.dataRequirements = cms.Sequence() +if customize.processId == "Data": + process.dataRequirements += process.hltHighLevel + process.dataRequirements += process.eeBadScFilter + if customize.doMuFilter: + process.dataRequirements += process.noBadGlobalMuons + +# Split WH and ZH +process.genFilter = cms.Sequence() + +# Split out prompt-fake or fake-fake +process.finalFilter = cms.Sequence() +if (customize.processId.count("qcd") or customize.processId.count("gjet")) and customize.processId.count("fake"): + process.load("flashgg/Systematics/PromptFakeFilter_cfi") + process.finalFilter += process.PromptFakeFilter + if (customize.processId.count("promptfake")): + process.PromptFakeFilter.doPromptFake = cms.bool(True) + process.PromptFakeFilter.doFakeFake =cms.bool(False) + elif (customize.processId.count("fakefake")): + process.PromptFakeFilter.doPromptFake =cms.bool(False) + process.PromptFakeFilter.doFakeFake =cms.bool(True) + else: + raise Exception,"Mis-configuration of python for prompt-fake filter" + + +if( not hasattr(process,"options") ): process.options = cms.untracked.PSet() +process.options.allowUnscheduled = cms.untracked.bool(True) + +#process.flashggTHQLeptonicTag.ElectronTag = "flashggElectronSystematics" +process.p = cms.Path(process.dataRequirements* + process.genFilter* + process.flashggUpdatedIdMVADiPhotons* + process.flashggDiPhotonSystematics* + #process.flashggMets* + #process.flashggMetSystematics* + process.flashggMuonSystematics*process.flashggElectronSystematics* + process.flashggUnpackedJets*process.jetSystematicsSequence* + process.flashggTagSequence*process.systematicsTagSequences* + #process.flashggSystTagMerger* + #process.finalFilter* + process.thqLeptonicTagDumper) + + + +print "--- Dumping modules that take diphotons as input: ---" +mns = process.p.moduleNames() +for mn in mns: + module = getattr(process,mn) + if hasattr(module,"src") and type(module.src) == type(cms.InputTag("")) and module.src.value().count("DiPhoton"): + print str(module),module.src + elif hasattr(module,"DiPhotonTag"): + print str(module),module.DiPhotonTag +print +printSystematicInfo(process) + +# Detailed tag interpretation information printout (blinded) +process.flashggTagSorter.StoreOtherTagInfo = True +process.flashggTagSorter.BlindedSelectionPrintout = True + +#### BELOW HERE IS MOSTLY DEBUGGING STUFF + +##################################################################### +## Memory and timing, n.b. igprof is very complicated to interpret ## +##################################################################### + +#from Validation.Performance.TimeMemoryInfo import customise as TimeMemoryCustomize +#TimeMemoryCustomize(process) +#process.MessageLogger.cerr.threshold = 'WARNING' + +#process.load("IgTools.IgProf.IgProfTrigger") +#process.igprof.reportEventInterval = cms.untracked.int32(250) +#process.igprof.reportToFileAtBeginJob = cms.untracked.string("|gzip -c>igprof.begin-job.gz") +#process.igprof.reportToFileAtEvent = cms.untracked.string("|gzip -c>igprof.%I.%E.%L.%R.event.gz") +#process.p += process.igprof + +################################ +## Dump merged tags to screen ## +################################ + +#process.load("flashgg/Taggers/flashggTagTester_cfi") +#process.flashggTagTester.TagSorter = cms.InputTag("flashggSystTagMerger") +#process.flashggTagTester.ExpectMultiples = cms.untracked.bool(True) +#process.p += process.flashggTagTester + +############################################ +## Additional details on tag sorter steps ## +############################################ + +#process.flashggTagSorter.Debug = True + +############## +## Dump EDM ## +############## + +#process.out = cms.OutputModule("PoolOutputModule", fileName = cms.untracked.string('CustomizeWillChangeThisAnyway.root'), +# outputCommands = cms.untracked.vstring('keep *') # dump everything! small tests only! +# ) +#process.e = cms.EndPath(process.out) + +############################ +## Dump the output Python ## +############################ +#print process.dumpPython() +#processDumpFile = open('processDump.py', 'w') +#print >> processDumpFile, process.dumpPython() + +# set default options if needed +customize.setDefault("maxEvents",1000) +customize.setDefault("targetLumi",1.00e+3) +# call the customization +customize(process) diff --git a/Taggers/plugins/THQLeptonicTagProducer.cc b/Taggers/plugins/THQLeptonicTagProducer.cc index 9edd51f5278..8032a0caf97 100644 --- a/Taggers/plugins/THQLeptonicTagProducer.cc +++ b/Taggers/plugins/THQLeptonicTagProducer.cc @@ -667,7 +667,7 @@ namespace flashgg { - if( tagBJets.size() == bjetsNumberThreshold_ && tagJets.size() >= jetsNumberThreshold_ && photonSelection ){ + if( tagBJets.size() >= bjetsNumberThreshold_ && tagJets.size() >= jetsNumberThreshold_ && photonSelection ){ //&& ( ( (tagMuons.size() == 1 && muonJets) and (tagElectrons.size() == 0 && !ElectronJets) ) || ( (tagMuons.size() == 0 && !muonJets) and (tagElectrons.size() == 1 && ElectronJets) ) ) ) @@ -695,7 +695,9 @@ namespace flashgg { edm::Ptr fwdJet = SelJetVect_EtaSorted[0]; edm::Ptr bJet = MediumBJetVect_BSorted[0]; float topMass = -100.; - if( deltaR( fwdJet->p4() , bJet->p4() ) < std::numeric_limits::epsilon() ) + //if( deltaR( fwdJet->p4() , bJet->p4() ) < std::numeric_limits::epsilon() ) + // fwdJet = SelJetVect_EtaSorted[1] ; + if( fwdJet == bJet ) fwdJet = SelJetVect_EtaSorted[1] ; if( LeptonType != 0){ @@ -735,7 +737,7 @@ namespace flashgg { thqltags_obj.setElectrons( tagElectrons ); thqltags_obj.setDiPhotonIndex( diphoIndex ); thqltags_obj.setSystLabel( systLabel_ ); - thqltags_obj.setValues( foxwolf1.another , eventshapes.pt , topMass ); + thqltags_obj.setValues( foxwolf1.another , eventshapes.pt , topMass, metL.Pt(), metL.Phi() ); thqltags->push_back( thqltags_obj ); }//thq tag diff --git a/Taggers/python/THQLeptonicTagVariables.py b/Taggers/python/THQLeptonicTagVariables.py new file mode 100644 index 00000000000..22063565749 --- /dev/null +++ b/Taggers/python/THQLeptonicTagVariables.py @@ -0,0 +1,209 @@ +#import flashgg.Taggers.globalVariables as globalVars + +#import FWCore.ParameterSet.Config as cms + +#from globalVariables_cff import globalVariables + +vtx_variables=[ + "vtxprob := diPhotonMVA.vtxprob", + "ptbal := diPhoton.ptBal", + "ptasym := diPhoton.ptAsym", + "logspt2 := diPhoton.logSumPt2", + "p2conv := diPhoton.pullConv", + "nconv := diPhoton.nConv", + "vtxmva := diPhoton.vtxProbMVA", + "vtxdz := diPhoton.dZ1", + "vtx_x := diPhoton.vtx.x", + "vtx_y := diPhoton.vtx.y", + "vtx_z := diPhoton.vtx.z", + "gv_x := diPhoton.genPV.x", + "gv_y := diPhoton.genPV.y", + "gv_z := diPhoton.genPV.z" + +] + +dipho_variables=[ + "dipho_sumpt := diPhoton.sumPt", + "dipho_cosphi := abs(cos(diPhoton.leadingPhoton.phi - diPhoton.subLeadingPhoton.phi))", + "dipho_mass := diPhoton.mass", + "dipho_pt := diPhoton.pt", + "dipho_phi := diPhoton.phi", + "dipho_eta := diPhoton.eta", + "dipho_PtoM := diPhoton.pt/diPhoton.mass", + "cosphi := diPhotonMVA.CosPhi", + "sigmaMrvoM := diPhotonMVA.sigmarv", + "sigmaMwvoM := diPhotonMVA.sigmawv", +] + +photon_variables=[ + "dipho_leadPt := diPhoton.leadingPhoton.pt", + "dipho_leadEt := diPhoton.leadingPhoton.et", + "dipho_leadEta := diPhoton.leadingPhoton.eta", + "dipho_leadPhi := diPhoton.leadingPhoton.phi", + "dipho_lead_sieie := diPhoton.leadingPhoton.sigmaIetaIeta", + "dipho_lead_hoe := diPhoton.leadingPhoton.hadronicOverEm", + "dipho_lead_sigmaEoE := diPhoton.leadingPhoton.sigEOverE", + "dipho_lead_ptoM := diPhoton.leadingPhoton.pt/diPhoton.mass", + "dipho_leadR9 := diPhoton.leadingPhoton.r9", + "dipho_leadIDMVA := diPhoton.leadingView.phoIdMvaWrtChosenVtx", + "dipho_lead_elveto := diPhoton.leadingPhoton.passElectronVeto", + "dipho_lead_prompt := diPhoton.leadingPhoton.genMatchType", + "dipho_lead_chiso := diPhoton.leadingView.pfChIso03WrtChosenVtx", + "dipho_lead_chisow := diPhoton.leadingPhoton.pfChgIsoWrtWorstVtx04", + "dipho_lead_phoiso := diPhoton.leadingPhoton.pfPhoIso03", + "dipho_lead_phoiso04 := diPhoton.leadingPhoton.pfPhoIso04", + "dipho_lead_neutiso := diPhoton.leadingPhoton.pfNeutIso03", + "dipho_lead_ecaliso03 := diPhoton.leadingPhoton.ecalRecHitSumEtConeDR03", + "dipho_lead_hcaliso03 := diPhoton.leadingPhoton.hcalTowerSumEtConeDR03", + "dipho_lead_pfcluecal03 := diPhoton.leadingPhoton.ecalPFClusterIso", + "dipho_lead_pfcluhcal03 := diPhoton.leadingPhoton.hcalPFClusterIso", + "dipho_lead_trkiso03 := diPhoton.leadingPhoton.trkSumPtHollowConeDR03", + "dipho_lead_pfchiso2 := diPhoton.leadingView.pfChIso02WrtChosenVtx", + "dipho_lead_haspixelseed:= diPhoton.leadingPhoton.hasPixelSeed", + "dipho_lead_sieip := diPhoton.leadingPhoton.sieip", + "dipho_lead_etawidth := diPhoton.leadingPhoton.superCluster.etaWidth", + "dipho_lead_phiwidth := diPhoton.leadingPhoton.superCluster.phiWidth", + "dipho_lead_regrerr := diPhoton.leadingPhoton.sigEOverE * diPhoton.leadingPhoton.energy", + "dipho_lead_s4ratio := diPhoton.leadingPhoton.s4", + "dipho_lead_effSigma := diPhoton.leadingPhoton.esEffSigmaRR", + "dipho_lead_scraw := diPhoton.leadingPhoton.superCluster.rawEnergy", + "dipho_lead_ese := diPhoton.leadingPhoton.superCluster.preshowerEnergy", + + "dipho_subleadPt := diPhoton.subLeadingPhoton.pt", + "dipho_subleadEt := diPhoton.subLeadingPhoton.et", + "dipho_subleadEta := diPhoton.subLeadingPhoton.eta", + "dipho_subleadPhi := diPhoton.subLeadingPhoton.phi", + "dipho_sublead_sieie := diPhoton.subLeadingPhoton.sigmaIetaIeta", + "dipho_sublead_hoe := diPhoton.subLeadingPhoton.hadronicOverEm", + "dipho_sublead_sigmaEoE := diPhoton.subLeadingPhoton.sigEOverE", + "dipho_sublead_ptoM := diPhoton.subLeadingPhoton.pt/diPhoton.mass", + "dipho_subleadR9 := diPhoton.subLeadingPhoton.r9", + "dipho_subleadIDMVA := diPhoton.subLeadingView.phoIdMvaWrtChosenVtx", + "dipho_sublead_elveto := diPhoton.subLeadingPhoton.passElectronVeto", + "dipho_sulead_prompt := diPhoton.subLeadingPhoton.genMatchType", + "dipho_lead_chiso := diPhoton.leadingView.pfChIso03WrtChosenVtx", + "dipho_sublead_chisow := diPhoton.subLeadingPhoton.pfChgIsoWrtWorstVtx04", + "dipho_sublead_phoiso := diPhoton.subLeadingPhoton.pfPhoIso03", + "dipho_sublead_phoiso04 := diPhoton.subLeadingPhoton.pfPhoIso04", + "dipho_sublead_neutiso := diPhoton.subLeadingPhoton.pfNeutIso03", + "dipho_sublead_ecaliso03:= diPhoton.subLeadingPhoton.ecalRecHitSumEtConeDR03", + "dipho_sublead_hcaliso03:= diPhoton.subLeadingPhoton.hcalTowerSumEtConeDR03", + "dipho_sublead_pfcluecal03 := diPhoton.subLeadingPhoton.ecalPFClusterIso", + "dipho_sublead_pfcluhcal03 := diPhoton.subLeadingPhoton.hcalPFClusterIso", + "dipho_sublead_trkiso03 := diPhoton.subLeadingPhoton.trkSumPtHollowConeDR03", + "dipho_sublead_pfchiso2 := diPhoton.subLeadingView.pfChIso02WrtChosenVtx", + "dipho_sublead_haspixelseed:= diPhoton.subLeadingPhoton.hasPixelSeed", + "dipho_sublead_sieip := diPhoton.subLeadingPhoton.sieip", + "dipho_sublead_etawidth := diPhoton.subLeadingPhoton.superCluster.etaWidth", + "dipho_sublead_phiwidth := diPhoton.subLeadingPhoton.superCluster.phiWidth", + "dipho_sublead_regrerr := diPhoton.subLeadingPhoton.sigEOverE * diPhoton.subLeadingPhoton.energy", + "dipho_sublead_s4ratio := diPhoton.subLeadingPhoton.s4", + "dipho_sublead_effSigma := diPhoton.subLeadingPhoton.esEffSigmaRR", + "dipho_sublead_scraw := diPhoton.subLeadingPhoton.superCluster.rawEnergy", + "dipho_sublead_ese := diPhoton.subLeadingPhoton.superCluster.preshowerEnergy", + +] + +lepton_variables=[ + "LeptonType :=getLeptonType()", + "n_ele := electrons.size", + "ele1_pt := ?(electrons.size>0)? electrons.at(0).pt : -999", + "ele2_pt := ?(electrons.size>1)? electrons.at(1).pt : -999", + "ele1_eta := ?(electrons.size>0)? electrons.at(0).superCluster().eta : -999", + "ele2_eta := ?(electrons.size>1)? electrons.at(1).superCluster().eta : -999", + "ele1_phi := ?(electrons.size>0)? electrons.at(0).superCluster().phi : -999", + "ele2_phi := ?(electrons.size>1)? electrons.at(1).superCluster().phi : -999", + "ele1_ch := ?(electrons.size>0)? electrons.at(0).charge : -999", + "ele2_ch := ?(electrons.size>1)? electrons.at(1).charge : -999", + "ele1_sigmaIetaIeta := ?(electrons.size>0)? electrons.at(0).full5x5_sigmaIetaIeta : -999", + "ele2_sigmaIetaIeta := ?(electrons.size>1)? electrons.at(1).full5x5_sigmaIetaIeta : -999", + "ele1_dEtaInSeed := ?(electrons.size>0)? electrons.at(0).deltaEtaSuperClusterTrackAtVtx() - electrons.at(0).superCluster().eta() + electrons.at(0).superCluster().seed().eta : -999", + "ele2_dEtaInSeed := ?(electrons.size>1)? electrons.at(1).deltaEtaSuperClusterTrackAtVtx() - electrons.at(1).superCluster().eta() + electrons.at(1).superCluster().seed().eta : -999", + "ele1_dPhiIn := ?(electrons.size>0)? electrons.at(0).deltaPhiSuperClusterTrackAtVtx : -999", + "ele2_dPhiIn := ?(electrons.size>1)? electrons.at(1).deltaPhiSuperClusterTrackAtVtx : -999", + "ele1_hOverE := ?(electrons.size>0)? electrons.at(0).hadronicOverEm : -999", + "ele2_hOverE := ?(electrons.size>1)? electrons.at(1).hadronicOverEm : -999", + #"ele1_RelIsoEA:= ?(electrons.size>0)? ( electrons.at(0).pfIsolationVariables().sumChargedHadronPt + max(0.0, electrons.at(0).pfIsolationVariables().sumNeutralHadronEt + electrons.at(0).pfIsolationVariables().sumPhotonEt - getElecAlpha(0)*globalVariables.rho) ) / electrons.at(0).pt : -999", + #"ele2_RelIsoEA:= ?(electrons.size>1)? ( electrons.at(1).pfIsolationVariables().sumChargedHadronPt + max(0.0, electrons.at(1).pfIsolationVariables().sumNeutralHadronEt + electrons.at(1).pfIsolationVariables().sumPhotonEt - getElecAlpha(1)*globalVariables.rho) ) / electrons.at(1).pt : -999", + "ele1_ooEmooP := ?(electrons.size>0)? abs(1.0 - electrons.at(0).eSuperClusterOverP)*(1./electrons.at(0).ecalEnergy) : -999", + "ele2_ooEmooP := ?(electrons.size>1)? abs(1.0 - electrons.at(1).eSuperClusterOverP)*(1./electrons.at(1).ecalEnergy) : -999", + "ele1_ConversionVeto := ?(electrons.size>0)? electrons.at(0).passConversionVeto : -999", + "ele2_ConversionVeto := ?(electrons.size>1)? electrons.at(1).passConversionVeto : -999", + "ele1_ChargedHadronPt := ?(electrons.size>0)? electrons.at(0).pfIsolationVariables().sumChargedHadronPt: -999", + "ele2_ChargedHadronPt := ?(electrons.size>1)? electrons.at(1).pfIsolationVariables().sumChargedHadronPt: -999", + "ele2_NeutralHadronEt := ?(electrons.size>1)? electrons.at(1).pfIsolationVariables().sumNeutralHadronEt: -999", + "ele1_NeutralHadronEt := ?(electrons.size>0)? electrons.at(0).pfIsolationVariables().sumNeutralHadronEt: -999", + "ele1_PhotonEt := ?(electrons.size>0)? electrons.at(0).pfIsolationVariables().sumPhotonEt: -999", + "ele2_PhotonEt := ?(electrons.size>1)? electrons.at(1).pfIsolationVariables().sumPhotonEt: -999", + "n_muons := muons.size", + "muon1_pt := ?(muons.size>0)? muons.at(0).pt : -999", + "muon2_pt := ?(muons.size>1)? muons.at(1).pt : -999", + "muon1_eta := ?(muons.size>0)? muons.at(0).eta : -999", + "muon2_eta := ?(muons.size>1)? muons.at(1).eta : -999", + "muon1_phi := ?(muons.size>0)? muons.at(0).phi : -999", + "muon2_phi := ?(muons.size>1)? muons.at(1).phi : -999", + "muon1_ch := ?(muons.size>0)? muons.at(0).charge : -999", + "muon2_ch := ?(muons.size>1)? muons.at(1).charge : -999", + "muon1_iso := ?(muons.size>0)? (muons.at(0).pfIsolationR04().sumChargedHadronPt+ max( 0.,muons.at(0).pfIsolationR04().sumNeutralHadronEt + muons.at(0).pfIsolationR04().sumPhotonEt - 0.5 * muons.at(0).pfIsolationR04().sumPUPt)) / ( muons.at(0).pt ) : -999.", + "muon2_iso := ?(muons.size>1)? (muons.at(1).pfIsolationR04().sumChargedHadronPt+ max( 0.,muons.at(1).pfIsolationR04().sumNeutralHadronEt + muons.at(1).pfIsolationR04().sumPhotonEt - 0.5 * muons.at(1).pfIsolationR04().sumPUPt)) / ( muons.at(1).pt ) : -999.", + "muon1_chi2 := ?(muons.size>0)? muons.at(0).globalTrack().normalizedChi2 : -999", + "muon2_chi2 := ?(muons.size>1)? muons.at(1).globalTrack().normalizedChi2 : -999", + "muon1_mHits := ?(muons.size>0)? muons.at(0).globalTrack().hitPattern().numberOfValidMuonHits : -999", + "muon2_mHits := ?(muons.size>1)? muons.at(1).globalTrack().hitPattern().numberOfValidMuonHits : -999", + "muon1_mStations := ?(muons.size>0)? muons.at(0).numberOfMatchedStations : -999", + "muon2_mStations := ?(muons.size>1)? muons.at(1).numberOfMatchedStations : -999", + #"muon1_dxy := ?(muons.size>0)? muons.at(0).muonBestTrack().dxy(diPhoton().vtx.position) : -999" + #"muon2_dxy := ?(muons.size>1)? muons.at(1).muonBestTrack().dxy() : -999" + "muon1_pxHits := ?(muons.size>0)? muons.at(0).innerTrack().hitPattern().numberOfValidPixelHits : -999", + "muon2_pxHits := ?(muons.size>1)? muons.at(1).innerTrack().hitPattern().numberOfValidPixelHits : -999", + "muon1_tkLayers := ?(muons.size>0)? muons.at(0).innerTrack().hitPattern().trackerLayersWithMeasurement : -999", + "muon2_tkLayers := ?(muons.size>1)? muons.at(1).innerTrack().hitPattern().trackerLayersWithMeasurement : -999" + + + +] +jet_variables=[ + + "n_fwdjets := nonbJets.size", + "fwdjet1_pt := ?nonbJets.size>0? nonbJets.at(0).pt : -999", + "fwdjet2_pt := ?nonbJets.size>1? nonbJets.at(1).pt : -999", + "fwdjet1_eta := ?nonbJets.size>0? nonbJets.at(0).eta: -999.", + "fwdjet2_eta := ?nonbJets.size>1? nonbJets.at(1).eta:-999.", + "fwdjet1_phi := ?nonbJets.size>0? nonbJets.at(0).phi: -999.", + "fwdjet2_phi := ?nonbJets.size>1? nonbJets.at(1).phi: -999.", + + + "n_bjets := bJets.size", + "bjet1_pt := ?bJets.size>0? bJets.at(0).pt : -999", + "bjet2_pt := ?bJets.size>1? bJets.at(1).pt : -999", + "bjet1_eta := ?bJets.size>0? bJets.at(0).eta: -999.", + "bjet2_eta := ?bJets.size>1? bJets.at(1).eta:-999.", + "bjet1_phi := ?bJets.size>0? bJets.at(0).phi: -999.", + "bjet2_phi := ?bJets.size>1? bJets.at(1).phi: -999.", + + # new variables + "n_jets := jets.size", + "jet1_pt := ?jets.size>0? jets.at(0).pt : -999", + "jet2_pt := ?jets.size>1? jets.at(1).pt : -999", + "jet3_pt := ?jets.size>2? jets.at(2).pt : -999", + "jet1_eta := ?jets.size>0? jets.at(0).eta : -999", + "jet2_eta := ?jets.size>1? jets.at(1).eta : -999", + "jet3_eta := ?jets.size>2? jets.at(2).eta : -999", + "jet1_phi := ?jets.size>0? jets.at(0).phi : -999", + "jet2_phi := ?jets.size>1? jets.at(1).phi : -999", + "jet3_phi := ?jets.size>2? jets.at(2).phi : -999", + +] + +thqmva_variables=[ + "fwdJetEta :=getFwdJet().eta", + "FoxWolf :=getFoxWolframMoment_ONE", + "Aplanarity :=getAplanarity()", + "MET :=getMET()", + "METPhi :=getMET_Phi()", + "MVA :=thqleptonicMvaRes()" + +] + +truth_variables=[ + ] From a83a8f3dbd930b21811f4e59182caf4ef7b57f2f Mon Sep 17 00:00:00 2001 From: Georgios Krintiras Date: Wed, 8 Feb 2017 14:09:35 +0100 Subject: [PATCH 2/2] corrected THQLeptonicTag --- DataFormats/interface/THQLeptonicTag.h | 7 ------- 1 file changed, 7 deletions(-) diff --git a/DataFormats/interface/THQLeptonicTag.h b/DataFormats/interface/THQLeptonicTag.h index fb7b2709f78..9c87c44693f 100644 --- a/DataFormats/interface/THQLeptonicTag.h +++ b/DataFormats/interface/THQLeptonicTag.h @@ -132,13 +132,6 @@ namespace flashgg { return MET_Phi; } - float getMET() const{ - return MET; - } - float getMET_Phi() const{ - return MET_Phi; - } - void setJets( std::vector > Jets ) { Jets_ = Jets; } void setBJets( std::vector > BJets ) { BJets_ = BJets;} void setLightJets( std::vector > Jets ) { nonBJets_ = Jets;}