void runWWAnalysisChain(TString inputfiles, TString outputfileName, TString PlotType, TString JetsName) {
//Trigger
HLTMod *hltmod = new HLTMod;
hltmod->SetPrintTable(kFALSE);
// hltmod->AddTrigger("HLT_IsoMu15");
// hltmod->AddTrigger("HLT_IsoEle15_L1I");
hltmod->AddTrigger("HLT_Mu5");
hltmod->AddTrigger("HLT_Ele10_SW_L1R");
hltmod->SetTrigObjsName("myhltobjs");
//PreSelection
HwwEvtPreSelMod *preSelectionMod = new HwwEvtPreSelMod;
//Object ID and Cleaning Sequence;
MuonIDMod *muonID = new MuonIDMod;
ElectronIDMod *electronID = new ElectronIDMod;
JetIDMod *JetID = new JetIDMod; //default names are IC5
JetID->SetJetName(JetsName); //for SC5 I have to set the names
JetID->SetGoodJetsName(TString("GoodJets"));
ElectronCleaningMod *electronCleaning = new ElectronCleaningMod;
JetCleaningMod *JetCleaning = new JetCleaningMod; //default names are ok for IC5
JetCleaning->SetGoodJetsName(TString("GoodJets"));
JetCleaning->SetCleanJetsName(TString("CleanJets"));
//Event Selection modules
WWEvtSelMod *eventSelectionMod = new WWEvtSelMod;
eventSelectionMod->SetLoadGenParticles(false);
eventSelectionMod->SetCleanJetsName(TString("CleanJets"));
eventSelectionMod->SetPlotType(PlotType);
eventSelectionMod->SetPrintDebug(false);
//chain modules together
hltmod->Add(preSelectionMod);
preSelectionMod->Add(muonID);
muonID->Add(electronID);
electronID->Add(JetID);
JetID->Add(electronCleaning);
electronCleaning->Add(JetCleaning);
JetCleaning->Add(eventSelectionMod);
// set up analysis
Analysis *ana = new Analysis;
//ana->SetUseHLT(false);
ana->SetKeepHierarchy(kFALSE);
ana->SetSuperModule(preSelectionMod);
ana->AddFile(inputfiles);
ana->SetOutputName(outputfileName.Data());
// run the analysis after successful initialisation
ana->Run(! gROOT->IsBatch());
cout << "HLTMod: Accepted " << hltmod->GetNAccepted()
<< " of " << hltmod->GetNEvents() << " events" << endl;
return;
}
//--------------------------------------------------------------------------------------------------
void runEMU(const char *fileset = "0000",
const char *skim = "noskim",
const char *dataset = "p10-pj15-v36",
const char *book = "local/filefi/016",
const char *catalogDir = "/home/cmsprod/catalog",
const char *outputName = "htt",
int nEvents = 1000)
{
printf("\n==== Enter macro ====\n");
//------------------------------------------------------------------------------------------------
// some parameters get passed through the environment
//------------------------------------------------------------------------------------------------
char json[1024], overlap[1024], src[1024];
float overlapCut = -1;
if (gSystem->Getenv("MIT_PROD_JSON"))
sprintf(json, "%s",gSystem->Getenv("MIT_PROD_JSON"));
else {
printf(" JSON file was not properly defined. EXIT!\n");
return;
}
TString jsonFile = TString("/home/cmsprod/json/") + TString(json);
Bool_t isData = (jsonFile.CompareTo("/home/cmsprod/json/~") != 0);
if (gSystem->Getenv("MIT_PROD_OVERLAP")) {
sprintf(overlap,"%s",gSystem->Getenv("MIT_PROD_OVERLAP"));
if (EOF == sscanf(overlap,"%f",&overlapCut)) {
printf(" Overlap was not properly defined. EXIT!\n");
return;
}
}
else {
printf(" OVERLAP file was not properly defined. EXIT!\n");
return;
}
if (gSystem->Getenv("src"))
sprintf(src, "%s",gSystem->Getenv("src"));
else {
printf(" src dir not defined. EXIT!\n");
return;
}
printf("\n Initialization worked. \n\n");
//------------------------------------------------------------------------------------------------
// some global setups
//------------------------------------------------------------------------------------------------
using namespace std;
using namespace mithep;
gDebugMask = Debug::kAnalysis;
gDebugLevel = 1;
//------------------------------------------------------------------------------------------------
// set up information
//------------------------------------------------------------------------------------------------
Bool_t applyISRFilter = kFALSE;
Bool_t applyMllGenCut = kFALSE;
RunLumiSelectionMod *runLumiSel = new RunLumiSelectionMod;
runLumiSel->SetAcceptMC(kTRUE); // Monte Carlo events are always accepted
// if([json is not ~] and [json is not -])
if ((jsonFile.CompareTo("/home/cmsprod/json/~") != 0) && //if not MC and
(jsonFile.CompareTo("/home/cmsprod/json/-") != 0) ) { //if json file not absent
runLumiSel->AddJSONFile(jsonFile.Data());
}
if ((jsonFile.CompareTo("/home/cmsprod/json/-") == 0) ) {
printf("\n WARNING -- Looking at data without JSON file: always accept.\n\n");
runLumiSel->SetAbortIfNotAccepted(kFALSE); // accept all events if there is no valid JSON file
}
printf("\n Run lumi worked. \n\n");
//GeneratorMod
GeneratorMod *generatorMod = new GeneratorMod;
generatorMod->SetPrintDebug(kFALSE);
generatorMod->SetPtLeptonMin(0.0);
generatorMod->SetEtaLeptonMax(2.7);
generatorMod->SetPtPhotonMin(15.0);
generatorMod->SetEtaPhotonMax(2.7);
generatorMod->SetPtRadPhotonMin(10.0);
generatorMod->SetEtaRadPhotonMax(2.7);
generatorMod->SetIsData(isData);
generatorMod->SetFillHist(!isData);
if(applyMllGenCut == kTRUE){
generatorMod->SetPdgIdCut(23);
generatorMod->SetMassMinCut( 0.);
generatorMod->SetMassMaxCut(50.);
}
generatorMod->SetApplyISRFilter(applyISRFilter);
//------------------------------------------------------------------------------------------------
// HLT information
//------------------------------------------------------------------------------------------------
HLTMod *hltMod = new HLTMod;
if (isData) {
// valentina:
// hltMod->AddTrigger("HLT_Mu17_Ele8_CaloIdL_v1",150000,161176);
// hltMod->AddTrigger("HLT_Mu8_Ele17_CaloIdL_v1",150000,161176);
// hltMod->AddTrigger("HLT_Mu17_Ele8_CaloIdL_v2",161179,999999);
// hltMod->AddTrigger("HLT_Mu8_Ele17_CaloIdL_v2",161179,999999);
hltMod->AddTrigger("HLT_Mu9",132440,147119);
hltMod->AddTrigger("HLT_Mu15",147120,9999999);
}
else {
hltMod->AddTrigger("HLT_Mu9");
hltMod->AddTrigger("HLT_Mu15");
// hltMod->AddTrigger("HLT_Ele10_SW_L1R_v2");
}
hltMod->SetTrigObjsName("MyHltObjs");
hltMod->SetAbortIfNotAccepted(kTRUE);
// hltMod->SetPrintTable(kTRUE);
//------------------------------------------------------------------------------------------------
// select events with a good primary vertex
//------------------------------------------------------------------------------------------------
GoodPVFilterMod *goodPVFilterMod = new GoodPVFilterMod;
goodPVFilterMod->SetMinVertexNTracks(0);
goodPVFilterMod->SetMinNDof(4); // should be 4
goodPVFilterMod->SetMaxAbsZ(24.0);
goodPVFilterMod->SetMaxRho(2.0);
//------------------------------------------------------------------------------------------------
// Publisher Modules
//------------------------------------------------------------------------------------------------
PublisherMod<PFJet,Jet> *pubPFJet = new PublisherMod<PFJet,Jet>("JetPub");
pubPFJet->SetInputName("AKt5PFJets");
pubPFJet->SetOutputName("PubAKt5PFJets");
PublisherMod<Met,Met> *pubTCMet = new PublisherMod<Met,Met>("MetTCPub");
pubTCMet->SetInputName("TCMet");
pubTCMet->SetOutputName("PubTCMet");
PublisherMod<PFMet,Met> *pubPFMet = new PublisherMod<PFMet,Met>("MetPFPub");
pubPFMet->SetInputName("PFMet");
pubPFMet->SetOutputName("PubPFMet");
PublisherMod<CaloMet> *pubCaloMet = new PublisherMod<CaloMet>("CaloMetPub");
// pubCaloMet->SetName("CaloMetPub");
pubCaloMet->SetInputName("CorMuonMet");
pubCaloMet->SetOutputName("pubCaloMet");
//------------------------------------------------------------------------------------------------
// Apply Jet Corrections
//------------------------------------------------------------------------------------------------
JetCorrectionMod *jetCorr = new JetCorrectionMod;
jetCorr->SetInputName(pubPFJet->GetOutputName());
jetCorr->SetCorrectedName("CorrectedJets");//corrected jets are PF jets!
jetCorr->ApplyL1FastJetCorrection(); // <<==== apply default L1 correction
string path(string(src)+"/MitPhysics/data/");
jetCorr->AddCorrectionFromFile(path+string("START38_V13_AK5PF_L2Relative.txt"));
jetCorr->AddCorrectionFromFile(path+string("START38_V13_AK5PF_L3Absolute.txt"));
if(isData) {
jetCorr->AddCorrectionFromFile(path+string("START38_V13_AK5PF_L2L3Residual.txt"));
}
//------------------------------------------------------------------------------------------------
// Apply Met Corrections
//------------------------------------------------------------------------------------------------
CaloMetCorrectionMod *metCaloCorr = new CaloMetCorrectionMod;
metCaloCorr->SetInputName(pubCaloMet->GetOutputName());
metCaloCorr->SetCorrectedJetsName(jetCorr->GetOutputName());
metCaloCorr->SetOutputName("pubCaloCorrectedMet");
//------------------------------------------------------------------------------------------------
// object id and cleaning sequence
//------------------------------------------------------------------------------------------------
MuonIDMod *muonId = new MuonIDMod;
muonId->SetClassType("Global"); // def is "Global"
muonId->SetIDType("WWMuId"); // def is "WWMuId"
muonId->SetIsoType("TrackCaloSliding"); // this is def
muonId->SetApplyD0Cut(kTRUE); // def is 1
muonId->SetPtMin(15.0); // def is 10
muonId->SetEtaCut(2.4); // def is 2.4
ElectronIDMod *electronId = new ElectronIDMod;
electronId->SetIDType("CustomTight"); // def is "CustomTight"
electronId->SetIsoType("TrackJuraSliding"); // this is default
electronId->SetApplyConversionFilterType1(kTRUE); // default is 1
electronId->SetApplyConversionFilterType2(kFALSE); // default is 0
electronId->SetChargeFilter(kTRUE); // def is 1
electronId->SetApplyD0Cut(kTRUE); // def is 1
electronId->SetNExpectedHitsInnerCut(0); // def is 999
electronId->SetPtMin(15.0); // def is 10
electronId->SetEtaMax(2.5); // def is 2.5
PhotonIDMod *photonId = new PhotonIDMod;
PFTauIDMod *pfTauId = new PFTauIDMod;
pfTauId->SetIsHPSSel(kTRUE);
pfTauId->SetPtMin(20.0);
JetIDMod *pfJetId = new JetIDMod;
pfJetId->SetInputName(jetCorr->GetOutputName());
pfJetId->SetPtCut(20.0); // def is 35
pfJetId->SetEtaMaxCut(5.0); // def is 5
pfJetId->SetJetEEMFractionMinCut(0.01); // def is 0.01
pfJetId->SetOutputName("GoodPFJets");
ElectronCleaningMod *electronCleaning = new ElectronCleaningMod;
PhotonCleaningMod *photonCleaning = new PhotonCleaningMod;
PFTauCleaningMod *pfTauCleaning = new PFTauCleaningMod;
JetCleaningMod *pfJetCleaning = new JetCleaningMod;
pfJetCleaning->SetGoodJetsName(pfJetId->GetOutputName());
pfJetCleaning->SetCleanJetsName("CleanPFJets");
//------------------------------------------------------------------------------------------------
// merge modules
//------------------------------------------------------------------------------------------------
MergeLeptonsMod *mergeLeptonsMod = new MergeLeptonsMod;
mergeLeptonsMod->SetMuonsName (muonId->GetOutputName());
mergeLeptonsMod->SetElectronsName(electronCleaning->GetOutputName());
//------------------------------------------------------------------------------------------------
// acceptance modules (gen -> reco)
//------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------
// id efficiency modules (reco -> id)
//------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------
// analysis modules
//------------------------------------------------------------------------------------------------
EMUAnalysis2 *analysisModEMU = new EMUAnalysis2;
analysisModEMU->SetTrigObjsName (hltMod -> GetOutputName());
analysisModEMU->SetMuonName (muonId -> GetOutputName());
analysisModEMU->SetElecName (electronCleaning -> GetOutputName());
analysisModEMU->SetJetName (pfJetCleaning -> GetOutputName());
// analysisModEMU->SetHistNamePref ("hXXXXX");
//------------------------------------------------------------------------------------------------
// making analysis chain
//------------------------------------------------------------------------------------------------
// just in case we have run lumi sel
if ((jsonFile.CompareTo("/home/cmsprod/json/~") != 0) &&
(jsonFile.CompareTo("/home/cmsprod/json/-") != 0) )
runLumiSel->Add(generatorMod);
generatorMod ->Add(hltMod);
hltMod ->Add(goodPVFilterMod);
goodPVFilterMod ->Add(muonId);
muonId ->Add(electronId);
electronId ->Add(photonId);
photonId ->Add(pubPFJet);
pubPFJet ->Add(pubTCMet);
pubTCMet ->Add(pubPFMet);
pubPFMet ->Add(pubCaloMet);
pubCaloMet ->Add(pfTauId);
pfTauId ->Add(jetCorr);
jetCorr ->Add(metCaloCorr);
metCaloCorr ->Add(pfJetId);
pfJetId ->Add(electronCleaning);
electronCleaning ->Add(photonCleaning);
photonCleaning ->Add(pfTauCleaning);
pfTauCleaning ->Add(pfJetCleaning);
pfJetCleaning ->Add(mergeLeptonsMod);
mergeLeptonsMod ->Add(analysisModEMU);
//------------------------------------------------------------------------------------------------
// setup analysis
//------------------------------------------------------------------------------------------------
Analysis *ana = new Analysis;
ana->SetUseHLT(kTRUE);
ana->SetKeepHierarchy(kTRUE);
if (nEvents >= 0)
ana->SetProcessNEvents(nEvents);
if ((jsonFile.CompareTo("/home/cmsprod/json/~") != 0) &&
(jsonFile.CompareTo("/home/cmsprod/json/-") != 0) )
ana->SetSuperModule(runLumiSel);
else
ana->SetSuperModule(generatorMod);
ana->SetPrintScale(100);
//------------------------------------------------------------------------------------------------
// organize input
//------------------------------------------------------------------------------------------------
Catalog *c = new Catalog(catalogDir);
TString skimdataset = TString(dataset)+TString("/") +TString(skim);
Dataset *d = NULL;
if (TString(skim).CompareTo("noskim") == 0)
d = c->FindDataset(book,dataset,fileset);
else
d = c->FindDataset(book,skimdataset.Data(),fileset);
ana->AddDataset(d);
//ana->AddFile("root://castorcms//castor/cern.ch/user/p/paus/filler/011/s09-ttbar-7-mc3/*.root");
//ana->AddFile("hgg-skim_r10a-eg-pr-v4_noskim_0000_000.root");
//ana->AddFile("hgg-skim_p10-h110gg-gf-v26_noskim_0000_000.root");
//------------------------------------------------------------------------------------------------
// organize output
//------------------------------------------------------------------------------------------------
TString rootFile = TString(outputName);
rootFile += TString("_") + TString(dataset) + TString("_") + TString(skim);
if (TString(fileset) != TString(""))
rootFile += TString("_") + TString(fileset);
rootFile += TString(".root");
ana->SetOutputName(rootFile.Data());
// use current directory:
// ana->SetOutputName((TString(outputName)+TString(".root")).Data());
ana->SetCacheSize(64*1024*1024);
//------------------------------------------------------------------------------------------------
// Say what we are doing
//------------------------------------------------------------------------------------------------
printf("\n==== PARAMETER SUMMARY FOR THIS JOB ====\n");
printf("\n JSON file: %s\n and overlap cut: %f (%s)\n",jsonFile.Data(),overlapCut,overlap);
printf("\n Rely on Catalog: %s\n",catalogDir);
printf(" -> Book: %s Dataset: %s Skim: %s Fileset: %s <-\n",book,dataset,skim,fileset);
printf("\n Root output: %s\n\n",rootFile.Data());
printf("\n========================================\n");
//------------------------------------------------------------------------------------------------
// run the analysis after successful initialisation
//------------------------------------------------------------------------------------------------
ana->Run(!gROOT->IsBatch());
return;
}
//--------------------------------------------------------------------------------------------------
void runFlatMonoJet(const char *fileset = "0000",
const char *skim = "noskim",
const char *dataset = "s12-wjets-ptw100-v7a",
const char *book = "t2mit/filefi/031",
const char *catalogDir = "/home/cmsprod/catalog",
const char *outputName = "MonoJet_August13",
int nEvents = 100)
{
//------------------------------------------------------------------------------------------------
// some parameters get passed through the environment
//------------------------------------------------------------------------------------------------
char json[1024], overlap[1024];
float overlapCut = -1;
if (gSystem->Getenv("MIT_PROD_JSON"))
sprintf(json, "%s",gSystem->Getenv("MIT_PROD_JSON"));
else {
sprintf(json, "%s", "~");
}
TString jsonFile = TString("/home/cmsprod/cms/json/") + TString(json);
std::cout<<"JSON "<<jsonFile<<std::endl;
Bool_t isData = ( (jsonFile.CompareTo("/home/cmsprod/cms/json/~") != 0) );
std::cout<<"*********** Is data?? **********"<<isData<<std::endl;
if (gSystem->Getenv("MIT_PROD_OVERLAP")) {
sprintf(overlap,"%s",gSystem->Getenv("MIT_PROD_OVERLAP"));
if (EOF == sscanf(overlap,"%f",&overlapCut)) {
printf(" Overlap was not properly defined. EXIT!\n");
return;
}
}
else {
sprintf(overlap,"%s", "-1.0");
//printf(" OVERLAP file was not properly defined. EXIT!\n");
//return;
}
printf("\n Initialization worked \n");
//------------------------------------------------------------------------------------------------
// some global setups
//------------------------------------------------------------------------------------------------
using namespace mithep;
gDebugMask = Debug::kGeneral;
gDebugLevel = 3;
//------------------------------------------------------------------------------------------------
// set up information
//------------------------------------------------------------------------------------------------
RunLumiSelectionMod *runLumiSel = new RunLumiSelectionMod;
runLumiSel->SetAcceptMC(!isData);
runLumiSel->SetAbortIfNotAccepted(kFALSE); // accept all events if there is no valid JSON file
// only select on run- and lumisection numbers when valid json file present
if ((jsonFile.CompareTo("/home/cmsprod/cms/json/~") != 0) &&
(jsonFile.CompareTo("/home/cmsprod/cms/json/-") != 0) ) {
runLumiSel->AddJSONFile(jsonFile.Data());
}
if ((jsonFile.CompareTo("/home/cmsprod/cms/json/-") == 0) ) {
printf("\n WARNING -- Looking at data without JSON file: always accept.\n\n");
}
printf("\n Run lumi worked\n");
// Generator info
GeneratorMod *generatorMod = new GeneratorMod;
generatorMod->SetPrintDebug(kFALSE);
generatorMod->SetPtLeptonMin(0.0);
generatorMod->SetEtaLeptonMax(2.7);
generatorMod->SetPtPhotonMin(0.0);
generatorMod->SetEtaPhotonMax(2.7);
generatorMod->SetPtRadPhotonMin(0.0);
generatorMod->SetEtaRadPhotonMax(2.7);
generatorMod->SetIsData(isData);
generatorMod->SetFillHist(!isData);
generatorMod->SetApplyISRFilter(kFALSE);
generatorMod->SetApplyVVFilter(kFALSE);
generatorMod->SetApplyVGFilter(kFALSE);
generatorMod->SetFilterBTEvents(kFALSE);
//-----------------------------------------------------------------------------------------------------------
// HLT information : trigger not applied (neither for data nor for MC, store info to apply selection offline
//-----------------------------------------------------------------------------------------------------------
HLTMod *hltModP = new HLTMod("HLTModP");
// monojet triggers
TString monoJetTriggers[12] = {"HLT_MonoCentralPFJet80_PFMETnoMu105_NHEF0p95_v4", "HLT_MonoCentralPFJet80_PFMETnoMu105_NHEF0p95_v3", "HLT_MonoCentralPFJet80_PFMETnoMu105_NHEF0p95_v1", "HLT_MonoCentralPFJet80_PFMETnoMu95_NHEF0p95_v5", "HLT_MonoCentralPFJet80_PFMETnoMu95_NHEF0p95_v4", "HLT_MonoCentralPFJet80_PFMETnoMu95_NHEF0p95_v3", "HLT_MonoCentralPFJet80_PFMETnoMu95_NHEF0p95_v2","HLT_MET120_HBHENoiseCleaned_v6", "HLT_MET120_HBHENoiseCleaned_v5", "HLT_MET120_HBHENoiseCleaned_v4", "HLT_MET120_HBHENoiseCleaned_v3", "HLT_MET120_HBHENoiseCleaned_v2"};
for (int i=0; i<12; i++) {
hltModP->AddTrigger(monoJetTriggers[i],0,999999); //jet 85 , met 90
hltModP->AddTrigger(TString("!"+monoJetTriggers[i]),0,999999); //jet 85 , met 90
}
// VBF triggers
TString vbfTriggers[12] = {"HLT_DiPFJet40_PFMETnoMu65_MJJ800VBF_AllJets_v9", "HLT_DiPFJet40_PFMETnoMu65_MJJ800VBF_AllJets_v8", "HLT_DiPFJet40_PFMETnoMu65_MJJ800VBF_AllJets_v6", "HLT_DiPFJet40_PFMETnoMu65_MJJ800VBF_AllJets_v5", "HLT_DiPFJet40_PFMETnoMu65_MJJ800VBF_AllJets_v4", "HLT_DiPFJet40_PFMETnoMu65_MJJ800VBF_AllJets_v3", "HLT_DiPFJet40_PFMETnoMu65_MJJ800VBF_AllJets_v2"};
for (int i=0; i<12; i++) {
hltModP->AddTrigger(vbfTriggers[i],0,999999); //jet 85 , met 90
hltModP->AddTrigger(TString("!"+vbfTriggers[i]),0,999999); //jet 85 , met 90
}
hltModP->SetBitsName("HLTBits");
hltModP->SetTrigObjsName("MyHltPhotObjs");
hltModP->SetAbortIfNotAccepted(isData);
hltModP->SetPrintTable(kFALSE); // set to true to print HLT table
//------------------------------------------------------------------------------------------------
// split pfcandidates to PFPU and PFnoPU
//------------------------------------------------------------------------------------------------
SeparatePileUpMod* SepPUMod = new SeparatePileUpMod;
// SepPUMod->SetUseAllVerteces(kFALSE);
// SepPUMod->SetVertexName("OutVtxCiC");
SepPUMod->SetPFNoPileUpName("pfnopileupcands");
SepPUMod->SetPFPileUpName("pfpileupcands");
SepPUMod->SetCheckClosestZVertex(kFALSE);
//------------------------------------------------------------------------------------------------
// select events with a good primary vertex
//------------------------------------------------------------------------------------------------
GoodPVFilterMod *goodPVFilterMod = new GoodPVFilterMod;
goodPVFilterMod->SetMinVertexNTracks(0);
goodPVFilterMod->SetMinNDof (4.0);
goodPVFilterMod->SetMaxAbsZ (24.0);
goodPVFilterMod->SetMaxRho (2.0);
goodPVFilterMod->SetIsMC(!isData);
goodPVFilterMod->SetVertexesName("PrimaryVertexes");
//------------------------------------------------------------------------------------------------
// object id and cleaning sequence
//------------------------------------------------------------------------------------------------
//-----------------------------------
// Lepton Selection
//-----------------------------------
ElectronIDMod* eleIdMod = new ElectronIDMod;
eleIdMod->SetPtMin(10.);
eleIdMod->SetEtaMax(2.5);
eleIdMod->SetApplyEcalFiducial(true);
eleIdMod->SetIDType("VBTFWorkingPoint95Id");
eleIdMod->SetIsoType("PFIso");
eleIdMod->SetApplyConversionFilterType1(kTRUE);
eleIdMod->SetApplyConversionFilterType2(kFALSE);
eleIdMod->SetChargeFilter(kFALSE);
eleIdMod->SetApplyD0Cut(kTRUE);
eleIdMod->SetApplyDZCut(kTRUE);
eleIdMod->SetWhichVertex(0);
eleIdMod->SetNExpectedHitsInnerCut(0);
eleIdMod->SetGoodElectronsName("GoodElectronsBS");
eleIdMod->SetRhoType(RhoUtilities::CMS_RHO_RHOKT6PFJETS);
MuonIDMod* muonIdGammaGamma = new MuonIDMod;
// base kinematics
muonIdGammaGamma->SetPtMin(10.);
muonIdGammaGamma->SetEtaCut(2.4);
// base ID
muonIdGammaGamma->SetIDType("NoId");
muonIdGammaGamma->SetClassType("GlobalorTracker");
muonIdGammaGamma->SetWhichVertex(0); // this is a 'hack'.. but hopefully good enough...
muonIdGammaGamma->SetD0Cut(0.02);
muonIdGammaGamma->SetDZCut(0.5);
muonIdGammaGamma->SetIsoType("PFIsoBetaPUCorrected"); //h
muonIdGammaGamma->SetPFIsoCut(0.2); //h
muonIdGammaGamma->SetOutputName("HggLeptonTagMuons");
muonIdGammaGamma->SetPFNoPileUpName("pfnopileupcands");
muonIdGammaGamma->SetPFPileUpName("pfpileupcands");
muonIdGammaGamma->SetPVName(Names::gkPVBeamSpotBrn);
MuonIDMod *muonIdWW = new MuonIDMod;
muonIdWW->SetOutputName("HWWMuons");
muonIdWW->SetIntRadius(0.0);
muonIdWW->SetClassType("GlobalTracker");
muonIdWW->SetIDType("WWMuIdV4");
muonIdWW->SetIsoType("IsoRingsV0_BDTG_Iso");
muonIdWW->SetApplyD0Cut(kTRUE);
muonIdWW->SetApplyDZCut(kTRUE);
muonIdWW->SetWhichVertex(0);
muonIdWW->SetRhoType(RhoUtilities::CMS_RHO_RHOKT6PFJETS);
muonIdWW->SetPtMin(10.);
muonIdWW->SetEtaCut(2.4);
//MuonIDMod *muonId = muonIdWW;
MuonIDMod *muonId = muonIdGammaGamma;
ElectronCleaningMod *electronCleaning = new ElectronCleaningMod;
electronCleaning->SetCleanMuonsName(muonId->GetOutputName());
electronCleaning->SetGoodElectronsName(eleIdMod->GetOutputName());
electronCleaning->SetCleanElectronsName("CleanElectrons");
MergeLeptonsMod *merger = new MergeLeptonsMod;
merger->SetMuonsName(muonId->GetOutputName());
merger->SetElectronsName(electronCleaning->GetOutputName());
merger->SetMergedName("MergedLeptons");
//-----------------------------------
// Photon Regression + ID
//-----------------------------------
PhotonMvaMod *photreg = new PhotonMvaMod;
photreg->SetRegressionVersion(3);
photreg->SetRegressionWeights(std::string((gSystem->Getenv("CMSSW_BASE") + TString("/src/MitPhysics/data/gbrv3ph_52x.root")).Data()));
photreg->SetOutputName("GoodPhotonsRegr");
photreg->SetApplyShowerRescaling(kTRUE);
photreg->SetMinNumPhotons(0);
photreg->SetIsData(isData);
PhotonIDMod *photonIDMod = new PhotonIDMod;
photonIDMod->SetPtMin(0.0);
photonIDMod->SetOutputName("GoodPhotons");
photonIDMod->SetIDType("BaseLineCiCPFNoPresel");
photonIDMod->SetIsoType("NoIso");
photonIDMod->SetApplyElectronVeto(kTRUE);
photonIDMod->SetApplyPixelSeed(kTRUE);
photonIDMod->SetApplyConversionId(kTRUE);
photonIDMod->SetApplyFiduciality(kTRUE);
photonIDMod->SetIsData(isData);
photonIDMod->SetPhotonsFromBranch(kFALSE);
photonIDMod->SetInputName(photreg->GetOutputName());
//get the photon with regression energy
photonIDMod->DoMCSmear(kTRUE);
photonIDMod->DoDataEneCorr(kTRUE);
//------------------------------------------Energy smear and scale--------------------------------------------------------------
photonIDMod->SetMCSmearFactors2012HCP(0.0111,0.0111,0.0107,0.0107,0.0155,0.0194,0.0295,0.0276,0.037,0.0371);
photonIDMod->AddEnCorrPerRun2012HCP(190645,190781,0.9964,0.9964,1.0020,1.0020,0.9893,1.0028,0.9871,0.9937,0.9839,0.9958);
photonIDMod->AddEnCorrPerRun2012HCP(190782,191042,1.0024,1.0024,1.0079,1.0079,0.9923,1.0058,0.9911,0.9977,0.9886,1.0005);
photonIDMod->AddEnCorrPerRun2012HCP(191043,193555,0.9935,0.9935,0.9991,0.9991,0.9861,0.9997,0.9894,0.9960,0.9864,0.9982);
photonIDMod->AddEnCorrPerRun2012HCP(193556,194150,0.9920,0.9920,0.9976,0.9976,0.9814,0.9951,0.9896,0.9962,0.9872,0.9990);
photonIDMod->AddEnCorrPerRun2012HCP(194151,194532,0.9925,0.9925,0.9981,0.9981,0.9826,0.9963,0.9914,0.9980,0.9874,0.9993);
photonIDMod->AddEnCorrPerRun2012HCP(194533,195113,0.9927,0.9927,0.9983,0.9983,0.9844,0.9981,0.9934,0.9999,0.9878,0.9996);
photonIDMod->AddEnCorrPerRun2012HCP(195114,195915,0.9929,0.9929,0.9984,0.9984,0.9838,0.9974,0.9942,1.0007,0.9878,0.9997);
photonIDMod->AddEnCorrPerRun2012HCP(195916,198115,0.9919,0.9919,0.9975,0.9975,0.9827,0.9964,0.9952,1.0017,0.9869,0.9987);
photonIDMod->AddEnCorrPerRun2012HCP(198116,199803,0.9955,0.9955,1.0011,1.0011,0.9859,0.9995,0.9893,0.9959,0.9923,1.0041);
photonIDMod->AddEnCorrPerRun2012HCP(199804,200048,0.9967,0.9967,1.0023,1.0023,0.9870,1.0006,0.9893,0.9959,0.9937,1.0055);
photonIDMod->AddEnCorrPerRun2012HCP(200049,200151,0.9980,0.9980,1.0036,1.0036,0.9877,1.0012,0.9910,0.9976,0.9980,1.0097);
photonIDMod->AddEnCorrPerRun2012HCP(200152,200490,0.9958,0.9958,1.0013,1.0013,0.9868,1.0004,0.9922,0.9988,0.9948,1.0065);
photonIDMod->AddEnCorrPerRun2012HCP(200491,200531,0.9979,0.9979,1.0035,1.0035,0.9876,1.0012,0.9915,0.9981,0.9979,1.0096);
photonIDMod->AddEnCorrPerRun2012HCP(200532,201656,0.9961,0.9961,1.0017,1.0017,0.9860,0.9996,0.9904,0.9970,0.9945,1.0063);
photonIDMod->AddEnCorrPerRun2012HCP(201657,202305,0.9969,0.9969,1.0025,1.0025,0.9866,1.0002,0.9914,0.9980,0.9999,1.0116);
photonIDMod->AddEnCorrPerRun2012HCP(202305,203002,0.9982,0.9982,1.0038,1.0038,0.9872,1.0008,0.9934,1.0000,1.0018,1.0135);
photonIDMod->AddEnCorrPerRun2012HCP(203003,203984,1.0006,1.0006,1.0061,1.0061,0.9880,1.0017,0.9919,0.9988,0.9992,1.0104);
photonIDMod->AddEnCorrPerRun2012HCP(203985,205085,0.9993,0.9993,1.0048,1.0048,0.9903,1.0040,0.9928,0.9997,0.9987,1.0099);
photonIDMod->AddEnCorrPerRun2012HCP(205086,205310,1.0004,1.0004,1.0059,1.0059,0.9901,1.0037,0.9987,1.0055,1.0091,1.0202);
photonIDMod->AddEnCorrPerRun2012HCP(205311,206207,1.0000,1.0000,1.0055,1.0055,0.9891,1.0028,0.9948,1.0017,1.0032,1.0144);
photonIDMod->AddEnCorrPerRun2012HCP(206208,206483,1.0003,1.0003,1.0058,1.0058,0.9895,1.0032,0.9921,0.9989,1.0056,1.0167);
photonIDMod->AddEnCorrPerRun2012HCP(206484,206597,1.0005,1.0005,1.0060,1.0060,0.9895,1.0032,0.9968,1.0036,1.0046,1.0158);
photonIDMod->AddEnCorrPerRun2012HCP(206598,206896,1.0006,1.0006,1.0061,1.0061,0.9881,1.0017,0.9913,0.9982,1.0050,1.0162);
photonIDMod->AddEnCorrPerRun2012HCP(206897,207220,1.0006,1.0006,1.0061,1.0061,0.9884,1.0021,0.9909,0.9978,1.0053,1.0165);
photonIDMod->AddEnCorrPerRun2012HCP(207221,208686,1.0006,1.0006,1.0061,1.0061,0.9894,1.0030,0.9951,1.0020,1.0060,1.0172);
//---------------------------------shower shape scale--------------------------------------------------------------------------------
photonIDMod->SetDoShowerShapeScaling(kTRUE);
photonIDMod->SetShowerShapeType("2012ShowerShape");
photonIDMod->Set2012HCP(kTRUE);
PFTauIDMod *pftauIDMod = new PFTauIDMod;
pftauIDMod->SetPFTausName("HPSTaus");
pftauIDMod->SetIsLooseId(kFALSE);
PhotonCleaningMod *photonCleaningMod = new PhotonCleaningMod;
photonCleaningMod->SetCleanElectronsName(electronCleaning->GetOutputName());
photonCleaningMod->SetGoodPhotonsName(photonIDMod->GetOutputName());
photonCleaningMod->SetCleanPhotonsName("CleanPhotons");
PFTauCleaningMod *pftauCleaningMod = new PFTauCleaningMod;
pftauCleaningMod->SetGoodPFTausName(pftauIDMod->GetGoodPFTausName());
pftauCleaningMod->SetCleanMuonsName(muonId->GetOutputName());
PublisherMod<PFJet,Jet> *pubJet = new PublisherMod<PFJet,Jet>("JetPub");
pubJet->SetInputName("AKt5PFJets");
pubJet->SetOutputName("PubAKt5PFJets");
JetCorrectionMod *jetCorr = new JetCorrectionMod;
if(isData){
jetCorr->AddCorrectionFromFile(std::string((gSystem->Getenv("CMSSW_BASE") + TString("/src/MitPhysics/data/Summer13_V1_DATA_L1FastJet_AK5PF.txt")).Data()));
jetCorr->AddCorrectionFromFile(std::string((gSystem->Getenv("CMSSW_BASE") + TString("/src/MitPhysics/data/Summer13_V1_DATA_L2Relative_AK5PF.txt")).Data()));
jetCorr->AddCorrectionFromFile(std::string((gSystem->Getenv("CMSSW_BASE") + TString("/src/MitPhysics/data/Summer13_V1_DATA_L3Absolute_AK5PF.txt")).Data()));
jetCorr->AddCorrectionFromFile(std::string((gSystem->Getenv("CMSSW_BASE") + TString("/src/MitPhysics/data/Summer13_V1_DATA_L2L3Residual_AK5PF.txt")).Data()));
}
else {
jetCorr->AddCorrectionFromFile(std::string((gSystem->Getenv("CMSSW_BASE") + TString("/src/MitPhysics/data/Summer13_V1_MC_L1FastJet_AK5PF.txt")).Data()));
jetCorr->AddCorrectionFromFile(std::string((gSystem->Getenv("CMSSW_BASE") + TString("/src/MitPhysics/data/Summer13_V1_MC_L2Relative_AK5PF.txt")).Data()));
jetCorr->AddCorrectionFromFile(std::string((gSystem->Getenv("CMSSW_BASE") + TString("/src/MitPhysics/data/Summer13_V1_MC_L3Absolute_AK5PF.txt")).Data()));
}
jetCorr->SetInputName(pubJet->GetOutputName());
jetCorr->SetCorrectedName("CorrectedJets");
JetIDMod *theJetID = new JetIDMod;
theJetID->SetInputName(jetCorr->GetOutputName());
theJetID->SetPtCut(30.0);
theJetID->SetEtaMaxCut(4.7);
theJetID->SetJetEEMFractionMinCut(0.00);
theJetID->SetOutputName("GoodJets");
theJetID->SetApplyBetaCut(kFALSE);
theJetID->SetApplyMVACut(kTRUE);
JetCleaningMod *theJetCleaning = new JetCleaningMod;
theJetCleaning->SetCleanElectronsName(electronCleaning->GetOutputName());
theJetCleaning->SetCleanMuonsName(muonId->GetOutputName());
theJetCleaning->SetCleanPhotonsName(photonCleaningMod->GetOutputName());
theJetCleaning->SetApplyPhotonRemoval(kTRUE);
theJetCleaning->SetGoodJetsName(theJetID->GetOutputName());
theJetCleaning->SetCleanJetsName("CleanJets");
MetCorrectionMod *metCorrT0T1Shift = new MetCorrectionMod;
metCorrT0T1Shift->SetInputName("PFMet");
metCorrT0T1Shift->SetJetsName(pubJet->GetOutputName());
metCorrT0T1Shift->SetCorrectedJetsName(jetCorr->GetOutputName());
metCorrT0T1Shift->SetCorrectedName("PFMetT0T1Shift");
metCorrT0T1Shift->ApplyType0(kTRUE);
metCorrT0T1Shift->ApplyType1(kTRUE);
metCorrT0T1Shift->ApplyShift(kTRUE);
metCorrT0T1Shift->IsData(isData);
metCorrT0T1Shift->SetPrint(kFALSE);
MonoJetTreeWriter *jetplusmettree = new MonoJetTreeWriter("MonoJetTreeWriter");
jetplusmettree->SetTriggerObjectsName(hltModP->GetOutputName());
jetplusmettree->SetMetName(metCorrT0T1Shift->GetOutputName()); //corrected met
jetplusmettree->SetMetFromBranch(kFALSE);
jetplusmettree->SetPhotonsFromBranch(kFALSE);
jetplusmettree->SetPhotonsName(photonCleaningMod->GetOutputName());
jetplusmettree->SetElectronsFromBranch(kFALSE);
jetplusmettree->SetElectronsName(electronCleaning->GetOutputName());
jetplusmettree->SetMuonsFromBranch(kFALSE);
jetplusmettree->SetMuonsName(muonId->GetOutputName());
jetplusmettree->SetTausFromBranch(kFALSE);
jetplusmettree->SetTausName(pftauCleaningMod->GetOutputName());
jetplusmettree->SetJetsFromBranch(kFALSE);
jetplusmettree->SetJetsName(theJetCleaning->GetOutputName());
jetplusmettree->SetPVFromBranch(kFALSE);
jetplusmettree->SetPVName(goodPVFilterMod->GetOutputName());
jetplusmettree->SetLeptonsName(merger->GetOutputName());
jetplusmettree->SetIsData(isData);
jetplusmettree->SetProcessID(0);
jetplusmettree->SetFillNtupleType(0);
//------------------------------------------------------------------------------------------------
// making analysis chain
//------------------------------------------------------------------------------------------------
// this is how it always starts
runLumiSel->Add(generatorMod);
generatorMod->Add(goodPVFilterMod);
goodPVFilterMod->Add(hltModP);
// photon regression
hltModP->Add(photreg);
// simple object id modules
photreg ->Add(SepPUMod);
SepPUMod ->Add(muonId);
muonId ->Add(eleIdMod);
eleIdMod ->Add(electronCleaning);
electronCleaning ->Add(merger);
merger ->Add(photonIDMod);
photonIDMod ->Add(photonCleaningMod);
photonCleaningMod->Add(pftauIDMod);
pftauIDMod ->Add(pftauCleaningMod);
pftauCleaningMod ->Add(pubJet);
pubJet ->Add(jetCorr);
jetCorr ->Add(metCorrT0T1Shift);
metCorrT0T1Shift ->Add(theJetID);
theJetID ->Add(theJetCleaning);
theJetCleaning ->Add(jetplusmettree);
//------------------------------------------------------------------------------------------------
// setup analysis
//------------------------------------------------------------------------------------------------
Analysis *ana = new Analysis;
ana->SetUseHLT(kTRUE);
ana->SetKeepHierarchy(kTRUE);
ana->SetSuperModule(runLumiSel);
ana->SetPrintScale(100);
if (nEvents >= 0) ana->SetProcessNEvents(nEvents);
//------------------------------------------------------------------------------------------------
// organize input
//------------------------------------------------------------------------------------------------
Catalog *c = new Catalog(catalogDir);
TString skimdataset = TString(dataset)+TString("/") +TString(skim);
Dataset *d = NULL;
TString bookstr = book;
if (TString(skim).CompareTo("noskim") == 0) {
d = c->FindDataset(bookstr,dataset,fileset, true); // chaching on
//d = c->FindDataset(bookstr,dataset,fileset, false); // chaching off
}
else {
d = c->FindDataset(bookstr,skimdataset.Data(),fileset, true);
//d = c->FindDataset(bookstr,skimdataset.Data(),fileset, false);
}
ana->AddDataset(d);
//ana->AddFile("/mnt/hadoop/cms/store/user/paus/filefi/032/r12a-met-j22-v1/C4AC0AB8-BA82-E211-B238-003048678FF4.root");
//------------------------------------------------------------------------------------------------
// organize output
//------------------------------------------------------------------------------------------------
TString rootFile = TString(outputName);
rootFile += TString("_") + TString(dataset) + TString("_") + TString(skim);
if (TString(fileset) != TString(""))
rootFile += TString("_") + TString(fileset);
rootFile += TString(".root");
ana->SetOutputName(rootFile.Data());
//ana->SetCacheSize(64*1024*1024);
ana->SetCacheSize(0);
//------------------------------------------------------------------------------------------------
// Say what we are doing
//------------------------------------------------------------------------------------------------
printf("\n==== PARAMETER SUMMARY FOR THIS JOB ====\n");
printf("\n JSON file: %s\n and overlap cut: %f (%s)\n",jsonFile.Data(),overlapCut,overlap);
printf("\n Rely on Catalog: %s\n",catalogDir);
printf(" -> Book: %s Dataset: %s Skim: %s Fileset: %s <-\n",book,dataset,skim,fileset);
printf("\n Root output: %s\n\n",rootFile.Data());
printf("\n========================================\n");
//------------------------------------------------------------------------------------------------
// run the analysis after successful initialisation
//------------------------------------------------------------------------------------------------
ana->Run(!gROOT->IsBatch());
return;
}
//--------------------------------------------------------------------------------------------------
void runMonoPhoton(const char *fileset = "0000",
const char *skim = "noskim",
const char *dataset = "s12-zgllg-v7a",
const char *book = "cern/filefi/031",
const char *catalogDir = "~/scratch0/catalog",
const char *outputName = "test/jmet",
int nEvents = 10000)
{
//------------------------------------------------------------------------------------------------
// some parameters get passed through the environment
//------------------------------------------------------------------------------------------------
char json[1024], overlap[1024];
TString jsonFile = "";
float overlapCut = -1;
Bool_t isData = false;
printf("\n Initialization worked \n");
//------------------------------------------------------------------------------------------------
// some global setups
//------------------------------------------------------------------------------------------------
using namespace mithep;
gDebugMask = Debug::kAnalysis;
gDebugLevel = 3;
//------------------------------------------------------------------------------------------------
// set up information
//------------------------------------------------------------------------------------------------
MCProcessSelectionMod *mcselmod = new MCProcessSelectionMod;
MVASystematicsMod *sysMod = new MVASystematicsMod;
sysMod->SetMCR9Scale(1.0035, 1.0035);
sysMod->SetIsData(isData);
RunLumiSelectionMod *runLumiSel = new RunLumiSelectionMod;
runLumiSel->SetAcceptMC(!isData);
runLumiSel->AddJSONFile(string(getenv("CMSSW_BASE")+string("/src/json/Cert_Current_JSON.txt")));
printf("\n Run lumi worked\n");
// Dataset Flags
bool isDataSinglePh = false;
bool isDataPhHad = false;
if (TString(dataset).Contains("-pho-") || TString(dataset).Contains("-sph-")) isDataSinglePh = true;
if (TString(dataset).Contains("-phh-")) isDataPhHad = true;
// Generator info
GeneratorMod *generatorMod = new GeneratorMod;
generatorMod->SetPrintDebug(kFALSE);
generatorMod->SetPtLeptonMin(0.0);
generatorMod->SetEtaLeptonMax(2.7);
generatorMod->SetPtPhotonMin(15.0);
generatorMod->SetEtaPhotonMax(2.7);
generatorMod->SetPtRadPhotonMin(10.0);
generatorMod->SetEtaRadPhotonMax(2.7);
generatorMod->SetIsData(isData);
generatorMod->SetFillHist(!isData);
generatorMod->SetApplyISRFilter(kFALSE);
generatorMod->SetApplyVVFilter(kFALSE);
generatorMod->SetApplyVGFilter(kFALSE);
generatorMod->SetFilterBTEvents(kFALSE);
//------------------------------------------------------------------------------------------------
// HLT information
//------------------------------------------------------------------------------------------------
HLTMod *hltModP = new HLTMod("HLTModP");
//------------------------------------------------------------------------------------------------
// Run2011
//------------------------------------------------------------------------------------------------
hltModP->AddTrigger("HLT_Photon75_CaloIdVL_v*",160404,165087);
hltModP->AddTrigger("HLT_Photon125_v*",165088,163869);
hltModP->AddTrigger("HLT_Photon135_v*",167039,190455);
//------------------------------------------------------------------------------------------------
// Run2012
//------------------------------------------------------------------------------------------------
if (isData){//DATA
if (isDataSinglePh){
hltModP->AddTrigger("HLT_Photon135_v*",190456,193686);
hltModP->AddTrigger("HLT_Photon150_v*",193687,199695);
hltModP->AddTrigger("HLT_Photon135_v*",199696,209151);
}
else if (isDataPhHad){
hltModP->AddTrigger("!HLT_Photon135_v*&HLT_Photon70_CaloIdXL_PFMET100_v*",190456,193686);
hltModP->AddTrigger("!HLT_Photon150_v*&HLT_Photon70_CaloIdXL_PFMET100_v*",193687,199695);
hltModP->AddTrigger("!HLT_Photon135_v*&HLT_Photon70_CaloIdXL_PFMET100_v*",199696,209151);
}
else{
printf("ERROR, WRONG DATASET IDENTIFICATION FOR: %s\n",dataset);
return;
}
}
else{//MC
hltModP->AddTrigger("HLT_Photon135_v*",0,999999);
hltModP->AddTrigger("HLT_Photon70_CaloIdXL_PFMET100*",0,999999);
hltModP->AddTrigger("HLT_MonoCentralPFJet80_PFMETnoMu95_NHEF0p95_v*",0,999999);
hltModP->AddTrigger("HLT_MonoCentralPFJet80_PFMETnoMu105_NHEF0p95_v*",0,999999);
hltModP->AddTrigger("HLT_MET120_HBHENoiseCleaned_v*",0,999999);
hltModP->AddTrigger("HLT_MET120_v10",0,999999);
hltModP->AddTrigger("!HLT_MET120_v10",0,999999);
}
hltModP->SetTrigObjsName("MyHltPhotObjs");
hltModP->SetAbortIfNotAccepted(isData);
hltModP->SetPrintTable(kFALSE); // set to true to print HLT table
//------------------------------------------------------------------------------------------------
// split pfcandidates to PFPU and PFnoPU
//------------------------------------------------------------------------------------------------
SeparatePileUpMod* SepPUMod = new SeparatePileUpMod;
// SepPUMod->SetUseAllVerteces(kFALSE);
// SepPUMod->SetVertexName("OutVtxCiC");
SepPUMod->SetPFNoPileUpName("pfnopileupcands");
SepPUMod->SetPFPileUpName("pfpileupcands");
SepPUMod->SetCheckClosestZVertex(kFALSE);
//------------------------------------------------------------------------------------------------
// select events with a good primary vertex
//------------------------------------------------------------------------------------------------
GoodPVFilterMod *goodPVFilterMod = new GoodPVFilterMod;
goodPVFilterMod->SetMinVertexNTracks(0);
goodPVFilterMod->SetMinNDof (4.0);
goodPVFilterMod->SetMaxAbsZ (24.0);
goodPVFilterMod->SetMaxRho (2.0);
goodPVFilterMod->SetIsMC(!isData);
goodPVFilterMod->SetVertexesName("PrimaryVertexes");
//------------------------------------------------------------------------------------------------
// object id and cleaning sequence
//------------------------------------------------------------------------------------------------
//-----------------------------------
// Lepton Selection
//-----------------------------------
ElectronIDMod* eleIdMod = new ElectronIDMod;
eleIdMod->SetIDType("VBTFWorkingPointLowPtId");
eleIdMod->SetIsoType("PFIso");
eleIdMod->SetApplyConversionFilterType1(kTRUE);
eleIdMod->SetApplyConversionFilterType2(kFALSE);
eleIdMod->SetChargeFilter(kFALSE);
eleIdMod->SetApplyD0Cut(kTRUE);
eleIdMod->SetApplyDZCut(kTRUE);
eleIdMod->SetWhichVertex(-1);
eleIdMod->SetNExpectedHitsInnerCut(0);
eleIdMod->SetGoodElectronsName("GoodElectrons");
eleIdMod->SetRhoType(RhoUtilities::CMS_RHO_RHOKT6PFJETS);
MuonIDMod* muonIdMod = new MuonIDMod;
// base kinematics
muonIdMod -> SetPtMin(10.);
muonIdMod -> SetEtaCut(2.4);
// base ID
muonIdMod -> SetIDType("Tight");
muonIdMod -> SetWhichVertex(-1); // this is a 'hack'.. but hopefully good enough...
muonIdMod -> SetD0Cut(0.02);
muonIdMod -> SetDZCut(0.5);
muonIdMod -> SetIsoType("PFIsoBetaPUCorrected"); //h
muonIdMod -> SetPFIsoCut(0.2); //h
muonIdMod -> SetOutputName("HggLeptonTagMuons");
muonIdMod -> SetPFNoPileUpName("pfnopileupcands");
muonIdMod -> SetPFPileUpName("pfpileupcands");
muonIdMod -> SetPVName(Names::gkPVBeamSpotBrn);
ElectronCleaningMod *electronCleaning = new ElectronCleaningMod;
electronCleaning->SetCleanMuonsName(muonIdMod->GetOutputName());
electronCleaning->SetGoodElectronsName(eleIdMod->GetOutputName());
electronCleaning->SetCleanElectronsName("CleanElectrons");
CosmicCleaningMod *cosmicCleaning = new CosmicCleaningMod;
cosmicCleaning->SetCleanMuonsName(muonIdMod->GetOutputName());
cosmicCleaning->SetCosmicsName("CosmicMuons");
cosmicCleaning->SetCleanCosmicsName("CleanCosmics");
MergeLeptonsMod *merger = new MergeLeptonsMod;
merger->SetMuonsName(muonIdMod->GetOutputName());
merger->SetElectronsName(electronCleaning->GetOutputName());
merger->SetMergedName("MergedLeptons");
//-----------------------------------
// Photon Regression + ID
//-----------------------------------
PhotonMvaMod *photreg = new PhotonMvaMod;
photreg->SetRegressionVersion(3);
photreg->SetRegressionWeights(std::string((gSystem->Getenv("CMSSW_BASE") + TString("/src/MitPhysics/data/gbrv3ph_52x.root")).Data()));
photreg->SetOutputName("GoodPhotonsRegr");
photreg->SetApplyShowerRescaling(kTRUE);
photreg->SetMinNumPhotons(1);
photreg->SetIsData(isData);
photreg->SetDoPreselection(kFALSE);
PhotonIDMod *photonIDMod = new PhotonIDMod;
photonIDMod->SetPtMin(20.0);
photonIDMod->SetOutputName("GoodPhotons");
photonIDMod->SetIDType("BaseLineCiCPFNoPresel");
photonIDMod->SetIsoType("NoIso");
photonIDMod->SetApplyElectronVeto(kFALSE);
photonIDMod->SetApplyPixelSeed(kFALSE);
photonIDMod->SetApplyConversionId(kTRUE);
photonIDMod->SetApplyFiduciality(kTRUE);
photonIDMod->SetIsData(isData);
photonIDMod->SetPhotonsFromBranch(kFALSE);
photonIDMod->SetInputName(photreg->GetOutputName());
//get the photon with regression energy
photonIDMod->DoMCSmear(kTRUE);
photonIDMod->DoDataEneCorr(kTRUE);
//------------------------------------------Energy smear and scale--------------------------------------------------------------
photonIDMod->SetMCSmearFactors2012HCP(0.0111,0.0111,0.0107,0.0107,0.0155,0.0194,0.0295,0.0276,0.037,0.0371);
photonIDMod->AddEnCorrPerRun2012HCP(190645,190781,0.9964,0.9964,1.0020,1.0020,0.9893,1.0028,0.9871,0.9937,0.9839,0.9958);
photonIDMod->AddEnCorrPerRun2012HCP(190782,191042,1.0024,1.0024,1.0079,1.0079,0.9923,1.0058,0.9911,0.9977,0.9886,1.0005);
photonIDMod->AddEnCorrPerRun2012HCP(191043,193555,0.9935,0.9935,0.9991,0.9991,0.9861,0.9997,0.9894,0.9960,0.9864,0.9982);
photonIDMod->AddEnCorrPerRun2012HCP(193556,194150,0.9920,0.9920,0.9976,0.9976,0.9814,0.9951,0.9896,0.9962,0.9872,0.9990);
photonIDMod->AddEnCorrPerRun2012HCP(194151,194532,0.9925,0.9925,0.9981,0.9981,0.9826,0.9963,0.9914,0.9980,0.9874,0.9993);
photonIDMod->AddEnCorrPerRun2012HCP(194533,195113,0.9927,0.9927,0.9983,0.9983,0.9844,0.9981,0.9934,0.9999,0.9878,0.9996);
photonIDMod->AddEnCorrPerRun2012HCP(195114,195915,0.9929,0.9929,0.9984,0.9984,0.9838,0.9974,0.9942,1.0007,0.9878,0.9997);
photonIDMod->AddEnCorrPerRun2012HCP(195916,198115,0.9919,0.9919,0.9975,0.9975,0.9827,0.9964,0.9952,1.0017,0.9869,0.9987);
photonIDMod->AddEnCorrPerRun2012HCP(198116,199803,0.9955,0.9955,1.0011,1.0011,0.9859,0.9995,0.9893,0.9959,0.9923,1.0041);
photonIDMod->AddEnCorrPerRun2012HCP(199804,200048,0.9967,0.9967,1.0023,1.0023,0.9870,1.0006,0.9893,0.9959,0.9937,1.0055);
photonIDMod->AddEnCorrPerRun2012HCP(200049,200151,0.9980,0.9980,1.0036,1.0036,0.9877,1.0012,0.9910,0.9976,0.9980,1.0097);
photonIDMod->AddEnCorrPerRun2012HCP(200152,200490,0.9958,0.9958,1.0013,1.0013,0.9868,1.0004,0.9922,0.9988,0.9948,1.0065);
photonIDMod->AddEnCorrPerRun2012HCP(200491,200531,0.9979,0.9979,1.0035,1.0035,0.9876,1.0012,0.9915,0.9981,0.9979,1.0096);
photonIDMod->AddEnCorrPerRun2012HCP(200532,201656,0.9961,0.9961,1.0017,1.0017,0.9860,0.9996,0.9904,0.9970,0.9945,1.0063);
photonIDMod->AddEnCorrPerRun2012HCP(201657,202305,0.9969,0.9969,1.0025,1.0025,0.9866,1.0002,0.9914,0.9980,0.9999,1.0116);
photonIDMod->AddEnCorrPerRun2012HCP(202305,203002,0.9982,0.9982,1.0038,1.0038,0.9872,1.0008,0.9934,1.0000,1.0018,1.0135);
photonIDMod->AddEnCorrPerRun2012HCP(203003,203984,1.0006,1.0006,1.0061,1.0061,0.9880,1.0017,0.9919,0.9988,0.9992,1.0104);
photonIDMod->AddEnCorrPerRun2012HCP(203985,205085,0.9993,0.9993,1.0048,1.0048,0.9903,1.0040,0.9928,0.9997,0.9987,1.0099);
photonIDMod->AddEnCorrPerRun2012HCP(205086,205310,1.0004,1.0004,1.0059,1.0059,0.9901,1.0037,0.9987,1.0055,1.0091,1.0202);
photonIDMod->AddEnCorrPerRun2012HCP(205311,206207,1.0000,1.0000,1.0055,1.0055,0.9891,1.0028,0.9948,1.0017,1.0032,1.0144);
photonIDMod->AddEnCorrPerRun2012HCP(206208,206483,1.0003,1.0003,1.0058,1.0058,0.9895,1.0032,0.9921,0.9989,1.0056,1.0167);
photonIDMod->AddEnCorrPerRun2012HCP(206484,206597,1.0005,1.0005,1.0060,1.0060,0.9895,1.0032,0.9968,1.0036,1.0046,1.0158);
photonIDMod->AddEnCorrPerRun2012HCP(206598,206896,1.0006,1.0006,1.0061,1.0061,0.9881,1.0017,0.9913,0.9982,1.0050,1.0162);
photonIDMod->AddEnCorrPerRun2012HCP(206897,207220,1.0006,1.0006,1.0061,1.0061,0.9884,1.0021,0.9909,0.9978,1.0053,1.0165);
photonIDMod->AddEnCorrPerRun2012HCP(207221,208686,1.0006,1.0006,1.0061,1.0061,0.9894,1.0030,0.9951,1.0020,1.0060,1.0172);
//---------------------------------shower shape scale--------------------------------------------------------------------------------
photonIDMod->SetDoShowerShapeScaling(kTRUE);
photonIDMod->SetShowerShapeType("2012ShowerShape");
photonIDMod->Set2012HCP(kTRUE);
PhotonCleaningMod *photonCleaningMod = new PhotonCleaningMod;
photonCleaningMod->SetCleanElectronsName(electronCleaning->GetOutputName());
photonCleaningMod->SetGoodPhotonsName(photonIDMod->GetOutputName());
photonCleaningMod->SetCleanPhotonsName("CleanPhotons");
PublisherMod<PFJet,Jet> *pubJet = new PublisherMod<PFJet,Jet>("JetPub");
pubJet->SetInputName("AKt5PFJets");
pubJet->SetOutputName("PubAKt5PFJets");
JetCorrectionMod *jetCorr = new JetCorrectionMod;
if(isData){
jetCorr->AddCorrectionFromFile(std::string((gSystem->Getenv("CMSSW_BASE") + TString("/src/MitPhysics/data/Summer12_V7_DATA_L1FastJet_AK5PF.txt")).Data()));
jetCorr->AddCorrectionFromFile(std::string((gSystem->Getenv("CMSSW_BASE") + TString("/src/MitPhysics/data/Summer12_V7_DATA_L2Relative_AK5PF.txt")).Data()));
jetCorr->AddCorrectionFromFile(std::string((gSystem->Getenv("CMSSW_BASE") + TString("/src/MitPhysics/data/Summer12_V7_DATA_L3Absolute_AK5PF.txt")).Data()));
jetCorr->AddCorrectionFromFile(std::string((gSystem->Getenv("CMSSW_BASE") + TString("/src/MitPhysics/data/Summer12_V7_DATA_L2L3Residual_AK5PF.txt")).Data()));
}
else {
jetCorr->AddCorrectionFromFile(std::string((gSystem->Getenv("CMSSW_BASE") + TString("/src/MitPhysics/data/Summer12_V7_MC_L1FastJet_AK5PF.txt")).Data()));
jetCorr->AddCorrectionFromFile(std::string((gSystem->Getenv("CMSSW_BASE") + TString("/src/MitPhysics/data/Summer12_V7_MC_L2Relative_AK5PF.txt")).Data()));
jetCorr->AddCorrectionFromFile(std::string((gSystem->Getenv("CMSSW_BASE") + TString("/src/MitPhysics/data/Summer12_V7_MC_L3Absolute_AK5PF.txt")).Data()));
}
jetCorr->SetInputName(pubJet->GetOutputName());
jetCorr->SetCorrectedName("CorrectedJets");
JetIDMod *theJetID = new JetIDMod;
theJetID->SetInputName(jetCorr->GetOutputName());
theJetID->SetPtCut(30.0);
theJetID->SetEtaMaxCut(4.7);
theJetID->SetJetEEMFractionMinCut(0.00);
theJetID->SetOutputName("GoodJets");
theJetID->SetApplyBetaCut(kFALSE);
theJetID->SetApplyMVACut(kTRUE);
JetCleaningMod *theJetCleaning = new JetCleaningMod;
theJetCleaning->SetCleanElectronsName(electronCleaning->GetOutputName());
theJetCleaning->SetCleanMuonsName(muonIdMod->GetOutputName());
theJetCleaning->SetCleanPhotonsName(photonCleaningMod->GetOutputName());
theJetCleaning->SetApplyPhotonRemoval(kTRUE);
theJetCleaning->SetGoodJetsName(theJetID->GetOutputName());
theJetCleaning->SetCleanJetsName("CleanJets");
//------------------------------------------------------------------------------------------------
// select events with photon+MET
//------------------------------------------------------------------------------------------------
MonoPhotonAnalysisMod *phplusmet = new MonoPhotonAnalysisMod("MonoPhotonSelector");
phplusmet->SetInputPhotonsName(photonCleaningMod->GetOutputName()); //identified photons
phplusmet->SetInputElectronsName(electronCleaning->GetOutputName()); //identified electrons
phplusmet->SetInputMuonsName(muonIdMod->GetOutputName()); //muons
phplusmet->SetPhotonsFromBranch(kFALSE);
phplusmet->SetElectronsFromBranch(kFALSE);
phplusmet->SetMuonsFromBranch(kFALSE);
phplusmet->SetMinNumPhotons(1);
phplusmet->SetMinNumLeptons(0);
phplusmet->SetMinPhotonEt(100);
phplusmet->SetMaxPhotonEta(2.4);
phplusmet->SetMinMetEt(100);
MonoPhotonAnalysisMod *dilepton = new MonoPhotonAnalysisMod("MonoPhotonSelector_dilepton");
dilepton->SetInputPhotonsName(photonCleaningMod->GetOutputName()); //identified photons
dilepton->SetInputElectronsName(electronCleaning->GetOutputName()); //identified electrons
dilepton->SetInputMuonsName(muonIdMod->GetOutputName()); //muons
dilepton->SetPhotonsFromBranch(kFALSE);
dilepton->SetElectronsFromBranch(kFALSE);
dilepton->SetMuonsFromBranch(kFALSE);
dilepton->SetMinNumPhotons(1);
dilepton->SetMinNumLeptons(2);
dilepton->SetMinPhotonEt(0);
dilepton->SetMaxPhotonEta(2.4);
dilepton->SetMinMetEt(0);
MonoPhotonAnalysisMod *phfake = new MonoPhotonAnalysisMod("MonoPhotonSelector_phfake");
phfake->SetInputPhotonsName(photreg->GetOutputName()); //all photons
phfake->SetInputElectronsName(electronCleaning->GetOutputName()); //identified electrons
phfake->SetInputMuonsName(muonIdMod->GetOutputName()); //muons
phfake->SetPhotonsFromBranch(kFALSE);
phfake->SetElectronsFromBranch(kFALSE);
phfake->SetMuonsFromBranch(kFALSE);
phfake->SetMinNumPhotons(1);
phfake->SetMinNumLeptons(0);
phfake->SetMinPhotonEt(100);
phfake->SetMaxPhotonEta(2.4);
phfake->SetMinMetEt(0);
MonoPhotonAnalysisMod *beamhalo = new MonoPhotonAnalysisMod("MonoPhotonSelector_beamhalo");
beamhalo->SetInputPhotonsName(photreg->GetOutputName()); //all photons
beamhalo->SetInputElectronsName(electronCleaning->GetOutputName()); //identified electrons
beamhalo->SetInputMuonsName(muonIdMod->GetOutputName()); //muons
beamhalo->SetPhotonsFromBranch(kFALSE);
beamhalo->SetElectronsFromBranch(kFALSE);
beamhalo->SetMuonsFromBranch(kFALSE);
beamhalo->SetMinNumPhotons(1);
beamhalo->SetMinNumLeptons(0);
beamhalo->SetMinPhotonEt(100);
beamhalo->SetMaxPhotonEta(2.4);
beamhalo->SetMinMetEt(100);
MonoPhotonTreeWriter *phplusmettree = new MonoPhotonTreeWriter("MonoPhotonTreeWriter");
phplusmettree->SetPhotonsFromBranch(kFALSE);
phplusmettree->SetPhotonsName(photonCleaningMod->GetOutputName());
phplusmettree->SetElectronsFromBranch(kFALSE);
phplusmettree->SetElectronsName(electronCleaning->GetOutputName());
phplusmettree->SetMuonsFromBranch(kFALSE);
phplusmettree->SetMuonsName(muonIdMod->GetOutputName());
phplusmettree->SetJetsFromBranch(kFALSE);
phplusmettree->SetJetsName(theJetCleaning->GetOutputName());
phplusmettree->SetCosmicsFromBranch(kTRUE);
phplusmettree->SetPVFromBranch(kFALSE);
phplusmettree->SetPVName(goodPVFilterMod->GetOutputName());
phplusmettree->SetLeptonsName(merger->GetOutputName());
phplusmettree->SetHltObjsName(hltModP->GetOutputName());
phplusmettree->SetIsData(isData);
phplusmettree->SetProcessID(0);
phplusmettree->SetFillNtupleType(0);
MonoPhotonTreeWriter *dileptontree = new MonoPhotonTreeWriter("MonoPhotonTreeWriter_dilepton");
dileptontree->SetPhotonsFromBranch(kFALSE);
dileptontree->SetPhotonsName(photonCleaningMod->GetOutputName());
dileptontree->SetElectronsFromBranch(kFALSE);
dileptontree->SetElectronsName(electronCleaning->GetOutputName());
dileptontree->SetMuonsFromBranch(kFALSE);
dileptontree->SetMuonsName(muonIdMod->GetOutputName());
dileptontree->SetJetsFromBranch(kFALSE);
dileptontree->SetJetsName(theJetCleaning->GetOutputName());
dileptontree->SetCosmicsFromBranch(kTRUE);
dileptontree->SetPVFromBranch(kFALSE);
dileptontree->SetPVName(goodPVFilterMod->GetOutputName());
dileptontree->SetLeptonsName(merger->GetOutputName());
dileptontree->SetHltObjsName(hltModP->GetOutputName());
dileptontree->SetIsData(isData);
dileptontree->SetProcessID(0);
dileptontree->SetFillNtupleType(1);//dilepton
MonoPhotonTreeWriter *phfaketree = new MonoPhotonTreeWriter("MonoPhotonTreeWriter_phfake");
phfaketree->SetPhotonsFromBranch(kFALSE);
phfaketree->SetPhotonsName(photreg->GetOutputName());
phfaketree->SetElectronsFromBranch(kFALSE);
phfaketree->SetElectronsName(electronCleaning->GetOutputName());
phfaketree->SetMuonsFromBranch(kFALSE);
phfaketree->SetMuonsName(muonIdMod->GetOutputName());
phfaketree->SetJetsFromBranch(kFALSE);
phfaketree->SetJetsName(theJetCleaning->GetOutputName());
phfaketree->SetCosmicsFromBranch(kTRUE);
phfaketree->SetPVFromBranch(kFALSE);
phfaketree->SetPVName(goodPVFilterMod->GetOutputName());
phfaketree->SetLeptonsName(merger->GetOutputName());
phfaketree->SetHltObjsName(hltModP->GetOutputName());
phfaketree->SetIsData(isData);
phfaketree->SetProcessID(0);
phfaketree->SetFillNtupleType(2);//phfake;
MonoPhotonTreeWriter *beamhalotree = new MonoPhotonTreeWriter("MonoPhotonTreeWriter_beamhalo");
beamhalotree->SetPhotonsFromBranch(kFALSE);
beamhalotree->SetPhotonsName(photreg->GetOutputName());
beamhalotree->SetElectronsFromBranch(kFALSE);
beamhalotree->SetElectronsName(electronCleaning->GetOutputName());
beamhalotree->SetMuonsFromBranch(kFALSE);
beamhalotree->SetMuonsName(muonIdMod->GetOutputName());
beamhalotree->SetJetsFromBranch(kFALSE);
beamhalotree->SetJetsName(theJetCleaning->GetOutputName());
beamhalotree->SetCosmicsFromBranch(kTRUE);
beamhalotree->SetPVFromBranch(kFALSE);
beamhalotree->SetPVName(goodPVFilterMod->GetOutputName());
beamhalotree->SetLeptonsName(merger->GetOutputName());
beamhalotree->SetHltObjsName(hltModP->GetOutputName());
beamhalotree->SetIsData(isData);
beamhalotree->SetProcessID(0);
beamhalotree->SetFillNtupleType(3);//beamhalo
//------------------------------------------------------------------------------------------------
// making analysis chain
//------------------------------------------------------------------------------------------------
// this is how it always starts
runLumiSel ->Add(mcselmod);
mcselmod->Add(generatorMod);
generatorMod->Add(goodPVFilterMod);
goodPVFilterMod->Add(hltModP);
// photon regression
hltModP->Add(photreg);
// simple object id modules
photreg ->Add(SepPUMod);
SepPUMod ->Add(muonIdMod);
muonIdMod ->Add(cosmicCleaning);
cosmicCleaning ->Add(eleIdMod);
eleIdMod ->Add(electronCleaning);
electronCleaning ->Add(merger);
merger ->Add(photonIDMod);
photonIDMod ->Add(photonCleaningMod);
photonCleaningMod->Add(pubJet);
pubJet ->Add(jetCorr);
jetCorr ->Add(theJetID);
theJetID ->Add(theJetCleaning);
// Gamma+met selection
//theJetCleaning ->Add(phplusmet);
//phplusmet ->Add(phplusmettree);
theJetCleaning ->Add(phplusmettree);
// Dilepton selection
theJetCleaning ->Add(dilepton);
dilepton ->Add(dileptontree);
// Fake photon selection
theJetCleaning ->Add(phfake);
phfake ->Add(phfaketree);
// Beam Halo selection
theJetCleaning ->Add(beamhalo);
beamhalo ->Add(beamhalotree);
//------------------------------------------------------------------------------------------------
// setup analysis
//------------------------------------------------------------------------------------------------
Analysis *ana = new Analysis;
ana->SetUseHLT(kTRUE);
ana->SetKeepHierarchy(kFALSE);
ana->SetSuperModule(runLumiSel);
ana->SetPrintScale(100);
if (nEvents >= 0)
ana->SetProcessNEvents(nEvents);
//------------------------------------------------------------------------------------------------
// organize input
//------------------------------------------------------------------------------------------------
Catalog *c = new Catalog(catalogDir);
TString skimdataset = TString(dataset)+TString("/") +TString(skim);
Dataset *d = NULL;
TString bookstr = book;
if (TString(skim).CompareTo("noskim") == 0)
d = c->FindDataset(bookstr,dataset,fileset,true);
else
d = c->FindDataset(bookstr,skimdataset.Data(),fileset,true);
ana->AddDataset(d);
//------------------------------------------------------------------------------------------------
// organize output
//------------------------------------------------------------------------------------------------
TString rootFile = TString(outputName);
rootFile += TString("_") + TString(dataset) + TString("_") + TString(skim);
if (TString(fileset) != TString(""))
rootFile += TString("_") + TString(fileset);
rootFile += TString(".root");
ana->SetOutputName(rootFile.Data());
//ana->SetCacheSize(64*1024*1024);
ana->SetCacheSize(0);
//------------------------------------------------------------------------------------------------
// Say what we are doing
//------------------------------------------------------------------------------------------------
printf("\n==== PARAMETER SUMMARY FOR THIS JOB ====\n");
printf("\n JSON file: %s\n and overlap cut: %f (%s)\n",jsonFile.Data(),overlapCut,overlap);
printf("\n Rely on Catalog: %s\n",catalogDir);
printf(" -> Book: %s Dataset: %s Skim: %s Fileset: %s <-\n",book,dataset,skim,fileset);
printf("\n Root output: %s\n\n",rootFile.Data());
printf("\n========================================\n");
//------------------------------------------------------------------------------------------------
// run the analysis after successful initialisation
//------------------------------------------------------------------------------------------------
ana->Run(!gROOT->IsBatch());
return;
}
//--------------------------------------------------------------------------------------------------
void runMonoJetSkim(const char *fileset = "0000",
const char *skim = "noskim",
const char *dataset = "s12-zjets-ptz100-v7a",
const char *book = "t2mit/filefi/032",
const char *catalogDir = "/home/cmsprod/catalog",
const char *outputLabel = "monojet",
int nEvents = 1000)
{
//------------------------------------------------------------------------------------------------
// json parameters get passed through the environment
// for MC, the value must be "~"
//------------------------------------------------------------------------------------------------
TString json(gSystem->Getenv("MIT_PROD_JSON"));
if (json.Length() == 0) {
printf(" JSON file was not properly defined. EXIT!\n");
return;
}
TString jsonFile = TString("/home/cmsprod/cms/json/") + json;
Bool_t isData = (json != "~");
TString MitData(gSystem->Getenv("MIT_DATA"));
if(MitData.Length() == 0){
MitData = gSystem->Getenv("CMSSW_BASE");
MitData += "/src/MitPhysics/data";
}
printf("\n Initialization worked: \n\n");
printf(" JSON : %s (file: %s)\n", json.Data(), jsonFile.Data());
printf(" isData : %d\n\n",isData);
//------------------------------------------------------------------------------------------------
// some global setups
//------------------------------------------------------------------------------------------------
using namespace mithep;
gDebugMask = Debug::kGeneral;
gDebugLevel = 3;
//------------------------------------------------------------------------------------------------
// set up information
//------------------------------------------------------------------------------------------------
RunLumiSelectionMod *runLumiSel = new RunLumiSelectionMod;
runLumiSel->SetAcceptMC(kTRUE); // Monte Carlo events are always accepted
// only select on run- and lumisection numbers when valid json file present
if ((jsonFile.CompareTo("/home/cmsprod/cms/json/~") != 0) &&
(jsonFile.CompareTo("/home/cmsprod/cms/json/-") != 0) ) {
printf("\n Jason file added: %s \n\n",jsonFile.Data());
runLumiSel->AddJSONFile(jsonFile.Data());
}
if ((jsonFile.CompareTo("/home/cmsprod/cms/json/-") == 0) ) {
printf("\n WARNING -- Looking at data without JSON file: always accept.\n\n");
runLumiSel->SetAbortIfNotAccepted(kFALSE); // accept all events if there is no valid JSON file
}
printf("\n Run lumi worked. \n\n");
// Generator info
GeneratorMod *generatorMod = new GeneratorMod;
generatorMod->SetPrintDebug(kFALSE);
generatorMod->SetPtLeptonMin(0.0);
generatorMod->SetEtaLeptonMax(2.7);
generatorMod->SetPtPhotonMin(0.0);
generatorMod->SetEtaPhotonMax(2.7);
generatorMod->SetPtRadPhotonMin(0.0);
generatorMod->SetEtaRadPhotonMax(2.7);
generatorMod->SetIsData(isData);
generatorMod->SetFillHist(! isData);
generatorMod->SetApplyISRFilter(kFALSE);
generatorMod->SetApplyVVFilter(kFALSE);
generatorMod->SetApplyVGFilter(kFALSE);
generatorMod->SetFilterBTEvents(kFALSE);
//-----------------------------------------------------------------------------------------------------------
// HLT information : trigger not applied (neither for data nor for MC, store info to apply selection offline
//-----------------------------------------------------------------------------------------------------------
HLTMod *hltModP = new HLTMod("HLTModP");
// monojet triggers
const int nMjtTrigs = 12;
TString monoJetTriggers[nMjtTrigs] = { "HLT_MonoCentralPFJet80_PFMETnoMu105_NHEF0p95_v4",
"HLT_MonoCentralPFJet80_PFMETnoMu105_NHEF0p95_v3",
"HLT_MonoCentralPFJet80_PFMETnoMu105_NHEF0p95_v1",
"HLT_MonoCentralPFJet80_PFMETnoMu95_NHEF0p95_v5",
"HLT_MonoCentralPFJet80_PFMETnoMu95_NHEF0p95_v4",
"HLT_MonoCentralPFJet80_PFMETnoMu95_NHEF0p95_v3",
"HLT_MonoCentralPFJet80_PFMETnoMu95_NHEF0p95_v2",
"HLT_MET120_HBHENoiseCleaned_v6",
"HLT_MET120_HBHENoiseCleaned_v5",
"HLT_MET120_HBHENoiseCleaned_v4",
"HLT_MET120_HBHENoiseCleaned_v3",
"HLT_MET120_HBHENoiseCleaned_v2" };
for (int i=0; i<nMjtTrigs; i++)
hltModP->AddTrigger(TString("!+"+monoJetTriggers[i]),0,999999);
// VBF triggers
const int nVbfTrigs = 7;
TString vbfTriggers[nVbfTrigs] = { "HLT_DiPFJet40_PFMETnoMu65_MJJ800VBF_AllJets_v9",
"HLT_DiPFJet40_PFMETnoMu65_MJJ800VBF_AllJets_v8",
"HLT_DiPFJet40_PFMETnoMu65_MJJ800VBF_AllJets_v6",
"HLT_DiPFJet40_PFMETnoMu65_MJJ800VBF_AllJets_v5",
"HLT_DiPFJet40_PFMETnoMu65_MJJ800VBF_AllJets_v4",
"HLT_DiPFJet40_PFMETnoMu65_MJJ800VBF_AllJets_v3",
"HLT_DiPFJet40_PFMETnoMu65_MJJ800VBF_AllJets_v2" };
for (int i=0; i<nVbfTrigs; i++)
hltModP->AddTrigger((TString("!+")+vbfTriggers[i]).Data(),0,999999);
hltModP->SetBitsName("HLTBits");
hltModP->SetTrigObjsName("MyHltPhotObjs");
hltModP->SetAbortIfNotAccepted(isData);
hltModP->SetPrintTable(kFALSE);
//------------------------------------------------------------------------------------------------
// split pfcandidates to PFPU and PFnoPU
//------------------------------------------------------------------------------------------------
SeparatePileUpMod* SepPUMod = new SeparatePileUpMod;
SepPUMod->SetPFNoPileUpName("pfnopileupcands");
SepPUMod->SetPFPileUpName("pfpileupcands");
SepPUMod->SetCheckClosestZVertex(kFALSE);
//------------------------------------------------------------------------------------------------
// select events with a good primary vertex
//------------------------------------------------------------------------------------------------
GoodPVFilterMod *goodPvMod = new GoodPVFilterMod;
goodPvMod->SetMinVertexNTracks(0);
goodPvMod->SetMinNDof(4.0);
goodPvMod->SetMaxAbsZ(24.0);
goodPvMod->SetMaxRho(2.0);
goodPvMod->SetIsMC(!isData);
goodPvMod->SetVertexesName("PrimaryVertexes");
//------------------------------------------------------------------------------------------------
// object id and cleaning sequence
//------------------------------------------------------------------------------------------------
//-----------------------------------
// Lepton Selection
//-----------------------------------
ElectronIDMod* eleIdMod = new ElectronIDMod;
eleIdMod->SetPtMin(10.);
eleIdMod->SetEtaMax(2.5);
eleIdMod->SetApplyEcalFiducial(true);
eleIdMod->SetIDType(mithep::ElectronTools::kVBTFWorkingPoint95Id);
eleIdMod->SetIsoType(mithep::ElectronTools::kPFIso);
eleIdMod->SetApplyConversionFilterType1(kTRUE);
eleIdMod->SetApplyConversionFilterType2(kFALSE);
eleIdMod->SetChargeFilter(kFALSE);
eleIdMod->SetApplyD0Cut(kTRUE);
eleIdMod->SetApplyDZCut(kTRUE);
eleIdMod->SetWhichVertex(-1);
eleIdMod->SetGoodElectronsName("GoodElectronsBS");
eleIdMod->SetRhoAlgo(mithep::PileupEnergyDensity::kKt6PFJets);
MuonIDMod *muonId = new MuonIDMod;
muonId->SetOutputName("GoodMuons");
muonId->SetIntRadius(0.0);
muonId->SetClassType("GlobalTracker");
muonId->SetIDType("WWMuIdV4");
muonId->SetIsoType("IsoRingsV0_BDTG_Iso");
muonId->SetApplyD0Cut(kTRUE);
muonId->SetApplyDZCut(kTRUE);
muonId->SetWhichVertex(0);
muonId->SetRhoAlgo(mithep::PileupEnergyDensity::kKt6PFJets);
muonId->SetPtMin(10.);
muonId->SetEtaCut(2.4);
ElectronCleaningMod *electronCleaning = new ElectronCleaningMod;
electronCleaning->SetCleanMuonsName(muonId->GetOutputName());
electronCleaning->SetGoodElectronsName(eleIdMod->GetOutputName());
electronCleaning->SetCleanElectronsName("CleanElectrons");
MergeLeptonsMod *merger = new MergeLeptonsMod;
merger->SetMuonsName(muonId->GetOutputName());
merger->SetElectronsName(electronCleaning->GetOutputName());
merger->SetMergedName("MergedLeptons");
//-----------------------------------
// Photon Regression + ID
//-----------------------------------
PhotonMvaMod *photonReg = new PhotonMvaMod;
photonReg->SetRegressionVersion(3);
photonReg->SetRegressionWeights((MitData+TString("/gbrv3ph_52x.root")).Data());
photonReg->SetOutputName("GoodPhotonsRegr");
photonReg->SetApplyShowerRescaling(kTRUE);
photonReg->SetMinNumPhotons(0);
photonReg->SetIsData(isData);
PhotonIDMod *photonIDMod = new PhotonIDMod;
photonIDMod->SetPtMin(0.0);
photonIDMod->SetOutputName("GoodPhotons");
photonIDMod->SetIDType("BaseLineCiCPFNoPresel");
photonIDMod->SetIsoType("NoIso");
photonIDMod->SetApplyElectronVeto(kTRUE);
photonIDMod->SetApplyPixelSeed(kTRUE);
photonIDMod->SetApplyConversionId(kTRUE);
photonIDMod->SetApplyFiduciality(kTRUE);
photonIDMod->SetIsData(isData);
photonIDMod->SetPhotonsFromBranch(kFALSE);
photonIDMod->SetInputName(photonReg->GetOutputName());
//get the photon with regression energy
photonIDMod->DoMCSmear(kTRUE);
photonIDMod->DoDataEneCorr(kTRUE);
//---------------------------------shower shape scale--------------------------------------------------------------------------------
photonIDMod->SetDoShowerShapeScaling(kTRUE);
photonIDMod->SetShowerShapeType("2012ShowerShape");
PFTauIDMod *pfTauIDMod = new PFTauIDMod;
pfTauIDMod->SetPFTausName("HPSTaus");
pfTauIDMod->SetIsLooseId(kFALSE);
PhotonCleaningMod *photonCleaningMod = new PhotonCleaningMod;
photonCleaningMod->SetCleanElectronsName(electronCleaning->GetOutputName());
photonCleaningMod->SetGoodPhotonsName(photonIDMod->GetOutputName());
photonCleaningMod->SetCleanPhotonsName("CleanPhotons");
PFTauCleaningMod *pfTauCleaningMod = new PFTauCleaningMod;
pfTauCleaningMod->SetGoodPFTausName(pfTauIDMod->GetGoodPFTausName());
pfTauCleaningMod->SetCleanMuonsName(muonId->GetOutputName());
PublisherMod<PFJet,Jet> *pubJet = new PublisherMod<PFJet,Jet>("JetPub");
pubJet->SetInputName("AKt5PFJets");
pubJet->SetOutputName("PubAKt5PFJets");
JetCorrectionMod *jetCorr = new JetCorrectionMod;
if (isData){
jetCorr->AddCorrectionFromFile((MitData+TString("/Summer13_V1_DATA_L1FastJet_AK5PF.txt")).Data());
jetCorr->AddCorrectionFromFile((MitData+TString("/Summer13_V1_DATA_L2Relative_AK5PF.txt")).Data());
jetCorr->AddCorrectionFromFile((MitData+TString("/Summer13_V1_DATA_L3Absolute_AK5PF.txt")).Data());
jetCorr->AddCorrectionFromFile((MitData+TString("/Summer13_V1_DATA_L2L3Residual_AK5PF.txt")).Data());
}
else {
jetCorr->AddCorrectionFromFile((MitData+TString("/Summer13_V1_MC_L1FastJet_AK5PF.txt")).Data());
jetCorr->AddCorrectionFromFile((MitData+TString("/Summer13_V1_MC_L2Relative_AK5PF.txt")).Data());
jetCorr->AddCorrectionFromFile((MitData+TString("/Summer13_V1_MC_L3Absolute_AK5PF.txt")).Data());
}
jetCorr->SetInputName(pubJet->GetOutputName());
jetCorr->SetCorrectedName("CorrectedJets");
JetIDMod *jetID = new JetIDMod;
jetID->SetInputName(jetCorr->GetOutputName());
jetID->SetPtCut(30.0);
jetID->SetEtaMaxCut(4.7);
jetID->SetJetEEMFractionMinCut(0.00);
jetID->SetOutputName("GoodJets");
jetID->SetApplyBetaCut(kFALSE);
jetID->SetApplyMVACut(kTRUE);
JetCleaningMod *jetCleaning = new JetCleaningMod;
jetCleaning->SetCleanElectronsName(electronCleaning->GetOutputName());
jetCleaning->SetCleanMuonsName(muonId->GetOutputName());
jetCleaning->SetCleanPhotonsName(photonCleaningMod->GetOutputName());
jetCleaning->SetApplyPhotonRemoval(kTRUE);
jetCleaning->SetGoodJetsName(jetID->GetOutputName());
jetCleaning->SetCleanJetsName("CleanJets");
MetCorrectionMod *metCorrT0T1Shift = new MetCorrectionMod;
metCorrT0T1Shift->SetInputName("PFMet");
metCorrT0T1Shift->SetJetsName(pubJet->GetOutputName());
metCorrT0T1Shift->SetCorrectedJetsName(jetCorr->GetOutputName());
metCorrT0T1Shift->SetCorrectedName("PFMetT0T1Shift");
metCorrT0T1Shift->ApplyType0(kTRUE);
metCorrT0T1Shift->ApplyType1(kTRUE);
metCorrT0T1Shift->ApplyShift(kTRUE);
metCorrT0T1Shift->IsData(isData);
metCorrT0T1Shift->SetPrint(kFALSE);
//------------------------------------------------------------------------------------------------
// select events
//------------------------------------------------------------------------------------------------
float minLeadingJetEt = 100.;
float maxJetEta = 4.7;
float minMet = 160.;
MonoJetAnalysisMod *monojetSel = new MonoJetAnalysisMod("MonoJetSelector");
monojetSel->SetInputMetName(metCorrT0T1Shift->GetOutputName());
monojetSel->SetMetFromBranch(kFALSE);
monojetSel->SetJetsName(jetCleaning->GetOutputName());
monojetSel->SetJetsFromBranch(kFALSE);
monojetSel->SetElectronsName(electronCleaning->GetOutputName());
monojetSel->SetElectronsFromBranch(kFALSE);
monojetSel->SetMuonsName(muonId->GetOutputName());
monojetSel->SetMuonsFromBranch(kFALSE);
monojetSel->SetTausName(pfTauCleaningMod->GetOutputName());
monojetSel->SetTausFromBranch(kFALSE);
monojetSel->SetLeptonsName(merger->GetOutputName());
monojetSel->SetCategoriesName("MonoJetEventCategories");
// Jet + MET (signal region)
unsigned iCat = 0;
monojetSel->SetMinNumLeptons(iCat, 0);
monojetSel->SetMaxNumLeptons(iCat, 0);
monojetSel->SetMinNumTaus(iCat, 0);
monojetSel->SetMaxNumTaus(iCat, 0);
monojetSel->SetMinNumJets(iCat, 1);
monojetSel->SetMaxNumJets(iCat, 1);
monojetSel->SetMinNumGenNeutrinos(iCat, 0);
monojetSel->SetMinJetEt(iCat, minLeadingJetEt);
monojetSel->SetMaxJetEta(iCat, maxJetEta);
monojetSel->SetMinMetEt(iCat, minMet);
monojetSel->SetMinEmulMetEt(iCat, 0.);
monojetSel->SetMinChargedHadronFrac(iCat, 0.2);
monojetSel->SetMaxNeutralHadronFrac(iCat, 0.7);
monojetSel->SetMaxNeutralEmFrac(iCat, 0.7);
// Dilepton (Z->ll)
iCat = 1;
monojetSel->SetMinNumLeptons(iCat, 2);
monojetSel->SetMaxNumLeptons(iCat, 2);
monojetSel->SetMinNumTaus(iCat, 0);
monojetSel->SetMaxNumTaus(iCat, 0);
monojetSel->SetMinNumJets(iCat, 1);
monojetSel->SetMaxNumJets(iCat, 1);
monojetSel->SetMinNumGenNeutrinos(iCat, 0);
monojetSel->SetMinJetEt(iCat, minLeadingJetEt);
monojetSel->SetMaxJetEta(iCat, maxJetEta);
monojetSel->SetMinMetEt(iCat, 0.);
monojetSel->SetMinEmulMetEt(iCat, minMet);
monojetSel->SetMinChargedHadronFrac(iCat, 0.2);
monojetSel->SetMaxNeutralHadronFrac(iCat, 0.7);
monojetSel->SetMaxNeutralEmFrac(iCat, 0.7);
// Single lepton (W->lnu)
iCat = 2;
monojetSel->SetMinNumLeptons(iCat, 1);
monojetSel->SetMaxNumLeptons(iCat, 1);
monojetSel->SetMinNumTaus(iCat, 0);
monojetSel->SetMaxNumTaus(iCat, 0);
monojetSel->SetMinNumJets(iCat, 1);
monojetSel->SetMaxNumJets(iCat, 1);
monojetSel->SetMinNumGenNeutrinos(iCat, 0);
monojetSel->SetMinJetEt(iCat, minLeadingJetEt);
monojetSel->SetMaxJetEta(iCat, maxJetEta);
monojetSel->SetMinMetEt(iCat, minMet);
monojetSel->SetMinEmulMetEt(iCat, 0.);
monojetSel->SetMinChargedHadronFrac(iCat, 0.2);
monojetSel->SetMaxNeutralHadronFrac(iCat, 0.7);
monojetSel->SetMaxNeutralEmFrac(iCat, 0.7);
// if dataset is Z MC, skim based on the existence of neutrinos
if(TString(dataset).Contains("zjets")){
iCat = 3;
monojetSel->SetMinNumLeptons(iCat, 0);
monojetSel->SetMaxNumLeptons(iCat, 0);
monojetSel->SetMinNumTaus(iCat, 0);
monojetSel->SetMaxNumTaus(iCat, 0);
monojetSel->SetMinNumJets(iCat, 1);
monojetSel->SetMaxNumJets(iCat, 1);
// this is what makes this module special
monojetSel->SetMinNumGenNeutrinos(iCat, 2);
monojetSel->SetMinJetEt(iCat, minLeadingJetEt);
monojetSel->SetMaxJetEta(iCat, maxJetEta);
monojetSel->SetMinMetEt(iCat, minMet);
monojetSel->SetMinEmulMetEt(iCat, 0.);
monojetSel->SetMinChargedHadronFrac(iCat, 0.2);
monojetSel->SetMaxNeutralHadronFrac(iCat, 0.7);
monojetSel->SetMaxNeutralEmFrac(iCat, 0.7);
}
//------------------------------------------------------------------------------------------------
// making the analysis chain
//------------------------------------------------------------------------------------------------
// this is how it always starts
runLumiSel ->Add(generatorMod);
generatorMod ->Add(goodPvMod);
goodPvMod ->Add(hltModP);
// photon regression
hltModP ->Add(photonReg);
// simple object id modules
photonReg ->Add(SepPUMod);
SepPUMod ->Add(muonId);
muonId ->Add(eleIdMod);
eleIdMod ->Add(electronCleaning);
electronCleaning ->Add(merger);
merger ->Add(photonIDMod);
photonIDMod ->Add(photonCleaningMod);
photonCleaningMod->Add(pfTauIDMod);
pfTauIDMod ->Add(pfTauCleaningMod);
pfTauCleaningMod ->Add(pubJet);
pubJet ->Add(jetCorr);
jetCorr ->Add(metCorrT0T1Shift);
metCorrT0T1Shift ->Add(jetID);
jetID ->Add(jetCleaning);
jetCleaning ->Add(monojetSel);
//------------------------------------------------------------------------------------------------
// setup analysis
//------------------------------------------------------------------------------------------------
Analysis *ana = new Analysis;
ana->SetUseCacher(1);
ana->SetUseHLT(kTRUE);
ana->SetKeepHierarchy(kTRUE);
ana->SetSuperModule(runLumiSel);
ana->SetPrintScale(100);
if (nEvents >= 0)
ana->SetProcessNEvents(nEvents);
//------------------------------------------------------------------------------------------------
// organize input
//------------------------------------------------------------------------------------------------
Catalog *c = new Catalog(catalogDir);
TString skimDataset = TString(dataset)+TString("/") +TString(skim);
Dataset *d = NULL;
if (TString(skim).CompareTo("noskim") == 0)
d = c->FindDataset(book,dataset,fileset, 1); // 1 to use smartcache
else
d = c->FindDataset(book,skimDataset.Data(),fileset, 1);
ana->AddDataset(d);
ana->SetCacheSize(0);
//------------------------------------------------------------------------------------------------
// skim output
//------------------------------------------------------------------------------------------------
TString outputName = TString(outputLabel);
outputName += TString("_") + TString(dataset) + TString("_") + TString(skim);
if (TString(fileset) != TString(""))
outputName += TString("_") + TString(fileset);
OutputMod *skimOutput = new OutputMod;
skimOutput->Drop("*");
skimOutput->Keep("HLT*");
skimOutput->Keep("MC*");
skimOutput->Keep("PileupInfo");
skimOutput->Keep("Rho");
skimOutput->Keep("EvtSelData");
skimOutput->Keep("BeamSpot");
skimOutput->Keep("PrimaryVertexes");
skimOutput->Keep("PFMet");
skimOutput->Keep("AKt5PFJets");
skimOutput->Keep("Electrons");
skimOutput->Keep("Muons");
skimOutput->Keep("HPSTaus");
skimOutput->Keep("Photons");
// TODO find some object that is named and can hold bit mask info
skimOutput->AddNewBranch(monojetSel->GetCategoriesName());
skimOutput->SetMaxFileSize(10 * 1024); // 10 GB - should never exceed
skimOutput->SetFileName(outputName);
skimOutput->SetPathName(".");
monojetSel->Add(skimOutput);
//------------------------------------------------------------------------------------------------
// Say what we are doing
//------------------------------------------------------------------------------------------------
printf("\n==== PARAMETER SUMMARY FOR THIS JOB ====\n");
printf("\n JSON file: %s\n",jsonFile.Data());
printf("\n Rely on Catalog: %s\n",catalogDir);
printf(" -> Book: %s Dataset: %s Skim: %s Fileset: %s <-\n",book,dataset,skim,fileset);
printf("\n========================================\n");
//------------------------------------------------------------------------------------------------
// run the analysis after successful initialisation
//------------------------------------------------------------------------------------------------
ana->Run(false);
delete ana; // all modules deleted recursively
// rename the output file so that condor can see it
gSystem->Rename("./" + outputName + "_000.root", "./" + outputName + ".root");
return;
}
//--------------------------------------------------------------------------------------------------
void executeComputeElectronFakeRateMod(const char *fileset = "",
const char *skim = "noskim",
const char *dataset = "s8-ttbar-id9",
const char *book = "mit/filler/006",
const char *catalogDir = "/home/mitprod/catalog",
const char *outputName = "ComputeElectronFakeRateMod",
Int_t sampletype = 0,
int nEvents = -1)
{
//------------------------------------------------------------------------------------------------
// some global setups
//------------------------------------------------------------------------------------------------
using namespace mithep;
gDebugMask = Debug::kAnalysis;
gDebugLevel = 3;
string mctype = "";
Bool_t VetoTriggerJet = false;
Bool_t VetoGenLeptons = true;
if (sampletype == 10) {
VetoTriggerJet = true;
VetoGenLeptons = false;
}
if (sampletype == 20) {
VetoGenLeptons = false;
}
if (sampletype == 3 || string(dataset) == "s8-wjets-mg-id11" )
mctype = "kMCTypeVLightJets";
if (sampletype == 4 || string(dataset) == "s8-vqq-mg-id11")
mctype = "kMCTypeVQQ";
if (sampletype == 5 || string(dataset) == "f8-wc-mg-id11")
mctype = "kMCTypeWc";
//------------------------------------------------------------------------------------------------
// generator information
//------------------------------------------------------------------------------------------------
GeneratorMod *generatorMod = new GeneratorMod;
//generatorMod->SetFillHist(kTRUE);
PartonFlavorHistoryMod *partonFlavorHistoryMod = new PartonFlavorHistoryMod;
partonFlavorHistoryMod->SetMCSampleType(mctype.c_str());
partonFlavorHistoryMod->SetApplyPartonFlavorFilter(kTRUE);
//------------------------------------------------------------------------------------------------
// HLT information
//------------------------------------------------------------------------------------------------
// HLTMod *hltmod = new HLTMod;
// hltmod->SetPrintTable(kTRUE);
// hltmod->AddTrigger("HLT_IsoEle15_L1I");
// hltmod->AddTrigger("HLT_Ele15_SW_L1R");
// hltmod->AddTrigger("HLT_IsoEle15_LW_L1I");
// hltmod->AddTrigger("HLT_IsoEle18_L1R");
// hltmod->AddTrigger("HLT_Ele15_LW_L1R");
// hltmod->AddTrigger("HLT_LooseIsoEle15_LW_L1R");
// hltmod->AddTrigger("HLT_IsoMu15");
// hltmod->AddTrigger("HLT_Mu15");
// hltmod->SetTrigObjsName("myhltobjs");
HLTMod *hltmod_Jet30 = new HLTMod;
hltmod_Jet30->SetName("HLTMod_Jet30");
hltmod_Jet30->SetPrintTable(kFALSE);
hltmod_Jet30->AddTrigger("HLT_Jet30");
hltmod_Jet30->SetTrigObjsName("myhltobjs_Jet30");
HLTMod *hltmod_Jet50 = new HLTMod;
hltmod_Jet50->SetName("HLTMod_Jet50");
hltmod_Jet50->SetPrintTable(kFALSE);
hltmod_Jet50->AddTrigger("HLT_Jet50");
hltmod_Jet50->SetTrigObjsName("myhltobjs_Jet50");
HLTMod *hltmod_Jet80 = new HLTMod;
hltmod_Jet80->SetName("HLTMod_Jet80");
hltmod_Jet80->SetPrintTable(kFALSE);
hltmod_Jet80->AddTrigger("HLT_Jet80");
hltmod_Jet80->SetTrigObjsName("myhltobjs_Jet80");
HLTMod *hltmod_Jet110 = new HLTMod;
hltmod_Jet110->SetName("HLTMod_Jet110");
hltmod_Jet110->SetPrintTable(kFALSE);
hltmod_Jet110->AddTrigger("HLT_Jet110");
hltmod_Jet110->SetTrigObjsName("myhltobjs_Jet110");
HLTMod *hltmod_Photon15 = new HLTMod;
hltmod_Photon15->SetName("HLTMod_Photon15");
hltmod_Photon15->SetPrintTable(kFALSE);
hltmod_Photon15->AddTrigger("HLT_Photon15_L1R");
hltmod_Photon15->SetTrigObjsName("myhltobjs_Photon15");
HLTMod *hltmod_Photon25 = new HLTMod;
hltmod_Photon25->SetName("HLTMod_Photon25");
hltmod_Photon25->SetPrintTable(kFALSE);
hltmod_Photon25->AddTrigger("HLT_Photon25_L1R");
hltmod_Photon25->SetTrigObjsName("myhltobjs_Photon25");
//------------------------------------------------------------------------------------------------
// publisher Mod
//------------------------------------------------------------------------------------------------
PublisherMod<CaloJet,Jet> *pubJet = new PublisherMod<CaloJet,Jet>("JetPub");
pubJet->SetInputName("SisCone5Jets");
pubJet->SetOutputName("PubSisCone5Jets");
PublisherMod<CaloMet,Met> *pubMet = new PublisherMod<CaloMet,Met>("MetPub");
pubMet->SetInputName("SisCone5Met");
pubMet->SetOutputName(ModNames::gkCleanCaloMetName);
//------------------------------------------------------------------------------------------------
// object id and cleaning sequence
//------------------------------------------------------------------------------------------------
MuonIDMod *muonID = new MuonIDMod;
muonID->SetIDType("Loose");
muonID->SetIsoType("TrackCaloSliding");
ElectronIDMod *electronID = new ElectronIDMod;
electronID->SetIDType(TString("Tight"));
electronID->SetIsoType(TString("TrackJuraSliding"));
electronID->SetApplyConversionFilter(kTRUE);
PhotonIDMod *photonID = new PhotonIDMod;
photonID->SetIDType(TString("Custom"));
photonID->SetIsoType(TString("CombinedIso"));
photonID->SetPtMin(20.0);
JetIDMod *jetID = new JetIDMod;
jetID->SetInputName(pubJet->GetOutputName());
jetID->SetUseCorrection(kTRUE);
jetID->SetPtCut(35.0);
ElectronCleaningMod *electronCleaning = new ElectronCleaningMod;
PhotonCleaningMod *photonCleaning = new PhotonCleaningMod;
JetCleaningMod *jetCleaning = new JetCleaningMod;
MergeLeptonsMod *mergeLeptonsMod = new MergeLeptonsMod;
//------------------------------------------------------------------------------------------------
// generate fakeable objects
//------------------------------------------------------------------------------------------------
GenerateFakeableObjectsMod *generateFakeableObjectsMod = new GenerateFakeableObjectsMod;
generateFakeableObjectsMod->SetName("GenerateFakeableObjectsMod");
generateFakeableObjectsMod->SetElectronFOType("GsfPlusSC");
generateFakeableObjectsMod->SetMuonFOType("IsoTrack");
generateFakeableObjectsMod->SetVetoTriggerJet(VetoTriggerJet);
generateFakeableObjectsMod->SetVetoGenLeptons(VetoGenLeptons);
generateFakeableObjectsMod->SetVetoCleanLeptons(kFALSE);
generateFakeableObjectsMod->SetElectronFakeableObjectsName("GsfPlusSCElectronFakeableObjects");
generateFakeableObjectsMod->SetMuonFakeableObjectsName("IsoTrackMuonFakeableObjects");
GenerateFakeableObjectsMod *generateFakeableObjectsMod_Reco = new GenerateFakeableObjectsMod;
generateFakeableObjectsMod_Reco->SetName("GenerateFakeableObjectsMod_Reco");
generateFakeableObjectsMod_Reco->SetElectronFOType("Reco");
generateFakeableObjectsMod_Reco->SetMuonFOType("Global");
generateFakeableObjectsMod_Reco->SetVetoTriggerJet(VetoTriggerJet);
generateFakeableObjectsMod_Reco->SetVetoGenLeptons(VetoGenLeptons);
generateFakeableObjectsMod_Reco->SetVetoCleanLeptons(kFALSE);
generateFakeableObjectsMod_Reco->SetElectronFakeableObjectsName("RecoElectronFakeableObjects");
generateFakeableObjectsMod_Reco->SetMuonFakeableObjectsName("GlobalMuonFakeableObjects");
GenerateFakeableObjectsMod *generateFakeableObjectsMod_Jet30 = new GenerateFakeableObjectsMod;
generateFakeableObjectsMod_Jet30->SetName("GenerateFakeableObjectsMod_Jet30");
generateFakeableObjectsMod_Jet30->SetElectronFOType("GsfPlusSC");
generateFakeableObjectsMod_Jet30->SetMuonFOType("IsoTrack");
generateFakeableObjectsMod_Jet30->SetTriggerName("HLTMod_Jet30");
generateFakeableObjectsMod_Jet30->SetTriggerObjectsName("myhltobjs_Jet30");
generateFakeableObjectsMod_Jet30->SetVetoTriggerJet(VetoTriggerJet);
generateFakeableObjectsMod_Jet30->SetVetoGenLeptons(VetoGenLeptons);
generateFakeableObjectsMod_Jet30->SetVetoCleanLeptons(kFALSE);
generateFakeableObjectsMod_Jet30->SetElectronFakeableObjectsName("GsfPlusSCElectronFakeableObjects_Jet30");
generateFakeableObjectsMod_Jet30->SetMuonFakeableObjectsName("IsoTrackMuonFakeableObjects_Jet30");
GenerateFakeableObjectsMod *generateFakeableObjectsMod_Jet50 = new GenerateFakeableObjectsMod;
generateFakeableObjectsMod_Jet50->SetName("GenerateFakeableObjectsMod_Jet50");
generateFakeableObjectsMod_Jet50->SetElectronFOType("GsfPlusSC");
generateFakeableObjectsMod_Jet50->SetMuonFOType("IsoTrack");
generateFakeableObjectsMod_Jet50->SetTriggerName("HLTMod_Jet50");
generateFakeableObjectsMod_Jet50->SetTriggerObjectsName("myhltobjs_Jet50");
generateFakeableObjectsMod_Jet50->SetVetoTriggerJet(VetoTriggerJet);
generateFakeableObjectsMod_Jet50->SetVetoGenLeptons(VetoGenLeptons);
generateFakeableObjectsMod_Jet50->SetVetoCleanLeptons(kFALSE);
generateFakeableObjectsMod_Jet50->SetElectronFakeableObjectsName("GsfPlusSCElectronFakeableObjects_Jet50");
generateFakeableObjectsMod_Jet50->SetMuonFakeableObjectsName("IsoTrackMuonFakeableObjects_Jet50");
GenerateFakeableObjectsMod *generateFakeableObjectsMod_Jet80 = new GenerateFakeableObjectsMod;
generateFakeableObjectsMod_Jet80->SetName("GenerateFakeableObjectsMod_Jet80");
generateFakeableObjectsMod_Jet80->SetElectronFOType("GsfPlusSC");
generateFakeableObjectsMod_Jet80->SetMuonFOType("IsoTrack");
generateFakeableObjectsMod_Jet80->SetTriggerName("HLTMod_Jet80");
generateFakeableObjectsMod_Jet80->SetTriggerObjectsName("myhltobjs_Jet80");
generateFakeableObjectsMod_Jet80->SetVetoTriggerJet(VetoTriggerJet);
generateFakeableObjectsMod_Jet80->SetVetoGenLeptons(VetoGenLeptons);
generateFakeableObjectsMod_Jet80->SetVetoCleanLeptons(kFALSE);
generateFakeableObjectsMod_Jet80->SetElectronFakeableObjectsName("GsfPlusSCElectronFakeableObjects_Jet80");
generateFakeableObjectsMod_Jet80->SetMuonFakeableObjectsName("IsoTrackMuonFakeableObjects_Jet80");
GenerateFakeableObjectsMod *generateFakeableObjectsMod_Jet110 = new GenerateFakeableObjectsMod;
generateFakeableObjectsMod_Jet110->SetName("GenerateFakeableObjectsMod_Jet110");
generateFakeableObjectsMod_Jet110->SetElectronFOType("GsfPlusSC");
generateFakeableObjectsMod_Jet110->SetMuonFOType("IsoTrack");
generateFakeableObjectsMod_Jet110->SetTriggerName("HLTMod_Jet110");
generateFakeableObjectsMod_Jet110->SetTriggerObjectsName("myhltobjs_Jet110");
generateFakeableObjectsMod_Jet110->SetVetoTriggerJet(VetoTriggerJet);
generateFakeableObjectsMod_Jet110->SetVetoGenLeptons(VetoGenLeptons);
generateFakeableObjectsMod_Jet110->SetVetoCleanLeptons(kFALSE);
generateFakeableObjectsMod_Jet110->SetElectronFakeableObjectsName("GsfPlusSCElectronFakeableObjects_Jet110");
generateFakeableObjectsMod_Jet110->SetMuonFakeableObjectsName("IsoTrackMuonFakeableObjects_Jet110");
GenerateFakeableObjectsMod *generateFakeableObjectsMod_Reco_Jet30 = new GenerateFakeableObjectsMod;
generateFakeableObjectsMod_Reco_Jet30->SetName("GenerateFakeableObjectsMod_Reco_Jet30");
generateFakeableObjectsMod_Reco_Jet30->SetElectronFOType("Reco");
generateFakeableObjectsMod_Reco_Jet30->SetMuonFOType("Global");
generateFakeableObjectsMod_Reco_Jet30->SetTriggerName("HLTMod_Jet30");
generateFakeableObjectsMod_Reco_Jet30->SetTriggerObjectsName("myhltobjs_Jet30");
generateFakeableObjectsMod_Reco_Jet30->SetVetoTriggerJet(VetoTriggerJet);
generateFakeableObjectsMod_Reco_Jet30->SetVetoGenLeptons(VetoGenLeptons);
generateFakeableObjectsMod_Reco_Jet30->SetVetoCleanLeptons(kFALSE);
generateFakeableObjectsMod_Reco_Jet30->SetElectronFakeableObjectsName("RecoElectronFakeableObjects_Jet30");
generateFakeableObjectsMod_Reco_Jet30->SetMuonFakeableObjectsName("GlobalMuonFakeableObjects_Jet30");
GenerateFakeableObjectsMod *generateFakeableObjectsMod_Reco_Jet50 = new GenerateFakeableObjectsMod;
generateFakeableObjectsMod_Reco_Jet50->SetName("GenerateFakeableObjectsMod_Reco_Jet50");
generateFakeableObjectsMod_Reco_Jet50->SetElectronFOType("Reco");
generateFakeableObjectsMod_Reco_Jet50->SetMuonFOType("Global");
generateFakeableObjectsMod_Reco_Jet50->SetTriggerName("HLTMod_Jet50");
generateFakeableObjectsMod_Reco_Jet50->SetTriggerObjectsName("myhltobjs_Jet50");
generateFakeableObjectsMod_Reco_Jet50->SetVetoTriggerJet(VetoTriggerJet);
generateFakeableObjectsMod_Reco_Jet50->SetVetoGenLeptons(VetoGenLeptons);
generateFakeableObjectsMod_Reco_Jet50->SetVetoCleanLeptons(kFALSE);
generateFakeableObjectsMod_Reco_Jet50->SetElectronFakeableObjectsName("RecoElectronFakeableObjects_Jet50");
generateFakeableObjectsMod_Reco_Jet50->SetMuonFakeableObjectsName("GlobalMuonFakeableObjects_Jet50");
GenerateFakeableObjectsMod *generateFakeableObjectsMod_Reco_Jet80 = new GenerateFakeableObjectsMod;
generateFakeableObjectsMod_Reco_Jet80->SetName("GenerateFakeableObjectsMod_Reco_Jet80");
generateFakeableObjectsMod_Reco_Jet80->SetElectronFOType("Reco");
generateFakeableObjectsMod_Reco_Jet80->SetMuonFOType("Global");
generateFakeableObjectsMod_Reco_Jet80->SetTriggerName("HLTMod_Jet80");
generateFakeableObjectsMod_Reco_Jet80->SetTriggerObjectsName("myhltobjs_Jet80");
generateFakeableObjectsMod_Reco_Jet80->SetVetoTriggerJet(VetoTriggerJet);
generateFakeableObjectsMod_Reco_Jet80->SetVetoGenLeptons(VetoGenLeptons);
generateFakeableObjectsMod_Reco_Jet80->SetVetoCleanLeptons(kFALSE);
generateFakeableObjectsMod_Reco_Jet80->SetElectronFakeableObjectsName("RecoElectronFakeableObjects_Jet80");
generateFakeableObjectsMod_Reco_Jet80->SetMuonFakeableObjectsName("GlobalMuonFakeableObjects_Jet80");
GenerateFakeableObjectsMod *generateFakeableObjectsMod_Reco_Jet110 = new GenerateFakeableObjectsMod;
generateFakeableObjectsMod_Reco_Jet110->SetName("GenerateFakeableObjectsMod_Reco_Jet110");
generateFakeableObjectsMod_Reco_Jet110->SetElectronFOType("Reco");
generateFakeableObjectsMod_Reco_Jet110->SetMuonFOType("Global");
generateFakeableObjectsMod_Reco_Jet110->SetTriggerName("HLTMod_Jet110");
generateFakeableObjectsMod_Reco_Jet110->SetTriggerObjectsName("myhltobjs_Jet110");
generateFakeableObjectsMod_Reco_Jet110->SetVetoTriggerJet(VetoTriggerJet);
generateFakeableObjectsMod_Reco_Jet110->SetVetoGenLeptons(VetoGenLeptons);
generateFakeableObjectsMod_Reco_Jet110->SetVetoCleanLeptons(kFALSE);
generateFakeableObjectsMod_Reco_Jet110->SetElectronFakeableObjectsName("RecoElectronFakeableObjects_Jet110");
generateFakeableObjectsMod_Reco_Jet110->SetMuonFakeableObjectsName("GlobalMuonFakeableObjects_Jet110");
//------------------------------------------------------------------------------------------------
// analyses modules
//------------------------------------------------------------------------------------------------
ComputeElectronFakeRateMod *analysisMod = new ComputeElectronFakeRateMod;
analysisMod->SetName("ComputeElectronFakeRateMod");
analysisMod->SetVetoTriggerJet(VetoTriggerJet);
analysisMod->SetVetoGeneratorLeptons(VetoGenLeptons);
analysisMod->SetElectronFakeableObjectsName("GsfPlusSCElectronFakeableObjects");
analysisMod->SetMetName(pubMet->GetOutputName());
analysisMod->SetSampleType(sampletype);
ComputeElectronFakeRateMod *analysisMod_Reco = new ComputeElectronFakeRateMod;
analysisMod_Reco->SetName("ComputeElectronFakeRateMod_Reco");
analysisMod_Reco->SetVetoTriggerJet(VetoTriggerJet);
analysisMod_Reco->SetVetoGeneratorLeptons(VetoGenLeptons);
analysisMod_Reco->SetElectronFakeableObjectsName("RecoElectronFakeableObjects");
analysisMod_Reco->SetMetName(pubMet->GetOutputName());
analysisMod_Reco->SetSampleType(sampletype);
ComputeElectronFakeRateMod *analysisMod_Jet30 = new ComputeElectronFakeRateMod;
analysisMod_Jet30->SetName("ComputeElectronFakeRateMod_Jet30");
analysisMod_Jet30->SetTriggerName("HLT_Jet30");
analysisMod_Jet30->SetTriggerObjectsName("myhltobjs_Jet30");
analysisMod_Jet30->SetVetoTriggerJet(VetoTriggerJet);
analysisMod_Jet30->SetVetoGeneratorLeptons(VetoGenLeptons);
analysisMod_Jet30->SetElectronFakeableObjectsName("GsfPlusSCElectronFakeableObjects_Jet30");
analysisMod_Jet30->SetMetName(pubMet->GetOutputName());
analysisMod_Jet30->SetSampleType(sampletype);
ComputeElectronFakeRateMod *analysisMod_Jet50 = new ComputeElectronFakeRateMod;
analysisMod_Jet50->SetName("ComputeElectronFakeRateMod_Jet50");
analysisMod_Jet50->SetTriggerName("HLT_Jet50");
analysisMod_Jet50->SetTriggerObjectsName("myhltobjs_Jet50");
analysisMod_Jet50->SetVetoTriggerJet(VetoTriggerJet);
analysisMod_Jet50->SetVetoGeneratorLeptons(VetoGenLeptons);
analysisMod_Jet50->SetElectronFakeableObjectsName("GsfPlusSCElectronFakeableObjects_Jet50");
analysisMod_Jet50->SetMetName(pubMet->GetOutputName());
analysisMod_Jet50->SetSampleType(sampletype);
ComputeElectronFakeRateMod *analysisMod_Jet80 = new ComputeElectronFakeRateMod;
analysisMod_Jet80->SetName("ComputeElectronFakeRateMod_Jet80");
analysisMod_Jet80->SetTriggerName("HLT_Jet80");
analysisMod_Jet80->SetTriggerObjectsName("myhltobjs_Jet80");
analysisMod_Jet80->SetVetoTriggerJet(VetoTriggerJet);
analysisMod_Jet80->SetVetoGeneratorLeptons(VetoGenLeptons);
analysisMod_Jet80->SetElectronFakeableObjectsName("GsfPlusSCElectronFakeableObjects_Jet80");
analysisMod_Jet80->SetMetName(pubMet->GetOutputName());
analysisMod_Jet80->SetSampleType(sampletype);
ComputeElectronFakeRateMod *analysisMod_Jet110 = new ComputeElectronFakeRateMod;
analysisMod_Jet110->SetName("ComputeElectronFakeRateMod_Jet110");
analysisMod_Jet110->SetTriggerName("HLT_Jet110");
analysisMod_Jet110->SetTriggerObjectsName("myhltobjs_Jet110");
analysisMod_Jet110->SetVetoTriggerJet(VetoTriggerJet);
analysisMod_Jet110->SetVetoGeneratorLeptons(VetoGenLeptons);
analysisMod_Jet110->SetElectronFakeableObjectsName("GsfPlusSCElectronFakeableObjects_Jet110");
analysisMod_Jet110->SetMetName(pubMet->GetOutputName());
analysisMod_Jet110->SetSampleType(sampletype);
ComputeElectronFakeRateMod *analysisMod_Reco_Jet30 = new ComputeElectronFakeRateMod;
analysisMod_Reco_Jet30->SetName("ComputeElectronFakeRateMod_Reco_Jet30");
analysisMod_Reco_Jet30->SetTriggerName("HLT_Jet30");
analysisMod_Reco_Jet30->SetTriggerObjectsName("myhltobjs_Jet30");
analysisMod_Reco_Jet30->SetVetoTriggerJet(VetoTriggerJet);
analysisMod_Reco_Jet30->SetVetoGeneratorLeptons(VetoGenLeptons);
analysisMod_Reco_Jet30->SetElectronFakeableObjectsName("RecoElectronFakeableObjects_Jet30");
analysisMod_Reco_Jet30->SetMetName(pubMet->GetOutputName());
analysisMod_Reco_Jet30->SetSampleType(sampletype);
ComputeElectronFakeRateMod *analysisMod_Reco_Jet50 = new ComputeElectronFakeRateMod;
analysisMod_Reco_Jet50->SetName("ComputeElectronFakeRateMod_Reco_Jet50");
analysisMod_Reco_Jet50->SetTriggerName("HLT_Jet50");
analysisMod_Reco_Jet50->SetTriggerObjectsName("myhltobjs_Jet50");
analysisMod_Reco_Jet50->SetVetoTriggerJet(VetoTriggerJet);
analysisMod_Reco_Jet50->SetVetoGeneratorLeptons(VetoGenLeptons);
analysisMod_Reco_Jet50->SetElectronFakeableObjectsName("RecoElectronFakeableObjects_Jet50");
analysisMod_Reco_Jet50->SetMetName(pubMet->GetOutputName());
analysisMod_Reco_Jet50->SetSampleType(sampletype);
ComputeElectronFakeRateMod *analysisMod_Reco_Jet80 = new ComputeElectronFakeRateMod;
analysisMod_Reco_Jet80->SetName("ComputeElectronFakeRateMod_Reco_Jet80");
analysisMod_Reco_Jet80->SetTriggerName("HLT_Jet80");
analysisMod_Reco_Jet80->SetTriggerObjectsName("myhltobjs_Jet80");
analysisMod_Reco_Jet80->SetVetoTriggerJet(VetoTriggerJet);
analysisMod_Reco_Jet80->SetVetoGeneratorLeptons(VetoGenLeptons);
analysisMod_Reco_Jet80->SetElectronFakeableObjectsName("RecoElectronFakeableObjects_Jet80");
analysisMod_Reco_Jet80->SetMetName(pubMet->GetOutputName());
analysisMod_Reco_Jet80->SetSampleType(sampletype);
ComputeElectronFakeRateMod *analysisMod_Reco_Jet110 = new ComputeElectronFakeRateMod;
analysisMod_Reco_Jet110->SetName("ComputeElectronFakeRateMod_Reco_Jet110");
analysisMod_Reco_Jet110->SetTriggerName("HLT_Jet110");
analysisMod_Reco_Jet110->SetTriggerObjectsName("myhltobjs_Jet110");
analysisMod_Reco_Jet110->SetVetoTriggerJet(VetoTriggerJet);
analysisMod_Reco_Jet110->SetVetoGeneratorLeptons(VetoGenLeptons);
analysisMod_Reco_Jet110->SetElectronFakeableObjectsName("RecoElectronFakeableObjects_Jet110");
analysisMod_Reco_Jet110->SetMetName(pubMet->GetOutputName());
analysisMod_Reco_Jet110->SetSampleType(sampletype);
ComputeElectronFakeRateMod *analysisMod_Photon15 = new ComputeElectronFakeRateMod;
analysisMod_Photon15->SetName("ComputeElectronFakeRateMod_Photon15");
analysisMod_Photon15->SetTriggerName("HLT_Photon15_L1R");
analysisMod_Photon15->SetTriggerObjectsName("myhltobjs_Photon15");
analysisMod_Photon15->SetVetoTriggerJet(VetoTriggerJet);
analysisMod_Photon15->SetVetoGeneratorLeptons(VetoGenLeptons);
analysisMod_Photon15->SetElectronFakeableObjectsName("GsfPlusSCElectronFakeableObjects");
analysisMod_Photon15->SetMetName(pubMet->GetOutputName());
analysisMod_Photon15->SetSampleType(sampletype);
ComputeElectronFakeRateMod *analysisMod_Photon25 = new ComputeElectronFakeRateMod;
analysisMod_Photon25->SetName("ComputeElectronFakeRateMod_Photon25");
analysisMod_Photon25->SetTriggerName("HLT_Photon25_L1R");
analysisMod_Photon25->SetTriggerObjectsName("myhltobjs_Photon25");
analysisMod_Photon25->SetVetoTriggerJet(VetoTriggerJet);
analysisMod_Photon25->SetVetoGeneratorLeptons(VetoGenLeptons);
analysisMod_Photon25->SetElectronFakeableObjectsName("GsfPlusSCElectronFakeableObjects");
analysisMod_Photon25->SetMetName(pubMet->GetOutputName());
analysisMod_Photon25->SetSampleType(sampletype);
ComputeElectronFakeRateMod *analysisMod_Reco_Photon15 = new ComputeElectronFakeRateMod;
analysisMod_Reco_Photon15->SetName("ComputeElectronFakeRateMod_Reco_Photon15");
analysisMod_Reco_Photon15->SetTriggerName("HLT_Photon15_L1R");
analysisMod_Reco_Photon15->SetTriggerObjectsName("myhltobjs_Photon15");
analysisMod_Reco_Photon15->SetVetoTriggerJet(VetoTriggerJet);
analysisMod_Reco_Photon15->SetVetoGeneratorLeptons(VetoGenLeptons);
analysisMod_Reco_Photon15->SetElectronFakeableObjectsName("RecoElectronFakeableObjects");
analysisMod_Reco_Photon15->SetMetName(pubMet->GetOutputName());
analysisMod_Reco_Photon15->SetSampleType(sampletype);
ComputeElectronFakeRateMod *analysisMod_Reco_Photon25 = new ComputeElectronFakeRateMod;
analysisMod_Reco_Photon25->SetName("ComputeElectronFakeRateMod_Reco_Photon25");
analysisMod_Reco_Photon25->SetTriggerName("HLT_Photon25_L1R");
analysisMod_Reco_Photon25->SetTriggerObjectsName("myhltobjs_Photon25");
analysisMod_Reco_Photon25->SetVetoTriggerJet(VetoTriggerJet);
analysisMod_Reco_Photon25->SetVetoGeneratorLeptons(VetoGenLeptons);
analysisMod_Reco_Photon25->SetElectronFakeableObjectsName("RecoElectronFakeableObjects");
analysisMod_Reco_Photon25->SetMetName(pubMet->GetOutputName());
analysisMod_Reco_Photon25->SetSampleType(sampletype);
//------------------------------------------------------------------------------------------------
// making analysis chain
//------------------------------------------------------------------------------------------------
if (sampletype == 3 ||sampletype == 4 || sampletype == 5
|| string(dataset) == "s8-wjets-mg-id11" || string(dataset) == "s8-vqq-mg-id11"
) {
generatorMod->Add(partonFlavorHistoryMod);
partonFlavorHistoryMod->Add(pubJet);
} else {
generatorMod->Add(pubJet);
}
pubJet->Add(pubMet);
pubMet->Add(muonID);
muonID->Add(electronID);
electronID->Add(photonID);
photonID->Add(jetID);
jetID->Add(electronCleaning);
electronCleaning->Add(photonCleaning);
photonCleaning->Add(jetCleaning);
jetCleaning->Add(mergeLeptonsMod);
//For W+Jet samples
if (sampletype == 3 || sampletype == 4 || sampletype == 5 || sampletype == 1 ) {
mergeLeptonsMod->Add(generateFakeableObjectsMod);
generateFakeableObjectsMod->Add(analysisMod);
mergeLeptonsMod->Add(generateFakeableObjectsMod_Reco);
generateFakeableObjectsMod_Reco->Add(analysisMod_Reco);
} else if (sampletype == 20) {
//For photon trigger samples
mergeLeptonsMod->Add(hltmod_Photon15);
hltmod_Photon15->Add(generateFakeableObjectsMod);
generateFakeableObjectsMod->Add(analysisMod_Photon15);
hltmod_Photon15->Add(generateFakeableObjectsMod_Reco);
generateFakeableObjectsMod_Reco->Add(analysisMod_Reco_Photon15);
// mergeLeptonsMod->Add(hltmod_Photon25);
// hltmod_Photon25->Add(generateFakeableObjectsMod);
// generateFakeableObjectsMod->Add(analysisMod_Photon25);
// hltmod_Photon25->Add(generateFakeableObjectsMod_Reco);
// generateFakeableObjectsMod_Reco->Add(analysisMod_Reco_Photon25);
} else if (sampletype == 10) {
//For Jet Trigger samples
mergeLeptonsMod->Add(hltmod_Jet30);
hltmod_Jet30->Add(generateFakeableObjectsMod_Jet30);
generateFakeableObjectsMod_Jet30->Add(analysisMod_Jet30);
hltmod_Jet30->Add(generateFakeableObjectsMod_Reco_Jet30);
generateFakeableObjectsMod_Reco_Jet30->Add(analysisMod_Reco_Jet30);
mergeLeptonsMod->Add(hltmod_Jet50);
hltmod_Jet50->Add(generateFakeableObjectsMod_Jet50);
generateFakeableObjectsMod_Jet50->Add(analysisMod_Jet50);
hltmod_Jet50->Add(generateFakeableObjectsMod_Reco_Jet50);
generateFakeableObjectsMod_Reco_Jet50->Add(analysisMod_Reco_Jet50);
mergeLeptonsMod->Add(hltmod_Jet80);
hltmod_Jet80->Add(generateFakeableObjectsMod_Jet80);
generateFakeableObjectsMod_Jet80->Add(analysisMod_Jet80);
hltmod_Jet80->Add(generateFakeableObjectsMod_Reco_Jet80);
generateFakeableObjectsMod_Reco_Jet80->Add(analysisMod_Reco_Jet80);
mergeLeptonsMod->Add(hltmod_Jet110);
hltmod_Jet110->Add(generateFakeableObjectsMod_Jet110);
generateFakeableObjectsMod_Jet110->Add(analysisMod_Jet110);
hltmod_Jet110->Add(generateFakeableObjectsMod_Reco_Jet110);
generateFakeableObjectsMod_Reco_Jet110->Add(analysisMod_Reco_Jet110);
}
//------------------------------------------------------------------------------------------------
// setup analysis
//------------------------------------------------------------------------------------------------
Analysis *ana = new Analysis;
ana->SetUseHLT(kTRUE);
ana->SetKeepHierarchy(kTRUE);
if (nEvents >= 0)
ana->SetProcessNEvents(nEvents);
ana->SetSuperModule(generatorMod);
//ana->SetSkipFirstNEvents(47500);
//------------------------------------------------------------------------------------------------
// organize input
//------------------------------------------------------------------------------------------------
printf("\nRely on Catalog: %s\n",catalogDir);
printf(" -> Book: %s Dataset: %s Skim: %s Fileset: %s <-\n\n",book,dataset,skim,fileset);
Catalog *c = new Catalog(catalogDir);
TString skimdataset = TString(dataset)+TString("/") +TString(skim);
Dataset *d = NULL;
if (TString(skim).CompareTo("noskim") == 0)
d = c->FindDataset(book,dataset,fileset);
else
d = c->FindDataset(book,skimdataset.Data(),fileset);
ana->AddDataset(d);
//------------------------------------------------------------------------------------------------
// organize output
//------------------------------------------------------------------------------------------------
TString rootFile = TString(outputName);
rootFile += TString("_") + TString(dataset) + TString("_") + TString(skim);
if (TString(fileset) != TString(""))
rootFile += TString("_") + TString(fileset);
rootFile += TString(".root");
printf("\nRoot output: %s\n\n",rootFile.Data());
ana->SetOutputName(rootFile.Data());
//------------------------------------------------------------------------------------------------
// run the analysis after successful initialisation
//------------------------------------------------------------------------------------------------
ana->Run(!gROOT->IsBatch());
if (sampletype == 10) {
cout << "HLTMod Jet30: Accepted " << hltmod_Jet30->GetNAccepted()
<< " of " << hltmod_Jet30->GetNEvents() << " events" << endl;
cout << "HLTMod Jet50: Accepted " << hltmod_Jet50->GetNAccepted()
<< " of " << hltmod_Jet50->GetNEvents() << " events" << endl;
cout << "HLTMod Jet80: Accepted " << hltmod_Jet80->GetNAccepted()
<< " of " << hltmod_Jet80->GetNEvents() << " events" << endl;
cout << "HLTMod Jet110: Accepted " << hltmod_Jet110->GetNAccepted()
<< " of " << hltmod_Jet110->GetNEvents() << " events" << endl;
}
if (sampletype == 20) {
cout << "HLTMod Photon15: Accepted " << hltmod_Photon15->GetNAccepted()
<< " of " << hltmod_Photon15->GetNEvents() << " events" << endl;
cout << "HLTMod Photon25: Accepted " << hltmod_Photon25->GetNAccepted()
<< " of " << hltmod_Photon25->GetNEvents() << " events" << endl;
}
return;
}
//--------------------------------------------------------------------------------------------------
void WWSelection(const char *fileset = "",
const char *dataset = "s8-ttbar-id9",
const char *book = "mit/filler/004",
const char *catalogDir = "/home/mitprod/catalog",
const char *outputName = "WWSelection",
int nEvents = -1)
{
//------------------------------------------------------------------------------------------------
// some global setups
//------------------------------------------------------------------------------------------------
using namespace mithep;
gDebugMask = Debug::kAnalysis;
gDebugLevel = 3;
//------------------------------------------------------------------------------------------------
// generator information
//------------------------------------------------------------------------------------------------
GeneratorMod *GeneratorMod = new GeneratorMod;
//------------------------------------------------------------------------------------------------
// HLT information
//------------------------------------------------------------------------------------------------
HLTMod *hltmod = new HLTMod;
hltmod->SetPrintTable(kTRUE);
hltmod->AddTrigger("HLT_IsoEle15_L1I");
hltmod->AddTrigger("HLT_Ele15_SW_L1R");
hltmod->AddTrigger("HLT_IsoEle15_LW_L1I");
hltmod->AddTrigger("HLT_IsoEle18_L1R");
hltmod->AddTrigger("HLT_Ele15_LW_L1R");
hltmod->AddTrigger("HLT_LooseIsoEle15_LW_L1R");
hltmod->AddTrigger("HLT_IsoMu15");
hltmod->AddTrigger("HLT_Mu15");
hltmod->SetTrigObjsName("myhltobjs");
//------------------------------------------------------------------------------------------------
// object id and cleaning sequence
//------------------------------------------------------------------------------------------------
MuonIDMod *muonID = new MuonIDMod;
muonID->SetMuonIDType("Loose");
muonID->SetMuonIsoType("TrackCaloSliding");
ElectronIDMod *electronID = new ElectronIDMod;
electronID->SetElectronIDType(TString("Tight"));
electronID->SetElectronIsoType(TString("TrackJuraSliding"));
JetIDMod *JetID = new JetIDMod;
JetID->SetJetBranchName(TString("SisCone5Jets")); //name of jet algorithm
JetID->SetGoodJetsName(TString("GoodJets"));
JetID->SetUseJetCorrection(true);
JetID->SetJetEtCut(30.0);
ElectronCleaningMod *electronCleaning = new ElectronCleaningMod;
JetCleaningMod *JetCleaning = new JetCleaningMod;
JetCleaning->SetGoodJetsName (TString("GoodJets"));
JetCleaning->SetCleanJetsName(TString("CleanJets"));
//------------------------------------------------------------------------------------------------
// analyses modules
//------------------------------------------------------------------------------------------------
WWEvtSelMod *analysisMod = new WWEvtSelMod;
analysisMod->SetLoadGenParticles(false);
analysisMod->SetCleanJetsName(TString("CleanJets"));
analysisMod->SetPrintDebug(false);
//------------------------------------------------------------------------------------------------
// making analysis chain
//------------------------------------------------------------------------------------------------
//GeneratorMod->Add(hltmod); hltmod->Add(muonID);
GeneratorMod->Add(muonID);
muonID->Add(electronID);
electronID->Add(JetID);
JetID->Add(electronCleaning);
electronCleaning->Add(JetCleaning);
JetCleaning->Add(analysisMod);
//------------------------------------------------------------------------------------------------
// setup analysis
//------------------------------------------------------------------------------------------------
Analysis *ana = new Analysis;
ana->SetUseHLT(true);
ana->SetKeepHierarchy(false);
if (nEvents >= 0)
ana->SetProcessNEvents(nEvents);
ana->SetSuperModule(GeneratorMod);
//------------------------------------------------------------------------------------------------
// organize input
//------------------------------------------------------------------------------------------------
printf("\nRely on Catalog: %s\n",catalogDir);
printf(" -> Book: %s Dataset: %s Fileset: %s <-\n\n",book,dataset,fileset);
Catalog *c = new Catalog(catalogDir);
Dataset *d = c->FindDataset(book,dataset,fileset);
ana->AddDataset(d);
//------------------------------------------------------------------------------------------------
// organize output
//------------------------------------------------------------------------------------------------
TString rootFile = TString(outputName);
rootFile += TString("_") + TString(dataset);
if (TString(fileset) != TString(""))
rootFile += TString("_") + TString(fileset);
rootFile += TString(".root");
printf("\nRoot output: %s\n\n",rootFile.Data());
ana->SetOutputName(rootFile.Data());
//------------------------------------------------------------------------------------------------
// run the analysis after successful initialisation
//------------------------------------------------------------------------------------------------
ana->Run(!gROOT->IsBatch());
return;
}
//--------------------------------------------------------------------------------------------------
void runBavantiBoostedV_Synch
(const char *fileset = "0000",
const char *skim = "noskim",
//const char *dataset = "s12-ttj-sl-v1-v7c",
const char *dataset = "GJets_HT-400ToInf_8TeV-madgraph+Summer12_DR53X-PU_S10_START53_V7A-v1+AODSIM",
const char *book = "t2mit/filefi/032",
const char *catalogDir = "/home/cmsprod/catalog",
const char *outputName = "boostedv",
int nEvents = 10)
{
//------------------------------------------------------------------------------------------------
// some parameters get passed through the environment
//------------------------------------------------------------------------------------------------
TString cataDir = getCatalogDir(catalogDir);
TString mitData = Utils::GetEnv("MIT_DATA");
TString json = Utils::GetEnv("MIT_PROD_JSON");
TString jsonFile = getJsonFile("/home/cmsprod/cms/json");
Bool_t isData = (json.CompareTo("~") != 0);
// only for synchrionization purposes
isData = kFALSE;
printf("\n Initialization worked. Data?: %d\n\n",isData);
//------------------------------------------------------------------------------------------------
// some global setups
//------------------------------------------------------------------------------------------------
// debugging config
using namespace mithep;
gDebugMask = (Debug::EDebugMask) (Debug::kGeneral | Debug::kTreeIO);
gDebugLevel = 3;
// Caching and how
Int_t local = 1, cacher = 1;
// local = 0 - as is,
// 1 - /mt/hadoop (MIT:SmartCache - preload one-by-one)
// 2 - /mnt/hadoop (MIT:SmartCache - preload complete fileset)
// 3 - ./ (xrdcp - preload one-by-one)
// cacher = 0 - no file by file caching
// 1 - file by file caching on
//------------------------------------------------------------------------------------------------
// set up information for master module
//------------------------------------------------------------------------------------------------
RunLumiSelectionMod *runLumiSel = new RunLumiSelectionMod;
runLumiSel->SetAcceptMC(kTRUE); // Monte Carlo events are always accepted
// only select on run- and lumisection numbers when valid json file present
if (json.CompareTo("~") != 0 && json.CompareTo("-") != 0) {
printf(" runBoostedV() - adding jsonFile: %s\n",jsonFile.Data());
runLumiSel->AddJSONFile(jsonFile.Data());
}
if (json.CompareTo("-") == 0) {
printf("\n WARNING -- Looking at data without JSON file: always accept.\n\n");
runLumiSel->SetAbortIfNotAccepted(kFALSE); // accept all events if there is no valid JSON file
}
printf("\n Run lumi worked. \n\n");
//------------------------------------------------------------------------------------------------
// setup analysis
//------------------------------------------------------------------------------------------------
Analysis *ana = new Analysis;
ana->SetUseCacher(cacher);
ana->SetUseHLT(kTRUE);
ana->SetKeepHierarchy(kTRUE);
ana->SetSuperModule(runLumiSel);
ana->SetPrintScale(100);
if (nEvents >= 0)
ana->SetProcessNEvents(nEvents);
//------------------------------------------------------------------------------------------------
// organize input
//------------------------------------------------------------------------------------------------
Catalog *c = new Catalog(cataDir.Data());
TString skimdataset = TString(dataset)+TString("/") +TString(skim);
Dataset *d = NULL;
TString bookstr = book;
if (TString(skim).CompareTo("noskim") == 0)
d = c->FindDataset(bookstr,dataset,fileset,local);
else
d = c->FindDataset(bookstr,skimdataset.Data(),fileset,local);
ana->AddDataset(d);
//------------------------------------------------------------------------------------------------
// organize output
//------------------------------------------------------------------------------------------------
TString rootFile = TString(outputName);
rootFile += TString("_") + TString(dataset) + TString("_") + TString(skim);
if (TString(fileset) != TString(""))
rootFile += TString("_") + TString(fileset);
TString ntupleFile = rootFile + TString("_ntuple");
rootFile += TString(".root");
ana->SetOutputName(rootFile.Data());
ana->SetCacheSize(0);
//------------------------------------------------------------------------------------------------
// HLT information
//------------------------------------------------------------------------------------------------
HLTMod *hltModP = new HLTMod("HLTModP");
hltModP->SetBitsName("HLTBits");
hltModP->SetTrigObjsName("HltObjsMonoJet");
hltModP->SetAbortIfNotAccepted(isData);
hltModP->SetPrintTable(kFALSE);
// monojet triggers
const int nMjtTrigs = 12;
TString monoJetTriggers[nMjtTrigs] = { "HLT_MonoCentralPFJet80_PFMETnoMu105_NHEF0p95_v4",
"HLT_MonoCentralPFJet80_PFMETnoMu105_NHEF0p95_v3",
"HLT_MonoCentralPFJet80_PFMETnoMu105_NHEF0p95_v1",
"HLT_MonoCentralPFJet80_PFMETnoMu95_NHEF0p95_v5",
"HLT_MonoCentralPFJet80_PFMETnoMu95_NHEF0p95_v4",
"HLT_MonoCentralPFJet80_PFMETnoMu95_NHEF0p95_v3",
"HLT_MonoCentralPFJet80_PFMETnoMu95_NHEF0p95_v2",
"HLT_MET120_HBHENoiseCleaned_v6",
"HLT_MET120_HBHENoiseCleaned_v5",
"HLT_MET120_HBHENoiseCleaned_v4",
"HLT_MET120_HBHENoiseCleaned_v3",
"HLT_MET120_HBHENoiseCleaned_v2"};
for (int i=0; i<nMjtTrigs; i++)
hltModP->AddTrigger(TString("!+"+monoJetTriggers[i]),0,999999);
// top semileptonic triggers
const int nTopTrigs = 14;
TString topTriggers[nTopTrigs] = { "HLT_IsoMu15_v2",
"HLT_IsoMu24_v2",
"HLT_IsoMu17_v6",
"HLT_IsoMu17_v8",
"HLT_IsoMu17_v9",
"HLT_IsoMu17_eta2p1_v1",
"HLT_IsoMu24_v8",
"HLT_IsoMu24_eta2p1_v3",
"HLT_IsoMu24_eta2p1_v6",
"HLT_IsoMu24_eta2p1_v7",
"HLT_IsoMu24_eta2p1_v12",
"HLT_IsoMu24_eta2p1_v13",
"HLT_IsoMu24_eta2p1_v14",
"HLT_IsoMu24_eta2p1_v15"};
for (int i=0; i<nTopTrigs; i++)
hltModP->AddTrigger(TString("!+"+topTriggers[i]),0,999999);
// photon triggers
const int nPhotonTrigs = 6;
TString photonTriggers[nPhotonTrigs] = { "HLT_Photon135_v4",
"HLT_Photon135_v5",
"HLT_Photon135_v6",
"HLT_Photon135_v7",
"HLT_Photon150_v3",
"HLT_Photon150_v4"};
for (int i=0; i<nPhotonTrigs; i++)
hltModP->AddTrigger(TString("!+"+photonTriggers[i]),0,999999);
// VBF triggers
const int nVbfTrigs = 7;
TString vbfTriggers[nVbfTrigs] = { "HLT_DiPFJet40_PFMETnoMu65_MJJ800VBF_AllJets_v9",
"HLT_DiPFJet40_PFMETnoMu65_MJJ800VBF_AllJets_v8",
"HLT_DiPFJet40_PFMETnoMu65_MJJ800VBF_AllJets_v6",
"HLT_DiPFJet40_PFMETnoMu65_MJJ800VBF_AllJets_v5",
"HLT_DiPFJet40_PFMETnoMu65_MJJ800VBF_AllJets_v4",
"HLT_DiPFJet40_PFMETnoMu65_MJJ800VBF_AllJets_v3",
"HLT_DiPFJet40_PFMETnoMu65_MJJ800VBF_AllJets_v2" };
for (int i=0; i<nVbfTrigs; i++)
hltModP->AddTrigger((TString("!+")+vbfTriggers[i]).Data(),0,999999);
//------------------------------------------------------------------------------------------------
// split pfcandidates to PFPU and PFnoPU
//------------------------------------------------------------------------------------------------
SeparatePileUpMod* sepPuMod = new SeparatePileUpMod;
//sepPuMod->SetUseAllVerteces(kFALSE);
//sepPuMod->SetVertexName("OutVtxCiC");
sepPuMod->SetPFNoPileUpName("pfnopileupcands");
sepPuMod->SetPFPileUpName("pfpileupcands");
sepPuMod->SetCheckClosestZVertex(kFALSE);
//------------------------------------------------------------------------------------------------
// select events with a good primary vertex
//------------------------------------------------------------------------------------------------
GoodPVFilterMod *goodPVFilterMod = new GoodPVFilterMod;
goodPVFilterMod->SetMinVertexNTracks(0);
goodPVFilterMod->SetMinNDof(4.0);
goodPVFilterMod->SetMaxAbsZ(24.0);
goodPVFilterMod->SetMaxRho(2.0);
goodPVFilterMod->SetIsMC(!isData);
goodPVFilterMod->SetVertexesName("PrimaryVertexes");
//------------------------------------------------------------------------------------------------
// object id and cleaning sequence
//------------------------------------------------------------------------------------------------
//-----------------------------------
// Lepton Selection
//-----------------------------------
ElectronIDMod* eleIdMod = new ElectronIDMod;
eleIdMod->SetPtMin(10.);
eleIdMod->SetEtaMax(2.5);
eleIdMod->SetApplyEcalFiducial(kTRUE);
eleIdMod->SetIDType("VBTFWorkingPoint95Id");
eleIdMod->SetIsoType("PFIso");
eleIdMod->SetApplyConversionFilterType1(kTRUE);
eleIdMod->SetApplyConversionFilterType2(kFALSE);
eleIdMod->SetChargeFilter(kFALSE);
eleIdMod->SetApplyD0Cut(kTRUE);
eleIdMod->SetApplyDZCut(kTRUE);
eleIdMod->SetWhichVertex(0);
eleIdMod->SetNExpectedHitsInnerCut(0);
eleIdMod->SetGoodElectronsName("GoodElectronsBS");
eleIdMod->SetRhoType(RhoUtilities::CMS_RHO_RHOKT6PFJETS);
MuonIDMod *muonIdIsoMod = new MuonIDMod;
muonIdIsoMod->SetOutputName("HWWMuons");
muonIdIsoMod->SetIntRadius(0.0);
muonIdIsoMod->SetClassType("GlobalTracker");
muonIdIsoMod->SetIDType("WWMuIdV4");
muonIdIsoMod->SetIsoType("IsoRingsV0_BDTG_Iso");
muonIdIsoMod->SetApplyD0Cut(kTRUE);
muonIdIsoMod->SetD0Cut(0.02);
muonIdIsoMod->SetApplyDZCut(kTRUE);
muonIdIsoMod->SetDZCut(0.1);
muonIdIsoMod->SetWhichVertex(0);
muonIdIsoMod->SetRhoType(RhoUtilities::CMS_RHO_RHOKT6PFJETS);
muonIdIsoMod->SetPtMin(10.);
muonIdIsoMod->SetEtaCut(2.4);
MuonIDMod *muonIdLooseMod = new MuonIDMod;
muonIdLooseMod->SetOutputName("POGMuons");
muonIdLooseMod->SetClassType("GlobalTracker");
muonIdLooseMod->SetIDType("NoId");
muonIdLooseMod->SetIsoType("NoIso");
muonIdLooseMod->SetApplyD0Cut(true);
muonIdLooseMod->SetD0Cut(0.2);
muonIdLooseMod->SetApplyDZCut(true);
muonIdLooseMod->SetDZCut(0.5);
muonIdLooseMod->SetPtMin(10.);
muonIdLooseMod->SetEtaCut(2.4);
ElectronCleaningMod *electronCleaning = new ElectronCleaningMod;
electronCleaning->SetCleanMuonsName(muonIdLooseMod->GetOutputName());
electronCleaning->SetGoodElectronsName(eleIdMod->GetOutputName());
electronCleaning->SetCleanElectronsName("CleanElectrons");
MergeLeptonsMod *merger = new MergeLeptonsMod;
merger->SetMuonsName(muonIdLooseMod->GetOutputName());
merger->SetElectronsName(electronCleaning->GetOutputName());
merger->SetMergedName("MergedLeptons");
//-----------------------------------
// Photon Egamma Medium ID
//-----------------------------------
PhotonIDMod *photonIdMod = new PhotonIDMod;
photonIdMod->SetPtMin(10.0);
photonIdMod->SetOutputName("GoodPhotons");
photonIdMod->SetIDType("EgammaMedium");
photonIdMod->SetIsoType("NoIso");
photonIdMod->SetApplyElectronVeto(kTRUE);
photonIdMod->SetApplyPixelSeed(kFALSE);
photonIdMod->SetApplyConversionId(kFALSE);
photonIdMod->SetApplyFiduciality(kTRUE);
photonIdMod->SetIsData(isData);
photonIdMod->SetPhotonsFromBranch(kTRUE);
PhotonCleaningMod *photonCleaningMod = new PhotonCleaningMod;
photonCleaningMod->SetCleanElectronsName(electronCleaning->GetOutputName());
photonCleaningMod->SetGoodPhotonsName(photonIdMod->GetOutputName());
photonCleaningMod->SetCleanPhotonsName("CleanPhotons");
PFTauIDMod *pftauIdMod = new PFTauIDMod;
pftauIdMod->SetPFTausName("HPSTaus");
pftauIdMod->SetIsLooseId(kTRUE);
pftauIdMod->SetIsHPSSel(kTRUE); // to get >= 5_3_14 samples running
pftauIdMod->SetPtMin(15); // to loosen the WP
PFTauCleaningMod *pftauCleaningMod = new PFTauCleaningMod;
pftauCleaningMod->SetGoodPFTausName(pftauIdMod->GetGoodPFTausName());
pftauCleaningMod->SetCleanMuonsName(muonIdLooseMod->GetOutputName());
pftauCleaningMod->SetCleanElectronsName(electronCleaning->GetOutputName());
PublisherMod<PFJet,Jet> *pubJet = new PublisherMod<PFJet,Jet>("JetPub");
pubJet->SetInputName("AKt4PFJets");
pubJet->SetOutputName("PubAKt4PFJets");
FastJetMod *pubFastJet = new FastJetMod;
pubFastJet->SetPfCandidatesName("pfnopileupcands");
pubFastJet->SetPfCandidatesFromBranch(kFALSE);
pubFastJet->SetConeSize(0.8);
JetCorrectionMod *jetCorr = new JetCorrectionMod;
if (isData){
jetCorr->AddCorrectionFromFile((mitData+TString("/Summer13_V1_DATA_L1FastJet_AK5PF.txt")).Data());
jetCorr->AddCorrectionFromFile((mitData+TString("/Summer13_V1_DATA_L2Relative_AK5PF.txt")).Data());
jetCorr->AddCorrectionFromFile((mitData+TString("/Summer13_V1_DATA_L3Absolute_AK5PF.txt")).Data());
jetCorr->AddCorrectionFromFile((mitData+TString("/Summer13_V1_DATA_L2L3Residual_AK5PF.txt")).Data());
}
else {
jetCorr->AddCorrectionFromFile((mitData+TString("/Summer13_V1_MC_L1FastJet_AK5PF.txt")).Data());
jetCorr->AddCorrectionFromFile((mitData+TString("/Summer13_V1_MC_L2Relative_AK5PF.txt")).Data());
jetCorr->AddCorrectionFromFile((mitData+TString("/Summer13_V1_MC_L3Absolute_AK5PF.txt")).Data());
}
jetCorr->SetInputName(pubJet->GetOutputName());
jetCorr->SetCorrectedName("CorrectedJets");
JetCorrectionMod *fatJetCorr = new JetCorrectionMod;
if (isData){
fatJetCorr->AddCorrectionFromFile((mitData+TString("/FT53_V21A_AN6_L1FastJet_AK7PFchs.txt")).Data());
fatJetCorr->AddCorrectionFromFile((mitData+TString("/FT53_V21A_AN6_L2Relative_AK7PFchs.txt")).Data());
fatJetCorr->AddCorrectionFromFile((mitData+TString("/FT53_V21A_AN6_L3Absolute_AK7PFchs.txt")).Data());
fatJetCorr->AddCorrectionFromFile((mitData+TString("/FT53_V21A_AN6_L2L3Residual_AK7PFchs.txt")).Data());
}
else {
fatJetCorr->AddCorrectionFromFile((mitData+TString("/FT53_V21A_AN6_L1FastJet_AK7PFchs.txt")).Data());
fatJetCorr->AddCorrectionFromFile((mitData+TString("/FT53_V21A_AN6_L2Relative_AK7PFchs.txt")).Data());
fatJetCorr->AddCorrectionFromFile((mitData+TString("/FT53_V21A_AN6_L3Absolute_AK7PFchs.txt")).Data());
}
fatJetCorr->SetInputName(pubFastJet->GetOutputJetsName());
fatJetCorr->SetCorrectedName("CorrectedFatJets");
JetIDMod *jetId = new JetIDMod;
jetId->SetInputName(jetCorr->GetOutputName());
jetId->SetPtCut(30.0);
jetId->SetEtaMaxCut(2.5);
jetId->SetJetEEMFractionMinCut(0.00);
jetId->SetOutputName("GoodJets");
jetId->SetApplyBetaCut(kFALSE);
jetId->SetApplyMVACut(kTRUE);
JetIDMod *fatJetId = new JetIDMod;
fatJetId->SetInputName(fatJetCorr->GetOutputName());
fatJetId->SetPtCut(30.0);
fatJetId->SetEtaMaxCut(2.5);
fatJetId->SetJetEEMFractionMinCut(0.00);
fatJetId->SetOutputName("GoodFatJets");
fatJetId->SetApplyBetaCut(kFALSE);
fatJetId->SetApplyMVACut(kFALSE);
fatJetId->SetApplyMVACHS(kFALSE);
JetCleaningMod *jetCleaning = new JetCleaningMod;
jetCleaning->SetCleanElectronsName(electronCleaning->GetOutputName());
jetCleaning->SetCleanMuonsName(muonIdIsoMod->GetOutputName());
jetCleaning->SetCleanPhotonsName(photonCleaningMod->GetOutputName());
jetCleaning->SetApplyPhotonRemoval(kTRUE);
jetCleaning->SetApplyTauRemoval(kFALSE);
jetCleaning->SetGoodJetsName(jetId->GetOutputName());
jetCleaning->SetCleanJetsName("CleanJets");
JetCleaningMod *fatJetCleaning = new JetCleaningMod;
fatJetCleaning->SetCleanElectronsName(electronCleaning->GetOutputName());
fatJetCleaning->SetCleanMuonsName(muonIdIsoMod->GetOutputName());
fatJetCleaning->SetCleanPhotonsName(photonCleaningMod->GetOutputName());
fatJetCleaning->SetMinDeltaRToElectron(0.5);
fatJetCleaning->SetMinDeltaRToMuon(0.5);
fatJetCleaning->SetMinDeltaRToPhoton(0.5);
fatJetCleaning->SetApplyPhotonRemoval(kTRUE);
fatJetCleaning->SetApplyTauRemoval(kFALSE);
fatJetCleaning->SetGoodJetsName(fatJetId->GetOutputName());
fatJetCleaning->SetCleanJetsName("CleanFatJets");
//------------------------------------------------------------------------------------------------
// select events with a monojet topology
//------------------------------------------------------------------------------------------------
BoostedVAnalysisMod *jetplusmet = new BoostedVAnalysisMod("MonoJetSelector");
jetplusmet->SetFatJetsName(fatJetCleaning->GetOutputName()); //identified fat jets
jetplusmet->SetFatJetsFromBranch(kFALSE);
jetplusmet->SetJetsName(jetCleaning->GetOutputName()); //identified jets
jetplusmet->SetJetsFromBranch(kFALSE);
jetplusmet->SetElectronsName(electronCleaning->GetOutputName());
jetplusmet->SetElectronsFromBranch(kFALSE);
jetplusmet->SetMuonsName(muonIdLooseMod->GetOutputName());
jetplusmet->SetMuonsFromBranch(kFALSE);
jetplusmet->SetPhotonsName(photonCleaningMod->GetOutputName());
jetplusmet->SetPhotonsFromBranch(kFALSE);
jetplusmet->ApplyResolvedPresel(kTRUE);
jetplusmet->ApplyTopPresel(kFALSE);
jetplusmet->ApplyWlepPresel(kTRUE);
jetplusmet->ApplyZeePresel(kTRUE);
jetplusmet->ApplyZmmPresel(kTRUE);
jetplusmet->ApplyMetPresel(kTRUE);
jetplusmet->ApplyVbfPresel(kFALSE);
jetplusmet->ApplyGjetPresel(kTRUE);
jetplusmet->SetMinFatJetPt(200);
jetplusmet->SetMinTagJetPt(110);
jetplusmet->SetMinMet(150);
jetplusmet->SetMinPhotonPt(160);
jetplusmet->SkipEvents(kFALSE);
//------------------------------------------------------------------------------------------------
// prepare the extended MVA met
//------------------------------------------------------------------------------------------------
FillerXlMet *extendedMetFiller = new FillerXlMet();
extendedMetFiller->SetIsData(isData);
extendedMetFiller->SetJetsFromBranch(kFALSE);
extendedMetFiller->SetJetsName(pubJet->GetOutputName());
extendedMetFiller->SetMuonsFromBranch(kTRUE);
//extendedMetFiller->SetMuonsName(muonIdLooseMod->GetOutputName());
extendedMetFiller->SetElectronsFromBranch(kTRUE);
//extendedMetFiller->SetElectronsName(electronCleaning->GetOutputName());
extendedMetFiller->SetTausFromBranch(kTRUE);
extendedMetFiller->SetTausName("HPSTaus");
extendedMetFiller->SetPhotonsFromBranch(kTRUE);
//extendedMetFiller->SetPhotonsName(photonCleaningMod->GetOutputName());
extendedMetFiller->SetPVFromBranch(kFALSE);
extendedMetFiller->SetPVName(goodPVFilterMod->GetOutputName());
extendedMetFiller->SetXlMetName("PFMetMVA");
//------------------------------------------------------------------------------------------------
// prepare the extended jets with QG/color pull information
//------------------------------------------------------------------------------------------------
FillerXlJets *boostedJetsFiller = new FillerXlJets;
boostedJetsFiller->SetJetsName(jetCleaning->GetOutputName());
boostedJetsFiller->SetJetsFromBranch(kFALSE);
//------------------------------------------------------------------------------------------------
// prepare the extended jets with substructure information
//------------------------------------------------------------------------------------------------
FillerXlFatJets *boostedFatJetsFiller = new FillerXlFatJets;
boostedFatJetsFiller->FillTopSubJets(kFALSE);
boostedFatJetsFiller->SetJetsName(fatJetCleaning->GetOutputName());
boostedFatJetsFiller->SetJetsFromBranch(kFALSE);
boostedFatJetsFiller->SetConeSize(0.8);
//------------------------------------------------------------------------------------------------
// prepare the reduced isolated particles
//------------------------------------------------------------------------------------------------
FillerXsIsoParticles *boostedXsIsoParticlesFiller = new FillerXsIsoParticles;
boostedXsIsoParticlesFiller->FillXsMuons(kTRUE);
boostedXsIsoParticlesFiller->FillXsElectrons(kTRUE);
boostedXsIsoParticlesFiller->FillXsTaus(kTRUE);
boostedXsIsoParticlesFiller->FillXsPhotons(kTRUE);
boostedXsIsoParticlesFiller->SetMuonsName(muonIdLooseMod->GetOutputName());
boostedXsIsoParticlesFiller->SetMuonsFromBranch(kFALSE);
boostedXsIsoParticlesFiller->SetIsoMuonsName(muonIdIsoMod->GetOutputName());
boostedXsIsoParticlesFiller->SetIsoMuonsFromBranch(kFALSE);
boostedXsIsoParticlesFiller->SetElectronsName(eleIdMod->GetOutputName());
boostedXsIsoParticlesFiller->SetElectronsFromBranch(kFALSE);
boostedXsIsoParticlesFiller->SetTausName(pftauCleaningMod->GetOutputName());
boostedXsIsoParticlesFiller->SetTausFromBranch(kFALSE);
boostedXsIsoParticlesFiller->SetPhotonsName(photonCleaningMod->GetOutputName());
boostedXsIsoParticlesFiller->SetPhotonsFromBranch(kFALSE);
//------------------------------------------------------------------------------------------------
// keep the skimmed collections for further usage
//------------------------------------------------------------------------------------------------
//SkimMod<PFCandidate> *skmPFCandidates = new SkimMod<PFCandidate>;
//skmPFCandidates->SetBranchName(Names::gkPFCandidatesBrn);
//skmPFCandidates->SetPublishArray(kTRUE);
SkimJetsMod *skmJets = new SkimJetsMod;
skmJets->SetBranchName(jetCleaning->GetOutputName());
skmJets->SetColFromBranch(kFALSE);
skmJets->SetColMarkFilter(kFALSE);
skmJets->SetPublishArray(kTRUE);
SkimMod<TriggerObject> *skmTrigger = new SkimMod<TriggerObject>;
skmTrigger->SetBranchName(hltModP->GetOutputName());
skmTrigger->SetColFromBranch(kFALSE);
skmTrigger->SetColMarkFilter(kFALSE);
skmTrigger->SetPublishArray(kTRUE);
//------------------------------------------------------------------------------------------------
// save all this in an output ntuple
//------------------------------------------------------------------------------------------------
OutputMod *outMod = new OutputMod;
outMod->SetUseBrDep(kFALSE);
outMod->SetKeepTamBr(kFALSE);
outMod->SetFileName(ntupleFile);
outMod->SetMaxFileSize(4096);
outMod->Drop("*");
outMod->Keep(Names::gkMCEvtInfoBrn);
outMod->Keep(Names::gkMCPartBrn);
outMod->Keep(Names::gkPVBeamSpotBrn);
outMod->Keep(Names::gkPileupInfoBrn);
outMod->Keep(Names::gkPileupEnergyDensityBrn);
outMod->Keep("PFMet");
outMod->AddNewBranch("XlEvtSelData");
//outMod->AddNewBranch(TString("Skm") + Names::gkPFCandidatesBrn);
outMod->AddNewBranch(TString("Skm") + hltModP->GetOutputName());
outMod->AddNewBranch("PFMetMVA");
outMod->AddNewBranch("XlJets");
outMod->AddNewBranch("XlFatJets");
outMod->AddNewBranch("XlSubJets");
outMod->AddNewBranch("XsMuons");
outMod->AddNewBranch("XsElectrons");
outMod->AddNewBranch("XsTaus");
outMod->AddNewBranch("XsPhotons");
//------------------------------------------------------------------------------------------------
// making analysis chain
//------------------------------------------------------------------------------------------------
runLumiSel ->Add(goodPVFilterMod);
goodPVFilterMod ->Add(hltModP);
hltModP ->Add(sepPuMod);
sepPuMod ->Add(muonIdIsoMod);
muonIdIsoMod ->Add(muonIdLooseMod);
muonIdLooseMod ->Add(eleIdMod);
eleIdMod ->Add(electronCleaning);
electronCleaning ->Add(merger);
merger ->Add(photonIdMod);
photonIdMod ->Add(photonCleaningMod);
photonCleaningMod ->Add(pftauIdMod);
pftauIdMod ->Add(pftauCleaningMod);
pftauCleaningMod ->Add(pubJet);
pubJet ->Add(jetCorr);
jetCorr ->Add(jetId);
jetId ->Add(jetCleaning);
jetCleaning ->Add(pubFastJet);
pubFastJet ->Add(fatJetCorr);
fatJetCorr ->Add(fatJetId);
fatJetId ->Add(fatJetCleaning);
fatJetCleaning ->Add(jetplusmet);
jetplusmet ->Add(extendedMetFiller);
extendedMetFiller ->Add(boostedJetsFiller);
boostedJetsFiller ->Add(boostedFatJetsFiller);
boostedFatJetsFiller ->Add(boostedXsIsoParticlesFiller);
boostedXsIsoParticlesFiller->Add(skmJets);
skmJets ->Add(skmTrigger);
skmTrigger ->Add(outMod);
//------------------------------------------------------------------------------------------------
// Say what we are doing
//------------------------------------------------------------------------------------------------
printf("\n==== PARAMETER SUMMARY FOR THIS JOB ====\n");
printf("\n JSON file: %s\n",jsonFile.Data());
printf("\n Rely on Catalog: %s\n",cataDir.Data());
printf(" -> Book: %s Dataset: %s Skim: %s Fileset: %s <-\n",book,dataset,skim,fileset);
printf("\n Root output: %s\n",rootFile.Data());
printf("\n Ntuple output: %s\n\n",(ntupleFile + TString(".root")).Data());
printf("\n========================================\n");
//------------------------------------------------------------------------------------------------
// run the analysis after successful initialisation
//------------------------------------------------------------------------------------------------
ana->Run(!gROOT->IsBatch());
return;
}
//--------------------------------------------------------------------------------------------------
void executeComputeElectronFakeRateMod(const char *fileset = "",
const char *dataset = "s8-ttbar-id9",
const char *book = "mit/filler/006",
const char *catalogDir = "/home/mitprod/catalog",
const char *outputName = "JetChargeCorrelationStudy",
int nEvents = -1)
{
//------------------------------------------------------------------------------------------------
// some global setups
//------------------------------------------------------------------------------------------------
using namespace mithep;
gDebugMask = Debug::kAnalysis;
gDebugLevel = 3;
//------------------------------------------------------------------------------------------------
// generator information
//------------------------------------------------------------------------------------------------
GeneratorMod *generatorMod = new GeneratorMod;
generatorMod->SetFillHist(kTRUE);
//------------------------------------------------------------------------------------------------
// HLT information
//------------------------------------------------------------------------------------------------
HLTMod *hltmod = new HLTMod;
hltmod->SetPrintTable(kTRUE);
hltmod->AddTrigger("HLT_IsoEle15_L1I");
hltmod->AddTrigger("HLT_Ele15_SW_L1R");
hltmod->AddTrigger("HLT_IsoEle15_LW_L1I");
hltmod->AddTrigger("HLT_IsoEle18_L1R");
hltmod->AddTrigger("HLT_Ele15_LW_L1R");
hltmod->AddTrigger("HLT_LooseIsoEle15_LW_L1R");
hltmod->AddTrigger("HLT_IsoMu15");
hltmod->AddTrigger("HLT_Mu15");
hltmod->SetTrigObjsName("myhltobjs");
//------------------------------------------------------------------------------------------------
// object id and cleaning sequence
//------------------------------------------------------------------------------------------------
MuonIDMod *muonID = new MuonIDMod;
muonID->SetIDType("Loose");
muonID->SetIsoType("TrackCaloSliding");
ElectronIDMod *electronID = new ElectronIDMod;
electronID->SetIDType(TString("Tight"));
electronID->SetIsoType(TString("TrackJuraSliding"));
PhotonIDMod *photonID = new PhotonIDMod;
photonID->SetIDType(TString("Tight"));
photonID->SetPtMin(20.0);
JetIDMod *jetID = new JetIDMod;
jetID->SetInputName(TString("SisCone5Jets"));
jetID->SetUseCorrection(kTRUE);
jetID->SetPtCut(35.0);
ElectronCleaningMod *electronCleaning = new ElectronCleaningMod;
PhotonCleaningMod *photonCleaning = new PhotonCleaningMod;
JetCleaningMod *jetCleaning = new JetCleaningMod;
//------------------------------------------------------------------------------------------------
// merge modules
//------------------------------------------------------------------------------------------------
//MergeLeptonsMod *mergeLeptonsMod = new MergeLeptonsMod;
//------------------------------------------------------------------------------------------------
// analyses modules
//------------------------------------------------------------------------------------------------
JetChargeCorrelationStudyMod *analysisMod = new JetChargeCorrelationStudyMod;
analysisMod->SetVetoGeneratorLeptons(kTRUE);
//------------------------------------------------------------------------------------------------
// making analysis chain
//------------------------------------------------------------------------------------------------
hltmod->Add(muonID);
generatorMod->Add(muonID);
muonID->Add(electronID);
electronID->Add(photonID);
photonID->Add(jetID);
jetID->Add(electronCleaning);
electronCleaning->Add(photonCleaning);
photonCleaning->Add(jetCleaning);
jetCleaning->Add(analysisMod);
//------------------------------------------------------------------------------------------------
// setup analysis
//------------------------------------------------------------------------------------------------
Analysis *ana = new Analysis;
ana->SetUseHLT(kFALSE);
ana->SetKeepHierarchy(kTRUE);
if (nEvents >= 0)
ana->SetProcessNEvents(nEvents);
//ana->SetSuperModule(muonID);
ana->SetSuperModule(generatorMod);
//------------------------------------------------------------------------------------------------
// organize input
//------------------------------------------------------------------------------------------------
printf("\nRely on Catalog: %s\n",catalogDir);
printf(" -> Book: %s Dataset: %s Fileset: %s <-\n\n",book,dataset,fileset);
Catalog *c = new Catalog(catalogDir);
Dataset *d = c->FindDataset(book,dataset,fileset);
ana->AddDataset(d);
//------------------------------------------------------------------------------------------------
// organize output
//------------------------------------------------------------------------------------------------
TString rootFile = TString(outputName);
rootFile += TString("_") + TString(dataset);
if (TString(fileset) != TString(""))
rootFile += TString("_") + TString(fileset);
rootFile += TString(".root");
printf("\nRoot output: %s\n\n",rootFile.Data());
ana->SetOutputName(rootFile.Data());
//------------------------------------------------------------------------------------------------
// run the analysis after successful initialisation
//------------------------------------------------------------------------------------------------
ana->Run(!gROOT->IsBatch());
return;
}
//--------------------------------------------------------------------------------------------------
void runFlatMonoJet(const char *fileset = "0000",
const char *skim = "noskim",
const char *dataset = "s12-zjets-ptz70-100-v7c",
const char *book = "t2mit/filefi/032",
const char *catalogDir = "/home/cmsprod/catalog",
const char *outputName = "MonoJet_August13",
int nEvents = 100)
{
//------------------------------------------------------------------------------------------------
// some parameters get passed through the environment
//------------------------------------------------------------------------------------------------
TString cataDir = getCatalogDir(catalogDir);
TString mitData = mithep::Utils::GetEnv("MIT_DATA");
TString json = mithep::Utils::GetEnv("MIT_PROD_JSON");
TString jsonFile = getJsonFile("/home/cmsprod/cms/json");
Bool_t isData = (json.CompareTo("~") != 0);
printf("\n Initialization worked. Data?: %d\n\n",isData);
std::cout<<"*********** Is data?? **********"<<isData<<std::endl;
//------------------------------------------------------------------------------------------------
// some global setups
//------------------------------------------------------------------------------------------------
using namespace mithep;
gDebugMask = (Debug::EDebugMask) (Debug::kGeneral | Debug::kTreeIO);
gDebugLevel = 3;
// Caching and how
Int_t local = 1, cacher = 1;
// local = 0 - as is,
// 1 - /mnt/hadoop (MIT:SmartCache - preload one-by-one)
// 2 - /mnt/hadoop (MIT:SmartCache - preload complete fileset)
// 3 - ./ (xrdcp - preload one-by-one)
// cacher = 0 - no file by file caching
// 1 - file by file caching on
//------------------------------------------------------------------------------------------------
// set up information
//------------------------------------------------------------------------------------------------
RunLumiSelectionMod *runLumiSel = new RunLumiSelectionMod;
runLumiSel->SetAcceptMC(!isData);
runLumiSel->SetAbortIfNotAccepted(kFALSE); // accept all events if there is no valid JSON file
// only select on run- and lumisection numbers when valid json file present
if (json.CompareTo("~") != 0 && json.CompareTo("-") != 0) {
printf(" runBoostedV() - adding jsonFile: %s\n",jsonFile.Data());
runLumiSel->AddJSONFile(jsonFile.Data());
}
if (json.CompareTo("-") == 0) {
printf("\n WARNING -- Looking at data without JSON file: always accept.\n\n");
runLumiSel->SetAbortIfNotAccepted(kFALSE); // accept all events if there is no valid JSON file
}
printf("\n Run lumi worked. \n\n");
// Generator info
GeneratorMod *generatorMod = new GeneratorMod;
generatorMod->SetPrintDebug(kFALSE);
generatorMod->SetPtLeptonMin(0.0);
generatorMod->SetEtaLeptonMax(2.7);
generatorMod->SetPtPhotonMin(0.0);
generatorMod->SetEtaPhotonMax(2.7);
generatorMod->SetPtRadPhotonMin(0.0);
generatorMod->SetEtaRadPhotonMax(2.7);
generatorMod->SetIsData(isData);
generatorMod->SetFillHist(!isData);
generatorMod->SetApplyISRFilter(kFALSE);
generatorMod->SetApplyVVFilter(kFALSE);
generatorMod->SetApplyVGFilter(kFALSE);
generatorMod->SetFilterBTEvents(kFALSE);
//-----------------------------------------------------------------------------------------------------------
// HLT information : trigger not applied (neither for data nor for MC, store info to apply selection offline
//-----------------------------------------------------------------------------------------------------------
HLTMod *hltModP = new HLTMod("HLTModP");
// monojet triggers
const int nMjtTrigs = 12;
TString monoJetTriggers[nMjtTrigs] = { "HLT_MonoCentralPFJet80_PFMETnoMu105_NHEF0p95_v4",
"HLT_MonoCentralPFJet80_PFMETnoMu105_NHEF0p95_v3",
"HLT_MonoCentralPFJet80_PFMETnoMu105_NHEF0p95_v1",
"HLT_MonoCentralPFJet80_PFMETnoMu95_NHEF0p95_v5",
"HLT_MonoCentralPFJet80_PFMETnoMu95_NHEF0p95_v4",
"HLT_MonoCentralPFJet80_PFMETnoMu95_NHEF0p95_v3",
"HLT_MonoCentralPFJet80_PFMETnoMu95_NHEF0p95_v2",
"HLT_MET120_HBHENoiseCleaned_v6",
"HLT_MET120_HBHENoiseCleaned_v5",
"HLT_MET120_HBHENoiseCleaned_v4",
"HLT_MET120_HBHENoiseCleaned_v3",
"HLT_MET120_HBHENoiseCleaned_v2" };
for (int i=0; i<nMjtTrigs; i++)
hltModP->AddTrigger(TString("!+"+monoJetTriggers[i]),0,999999);
// VBF triggers
const int nVbfTrigs = 7;
TString vbfTriggers[nVbfTrigs] = { "HLT_DiPFJet40_PFMETnoMu65_MJJ800VBF_AllJets_v9",
"HLT_DiPFJet40_PFMETnoMu65_MJJ800VBF_AllJets_v8",
"HLT_DiPFJet40_PFMETnoMu65_MJJ800VBF_AllJets_v6",
"HLT_DiPFJet40_PFMETnoMu65_MJJ800VBF_AllJets_v5",
"HLT_DiPFJet40_PFMETnoMu65_MJJ800VBF_AllJets_v4",
"HLT_DiPFJet40_PFMETnoMu65_MJJ800VBF_AllJets_v3",
"HLT_DiPFJet40_PFMETnoMu65_MJJ800VBF_AllJets_v2" };
for (int i=0; i<nVbfTrigs; i++)
hltModP->AddTrigger((TString("!+")+vbfTriggers[i]).Data(),0,999999);
hltModP->SetBitsName("HLTBits");
hltModP->SetTrigObjsName("MyHltPhotObjs");
hltModP->SetAbortIfNotAccepted(isData);
hltModP->SetPrintTable(kFALSE);
//------------------------------------------------------------------------------------------------
// split pfcandidates to PFPU and PFnoPU
//------------------------------------------------------------------------------------------------
SeparatePileUpMod* SepPUMod = new SeparatePileUpMod;
// SepPUMod->SetUseAllVerteces(kFALSE);
// SepPUMod->SetVertexName("OutVtxCiC");
SepPUMod->SetPFNoPileUpName("pfnopileupcands");
SepPUMod->SetPFPileUpName("pfpileupcands");
SepPUMod->SetCheckClosestZVertex(kFALSE);
//------------------------------------------------------------------------------------------------
// select events with a good primary vertex
//------------------------------------------------------------------------------------------------
GoodPVFilterMod *goodPVFilterMod = new GoodPVFilterMod;
goodPVFilterMod->SetMinVertexNTracks(0);
goodPVFilterMod->SetMinNDof (4.0);
goodPVFilterMod->SetMaxAbsZ (24.0);
goodPVFilterMod->SetMaxRho (2.0);
goodPVFilterMod->SetIsMC(!isData);
goodPVFilterMod->SetVertexesName("PrimaryVertexes");
//------------------------------------------------------------------------------------------------
// object id and cleaning sequence
//------------------------------------------------------------------------------------------------
//-----------------------------------
// Lepton Selection
//-----------------------------------
ElectronIDMod* eleIdMod = new ElectronIDMod;
eleIdMod->SetPtMin(10.);
eleIdMod->SetEtaMax(2.5);
eleIdMod->SetApplyEcalFiducial(kTRUE);
eleIdMod->SetIDType("CustomLoose");
eleIdMod->SetIsoType("PFIso_HggLeptonTag2012HCP");
eleIdMod->SetPFNoPileUpName("pfnopileupcands");
eleIdMod->SetApplyConversionFilterType1(kTRUE);
eleIdMod->SetApplyConversionFilterType2(kFALSE);
eleIdMod->SetChargeFilter(kFALSE);
eleIdMod->SetApplyD0Cut(kTRUE);
eleIdMod->SetApplyDZCut(kTRUE);
eleIdMod->SetWhichVertex(0);
eleIdMod->SetNExpectedHitsInnerCut(0);
eleIdMod->SetGoodElectronsName("GoodElectronsBS");
eleIdMod->SetRhoType(RhoUtilities::CMS_RHO_RHOKT6PFJETS);
MuonIDMod *muonIdWW = new MuonIDMod;
muonIdWW->SetOutputName("HWWMuons");
muonIdWW->SetIntRadius(0.0);
muonIdWW->SetClassType("GlobalTracker");
muonIdWW->SetIDType("WWMuIdV4");
muonIdWW->SetIsoType("IsoRingsV0_BDTG_Iso");
muonIdWW->SetApplyD0Cut(kTRUE);
muonIdWW->SetApplyDZCut(kTRUE);
muonIdWW->SetWhichVertex(0);
muonIdWW->SetRhoType(RhoUtilities::CMS_RHO_RHOKT6PFJETS);
muonIdWW->SetPtMin(10.);
muonIdWW->SetEtaCut(2.4);
MuonIDMod *muonIdPOG = new MuonIDMod;
muonIdPOG->SetOutputName("POGMuons");
muonIdPOG->SetClassType("GlobalTracker");
muonIdPOG->SetIDType("NoId");
muonIdPOG->SetApplyD0Cut(true);
muonIdPOG->SetD0Cut(0.2);
muonIdPOG->SetApplyDZCut(true);
muonIdPOG->SetDZCut(0.5);
//muonIdPOG->SetIsoType("PFIsoBetaPUCorrected");
//muonIdPOG->SetPFNoPileUpName("pfnopileupcands");
//muonIdPOG->SetPFPileUpName("pfpileupcands");
muonIdPOG->SetIsoType("NoIso");
muonIdPOG->SetPtMin(10.);
muonIdPOG->SetEtaCut(2.4);
MuonIDMod* muonIdIso = new MuonIDMod;
muonIdIso->SetOutputName("IsolatedPOGMuons");
muonIdIso->SetClassType("GlobalorTracker");
muonIdIso->SetIDType("NoId");
muonIdIso->SetApplyD0Cut(true);
muonIdIso->SetD0Cut(0.2);
muonIdIso->SetApplyDZCut(true);
muonIdIso->SetDZCut(0.5);
muonIdIso->SetIsoType("PFIsoBetaPUCorrected"); //h
muonIdIso->SetPFNoPileUpName("pfnopileupcands");
muonIdIso->SetPFPileUpName("pfpileupcands");
muonIdIso->SetPtMin(10.);
muonIdIso->SetEtaCut(2.4);
MuonIDMod *muonId = muonIdPOG;
//MuonIDMod *muonId = muonIdIso;
ElectronCleaningMod *electronCleaning = new ElectronCleaningMod;
electronCleaning->SetCleanMuonsName(muonId->GetOutputName());
electronCleaning->SetGoodElectronsName(eleIdMod->GetOutputName());
electronCleaning->SetCleanElectronsName("CleanElectrons");
MergeLeptonsMod *merger = new MergeLeptonsMod;
merger->SetMuonsName(muonId->GetOutputName());
merger->SetElectronsName(electronCleaning->GetOutputName());
merger->SetMergedName("MergedLeptons");
//-----------------------------------
// Photon Regression + ID
//-----------------------------------
PhotonMvaMod *photreg = new PhotonMvaMod;
photreg->SetRegressionVersion(3);
photreg->SetRegressionWeights(std::string(
(gSystem->Getenv("MIT_DATA") + TString("/gbrv3ph_52x.root")).Data()
));
photreg->SetOutputName("GoodPhotonsRegr");
photreg->SetApplyShowerRescaling(kTRUE);
photreg->SetMinNumPhotons(0);
photreg->SetIsData(isData);
PhotonIDMod *photonIDMod = new PhotonIDMod;
photonIDMod->SetPtMin(15.0);
photonIDMod->SetOutputName("GoodPhotons");
photonIDMod->SetIDType("MITMVAId");
photonIDMod->SetBdtCutBarrel(0.02);
photonIDMod->SetBdtCutEndcap(0.1);
photonIDMod->SetIdMVAType("2013FinalIdMVA_8TeV");
photonIDMod->SetApplyElectronVeto(kTRUE);
photonIDMod->SetApplyFiduciality(kTRUE);
photonIDMod->SetIsData(isData);
photonIDMod->SetPhotonsFromBranch(kFALSE);
photonIDMod->SetInputName(photreg->GetOutputName());
PFTauIDMod *pftauIDMod = new PFTauIDMod;
pftauIDMod->SetPFTausName("HPSTaus");
pftauIDMod->SetIsLooseId(kFALSE);
pftauIDMod->SetIsHPSSel(kTRUE); // to get >= 5_3_14 samples running
PhotonCleaningMod *photonCleaningMod = new PhotonCleaningMod;
photonCleaningMod->SetCleanElectronsName(electronCleaning->GetOutputName());
photonCleaningMod->SetGoodPhotonsName(photonIDMod->GetOutputName());
photonCleaningMod->SetCleanPhotonsName("CleanPhotons");
PFTauCleaningMod *pftauCleaningMod = new PFTauCleaningMod;
pftauCleaningMod->SetGoodPFTausName(pftauIDMod->GetGoodPFTausName());
pftauCleaningMod->SetCleanMuonsName(muonId->GetOutputName());
PublisherMod<PFJet,Jet> *pubJet = new PublisherMod<PFJet,Jet>("JetPub");
pubJet->SetInputName("AKt5PFJets");
pubJet->SetOutputName("PubAKt5PFJets");
JetCorrectionMod *jetCorr = new JetCorrectionMod;
if(isData){
jetCorr->AddCorrectionFromFile(std::string((gSystem->Getenv("CMSSW_BASE") + TString("/src/MitPhysics/data/Summer13_V1_DATA_L1FastJet_AK5PF.txt")).Data()));
jetCorr->AddCorrectionFromFile(std::string((gSystem->Getenv("CMSSW_BASE") + TString("/src/MitPhysics/data/Summer13_V1_DATA_L2Relative_AK5PF.txt")).Data()));
jetCorr->AddCorrectionFromFile(std::string((gSystem->Getenv("CMSSW_BASE") + TString("/src/MitPhysics/data/Summer13_V1_DATA_L3Absolute_AK5PF.txt")).Data()));
jetCorr->AddCorrectionFromFile(std::string((gSystem->Getenv("CMSSW_BASE") + TString("/src/MitPhysics/data/Summer13_V1_DATA_L2L3Residual_AK5PF.txt")).Data()));
}
else {
jetCorr->AddCorrectionFromFile(std::string((gSystem->Getenv("CMSSW_BASE") + TString("/src/MitPhysics/data/Summer13_V1_MC_L1FastJet_AK5PF.txt")).Data()));
jetCorr->AddCorrectionFromFile(std::string((gSystem->Getenv("CMSSW_BASE") + TString("/src/MitPhysics/data/Summer13_V1_MC_L2Relative_AK5PF.txt")).Data()));
jetCorr->AddCorrectionFromFile(std::string((gSystem->Getenv("CMSSW_BASE") + TString("/src/MitPhysics/data/Summer13_V1_MC_L3Absolute_AK5PF.txt")).Data()));
}
jetCorr->SetInputName(pubJet->GetOutputName());
jetCorr->SetCorrectedName("CorrectedJets");
JetIDMod *jetID = new JetIDMod;
jetID->SetInputName(jetCorr->GetOutputName());
jetID->SetPtCut(30.0);
jetID->SetEtaMaxCut(4.7);
jetID->SetJetEEMFractionMinCut(0.00);
jetID->SetOutputName("GoodJets");
jetID->SetApplyBetaCut(kFALSE);
jetID->SetApplyMVACut(kTRUE);
JetCleaningMod *jetCleaning = new JetCleaningMod;
jetCleaning->SetCleanElectronsName(electronCleaning->GetOutputName());
jetCleaning->SetCleanMuonsName(muonIdIso->GetOutputName()); // clean up isolated muons (instead of the loose ones)
jetCleaning->SetCleanPhotonsName(photonCleaningMod->GetOutputName());
jetCleaning->SetApplyPhotonRemoval(kTRUE);
jetCleaning->SetGoodJetsName(jetID->GetOutputName());
jetCleaning->SetCleanJetsName("CleanJets");
MetCorrectionMod *metCorrT0T1Shift = new MetCorrectionMod;
metCorrT0T1Shift->SetInputName("PFMet");
metCorrT0T1Shift->SetJetsName(pubJet->GetOutputName());
metCorrT0T1Shift->SetCorrectedJetsName(jetCorr->GetOutputName());
metCorrT0T1Shift->SetCorrectedName("PFMetT0T1Shift");
metCorrT0T1Shift->ApplyType0(kTRUE);
metCorrT0T1Shift->ApplyType1(kTRUE);
metCorrT0T1Shift->ApplyShift(kTRUE);
metCorrT0T1Shift->IsData(isData);
metCorrT0T1Shift->SetPrint(kFALSE);
MonoJetTreeWriter *jetplusmettree = new MonoJetTreeWriter("MonoJetTreeWriter");
jetplusmettree->SetTriggerObjectsName(hltModP->GetOutputName());
jetplusmettree->SetMetName(metCorrT0T1Shift->GetOutputName()); //corrected met
jetplusmettree->SetMetFromBranch(kFALSE);
jetplusmettree->SetPhotonsFromBranch(kFALSE);
jetplusmettree->SetPhotonsName(photonCleaningMod->GetOutputName());
jetplusmettree->SetElectronsFromBranch(kFALSE);
jetplusmettree->SetElectronsName(electronCleaning->GetOutputName());
jetplusmettree->SetMuonsFromBranch(kFALSE);
jetplusmettree->SetMuonsName(muonId->GetOutputName());
jetplusmettree->SetTausFromBranch(kFALSE);
jetplusmettree->SetTausName(pftauCleaningMod->GetOutputName());
jetplusmettree->SetJetsFromBranch(kFALSE);
jetplusmettree->SetJetsName(jetCleaning->GetOutputName());
jetplusmettree->SetRawJetsName(pubJet->GetOutputName());
jetplusmettree->SetPVFromBranch(kFALSE);
jetplusmettree->SetPVName(goodPVFilterMod->GetOutputName());
jetplusmettree->SetLeptonsName(merger->GetOutputName());
jetplusmettree->SetIsData(isData);
jetplusmettree->SetProcessID(0);
jetplusmettree->SetFillNtupleType(0);
//------------------------------------------------------------------------------------------------
// making analysis chain
//------------------------------------------------------------------------------------------------
// this is how it always starts
runLumiSel->Add(generatorMod);
generatorMod->Add(goodPVFilterMod);
goodPVFilterMod->Add(hltModP);
// photon regression
hltModP->Add(photreg);
// simple object id modules
photreg ->Add(SepPUMod);
SepPUMod ->Add(muonId);
muonId ->Add(eleIdMod);
eleIdMod ->Add(electronCleaning);
electronCleaning ->Add(merger);
merger ->Add(photonIDMod);
photonIDMod ->Add(photonCleaningMod);
photonCleaningMod->Add(pftauIDMod);
pftauIDMod ->Add(pftauCleaningMod);
pftauCleaningMod ->Add(pubJet);
pubJet ->Add(jetCorr);
jetCorr ->Add(metCorrT0T1Shift);
metCorrT0T1Shift ->Add(jetID);
jetID ->Add(muonIdIso);
muonIdIso ->Add(jetCleaning);
jetCleaning ->Add(jetplusmettree);
//------------------------------------------------------------------------------------------------
// setup analysis
//------------------------------------------------------------------------------------------------
Analysis *ana = new Analysis;
ana->SetUseCacher(cacher);
ana->SetUseHLT(kTRUE);
ana->SetKeepHierarchy(kTRUE);
ana->SetSuperModule(runLumiSel);
ana->SetPrintScale(100);
if (nEvents >= 0)
ana->SetProcessNEvents(nEvents);
//------------------------------------------------------------------------------------------------
// organize input
//------------------------------------------------------------------------------------------------
TString skimdataset = TString(dataset)+TString("/") +TString(skim);
TString bookstr = book;
Catalog *c = new Catalog(cataDir.Data());
Dataset *d = NULL;
if (TString(skim).CompareTo("noskim") == 0)
d = c->FindDataset(bookstr,dataset,fileset,local);
else
d = c->FindDataset(bookstr,skimdataset.Data(),fileset,local);
ana->AddDataset(d);
//ana->AddFile("/mnt/hadoop/cms/store/user/paus/filefi/032/r12a-met-j22-v1/C4AC0AB8-BA82-E211-B238-003048678FF4.root");
//------------------------------------------------------------------------------------------------
// organize output
//------------------------------------------------------------------------------------------------
TString rootFile = TString(outputName);
rootFile += TString("_") + TString(dataset) + TString("_") + TString(skim);
if (TString(fileset) != TString(""))
rootFile += TString("_") + TString(fileset);
rootFile += TString(".root");
ana->SetOutputName(rootFile.Data());
ana->SetCacheSize(0);
//------------------------------------------------------------------------------------------------
// Say what we are doing
//------------------------------------------------------------------------------------------------
printf("\n==== PARAMETER SUMMARY FOR THIS JOB ====\n");
printf("\n JSON file: %s\n",jsonFile.Data());
printf("\n Rely on Catalog: %s\n",cataDir.Data());
printf(" -> Book: %s Dataset: %s Skim: %s Fileset: %s <-\n",book,dataset,skim,fileset);
printf("\n Root output: %s\n\n",rootFile.Data());
printf("\n========================================\n");
//------------------------------------------------------------------------------------------------
// run the analysis after successful initialisation
//------------------------------------------------------------------------------------------------
ana->Run(kFALSE);
return;
}
//--------------------------------------------------------------------------------------------------
void runMonoJetTrigger(const char *fileset = "0000",
const char *skim = "noskim",
const char *dataset = "s12-wglg-v7a",
const char *book = "t2mit/filefi/029",
const char *catalogDir = "/home/cmsprod/catalog",
const char *outputName = "gmet",
int nEvents = 1000)
{
//------------------------------------------------------------------------------------------------
// some parameters get passed through the environment
//------------------------------------------------------------------------------------------------
char json[1024], overlap[1024];
float overlapCut = -1;
if (gSystem->Getenv("MIT_PROD_JSON"))
sprintf(json, "%s",gSystem->Getenv("MIT_PROD_JSON"));
else {
sprintf(json, "%s", "~");
//printf(" JSON file was not properly defined. EXIT!\n");
//return;
}
TString jsonFile = TString("/home/cmsprod/cms/json/") + TString(json);
//TString jsonFile = TString("/home/cmsprod/cms/json/") + TString("Cert_136033-149442_7TeV_Dec22ReReco_Collisions10_JSON_v4.txt");
Bool_t isData = ( (jsonFile.CompareTo("/home/cmsprod/cms/json/~") != 0) );
if (gSystem->Getenv("MIT_PROD_OVERLAP")) {
sprintf(overlap,"%s",gSystem->Getenv("MIT_PROD_OVERLAP"));
if (EOF == sscanf(overlap,"%f",&overlapCut)) {
printf(" Overlap was not properly defined. EXIT!\n");
return;
}
}
else {
sprintf(overlap,"%s", "-1.0");
//printf(" OVERLAP file was not properly defined. EXIT!\n");
//return;
}
printf("\n Initialization worked \n");
//------------------------------------------------------------------------------------------------
// some global setups
//------------------------------------------------------------------------------------------------
using namespace mithep;
gDebugMask = Debug::kGeneral;
gDebugLevel = 3;
//------------------------------------------------------------------------------------------------
// set up information
//------------------------------------------------------------------------------------------------
MVASystematicsMod *sysMod = new MVASystematicsMod;
sysMod->SetMCR9Scale(1.0035, 1.0035);
sysMod->SetIsData(isData);
RunLumiSelectionMod *runLumiSel = new RunLumiSelectionMod;
runLumiSel->SetAcceptMC(!isData);
runLumiSel->SetAbortIfNotAccepted(kFALSE); // accept all events if there is no valid JSON file
// only select on run- and lumisection numbers when valid json file present
if ((jsonFile.CompareTo("/home/cmsprod/cms/json/~") != 0) &&
(jsonFile.CompareTo("/home/cmsprod/cms/json/-") != 0) ) {
runLumiSel->AddJSONFile(jsonFile.Data());
}
if ((jsonFile.CompareTo("/home/cmsprod/cms/json/-") == 0) ) {
printf("\n WARNING -- Looking at data without JSON file: always accept.\n\n");
// runLumiSel->SetAbortIfNotAccepted(kFALSE); // accept all events if there is no valid JSON file
}
printf("\n Run lumi worked\n");
//------------------------------------------------------------------------------------------------
// HLT information : [TBF]
//------------------------------------------------------------------------------------------------
HLTMod *hltModP = new HLTMod("HLTModP");
//------------------------------------------------------------------------------------------------
// Run2012
//------------------------------------------------------------------------------------------------
hltModP->AddTrigger("HLT_IsoMu24_eta2p1_v*",0,999999);
//store the relevant objects
hltModP->AddTrigger("HLT_MET120_HBHENoiseCleaned_v*",0,999999); //met type 87
hltModP->AddTrigger("!HLT_MET120_HBHENoiseCleaned_v*",0,999999); //met type 87
hltModP->AddTrigger("HLT_MonoCentralPFJet80_PFMETnoMu95_NHEF0p95_v*",0,999999); //jet 85 , met 90
hltModP->AddTrigger("!HLT_MonoCentralPFJet80_PFMETnoMu95_NHEF0p95_v*",0,999999); //jet 85 , met 90
hltModP->AddTrigger("HLT_MonoCentralPFJet80_PFMETnoMu105_NHEF0p95_v*",0,999999); //jet 85 , met 90
hltModP->AddTrigger("!HLT_MonoCentralPFJet80_PFMETnoMu105_NHEF0p95_v*",0,999999); //jet 85 , met 90
hltModP->SetTrigObjsName("MyHltObjs");
hltModP->SetAbortIfNotAccepted(isData);
hltModP->SetPrintTable(kFALSE); // set to true to print HLT table
//------------------------------------------------------------------------------------------------
// split pfcandidates to PFPU and PFnoPU
//------------------------------------------------------------------------------------------------
SeparatePileUpMod* SepPUMod = new SeparatePileUpMod;
// SepPUMod->SetUseAllVerteces(kFALSE);
// SepPUMod->SetVertexName("OutVtxCiC");
SepPUMod->SetPFNoPileUpName("pfnopileupcands");
SepPUMod->SetPFPileUpName("pfpileupcands");
SepPUMod->SetCheckClosestZVertex(kFALSE);
//------------------------------------------------------------------------------------------------
// select events with a good primary vertex
//------------------------------------------------------------------------------------------------
GoodPVFilterMod *goodPVFilterMod = new GoodPVFilterMod;
goodPVFilterMod->SetMinVertexNTracks(0);
goodPVFilterMod->SetMinNDof (4.0);
goodPVFilterMod->SetMaxAbsZ (24.0);
goodPVFilterMod->SetMaxRho (2.0);
goodPVFilterMod->SetIsMC(!isData);
goodPVFilterMod->SetVertexesName("PrimaryVertexes");
//------------------------------------------------------------------------------------------------
// object id and cleaning sequence
//------------------------------------------------------------------------------------------------
//-----------------------------------
// Lepton Selection
//-----------------------------------
ElectronIDMod* eleIdMod = new ElectronIDMod;
eleIdMod -> SetPtMin(10);
eleIdMod -> SetEtaMax(2.5);
eleIdMod -> SetApplyEcalFiducial(true);
eleIdMod -> SetIDType("Hgg_LeptonTag_2012IdHCP");
eleIdMod -> SetElectronMVAWeightsSubdet0Pt10To20(TString((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/ElectronMVAWeights/ElectronID_BDTG_EGamma2012NonTrigV0_Cat1.weights.xml"))));
eleIdMod -> SetElectronMVAWeightsSubdet1Pt10To20(TString((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/ElectronMVAWeights/ElectronID_BDTG_EGamma2012NonTrigV0_Cat2.weights.xml"))));
eleIdMod -> SetElectronMVAWeightsSubdet2Pt10To20(TString((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/ElectronMVAWeights/ElectronID_BDTG_EGamma2012NonTrigV0_Cat3.weights.xml"))));
eleIdMod -> SetElectronMVAWeightsSubdet0Pt20ToInf(TString((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/ElectronMVAWeights/ElectronID_BDTG_EGamma2012NonTrigV0_Cat4.weights.xml"))));
eleIdMod -> SetElectronMVAWeightsSubdet1Pt20ToInf(TString((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/ElectronMVAWeights/ElectronID_BDTG_EGamma2012NonTrigV0_Cat5.weights.xml"))));
eleIdMod -> SetElectronMVAWeightsSubdet2Pt20ToInf(TString((getenv("CMSSW_BASE")+string("/src/MitPhysics/data/ElectronMVAWeights/ElectronID_BDTG_EGamma2012NonTrigV0_Cat6.weights.xml"))));
eleIdMod -> SetWhichVertex(-1);
eleIdMod -> SetD0Cut(0.02);
eleIdMod -> SetDZCut(0.2); //h
eleIdMod -> SetIsoType("PFIso_HggLeptonTag2012HCP"); //h
eleIdMod -> SetOutputName("HggLeptonTagElectrons");
eleIdMod -> SetRhoType(RhoUtilities::CMS_RHO_RHOKT6PFJETS);
eleIdMod -> SetPFNoPileUpName("pfnopileupcands");
eleIdMod -> SetInvertNExpectedHitsInnerCut(kFALSE);
eleIdMod -> SetNExpectedHitsInnerCut(1);
eleIdMod -> SetApplyConversionFilterType1(kTRUE);
eleIdMod -> SetPVName(Names::gkPVBeamSpotBrn);
MuonIDMod* muonIdMod = new MuonIDMod;
// base kinematics
muonIdMod -> SetPtMin(10.);
muonIdMod -> SetEtaCut(2.4);
// base ID
muonIdMod -> SetIDType("Tight");
muonIdMod -> SetWhichVertex(-1); // this is a 'hack'.. but hopefully good enough...
muonIdMod -> SetD0Cut(0.02);
muonIdMod -> SetDZCut(0.5);
muonIdMod -> SetIsoType("PFIsoBetaPUCorrected"); //h
muonIdMod -> SetPFIsoCut(0.2); //h
muonIdMod -> SetOutputName("HggLeptonTagMuons");
muonIdMod -> SetPFNoPileUpName("pfnopileupcands");
muonIdMod -> SetPFPileUpName("pfpileupcands");
muonIdMod -> SetPVName(Names::gkPVBeamSpotBrn);
ElectronCleaningMod *electronCleaning = new ElectronCleaningMod;
electronCleaning->SetCleanMuonsName(muonIdMod->GetOutputName());
electronCleaning->SetGoodElectronsName(eleIdMod->GetOutputName());
electronCleaning->SetCleanElectronsName("CleanElectrons");
MergeLeptonsMod *merger = new MergeLeptonsMod;
merger->SetMuonsName(muonIdMod->GetOutputName());
merger->SetElectronsName(electronCleaning->GetOutputName());
merger->SetMergedName("MergedLeptons");
//-----------------------------------
// Photon Regression + ID
//-----------------------------------
PhotonMvaMod *photreg = new PhotonMvaMod;
photreg->SetRegressionVersion(3);
photreg->SetRegressionWeights(std::string((gSystem->Getenv("CMSSW_BASE") + TString("/src/MitPhysics/data/gbrv3ph_52x.root")).Data()));
photreg->SetOutputName("GoodPhotonsRegr");
photreg->SetApplyShowerRescaling(kTRUE);
photreg->SetMinNumPhotons(0);
photreg->SetIsData(isData);
PhotonIDMod *photonIDMod = new PhotonIDMod;
photonIDMod->SetPtMin(0.0);
photonIDMod->SetOutputName("GoodPhotons");
photonIDMod->SetIDType("BaseLineCiCPFNoPresel");
photonIDMod->SetIsoType("NoIso");
photonIDMod->SetApplyElectronVeto(kTRUE);
photonIDMod->SetApplyPixelSeed(kTRUE);
photonIDMod->SetApplyConversionId(kTRUE);
photonIDMod->SetApplyFiduciality(kTRUE);
photonIDMod->SetIsData(isData);
photonIDMod->SetPhotonsFromBranch(kFALSE);
photonIDMod->SetInputName(photreg->GetOutputName());
//get the photon with regression energy
photonIDMod->DoMCSmear(kTRUE);
photonIDMod->DoDataEneCorr(kTRUE);
//------------------------------------------Energy smear and scale--------------------------------------------------------------
photonIDMod->SetMCSmearFactors2012HCP(0.0111,0.0111,0.0107,0.0107,0.0155,0.0194,0.0295,0.0276,0.037,0.0371);
photonIDMod->AddEnCorrPerRun2012HCP(190645,190781,0.9964,0.9964,1.0020,1.0020,0.9893,1.0028,0.9871,0.9937,0.9839,0.9958);
photonIDMod->AddEnCorrPerRun2012HCP(190782,191042,1.0024,1.0024,1.0079,1.0079,0.9923,1.0058,0.9911,0.9977,0.9886,1.0005);
photonIDMod->AddEnCorrPerRun2012HCP(191043,193555,0.9935,0.9935,0.9991,0.9991,0.9861,0.9997,0.9894,0.9960,0.9864,0.9982);
photonIDMod->AddEnCorrPerRun2012HCP(193556,194150,0.9920,0.9920,0.9976,0.9976,0.9814,0.9951,0.9896,0.9962,0.9872,0.9990);
photonIDMod->AddEnCorrPerRun2012HCP(194151,194532,0.9925,0.9925,0.9981,0.9981,0.9826,0.9963,0.9914,0.9980,0.9874,0.9993);
photonIDMod->AddEnCorrPerRun2012HCP(194533,195113,0.9927,0.9927,0.9983,0.9983,0.9844,0.9981,0.9934,0.9999,0.9878,0.9996);
photonIDMod->AddEnCorrPerRun2012HCP(195114,195915,0.9929,0.9929,0.9984,0.9984,0.9838,0.9974,0.9942,1.0007,0.9878,0.9997);
photonIDMod->AddEnCorrPerRun2012HCP(195916,198115,0.9919,0.9919,0.9975,0.9975,0.9827,0.9964,0.9952,1.0017,0.9869,0.9987);
photonIDMod->AddEnCorrPerRun2012HCP(198116,199803,0.9955,0.9955,1.0011,1.0011,0.9859,0.9995,0.9893,0.9959,0.9923,1.0041);
photonIDMod->AddEnCorrPerRun2012HCP(199804,200048,0.9967,0.9967,1.0023,1.0023,0.9870,1.0006,0.9893,0.9959,0.9937,1.0055);
photonIDMod->AddEnCorrPerRun2012HCP(200049,200151,0.9980,0.9980,1.0036,1.0036,0.9877,1.0012,0.9910,0.9976,0.9980,1.0097);
photonIDMod->AddEnCorrPerRun2012HCP(200152,200490,0.9958,0.9958,1.0013,1.0013,0.9868,1.0004,0.9922,0.9988,0.9948,1.0065);
photonIDMod->AddEnCorrPerRun2012HCP(200491,200531,0.9979,0.9979,1.0035,1.0035,0.9876,1.0012,0.9915,0.9981,0.9979,1.0096);
photonIDMod->AddEnCorrPerRun2012HCP(200532,201656,0.9961,0.9961,1.0017,1.0017,0.9860,0.9996,0.9904,0.9970,0.9945,1.0063);
photonIDMod->AddEnCorrPerRun2012HCP(201657,202305,0.9969,0.9969,1.0025,1.0025,0.9866,1.0002,0.9914,0.9980,0.9999,1.0116);
photonIDMod->AddEnCorrPerRun2012HCP(202305,203002,0.9982,0.9982,1.0038,1.0038,0.9872,1.0008,0.9934,1.0000,1.0018,1.0135);
photonIDMod->AddEnCorrPerRun2012HCP(203003,203984,1.0006,1.0006,1.0061,1.0061,0.9880,1.0017,0.9919,0.9988,0.9992,1.0104);
photonIDMod->AddEnCorrPerRun2012HCP(203985,205085,0.9993,0.9993,1.0048,1.0048,0.9903,1.0040,0.9928,0.9997,0.9987,1.0099);
photonIDMod->AddEnCorrPerRun2012HCP(205086,205310,1.0004,1.0004,1.0059,1.0059,0.9901,1.0037,0.9987,1.0055,1.0091,1.0202);
photonIDMod->AddEnCorrPerRun2012HCP(205311,206207,1.0000,1.0000,1.0055,1.0055,0.9891,1.0028,0.9948,1.0017,1.0032,1.0144);
photonIDMod->AddEnCorrPerRun2012HCP(206208,206483,1.0003,1.0003,1.0058,1.0058,0.9895,1.0032,0.9921,0.9989,1.0056,1.0167);
photonIDMod->AddEnCorrPerRun2012HCP(206484,206597,1.0005,1.0005,1.0060,1.0060,0.9895,1.0032,0.9968,1.0036,1.0046,1.0158);
photonIDMod->AddEnCorrPerRun2012HCP(206598,206896,1.0006,1.0006,1.0061,1.0061,0.9881,1.0017,0.9913,0.9982,1.0050,1.0162);
photonIDMod->AddEnCorrPerRun2012HCP(206897,207220,1.0006,1.0006,1.0061,1.0061,0.9884,1.0021,0.9909,0.9978,1.0053,1.0165);
photonIDMod->AddEnCorrPerRun2012HCP(207221,208686,1.0006,1.0006,1.0061,1.0061,0.9894,1.0030,0.9951,1.0020,1.0060,1.0172);
//---------------------------------shower shape scale--------------------------------------------------------------------------------
photonIDMod->SetDoShowerShapeScaling(kTRUE);
photonIDMod->SetShowerShapeType("2012ShowerShape");
photonIDMod->Set2012HCP(kTRUE);
PhotonCleaningMod *photonCleaningMod = new PhotonCleaningMod;
photonCleaningMod->SetCleanElectronsName(electronCleaning->GetOutputName());
photonCleaningMod->SetGoodPhotonsName(photonIDMod->GetOutputName());
photonCleaningMod->SetCleanPhotonsName("CleanPhotons");
PublisherMod<PFJet,Jet> *pubJet = new PublisherMod<PFJet,Jet>("JetPub");
pubJet->SetInputName("AKt5PFJets");
pubJet->SetOutputName("PubAKt5PFJets");
JetCorrectionMod *jetCorr = new JetCorrectionMod;
if(isData){
jetCorr->AddCorrectionFromFile(std::string((gSystem->Getenv("CMSSW_BASE") + TString("/src/MitPhysics/data/Summer12_V7_DATA_L1FastJet_AK5PF.txt")).Data()));
jetCorr->AddCorrectionFromFile(std::string((gSystem->Getenv("CMSSW_BASE") + TString("/src/MitPhysics/data/Summer12_V7_DATA_L2Relative_AK5PF.txt")).Data()));
jetCorr->AddCorrectionFromFile(std::string((gSystem->Getenv("CMSSW_BASE") + TString("/src/MitPhysics/data/Summer12_V7_DATA_L3Absolute_AK5PF.txt")).Data()));
jetCorr->AddCorrectionFromFile(std::string((gSystem->Getenv("CMSSW_BASE") + TString("/src/MitPhysics/data/Summer12_V7_DATA_L2L3Residual_AK5PF.txt")).Data()));
}
else {
jetCorr->AddCorrectionFromFile(std::string((gSystem->Getenv("CMSSW_BASE") + TString("/src/MitPhysics/data/Summer12_V7_MC_L1FastJet_AK5PF.txt")).Data()));
jetCorr->AddCorrectionFromFile(std::string((gSystem->Getenv("CMSSW_BASE") + TString("/src/MitPhysics/data/Summer12_V7_MC_L2Relative_AK5PF.txt")).Data()));
jetCorr->AddCorrectionFromFile(std::string((gSystem->Getenv("CMSSW_BASE") + TString("/src/MitPhysics/data/Summer12_V7_MC_L3Absolute_AK5PF.txt")).Data()));
}
jetCorr->SetInputName(pubJet->GetOutputName());
jetCorr->SetCorrectedName("CorrectedJets");
JetIDMod *theJetID = new JetIDMod;
theJetID->SetInputName(jetCorr->GetOutputName());
theJetID->SetPtCut(30.0);
theJetID->SetEtaMaxCut(4.7);
theJetID->SetJetEEMFractionMinCut(0.00);
theJetID->SetOutputName("GoodJets");
theJetID->SetApplyBetaCut(kFALSE);
theJetID->SetApplyMVACut(kTRUE);
JetCleaningMod *theJetCleaning = new JetCleaningMod;
theJetCleaning->SetCleanElectronsName(electronCleaning->GetOutputName());
theJetCleaning->SetCleanMuonsName(muonIdMod->GetOutputName());
theJetCleaning->SetCleanPhotonsName(photonCleaningMod->GetOutputName());
theJetCleaning->SetApplyPhotonRemoval(kTRUE);
theJetCleaning->SetGoodJetsName(theJetID->GetOutputName());
theJetCleaning->SetCleanJetsName("CleanJets");
//------------------------------------------------------------------------------------------------
// select events with jet+MET
//------------------------------------------------------------------------------------------------
MonoJetAnalysisMod *jetplusmet = new MonoJetAnalysisMod("MonoJetSelector");
jetplusmet->SetJetsName(theJetCleaning->GetOutputName()); //identified jets
jetplusmet->SetJetsFromBranch(kFALSE);
jetplusmet->SetElectronsName(electronCleaning->GetOutputName());
jetplusmet->SetElectronsFromBranch(kFALSE);
jetplusmet->SetMuonsName(muonIdMod->GetOutputName());
jetplusmet->SetMuonsFromBranch(kFALSE);
jetplusmet->SetLeptonsName(merger->GetOutputName());
jetplusmet->SetMinNumJets(1);
jetplusmet->SetMinNumLeptons(0);
jetplusmet->SetMinJetEt(30);
jetplusmet->SetMaxJetEta(2.7);
jetplusmet->SetMinChargedHadronFrac(0.3);
jetplusmet->SetMaxNeutralHadronFrac(0.7);
jetplusmet->SetMaxNeutralEmFrac(0.7);
jetplusmet->SetMinMetEt(30);
HLTEvtSelMod *hlttree = new HLTEvtSelMod("MonoJetHLTTreeWriter");
hlttree->SetCleanJetsName(theJetCleaning->GetOutputName());
hlttree->SetVertexName(goodPVFilterMod->GetOutputName());
hlttree->SetTrigObjsName(hltModP->GetOutputName());
//------------------------------------------------------------------------------------------------
// making analysis chain
//------------------------------------------------------------------------------------------------
// this is how it always starts
runLumiSel ->Add(goodPVFilterMod);
goodPVFilterMod->Add(hltModP);
// photon regression
hltModP->Add(photreg);
// simple object id modules
photreg ->Add(SepPUMod);
SepPUMod ->Add(muonIdMod);
muonIdMod ->Add(eleIdMod);
eleIdMod ->Add(electronCleaning);
electronCleaning ->Add(merger);
merger ->Add(photonIDMod);
photonIDMod ->Add(photonCleaningMod);
photonCleaningMod->Add(pubJet);
pubJet ->Add(jetCorr);
jetCorr ->Add(theJetID);
theJetID ->Add(theJetCleaning);
// Jet+met selection
theJetCleaning ->Add(jetplusmet);
jetplusmet ->Add(hlttree);
//------------------------------------------------------------------------------------------------
// setup analysis
//------------------------------------------------------------------------------------------------
Analysis *ana = new Analysis;
ana->SetUseHLT(kTRUE);
ana->SetKeepHierarchy(kTRUE);
ana->SetSuperModule(runLumiSel);
ana->SetPrintScale(100);
if (nEvents >= 0)
ana->SetProcessNEvents(nEvents);
//------------------------------------------------------------------------------------------------
// organize input
//------------------------------------------------------------------------------------------------
Catalog *c = new Catalog(catalogDir);
TString skimdataset = TString(dataset)+TString("/") +TString(skim);
Dataset *d = NULL;
TString bookstr = book;
if (TString(skim).CompareTo("noskim") == 0)
d = c->FindDataset(bookstr,dataset,fileset, true);
else
d = c->FindDataset(bookstr,skimdataset.Data(),fileset, true);
ana->AddDataset(d);
//------------------------------------------------------------------------------------------------
// organize output
//------------------------------------------------------------------------------------------------
TString rootFile = TString(outputName);
rootFile += TString("_") + TString(dataset) + TString("_") + TString(skim);
if (TString(fileset) != TString(""))
rootFile += TString("_") + TString(fileset);
rootFile += TString(".root");
ana->SetOutputName(rootFile.Data());
//ana->SetCacheSize(64*1024*1024);
ana->SetCacheSize(0);
//------------------------------------------------------------------------------------------------
// Say what we are doing
//------------------------------------------------------------------------------------------------
printf("\n==== PARAMETER SUMMARY FOR THIS JOB ====\n");
printf("\n JSON file: %s\n and overlap cut: %f (%s)\n",jsonFile.Data(),overlapCut,overlap);
printf("\n Rely on Catalog: %s\n",catalogDir);
printf(" -> Book: %s Dataset: %s Skim: %s Fileset: %s <-\n",book,dataset,skim,fileset);
printf("\n Root output: %s\n\n",rootFile.Data());
printf("\n========================================\n");
//------------------------------------------------------------------------------------------------
// run the analysis after successful initialisation
//------------------------------------------------------------------------------------------------
ana->Run(!gROOT->IsBatch());
return;
}