From 2656222396925967acaabda043eeb2f6c46bd195 Mon Sep 17 00:00:00 2001 From: amassiro <> Date: Mon, 26 Nov 2012 10:49:39 +0000 Subject: [PATCH] 3/4 lep --- .../interface/SkimEventProducer2L2N.h | 126 +++ AnalysisStep/plugins/SkimEventProducer2L2N.cc | 781 ++++++++++++++++++ .../python/skimEventProducer2L2N_cfi.py | 156 ++++ AnalysisStep/python/step3_cff.py | 16 + AnalysisStep/test/step3/step3.py | 147 ++-- 5 files changed, 1153 insertions(+), 73 deletions(-) create mode 100644 AnalysisStep/interface/SkimEventProducer2L2N.h create mode 100644 AnalysisStep/plugins/SkimEventProducer2L2N.cc create mode 100644 AnalysisStep/python/skimEventProducer2L2N_cfi.py diff --git a/AnalysisStep/interface/SkimEventProducer2L2N.h b/AnalysisStep/interface/SkimEventProducer2L2N.h new file mode 100644 index 0000000000000..25900c725514e --- /dev/null +++ b/AnalysisStep/interface/SkimEventProducer2L2N.h @@ -0,0 +1,126 @@ +#ifndef MYPRODUCERS_SkimEventProducer2L2N_SkimEventProducer2L2N_H +#define MYPRODUCERS_SkimEventProducer2L2N_SkimEventProducer2L2N_H + +#include + +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/EDProducer.h" + +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" + +#include "FWCore/ParameterSet/interface/ParameterSet.h" + +#include "WWAnalysis/DataFormats/interface/SkimEvent.h" + +#include "WWAnalysis/AnalysisStep/interface/TriggerBitChecker.h" + +#include "CommonTools/Utils/interface/StringCutObjectSelector.h" + +// BDT ElectronID +#include "HiggsAnalysis/HiggsToWW2Leptons/interface/ElectronIDMVA.h" + +// DYMVA +#include "DataFormats/Math/interface/deltaR.h" +#include "DYMvaInCMSSW/GetDYMVA/interface/GetDYMVA.h" + +// MVAMet +#include +#include "DataFormats/Math/interface/LorentzVector.h" +#include "DataFormats/Math/interface/Vector.h" +#include "pharris/MVAMet/interface/MetUtilities.h" +#include "pharris/MVAMet/interface/MVAMet.h" + +// MC information Gen level +#include "SimDataFormats/GeneratorProducts/interface/GenEventInfoProduct.h" + +class SkimEventProducer2L2N : public edm::EDProducer { + public: + explicit SkimEventProducer2L2N(const edm::ParameterSet&); + ~SkimEventProducer2L2N(); + + + // MVAMet + typedef math::XYZTLorentzVector LorentzVector; + typedef math::XYZVector Vector; + + struct JetInfo { + LorentzVector p4; + double mva; + double neutFrac; + }; + + + private: + virtual void beginJob() ; + virtual void produce(edm::Event&, const edm::EventSetup&); + virtual void endJob() ; + reco::MET doChMET(edm::Handle candsH, + const reco::Candidate* cand1,const reco::Candidate* cand2); + + std::string branchAlias_; + reco::SkimEvent::hypoType hypoType_; + + edm::InputTag triggerTag_; + TriggerBitChecker singleMuData_; + TriggerBitChecker singleElData_; + TriggerBitChecker doubleMuData_; + TriggerBitChecker doubleElData_; + TriggerBitChecker muEGData_; + TriggerBitChecker singleMuMC_; + TriggerBitChecker singleElMC_; + TriggerBitChecker doubleMuMC_; + TriggerBitChecker doubleElMC_; + TriggerBitChecker muEGMC_; + TriggerBitChecker AllEmbed_; + + edm::InputTag mcGenEventInfoTag_; + edm::InputTag mcGenWeightTag_; + edm::InputTag genParticlesTag_; + edm::InputTag muTag_; + edm::InputTag elTag_; + edm::InputTag softMuTag_; + edm::InputTag jetTag_; + edm::InputTag tagJetTag_; + edm::InputTag pfMetTag_; + edm::InputTag tcMetTag_; + edm::InputTag chargedMetTag_; + edm::InputTag vtxTag_; + // edm::InputTag allCandsTag_; // Needed for MVAMet + edm::InputTag chCandsTag_; + edm::InputTag sptTag_; + edm::InputTag spt2Tag_; + // std::string l2File_; + // std::string l3File_; + // std::string resFile_; + + GetDYMVA *getDYMVA_v0; + GetDYMVA *getDYMVA_v1; + + void addDYMVA(reco::SkimEvent* event); + + MVAMet *fMVAMet; + + std::vector > lPFInfo; + std::vector lJetInfo; + std::vector lVtxInfo; + + void makeJets (std::vector &iJetInfo, + const edm::Handle &jH, + reco::VertexCollection &iVertices); + + void makeCandidates (std::vector > &iPFInfo, + edm::Handle cH, + reco::Vertex *iPV); + + void makeVertices (std::vector &iPVInfo, + reco::VertexCollection &iVertices); + + reco::PFMET getMvaMet(const reco::Candidate *cand1, + const reco::Candidate *cand2, + reco::Vertex *iPV, + reco::PFMETCollection thePfMet); +}; + + +#endif diff --git a/AnalysisStep/plugins/SkimEventProducer2L2N.cc b/AnalysisStep/plugins/SkimEventProducer2L2N.cc new file mode 100644 index 0000000000000..3e2301ad07e86 --- /dev/null +++ b/AnalysisStep/plugins/SkimEventProducer2L2N.cc @@ -0,0 +1,781 @@ +#include "WWAnalysis/AnalysisStep/interface/SkimEventProducer2L2N.h" +#include "DataFormats/METReco/interface/MET.h" +#include "DataFormats/METReco/interface/METCollection.h" +#include "DataFormats/METReco/interface/PFMET.h" +#include "DataFormats/METReco/interface/PFMETCollection.h" +#include "DataFormats/PatCandidates/interface/Jet.h" +#include "DataFormats/PatCandidates/interface/Muon.h" +#include "DataFormats/PatCandidates/interface/Electron.h" +#include "DataFormats/VertexReco/interface/Vertex.h" +#include "DataFormats/VertexReco/interface/VertexFwd.h" +#include "DataFormats/Common/interface/ValueMap.h" + +#include +#include "Math/VectorUtil.h" + + +SkimEventProducer2L2N::SkimEventProducer2L2N(const edm::ParameterSet& cfg) : + // branchAlias_(cfg.getParameter("branchAlias")), + hypoType_(reco::SkimEvent::hypoTypeByName(cfg.getParameter("hypoType"))), + triggerTag_(cfg.getParameter("triggerTag")), + singleMuData_ ( cfg.getParameter >("singleMuDataPaths") ), + singleElData_ ( cfg.getParameter >("singleElDataPaths") ), + doubleMuData_ ( cfg.getParameter >("doubleMuDataPaths") ), + doubleElData_ ( cfg.getParameter >("doubleElDataPaths") ), + muEGData_ ( cfg.getParameter >("muEGDataPaths") ), + singleMuMC_ ( cfg.getParameter >("singleMuMCPaths") ), + singleElMC_ ( cfg.getParameter >("singleElMCPaths") ), + doubleMuMC_ ( cfg.getParameter >("doubleMuMCPaths") ), + doubleElMC_ ( cfg.getParameter >("doubleElMCPaths") ), + muEGMC_ ( cfg.getParameter >("muEGMCPaths") ), + AllEmbed_ ( cfg.getParameter >("AllEmbedPaths") ) +{ + mcGenEventInfoTag_ = cfg.getParameter("mcGenEventInfoTag"); + mcGenWeightTag_ = cfg.getParameter("mcGenWeightTag"); + genParticlesTag_ = cfg.getParameter("genParticlesTag"); + muTag_ = cfg.getParameter("muTag" ); + elTag_ = cfg.getParameter("elTag" ); + softMuTag_ = cfg.getParameter("softMuTag" ); + jetTag_ = cfg.getParameter("jetTag" ); + tagJetTag_ = cfg.getParameter("tagJetTag" ); + pfMetTag_ = cfg.getParameter("pfMetTag" ); + tcMetTag_ = cfg.getParameter("tcMetTag" ); + chargedMetTag_ = cfg.getParameter("chargedMetTag" ); + vtxTag_ = cfg.getParameter("vtxTag" ); + // allCandsTag_ = cfg.getParameter("allCandsTag" ); // Needed for MVAMet + chCandsTag_ = cfg.getParameter("chCandsTag" ); + + if (cfg.exists("sptTag" )) sptTag_ = cfg.getParameter("sptTag" ); + else sptTag_ = edm::InputTag("","",""); + if (cfg.exists("spt2Tag" )) spt2Tag_ = cfg.getParameter("spt2Tag" ); + else spt2Tag_ = edm::InputTag("","",""); + + produces >().setBranchAlias(cfg.getParameter("@module_label")); + + getDYMVA_v0 = new GetDYMVA(0); + getDYMVA_v1 = new GetDYMVA(1); + + // Needed for MVAMet + // fMVAMet = new MVAMet(0.1); + // fMVAMet->Initialize(cfg, + // TString((getenv("CMSSW_BASE") + std::string("/src/pharris/MVAMet/data/gbrmet_52.root"))), + // TString((getenv("CMSSW_BASE") + std::string("/src/pharris/MVAMet/data/gbrmetphi_52.root"))), + // TString((getenv("CMSSW_BASE") + std::string("/src/pharris/MVAMet/data/gbrmetu1cov_52.root"))), + // TString((getenv("CMSSW_BASE") + std::string("/src/pharris/MVAMet/data/gbrmetu2cov_52.root")))); +} + + +void SkimEventProducer2L2N::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) +{ + std::auto_ptr > skimEvent(new std::vector ); + + //SkimEvent::hypoType type = SkimEvent::hypoTypeByName(hypoType_); + + edm::Handle genParticles; + if(!(genParticlesTag_==edm::InputTag(""))) { + iEvent.getByLabel(genParticlesTag_,genParticles); + } + + edm::Handle jetH; + iEvent.getByLabel(jetTag_,jetH); + + edm::Handle rhoJetIso; + edm::InputTag rho_src ("kt6PFJetsForIso","rho"); + iEvent.getByLabel(rho_src,rhoJetIso); + + edm::Handle tagJetH; + if(!(tagJetTag_==edm::InputTag(""))) iEvent.getByLabel(tagJetTag_,tagJetH); + + edm::Handle pfMetH; + iEvent.getByLabel(pfMetTag_,pfMetH); + +// edm::Handle tcMetH; +// iEvent.getByLabel(tcMetTag_,tcMetH); + +// edm::Handle > chargedMetH; +// iEvent.getByLabel(chargedMetTag_,chargedMetH); + + edm::Handle vtxH; + iEvent.getByLabel(vtxTag_,vtxH); + + // Needed for MVAMet + // edm::Handle allCandsH; + // iEvent.getByLabel(allCandsTag_, allCandsH); + + edm::Handle candsH; + iEvent.getByLabel(chCandsTag_,candsH); + + edm::Handle > sptH; + if(!(sptTag_==edm::InputTag(""))) iEvent.getByLabel(sptTag_,sptH); + + edm::Handle > spt2H; + if(!(spt2Tag_==edm::InputTag(""))) iEvent.getByLabel(spt2Tag_,spt2H); + + edm::Handle triggerResults; + iEvent.getByLabel(triggerTag_,triggerResults); + + // May God have mercy on my soul ... + std::vector passBits; + passBits.push_back( singleMuData_.check(iEvent,*triggerResults) ); + passBits.push_back( singleElData_.check(iEvent,*triggerResults) ); + passBits.push_back( doubleMuData_.check(iEvent,*triggerResults) ); + passBits.push_back( doubleElData_.check(iEvent,*triggerResults) ); + passBits.push_back( muEGData_.check( iEvent,*triggerResults) ); + passBits.push_back( singleMuMC_.check(iEvent,*triggerResults) ); + passBits.push_back( singleElMC_.check(iEvent,*triggerResults) ); + passBits.push_back( doubleMuMC_.check(iEvent,*triggerResults) ); + passBits.push_back( doubleElMC_.check(iEvent,*triggerResults) ); + passBits.push_back( muEGMC_.check( iEvent,*triggerResults) ); + passBits.push_back( AllEmbed_.check( iEvent,*triggerResults) ); + + + edm::Handle > muons; + iEvent.getByLabel(muTag_,muons); + edm::Handle > softs; + iEvent.getByLabel(softMuTag_,softs); + edm::Handle > electrons; + iEvent.getByLabel(elTag_,electrons); + +// edm::Handle mcGenWeight; + edm::Handle mcGenWeight; + if (!(mcGenWeightTag_==edm::InputTag(""))) { + iEvent.getByLabel(mcGenWeightTag_, mcGenWeight); + } + + edm::Handle GenInfoHandle; + if (!(mcGenEventInfoTag_==edm::InputTag(""))) { + iEvent.getByLabel(mcGenEventInfoTag_, GenInfoHandle); + } + + // Needed for MVAMetsetJets + // reco::VertexCollection lVertices = *vtxH; + // reco::Vertex *lPV = 0; + // if (lVertices.size() > 0) lPV = &lVertices[0]; + // + // // makeCandidates(lPFInfo, allCandsH, lPV); // Needed for MVAMet + // makeCandidates(lPFInfo, candsH, lPV); // For now, use candsH instead of allCandsH + // makeJets (lJetInfo, jetH, lVertices); + // makeVertices (lVtxInfo, lVertices); + + + //---- choice of best candidate: highest pt lepton pair + + int type1 = -1; // 0 = electron, 1 = muon + int type2 = -1; // 0 = electron, 1 = muon + int type3 = -1; // 0 = electron, 1 = muon + int type4 = -1; // 0 = electron, 1 = muon + int index1 = -1; + int index2 = -1; + int index3 = -1; + int index4 = -1; + double ptmax1 = -1; + double ptmax2 = -1; + double ptmax3 = -1; + double ptmax4 = -1; + // loop on electrons + for(size_t i=0;isize();++i) { + double temppt = electrons->at(i).pt(); + if (temppt > ptmax1) { + // what was in 3 now is in 4 + ptmax4 = ptmax3; + type4 = type3; + index4 = index3; + + // what was in 2 now is in 3 + ptmax3 = ptmax2; + type3 = type2; + index3 = index2; + + // what was in 1 now is in 2 + ptmax2 = ptmax1; + type2 = type1; + index2 = index1; + + // the new should be in 1 + ptmax1 = temppt; + type1 = 0; + index1 = i; + } + else if (temppt > ptmax2) { + // what was in 3 now is in 4 + ptmax4 = ptmax3; + type4 = type3; + index4 = index3; + + // what was in 2 now is in 3 + ptmax3 = ptmax2; + type3 = type2; + index3 = index2; + + // the new should be in 1 + ptmax2 = temppt; + type2 = 0; + index2 = i; + } + else if (temppt > ptmax3) { + // what was in 3 now is in 4 + ptmax4 = ptmax3; + type4 = type3; + index4 = index3; + + // the new should be in 1 + ptmax3 = temppt; + type3 = 0; + index3 = i; + } + else if (temppt > ptmax4) { + + // the new should be in 1 + ptmax4 = temppt; + type4 = 0; + index4 = i; + } + } + + // loop on muons + for(size_t i=0;isize();++i) { + double temppt = muons->at(i).pt(); + if (temppt > ptmax1) { + // what was in 3 now is in 4 + ptmax4 = ptmax3; + type4 = type3; + index4 = index3; + + // what was in 2 now is in 3 + ptmax3 = ptmax2; + type3 = type2; + index3 = index2; + + // what was in 1 now is in 2 + ptmax2 = ptmax1; + type2 = type1; + index2 = index1; + + // the new should be in 1 + ptmax1 = temppt; + type1 = 1; + index1 = i; + } + else if (temppt > ptmax2) { + // what was in 3 now is in 4 + ptmax4 = ptmax3; + type4 = type3; + index4 = index3; + + // what was in 2 now is in 3 + ptmax3 = ptmax2; + type3 = type2; + index3 = index2; + + // the new should be in 1 + ptmax2 = temppt; + type2 = 1; + index2 = i; + } + else if (temppt > ptmax3) { + // what was in 3 now is in 4 + ptmax4 = ptmax3; + type4 = type3; + index4 = index3; + + // the new should be in 1 + ptmax3 = temppt; + type3 = 1; + index3 = i; + } + else if (temppt > ptmax4) { + + // the new should be in 1 + ptmax4 = temppt; + type4 = 1; + index4 = i; + } + } + + hypoType_ = reco::SkimEvent::hypoTypeByName("WWNONE"); + + if (type1 == 0 && type2 == 0) { + hypoType_ = reco::SkimEvent::hypoTypeByName("WWELEL"); + } + if (type1 == 1 && type2 == 0) { + hypoType_ = reco::SkimEvent::hypoTypeByName("WWMUEL"); + } + if (type1 == 0 && type2 == 1) { + hypoType_ = reco::SkimEvent::hypoTypeByName("WWELMU"); + } + if (type1 == 1 && type2 == 1) { + hypoType_ = reco::SkimEvent::hypoTypeByName("WWMUMU"); + } + +// std::cout << " ho scelto :: " << hypoType_ << " type1 = " << type1 << " :: " << " type2 = " << type2 << std::endl; +// std::cout << " electrons->size() = " << electrons->size() << std::endl; +// std::cout << " muons->size() = " << muons->size() << std::endl; +// std::cout << " index1 = " << index1 << std::endl; +// std::cout << " index2 = " << index2 << std::endl; +// std::cout << " index3 = " << index3 << std::endl; +// std::cout << " index4 = " << index4 << std::endl; + + if(hypoType_==reco::SkimEvent::WWELEL){//ELEL + size_t i = index1; + size_t j = index2; + skimEvent->push_back( *(new reco::SkimEvent(hypoType_) ) ); + skimEvent->back().setEventInfo(iEvent); + // Leptons + skimEvent->back().setLepton(electrons,i); + skimEvent->back().setLepton(electrons,j); + + + for(size_t k=0;ksize();++k) if(k!=i && k!=j) skimEvent->back().setExtraLepton(electrons,k); + for(size_t k=0;ksize();++k) { + float delta1 = ROOT::Math::VectorUtil::DeltaR(muons->at(k).p4(),electrons->at(i).p4()); + float delta2 = ROOT::Math::VectorUtil::DeltaR(muons->at(k).p4(),electrons->at(j).p4()); + if(delta1 > 0.1 && delta2 > 0.1) skimEvent->back().setExtraLepton(muons,k); + } + for(size_t k=0;ksize();++k) skimEvent->back().setSoftMuon(softs,k); + // Everything else + skimEvent->back().setTriggerBits(passBits); + skimEvent->back().setJets(jetH); + skimEvent->back().setJetRhoIso(rhoJetIso); + skimEvent->back().setPFMet(pfMetH); +// skimEvent->back().setTCMet(tcMetH); +// skimEvent->back().setChargedMet(chargedMetH->get(0)); + skimEvent->back().setVertex(vtxH); + if(sptH.isValid() ) skimEvent->back().setVtxSumPts(sptH); + if(spt2H.isValid() ) skimEvent->back().setVtxSumPt2s(spt2H); + if(tagJetH.isValid()) skimEvent->back().setTagJets(tagJetH); + else skimEvent->back().setTagJets(jetH); + skimEvent->back().setChargedMetSmurf(doChMET(candsH,&electrons->at(i),&electrons->at(j))); + // skimEvent->back().setMvaMet(getMvaMet(&electrons->at(i), &electrons->at(j), lPV, *pfMetH)); + if(genParticles.isValid()) { + skimEvent->back().setGenParticles(genParticles); + } + if (!(mcGenWeightTag_==edm::InputTag(""))) { + skimEvent->back().setGenWeight(mcGenWeight); + } + if (!(mcGenEventInfoTag_==edm::InputTag(""))) { + skimEvent->back().setGenInfo(GenInfoHandle); + } + + if (type3 == 0 && index3 != -1) skimEvent->back().setLepton(electrons,index3); + if (type3 == 1 && index3 != -1) skimEvent->back().setLepton(muons,index3); + + if (type4 == 0 && index4 != -1) skimEvent->back().setLepton(electrons,index4); + if (type4 == 1 && index4 != -1) skimEvent->back().setLepton(muons,index4); + + + }else if(hypoType_ == reco::SkimEvent::WWELMU){ + size_t i = index1; + size_t j = index2; + + if( muons->at(j).pt() < electrons->at(i).pt() ) { //---- only a cross check! + skimEvent->push_back( *(new reco::SkimEvent(hypoType_) ) ); + skimEvent->back().setEventInfo(iEvent); + // Leptons + skimEvent->back().setLepton(electrons,i); + skimEvent->back().setLepton(muons,j); + + + for(size_t k=0;ksize();++k) { + float delta1 = ROOT::Math::VectorUtil::DeltaR(electrons->at(k).p4(),muons->at(j).p4()); + if(k!=i && delta1 > 0.1) + skimEvent->back().setExtraLepton(electrons,k); + } + for(size_t k=0;ksize();++k) { + float delta1 = ROOT::Math::VectorUtil::DeltaR(muons->at(k).p4(),electrons->at(i).p4()); + if(delta1 > 0.1 && k!=j) + skimEvent->back().setExtraLepton(muons,k); + } + for(size_t k=0;ksize();++k) { + if(softs->at(k).pt() != muons->at(j).pt() || softs->at(k).eta() != muons->at(j).eta()) + skimEvent->back().setSoftMuon(softs,k); + } + // Everything else + skimEvent->back().setTriggerBits(passBits); + skimEvent->back().setJets(jetH); + skimEvent->back().setJetRhoIso(rhoJetIso); + skimEvent->back().setPFMet(pfMetH); +// skimEvent->back().setTCMet(tcMetH); +// skimEvent->back().setChargedMet(chargedMetH->get(0)); + skimEvent->back().setVertex(vtxH); + if(sptH.isValid() ) skimEvent->back().setVtxSumPts(sptH); + if(spt2H.isValid() ) skimEvent->back().setVtxSumPt2s(spt2H); + if(tagJetH.isValid()) skimEvent->back().setTagJets(tagJetH); + else skimEvent->back().setTagJets(jetH); + skimEvent->back().setChargedMetSmurf(doChMET(candsH,&electrons->at(i),&muons->at(j))); + // skimEvent->back().setMvaMet(getMvaMet(&electrons->at(i), &muons->at(j), lPV, *pfMetH)); + if(genParticles.isValid()) { + skimEvent->back().setGenParticles(genParticles); + } + if (!(mcGenWeightTag_==edm::InputTag(""))) { + skimEvent->back().setGenWeight(mcGenWeight); + } + if (!(mcGenEventInfoTag_==edm::InputTag(""))) { + skimEvent->back().setGenInfo(GenInfoHandle); + } + + if (type3 == 0 && index3 != -1) skimEvent->back().setLepton(electrons,index3); + if (type3 == 1 && index3 != -1) skimEvent->back().setLepton(muons,index3); + + if (type4 == 0 && index4 != -1) skimEvent->back().setLepton(electrons,index4); + if (type4 == 1 && index4 != -1) skimEvent->back().setLepton(muons,index4); + + } + + }else if(hypoType_ == reco::SkimEvent::WWMUEL){ + size_t i = index1; + size_t j = index2; + if( muons->at(j).pt() >= electrons->at(i).pt() ) { //---- only a cross check! + skimEvent->push_back( *(new reco::SkimEvent(hypoType_) ) ); + skimEvent->back().setEventInfo(iEvent); + // Leptons + skimEvent->back().setLepton(electrons,i); + skimEvent->back().setLepton(muons,j); + + for(size_t k=0;ksize();++k) { + float delta1 = ROOT::Math::VectorUtil::DeltaR(electrons->at(k).p4(),muons->at(j).p4()); + if(k!=i && delta1 > 0.1) + skimEvent->back().setExtraLepton(electrons,k); + } + for(size_t k=0;ksize();++k) { + float delta1 = ROOT::Math::VectorUtil::DeltaR(muons->at(k).p4(),electrons->at(i).p4()); + if(delta1 > 0.1 && k!=j) + skimEvent->back().setExtraLepton(muons,k); + } + for(size_t k=0;ksize();++k) { + if(softs->at(k).pt() != muons->at(j).pt() || softs->at(k).eta() != muons->at(j).eta()) + skimEvent->back().setSoftMuon(softs,k); + } + // Everything else + skimEvent->back().setTriggerBits(passBits); + skimEvent->back().setJets(jetH); + skimEvent->back().setJetRhoIso(rhoJetIso); + skimEvent->back().setPFMet(pfMetH); +// skimEvent->back().setTCMet(tcMetH); +// skimEvent->back().setChargedMet(chargedMetH->get(0)); + skimEvent->back().setVertex(vtxH); + if(sptH.isValid() ) skimEvent->back().setVtxSumPts(sptH); + if(spt2H.isValid() ) skimEvent->back().setVtxSumPt2s(spt2H); + if(tagJetH.isValid()) skimEvent->back().setTagJets(tagJetH); + else skimEvent->back().setTagJets(jetH); + skimEvent->back().setChargedMetSmurf(doChMET(candsH,&electrons->at(i),&muons->at(j))); + // skimEvent->back().setMvaMet(getMvaMet(&electrons->at(i), &muons->at(j), lPV, *pfMetH)); + if(genParticles.isValid()) { + skimEvent->back().setGenParticles(genParticles); + } + if (!(mcGenWeightTag_==edm::InputTag(""))) { + skimEvent->back().setGenWeight(mcGenWeight); + } + if (!(mcGenEventInfoTag_==edm::InputTag(""))) { + skimEvent->back().setGenInfo(GenInfoHandle); + } + + if (type3 == 0 && index3 != -1) skimEvent->back().setLepton(electrons,index3); + if (type3 == 1 && index3 != -1) skimEvent->back().setLepton(muons,index3); + + if (type4 == 0 && index4 != -1) skimEvent->back().setLepton(electrons,index4); + if (type4 == 1 && index4 != -1) skimEvent->back().setLepton(muons,index4); + } + + }else if(hypoType_==reco::SkimEvent::WWMUMU){//MUMU + size_t i = index1; + size_t j = index2; + skimEvent->push_back( *(new reco::SkimEvent(hypoType_) ) ); + skimEvent->back().setEventInfo(iEvent); + // Leptons + skimEvent->back().setLepton(muons,i); + skimEvent->back().setLepton(muons,j); + + for(size_t k=0;ksize();++k) { + float delta1 = ROOT::Math::VectorUtil::DeltaR(electrons->at(k).p4(),muons->at(i).p4()); + float delta2 = ROOT::Math::VectorUtil::DeltaR(electrons->at(k).p4(),muons->at(j).p4()); + if(delta1 > 0.1 && delta2 > 0.1) + skimEvent->back().setExtraLepton(electrons,k); + } + for(size_t k=0;ksize();++k) { + if(k!=i && k!=j) + skimEvent->back().setExtraLepton(muons,k); + } + for(size_t k=0;ksize();++k) { + if( (softs->at(k).pt() != muons->at(i).pt() || softs->at(k).eta() != muons->at(i).eta()) && + (softs->at(k).pt() != muons->at(j).pt() || softs->at(k).eta() != muons->at(j).eta()) ) + skimEvent->back().setSoftMuon(softs,k); + } + // Everything else + skimEvent->back().setTriggerBits(passBits); + skimEvent->back().setJets(jetH); + skimEvent->back().setJetRhoIso(rhoJetIso); + skimEvent->back().setPFMet(pfMetH); +// skimEvent->back().setTCMet(tcMetH); +// skimEvent->back().setChargedMet(chargedMetH->get(0)); + skimEvent->back().setVertex(vtxH); + if(sptH.isValid() ) skimEvent->back().setVtxSumPts(sptH); + if(spt2H.isValid() ) skimEvent->back().setVtxSumPt2s(spt2H); + if(tagJetH.isValid()) skimEvent->back().setTagJets(tagJetH); + else skimEvent->back().setTagJets(jetH); + skimEvent->back().setChargedMetSmurf(doChMET(candsH,&muons->at(i),&muons->at(j))); + // skimEvent->back().setMvaMet(getMvaMet(&muons->at(i), &muons->at(j), lPV, *pfMetH)); + if(genParticles.isValid()) { + skimEvent->back().setGenParticles(genParticles); + } + if (!(mcGenWeightTag_==edm::InputTag(""))) { + skimEvent->back().setGenWeight(mcGenWeight); + } + if (!(mcGenEventInfoTag_==edm::InputTag(""))) { + skimEvent->back().setGenInfo(GenInfoHandle); + } + + +// std::cout << " fin qui tutto bene! " << std::endl; + if (type3 == 0 && index3 != -1) skimEvent->back().setLepton(electrons,index3); + if (type3 == 1 && index3 != -1) skimEvent->back().setLepton(muons,index3); + + if (type4 == 0 && index4 != -1) skimEvent->back().setLepton(electrons,index4); + if (type4 == 1 && index4 != -1) skimEvent->back().setLepton(muons,index4); + + }else{ +// throw cms::Exception("BadInput") +// << "ERROR: event type " << hypoType_ << " is not known" ; +// std::cout << "ERROR: event type " << hypoType_ << " is not known" << std::endl ; + } + + + for (size_t jevent=0; jeventsize(); jevent++) { + + reco::SkimEvent* event = &skimEvent->at(jevent); + + addDYMVA(event); + } + + + iEvent.put(skimEvent); +} + + +reco::MET SkimEventProducer2L2N::doChMET(edm::Handle candsH, + const reco::Candidate* cand1,const reco::Candidate* cand2){ + using namespace std; + reco::Candidate::LorentzVector totalP4; + for(reco::CandidateView::const_iterator it= candsH->begin(), ed =candsH->end(); it != ed; ++it){ + if( it->charge() == 0 ) continue; + if(fabs(ROOT::Math::VectorUtil::DeltaR(it->p4(),cand1->p4())) <=0.1) continue; + if(fabs(ROOT::Math::VectorUtil::DeltaR(it->p4(),cand2->p4())) <=0.1) continue; + totalP4 += it->p4(); + } + totalP4 +=cand1->p4(); + totalP4 +=cand2->p4(); + reco::Candidate::LorentzVector invertedP4(-totalP4); + reco::MET met(invertedP4,reco::Candidate::Point(0,0,0)); + return met; +} + + +void SkimEventProducer2L2N::addDYMVA(reco::SkimEvent* event) +{ + float dymva0 = -999; + float dymva1 = -999; + + if (event->nLep() >= 2) { + + size_t index = 0; + float minPt = 0; + float eta = 4.7; + int applyCorrection = 1; + int applyID = 4; + + float jet1pt = event->leadingJetPt (index, minPt, eta, applyCorrection, applyID); + float jet1phi = event->leadingJetPhi(index, minPt, eta, applyCorrection, applyID); + + double dPhiDiLepJet1 = fabs(event->dPhillLeadingJet(eta, applyCorrection, applyID)); + double dPhiJet1MET = fabs(deltaPhi(jet1phi, event->pfMetPhi())); + double dPhillPfMET = fabs(event->dPhillPfMet()); + + if (jet1pt < 15) { + jet1pt = 15; + dPhiDiLepJet1 = -0.1; + dPhiJet1MET = -0.1; + } + + float px_rec = event->pfMet()*cos(event->pfMetPhi()) + event->pXll(); + float py_rec = event->pfMet()*sin(event->pfMetPhi()) + event->pYll(); + double recoil = sqrt(px_rec*px_rec + py_rec*py_rec); + + dymva0 = getDYMVA_v0->getValue(event->nCentralJets(30.0, eta, applyCorrection,applyID), + event->pfMet(), + event->chargedMetSmurf(), + jet1pt, + event->pfMetSignificance(), + dPhiDiLepJet1, + dPhiJet1MET, + event->mTHiggs(event->PFMET)); + + dymva1 = getDYMVA_v1->getValue(event->nCentralJets(30.0, eta, applyCorrection, applyID), + event->projPfMet(), + event->projChargedMetSmurf(), + event->nGoodVertices(), + event->pTll(), + jet1pt, + event->pfMetMEtSig(), + dPhiDiLepJet1, + dPhillPfMET, + dPhiJet1MET, + recoil, + event->mTHiggs(event->PFMET)); + + } + + event->addUserFloat("dymva0", dymva0); + event->addUserFloat("dymva1", dymva1); +} + + +//------------------------------------------------------------------------------ +// makeJets +//------------------------------------------------------------------------------ +void SkimEventProducer2L2N::makeJets(std::vector &iJetInfo, + const edm::Handle &jH, + reco::VertexCollection &iVertices) +{ + iJetInfo.clear(); + + pat::JetRefVector jrv; + + jrv.clear(); + + for (size_t ijet=0; ijetsize(); ++ijet) { + + jrv.push_back(pat::JetRef(jH,ijet)); + + double eta = jrv[ijet]->correctedJet("Uncorrected", "none").eta(); + double energy = jrv[ijet]->correctedJet("Uncorrected", "none").energy(); + double neutralHadronEnergy = jrv[ijet]->correctedJet("Uncorrected", "none").neutralHadronEnergy(); + double neutralEmEnergy = jrv[ijet]->correctedJet("Uncorrected", "none").neutralEmEnergy(); + double chargedHadronEnergy = jrv[ijet]->correctedJet("Uncorrected", "none").chargedHadronEnergy(); + double chargedEmEnergy = jrv[ijet]->correctedJet("Uncorrected", "none").chargedEmEnergy(); + // int nConstituents = jrv[ijet]->correctedJet("Uncorrected", "none").nConstituents(); + int chargedMultiplicity = jrv[ijet]->correctedJet("Uncorrected", "none").chargedMultiplicity(); + + if (energy == 0) continue; + if (neutralHadronEnergy / energy > 0.99) continue; + if (neutralEmEnergy / energy > 0.99) continue; + // if (nConstituents < 2) continue; + if (chargedHadronEnergy / energy <= 0 && fabs(eta) < 2.4) continue; + if (chargedEmEnergy / energy > 0.99 && fabs(eta) < 2.4) continue; + if (chargedMultiplicity < 1 && fabs(eta) < 2.4) continue; + + double lNeuFrac = (energy > 0) ? (neutralEmEnergy + neutralHadronEnergy) / energy : 9999; + + MetUtilities::JetInfo pJetObject; + + pJetObject.p4 = jrv[ijet]->p4(); + pJetObject.mva = jrv[ijet]->userFloat("jetMva"); + pJetObject.neutFrac = lNeuFrac; + + iJetInfo.push_back(pJetObject); + } +} + + +//------------------------------------------------------------------------------ +// makeCandidates +//------------------------------------------------------------------------------ +void SkimEventProducer2L2N::makeCandidates(std::vector > &iPFInfo, + edm::Handle cH, + reco::Vertex *iPV) +{ + iPFInfo.clear(); + + for (reco::CandidateView::const_iterator it=cH->begin(), ed=cH->end(); it!=ed; ++it) { + + double pDZ = -999; + + if (iPV != 0) { + + double bsx = iPV->x(); + double bsy = iPV->y(); + double bsz = iPV->z(); + + double vx = it->vx(); + double vy = it->vy(); + double vz = it->vz(); + + if (vx != 0 || vy != 0 || vz != 0) { + + double px = it->p4().px(); + double py = it->p4().py(); + double pz = it->p4().pz(); + double pt = it->p4().pt(); + + pDZ = fabs((vz - bsz) - ((vx - bsx)*px + (vy - bsy)*py)/pt * pz/pt); + + if (pDZ == 0) pDZ = -999; + } + } + + std::pair pPFObject(it->p4(), pDZ); + + iPFInfo.push_back(pPFObject); + } +} + + +//------------------------------------------------------------------------------ +// makeVertices +//------------------------------------------------------------------------------ +void SkimEventProducer2L2N::makeVertices(std::vector &iPVInfo, + reco::VertexCollection &iVertices) +{ + iPVInfo.clear(); + + for (int i0 = 0; i0<(int)iVertices.size(); i0++) { + + const reco::Vertex *pVertex = &(iVertices.at(i0)); + + Vector pVec; + + pVec.SetCoordinates(pVertex->x(), pVertex->y(), pVertex->z()); + + iPVInfo.push_back(pVec); + } +} + + +//------------------------------------------------------------------------------ +// getMvaMet +//------------------------------------------------------------------------------ +reco::PFMET SkimEventProducer2L2N::getMvaMet(const reco::Candidate *cand1, + const reco::Candidate *cand2, + reco::Vertex *iPV, + reco::PFMETCollection thePfMet) +{ + LorentzVector lVis1 = cand1->p4(); + LorentzVector lVis2 = cand2->p4(); + + std::vector theLeptons; + + theLeptons.push_back(lVis1); + theLeptons.push_back(lVis2); + + std::pair lMVAMetInfo = fMVAMet->GetMet(theLeptons, + lJetInfo, + lPFInfo, + lVtxInfo, + false); + + reco::PFMET lDummy; + + reco::PFMET lMVAMet(lDummy.getSpecific(), + thePfMet.at(0).sumEt(), + lMVAMetInfo.first, + iPV->position()); + + return lMVAMet; +} + + +SkimEventProducer2L2N::~SkimEventProducer2L2N() { + delete getDYMVA_v0; + delete getDYMVA_v1; +} +void SkimEventProducer2L2N::beginJob() { } +void SkimEventProducer2L2N::endJob() { } +DEFINE_FWK_MODULE(SkimEventProducer2L2N); diff --git a/AnalysisStep/python/skimEventProducer2L2N_cfi.py b/AnalysisStep/python/skimEventProducer2L2N_cfi.py new file mode 100644 index 0000000000000..46207279ab5d2 --- /dev/null +++ b/AnalysisStep/python/skimEventProducer2L2N_cfi.py @@ -0,0 +1,156 @@ +import FWCore.ParameterSet.Config as cms + +from WWAnalysis.AnalysisStep.wwElectrons_cfi import * +from WWAnalysis.AnalysisStep.wwMuons_cfi import * + + + +skimEventProducer = cms.EDProducer('SkimEventProducer2L2N', + mcGenEventInfoTag = cms.InputTag(""), + mcGenWeightTag = cms.InputTag(""), + genParticlesTag = cms.InputTag(""), + muTag = cms.InputTag("wwMuons"), + elTag = cms.InputTag("wwElectrons"), + softMuTag = cms.InputTag("wwMuons4Veto"), + # extraElTag = cms.InputTag("wwElectrons"), + jetTag = cms.InputTag("slimPatJetsTriggerMatch"), + tagJetTag = cms.InputTag("slimPatJetsTriggerMatch"), + pfMetTag = cms.InputTag("pfMet"), + tcMetTag = cms.InputTag("tcMet"), + chargedMetTag = cms.InputTag("trackMetProducer"), + vtxTag = cms.InputTag("goodPrimaryVertices"), +### allCandsTag = cms.InputTag("allReducedPFCands"), ### Needed for MVAMet + chCandsTag = cms.InputTag("reducedPFCands"), + sptTag = cms.InputTag("vertexMapProd","sumPt"), + spt2Tag = cms.InputTag("vertexMapProd","sumPt2"), + # branchAlias = cms.string("wwelmu"), + hypoType = cms.string("WWELMU"), + + triggerTag = cms.InputTag("TriggerResults","","HLT"), + singleMuDataPaths = cms.vstring( + "1-163261:HLT_Mu15_v*", + "163262-165099:HLT_Mu24_v*", + "165102-173235:HLT_Mu30_v*", + "173236-175972:HLT_Mu40_v*", + "175973-180252:HLT_Mu40_eta2p1_v*", + "163262-170901:HLT_IsoMu17_v*", + "171050-175910:HLT_IsoMu20_v*", + "175911-175921:HLT_IsoMu24_v*", + "175922-180252:HLT_IsoMu24_eta2p1_v*", +# end of 2011 Data + "190456-999999:HLT_IsoMu24_eta2p1_v*", + ), + doubleMuDataPaths = cms.vstring( + "1-165208:HLT_DoubleMu7_v*", + "165364-178419:HLT_Mu13_Mu8_v*", + "178420-180252:HLT_Mu17_Mu8_v*", + "178420-180252:HLT_Mu17_TkMu8_v*", +# end of 2011 Data + "190456-999999:HLT_Mu17_Mu8_v*", + "190456-999999:HLT_Mu17_TkMu8_v*", + ), + doubleElDataPaths = cms.vstring( + "1-170901:HLT_Ele17_CaloIdL_CaloIsoVL_Ele8_CaloIdL_CaloIsoVL_v*", + "171050-180252:HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v*", +# end of 2011 Data + "190456-999999:HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v*", + ), + muEGDataPaths = cms.vstring( + "1-175972:HLT_Mu17_Ele8_CaloIdL_v*", + "175973-180252:HLT_Mu17_Ele8_CaloIdT_CaloIsoVL_v*", + "1-167913:HLT_Mu8_Ele17_CaloIdL_v*", + "167914-180252:HLT_Mu8_Ele17_CaloIdT_CaloIsoVL_v*", +# end of 2011 Data + "190456-999999:HLT_Mu17_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v*", + "190456-999999:HLT_Mu8_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v*", + ), + singleElDataPaths = cms.vstring( + "1-164237:HLT_Ele27_CaloIdVT_CaloIsoT_TrkIdT_TrkIsoT_v*", + "165085-166967:HLT_Ele32_CaloIdVT_CaloIsoT_TrkIdT_TrkIsoT_v*", + "166968-170901:HLT_Ele52_CaloIdVT_TrkIdT_v*", + "170902-178419:HLT_Ele65_CaloIdVT_TrkIdT_v*", + "178420-180252:HLT_Ele80_CaloIdVT_TrkIdT_v*", +# end of 2011 Data + "190456-999999:HLT_Ele27_WP80_v*", + ), + AllEmbedPaths = cms.vstring( + "1-999999:HLT_*", + ), + + singleMuMCPaths = cms.vstring("*"), + singleElMCPaths = cms.vstring("*"), + doubleMuMCPaths = cms.vstring("*"), + doubleElMCPaths = cms.vstring("*"), + muEGMCPaths = cms.vstring("*"), + # singleMuMCPaths = cms.vstring("HLT_Mu21_v*"), + # singleElMCPaths = cms.vstring("FILLME"), + # doubleMuMCPaths = cms.vstring("HLT_DoubleMu5_v*"), + # doubleElMCPaths = cms.vstring("HLT_Ele17_SW_TightCaloEleId_Ele8HE_L1R_v*"), + # muEGMCPaths = cms.vstring("HLT_Mu5_Ele17_v*","HLT_Mu11_Ele8_v*"), + + looseMuSelection = cms.string(PRESEL_MU +"&&"+ MUON_ID_LOOSE), + tightMuSelection = cms.string(PRESEL_MU +"&&"+ MUON_ID_CUT +"&&"+ MUON_MERGE_ISO+"&&"+MUON_MERGE_IP), + looseEleSelection = cms.string(ELE_BASE + " && " + ELE_ID_LOOSE_2011), + tightEleSelection = cms.string(ELE_BASE + " && " + ELE_MERGE_ID + " && " + ELE_MERGE_ISO + " && " + ELE_MERGE_CONV + " && " + ELE_MERGE_IP), +) + +def addEventHypothesis(process,label,thisMuTag,thisEleTag,thisSoftMuTag='wwMuons4Veto',preSequence=cms.Sequence()): + hypos = ['ellell'] + #hypos = ['mumu','muel','elmu','elel'] + process.peakingFilter = cms.EDFilter("GenFilterDiBosons") + + tempSkimEventFilter = cms.EDFilter("SkimEventSelector", + src = cms.InputTag(""), + filter = cms.bool(True), + cut = cms.string("nLep >=2 "), + ) + + for hypo in hypos: + #create the four hypothesis: + setattr(process,'ww'+hypo+label,process.skimEventProducer.clone(hypoType='WW'+hypo.upper(),muTag=thisMuTag,elTag=thisEleTag,softMuTag=thisSoftMuTag)) + #create SkimEventSelectors (asking for nLep >=2) + setattr(process,'skim'+hypo+label,tempSkimEventFilter.clone(src='ww'+hypo+label)) + # create sequence +# p = cms.Path(preSequence) +# if peakingType == 'peaking': p = cms.Path( process.peakingFilter) +# if peakingType == 'non-peaking': p = cms.Path(~process.peakingFilter) + p = cms.Path( + getattr(process,thisMuTag) + + getattr(process,thisEleTag) + + getattr(process,thisSoftMuTag) + + getattr(process,'ww'+hypo+label) + + getattr(process,'skim'+hypo+label) + ) + setattr(process,'sel'+hypo+label,p) + # add to scheduler + if getattr(process,'schedule') != None: process.schedule.append( getattr(process,'sel'+hypo+label) ) + # add to pooloutput module + if hasattr(process,'out'): process.out.outputCommands.append( 'keep *_{0}_*_*'.format( 'ww'+hypo+label ) ) + if hasattr(process,'out'): process.out.SelectEvents.SelectEvents.append( 'sel'+hypo+label ) + + + +# process.ttLeps = cms.EDProducer("CandViewMerger", +# src = cms.VInputTag( +# cms.InputTag("wwMuonsMergeIP"), +# cms.InputTag("wwEleIPMerge"), +# ) +# ) +# +# process.ttDiLeps = cms.EDProducer("CandViewShallowCloneCombiner", +# decay = cms.string('ttLeps@+ ttLeps@-'), +# cut = cms.string( +# 'deltaR(daughter(0).eta,daughter(0).phi,daughter(1).eta,daughter(1).phi) > 0.05 && ' + +# 'min(daughter(0).pt,daughter(1).pt) > 10 && ' + +# 'max(daughter(0).pt,daughter(1).pt) > 20' +# ), +# checkCharge = cms.bool(True) +# ) +# +# process.ttCount = cms.EDFilter("CandViewCountFilter", src = cms.InputTag("ttDiLeps"), minNumber = cms.uint32(1)) +# +# +# process.ttFilter = cms.Sequence( process.wwEleIPMerge + process.wwMuonsMergeIP + process.ttLeps + process.ttDiLeps + process.ttCount) +# process.ttPath = cms.Path( process.ttFilter ) +# process.schedule.append( process.ttPath ) +# process.out.SelectEvents.SelectEvents.append( 'ttPath' ) diff --git a/AnalysisStep/python/step3_cff.py b/AnalysisStep/python/step3_cff.py index 7d098470145eb..ebccf0a75c0c0 100644 --- a/AnalysisStep/python/step3_cff.py +++ b/AnalysisStep/python/step3_cff.py @@ -140,20 +140,36 @@ jetRho = cms.string("getJetRhoIso()"), iso1 = cms.string("allIsoByPt(0)/ptByPt(0)"), iso2 = cms.string("allIsoByPt(1)/ptByPt(1)"), + iso3 = cms.string("allIsoByPt(2)/ptByPt(2)"), + iso4 = cms.string("allIsoByPt(3)/ptByPt(3)"), eta1 = cms.string("etaByPt(0)"), eta2 = cms.string("etaByPt(1)"), + eta3 = cms.string("etaByPt(2)"), + eta4 = cms.string("etaByPt(3)"), sceta1 = cms.string("etaSCByPt(0)"), sceta2 = cms.string("etaSCByPt(1)"), + sceta3 = cms.string("etaSCByPt(2)"), + sceta4 = cms.string("etaSCByPt(3)"), phi1 = cms.string("phiByPt(0)"), phi2 = cms.string("phiByPt(1)"), + phi3 = cms.string("phiByPt(2)"), + phi4 = cms.string("phiByPt(3)"), ch1 = cms.string("qByPt(0)"), ch2 = cms.string("qByPt(1)"), + ch3 = cms.string("qByPt(2)"), + ch4 = cms.string("qByPt(3)"), bdt1 = cms.string("leptBdtByPt(0)"), bdt2 = cms.string("leptBdtByPt(1)"), + bdt3 = cms.string("leptBdtByPt(2)"), + bdt4 = cms.string("leptBdtByPt(3)"), lh1 = cms.string("leptLHByPt(0)"), lh2 = cms.string("leptLHByPt(1)"), + lh3 = cms.string("leptLHByPt(2)"), + lh4 = cms.string("leptLHByPt(3)"), nbrem1 = cms.string("nBremByPt(0)"), nbrem2 = cms.string("nBremByPt(1)"), + nbrem3 = cms.string("nBremByPt(2)"), + nbrem4 = cms.string("nBremByPt(3)"), # in the 2012 selection, 2 BJet algorithms are used: softtche and hardbjpb ! # softbdisc = cms.string("highestBDiscRange(10.0,30.0,'trackCountingHighEffBJetTags',"+jetId_WP+","+DzBVeto+")"), # hardbdisc = cms.string("highestBDiscRange(30.0,999999.,'jetBProbabilityBJetTags',"+jetId_WP+","+DzBVeto+",1)"), diff --git a/AnalysisStep/test/step3/step3.py b/AnalysisStep/test/step3/step3.py index 2c952087a2bc3..fa5a70ea721dc 100644 --- a/AnalysisStep/test/step3/step3.py +++ b/AnalysisStep/test/step3/step3.py @@ -273,7 +273,8 @@ def addMuVars( s3 ): process.preSkim = cms.Path(process.reboosting) -process.load("WWAnalysis.AnalysisStep.skimEventProducer_cfi") +#process.load("WWAnalysis.AnalysisStep.skimEventProducer_cfi") +process.load("WWAnalysis.AnalysisStep.skimEventProducer2L2N_cfi") if options.selection == 'TightTight': label = "Scenario6"; muon = "wwMuScenario6"; ele = "wwEleScenario6"; softmu = "wwMu4VetoScenario6"; preSeq = cms.Sequence(); @@ -283,7 +284,7 @@ def addMuVars( s3 ): raise ValueError('selection must be either TightTight or LooseLoose') if options.two: # path already set up - from WWAnalysis.AnalysisStep.skimEventProducer_cfi import addEventHypothesis + from WWAnalysis.AnalysisStep.skimEventProducer2L2N_cfi import addEventHypothesis process.skimEventProducer.triggerTag = cms.InputTag("TriggerResults","","HLT") if doTauEmbed == True: process.skimEventProducer.triggerTag = cms.InputTag("TriggerResults","","EmbeddedRECO") @@ -291,87 +292,88 @@ def addMuVars( s3 ): addEventHypothesis(process,label,muon,ele,softmu,preSeq) -for X in "elel", "mumu", "elmu", "muel": - tree = process.step3Tree.clone(src = cms.InputTag("ww%s%s"% (X,label) )); - seq = cms.Sequence() - setattr(process, X+'TreeSequence', seq) - setattr(process, X+"Nvtx", process.nverticesModule.clone(probes = cms.InputTag("ww%s%s"% (X,label)))) - seq += getattr(process, X+"Nvtx") - tree.variables.nvtx = cms.InputTag(X+"Nvtx") - if IsoStudy: addIsoStudyVariables(process,tree) - if dataset[0] == 'MC': - setattr(process, X+"NPU", process.nPU.clone(src = cms.InputTag("ww%s%s"% (X,label)))) - if Summer11: - setattr(process, X+"PuWeight", process.puWeightS4AB.clone(src = cms.InputTag("ww%s%s"% (X,label)))) - setattr(process, X+"PuWeightA", process.puWeightS4A.clone (src = cms.InputTag("ww%s%s"% (X,label)))) - setattr(process, X+"PuWeightB", process.puWeightS4B.clone (src = cms.InputTag("ww%s%s"% (X,label)))) - elif Fall11: - setattr(process, X+"PuWeight", process.puWeightS6AB.clone(src = cms.InputTag("ww%s%s"% (X,label)))) - setattr(process, X+"PuWeightA", process.puWeightS6A.clone (src = cms.InputTag("ww%s%s"% (X,label)))) - setattr(process, X+"PuWeightB", process.puWeightS6B.clone (src = cms.InputTag("ww%s%s"% (X,label)))) - else : - setattr(process, X+"PuWeight", process.puWeightS7AB.clone(src = cms.InputTag("ww%s%s"% (X,label)), nTrueInt = cms.bool(True))) - setattr(process, X+"PuWeightA", process.puWeightS7A.clone (src = cms.InputTag("ww%s%s"% (X,label)), nTrueInt = cms.bool(True))) - setattr(process, X+"PuWeightB", process.puWeightS7B.clone (src = cms.InputTag("ww%s%s"% (X,label)), nTrueInt = cms.bool(True))) - tree.variables.trpu = cms.InputTag(X+"NPU:tr") - tree.variables.itpu = cms.InputTag(X+"NPU:it") - tree.variables.ootpum1 = cms.InputTag(X+"NPU:m1") - tree.variables.ootpup1 = cms.InputTag(X+"NPU:p1") - tree.variables.puW = cms.InputTag(X+"PuWeight") - tree.variables.puAW = cms.InputTag(X+"PuWeightA") - tree.variables.puBW = cms.InputTag(X+"PuWeightB") - seq += getattr(process, X+"NPU") - seq += getattr(process, X+"PuWeight") - seq += getattr(process, X+"PuWeightA") - seq += getattr(process, X+"PuWeightB") - if puStudy: addExtraPUWeights(process,tree,X+label,seq) - if dy: - setattr(process, X+"DYWeight", process.dyWeight.clone(src = cms.InputTag("ww%s%s"% (X,label)))) - tree.variables.kfW = cms.InputTag(X+"DYWeight") - seq += getattr(process, X+"DYWeight") - elif mhiggs > 0: - setattr(process, X+"PtWeight", process.ptWeight.clone(src = cms.InputTag("ww%s%s"% (X,label)))) - tree.variables.kfW = cms.InputTag(X+"PtWeight") - seq += process.higgsPt - seq += getattr(process, X+"PtWeight") - - if id in ["036", "037", "037c0", "037c1", "037c2", "037c3", "037c4", "037c5", "037c6", "037c7", "037c8", "037c9", "042", "043", "045", "046" ]: # DY-Madgraph sample - getattr(process,"ww%s%s"% (X,label)).genParticlesTag = "prunedGen" - tree.variables.mctruth = cms.string("getFinalStateMC()") +#for X in "elel", "mumu", "elmu", "muel": +X = "ellell" + +tree = process.step3Tree.clone(src = cms.InputTag("ww%s%s"% (X,label) )); +seq = cms.Sequence() +setattr(process, X+'TreeSequence', seq) +setattr(process, X+"Nvtx", process.nverticesModule.clone(probes = cms.InputTag("ww%s%s"% (X,label)))) +seq += getattr(process, X+"Nvtx") +tree.variables.nvtx = cms.InputTag(X+"Nvtx") +if IsoStudy: addIsoStudyVariables(process,tree) +if dataset[0] == 'MC': + setattr(process, X+"NPU", process.nPU.clone(src = cms.InputTag("ww%s%s"% (X,label)))) + if Summer11: + setattr(process, X+"PuWeight", process.puWeightS4AB.clone(src = cms.InputTag("ww%s%s"% (X,label)))) + setattr(process, X+"PuWeightA", process.puWeightS4A.clone (src = cms.InputTag("ww%s%s"% (X,label)))) + setattr(process, X+"PuWeightB", process.puWeightS4B.clone (src = cms.InputTag("ww%s%s"% (X,label)))) + elif Fall11: + setattr(process, X+"PuWeight", process.puWeightS6AB.clone(src = cms.InputTag("ww%s%s"% (X,label)))) + setattr(process, X+"PuWeightA", process.puWeightS6A.clone (src = cms.InputTag("ww%s%s"% (X,label)))) + setattr(process, X+"PuWeightB", process.puWeightS6B.clone (src = cms.InputTag("ww%s%s"% (X,label)))) + else : + setattr(process, X+"PuWeight", process.puWeightS7AB.clone(src = cms.InputTag("ww%s%s"% (X,label)), nTrueInt = cms.bool(True))) + setattr(process, X+"PuWeightA", process.puWeightS7A.clone (src = cms.InputTag("ww%s%s"% (X,label)), nTrueInt = cms.bool(True))) + setattr(process, X+"PuWeightB", process.puWeightS7B.clone (src = cms.InputTag("ww%s%s"% (X,label)), nTrueInt = cms.bool(True))) + tree.variables.trpu = cms.InputTag(X+"NPU:tr") + tree.variables.itpu = cms.InputTag(X+"NPU:it") + tree.variables.ootpum1 = cms.InputTag(X+"NPU:m1") + tree.variables.ootpup1 = cms.InputTag(X+"NPU:p1") + tree.variables.puW = cms.InputTag(X+"PuWeight") + tree.variables.puAW = cms.InputTag(X+"PuWeightA") + tree.variables.puBW = cms.InputTag(X+"PuWeightB") + seq += getattr(process, X+"NPU") + seq += getattr(process, X+"PuWeight") + seq += getattr(process, X+"PuWeightA") + seq += getattr(process, X+"PuWeightB") + if puStudy: addExtraPUWeights(process,tree,X+label,seq) + if dy: + setattr(process, X+"DYWeight", process.dyWeight.clone(src = cms.InputTag("ww%s%s"% (X,label)))) + tree.variables.kfW = cms.InputTag(X+"DYWeight") + seq += getattr(process, X+"DYWeight") + elif mhiggs > 0: + setattr(process, X+"PtWeight", process.ptWeight.clone(src = cms.InputTag("ww%s%s"% (X,label)))) + tree.variables.kfW = cms.InputTag(X+"PtWeight") + seq += process.higgsPt + seq += getattr(process, X+"PtWeight") + + if id in ["036", "037", "037c0", "037c1", "037c2", "037c3", "037c4", "037c5", "037c6", "037c7", "037c8", "037c9", "042", "043", "045", "046" ]: # DY-Madgraph sample + getattr(process,"ww%s%s"% (X,label)).genParticlesTag = "prunedGen" + tree.variables.mctruth = cms.string("getFinalStateMC()") - if doTauEmbed == True: - tree.variables.mctruth = cms.string("mcGenWeight()") +if doTauEmbed == True: + tree.variables.mctruth = cms.string("mcGenWeight()") - if wztth == True: - getattr(process,"ww%s%s"% (X,label)).mcGenEventInfoTag = "generator" - tree.variables.mctruth = cms.string("mcHiggsProd()") - getattr(process,"ww%s%s"% (X,label)).genParticlesTag = "prunedGen" - tree.variables.mcHWWdecay = cms.string("getWWdecayMC()") +if wztth == True: + getattr(process,"ww%s%s"% (X,label)).mcGenEventInfoTag = "generator" + tree.variables.mctruth = cms.string("mcHiggsProd()") + getattr(process,"ww%s%s"% (X,label)).genParticlesTag = "prunedGen" + tree.variables.mcHWWdecay = cms.string("getWWdecayMC()") - if doSusy == True : - getattr(process,"ww%s%s"% (X,label)).genParticlesTag = "prunedGen" - tree.variables.susyMstop = cms.string("getSusyStopMass()") - tree.variables.susyMLSP = cms.string("getSusyLSPMass()") +if doSusy == True : + getattr(process,"ww%s%s"% (X,label)).genParticlesTag = "prunedGen" + tree.variables.susyMstop = cms.string("getSusyStopMass()") + tree.variables.susyMLSP = cms.string("getSusyLSPMass()") - if doHiggs == True : - getattr(process,"ww%s%s"% (X,label)).genParticlesTag = "prunedGen" - tree.variables.MHiggs = cms.string("getHiggsMass()") +if doHiggs == True : + getattr(process,"ww%s%s"% (X,label)).genParticlesTag = "prunedGen" + tree.variables.MHiggs = cms.string("getHiggsMass()") - setattr(process,X+"Tree", tree) - seq += tree - if options.two: # path already set up - p = getattr(process,'sel'+X+label) - p += seq - setattr(process,'sel'+X+label,p) - else: # path not already set up - setattr(process,'sel'+X+label, cms.Path(seq)) +setattr(process,X+"Tree", tree) +seq += tree +if options.two: # path already set up + p = getattr(process,'sel'+X+label) + p += seq + setattr(process,'sel'+X+label,p) +else: # path not already set up + setattr(process,'sel'+X+label, cms.Path(seq)) process.TFileService = cms.Service("TFileService",fileName = cms.string(options.outputFile)) if IsoStudy: - for X in "elel", "mumu", "elmu", "muel": getattr(process,"ww%s%s"% (X,label)).elTag = "wwEleIDMerge" getattr(process,"ww%s%s"% (X,label)).muTag = "wwMuonsMergeID" getattr(process,"%sTree"% X).cut = cms.string("!isSTA(0) && !isSTA(1) && leptEtaCut(2.4,2.5) && ptMax > 20 && ptMin > 10 && passesIP && nExtraLep(10) == 0") @@ -380,7 +382,6 @@ def addMuVars( s3 ): if SameSign: - for X in "elel", "mumu", "elmu", "muel": getattr(process,"%sTree"% X).cut = cms.string("q(0)*q(1) > 0 && !isSTA(0) && !isSTA(1) && leptEtaCut(2.4,2.5) && ptMax > 20 && ptMin > 10")