void runPixelTreeMaker(Bool_t doMC = 0,
const char *files = 0,
const char *outfile = 0,
UInt_t nev = 0,
Float_t SDRelFrac = 1.)
{
gDebugMask = Debug::kAnalysis;
gDebugLevel = 1;
gErrorIgnoreLevel = kInfo;
// setup analysis object
Analysis *ana = new Analysis;
ana->SetUseHLT(1);
if (nev>0)
ana->SetProcessNEvents(nev);
TString ofname(gSystem->Getenv("MIT_OUTPUTFILE"));
if (!ofname.IsNull())
ana->SetOutputName(ofname);
if (files) {
TString dummy(files);
TString suffix(dummy(dummy.Length()-4,dummy.Length()));
if (suffix.CompareTo("root")==0)
ana->AddFile(files);
else
ana->AddFiles(files);
}
HLTMod *hmod = new HLTMod;
hmod->SetPrintTable(1);
ana->AddSuperModule(hmod);
// setup modules
PixelsMakerMod *mod = new PixelsMakerMod;
mod->SetIsMC(doMC);
mod->AddVertexName("Pixel3Vertexes");
mod->AddVertexName("TrackletVertexes");
mod->AddVertexName("ClusterVertexes");
mod->AddVertexName("PixelVertexes");
mod->AddVertexName("PrimaryVertexes");
mod->AddVertexName("PrimaryVertexesBeamSpot");
// - diffractive study -
mod->SetUseHfOnly(true);
mod->SetSDRelFrac(SDRelFrac);
if (outfile)
mod->SetFileName(Form("%s_SDRelFrac%.1f.root",outfile,SDRelFrac));
else
mod->SetFileName("pixeltree.root");
ana->AddSuperModule(mod);
// run the analysis after successful initialisation
ana->Run(!gROOT->IsBatch());
}
//--------------------------------------------------------------------------------------------------
void jetPlusIsoTrack(const char *fileset = "",
const char *dataset = "s8-wm-id9",
const char *book = "mit/filler/006",
const char *catalogDir = "/home/mitprod/catalog",
Int_t nEvents = -1)
{
TString skimName("jetPlusIsoTrack");
using namespace mithep;
gDebugMask = Debug::kAnalysis;
gDebugLevel = 1;
//------------------------------------------------------------------------------------------------
// organize selection
//------------------------------------------------------------------------------------------------
const char *jetInput = Names::gkSC5JetBrn;
const char *gsfTracks = "GsfTracks";
const Double_t jetPtMin = 30;
const Double_t trackPtMin = 10;
JetIDMod *jetId = new JetIDMod;
jetId->SetInputName (jetInput);
jetId->SetUseCorrection(kFALSE);
jetId->SetPtCut (jetPtMin);
JetPlusIsoTrackSelMod *selMod = new JetPlusIsoTrackSelMod;
selMod->SetTrackPtMin(trackPtMin);
selMod->SetJetColName(jetId->GetOutputName());
selMod->SetTrackerTrackColName(Names::gkTrackBrn);
selMod->SetGsfTrackColName(gsfTracks);
//------------------------------------------------------------------------------------------------
// link modules together
//------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------
// organize output
//------------------------------------------------------------------------------------------------
OutputMod *outMod = new OutputMod;
outMod->Keep("*");
selMod->Add(outMod);
TString rootFile = skimName;
if (TString(fileset) != TString(""))
rootFile += TString("_") + TString(fileset);
printf("\nRoot output: %s\n\n",rootFile.Data());
outMod->SetFileName(rootFile);
outMod->SetPathName(".");
//------------------------------------------------------------------------------------------------
// set up analysis
//------------------------------------------------------------------------------------------------
Analysis *ana = new Analysis;
ana->AddSuperModule(jetId);
ana->AddSuperModule(selMod);
if (nEvents>0)
ana->SetProcessNEvents(nEvents);
//------------------------------------------------------------------------------------------------
// 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);
//------------------------------------------------------------------------------------------------
// run the analysis after successful initialisation
//------------------------------------------------------------------------------------------------
ana->Run(kFALSE);
}
void runSCNtupler(const char *fileset,
const char *skim,
const char *dataset,
const char *book,
const char *catalogDir,
const char *outputName,
int nevents)
{
gDebugMask = Debug::kAnalysis; // debug message category
gDebugLevel = 1; // higher level allows more messages to print
// Set some useful flags
Bool_t isData = kTRUE; // is Data? kTRUE or kFALSE
Bool_t skipHLTFail = 1; // skip events that fail the HLT? 0 or 1 (generally 1 for data, 0 for MC)
Int_t useGen = 0; // use generator info? (see above)
Int_t fsrmode = 0; // fsr mode? related to what generator was used for MC (generally 0)
cout << "isData: " << isData << " useGen: " << useGen << " fsrmode: " << fsrmode << " skipHLTFail: " << skipHLTFail << endl;
// muon kinematics
const Double_t muPtMin = 20;
const Double_t muPtMax = 7000;
const Double_t muEtaMin = -3;
const Double_t muEtaMax = 3;
// electron kinematics
const Double_t eleEtMin = 20;
const Double_t eleEtMax = 7000;
const Double_t eleEtaMin = -3;
const Double_t eleEtaMax = 3;
// jet requirements
const Double_t jetPtMin = 20;
// SC requirements
const Double_t scEtMin = 20;
// good PV requirements
const UInt_t minNTracksFit = 0;
const Double_t minNdof = 4;
const Double_t maxAbsZ = 24;
const Double_t maxRho = 2;
//
// setup analysis object
//
Bool_t caching = kFALSE; // set this to true if you want to use file caching on t3
Analysis *ana = new Analysis;
ana->SetUseHLT(kTRUE);
if(nevents>0)
ana->SetProcessNEvents(nevents);
printf("\nRely on Catalog: %s\n",catalogDir);
printf(" -> Book: %s Dataset: %s Fileset: %s <-\n\n",book,dataset,fileset);
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,caching);
else
d = c->FindDataset(bookstr,skimdataset.Data(),fileset,caching);
ana->AddDataset(d);
//
// setup ntupler module
//
SCNtuplerMod *mymod = new SCNtuplerMod;
mymod->SetOutputName(outputName); // output ntuple file name
mymod->SetIsData(isData); // toggle data specific or MC specific procedures
mymod->SetUseGen(useGen); // use generator info
mymod->SetSkipIfHLTFail(skipHLTFail); // skip to next event if no HLT accept
mymod->SetFSRMode(fsrmode);
mymod->SetMuPtMin(muPtMin);
mymod->SetMuPtMax(muPtMax);
mymod->SetMuEtaMin(muEtaMin);
mymod->SetMuEtaMax(muEtaMax);
mymod->SetEleEtMin(eleEtMin);
mymod->SetEleEtMax(eleEtMax);
mymod->SetEleEtaMin(eleEtaMin);
mymod->SetEleEtaMax(eleEtaMax);
mymod->SetJetPtMin(jetPtMin);
mymod->SetSCEtMin(scEtMin);
mymod->SetMinNTracksFit(minNTracksFit);
mymod->SetMinNdof(minNdof);
mymod->SetMaxAbsZ(maxAbsZ);
mymod->SetMaxRho(maxRho);
// Jet corrections
char* PATH = getenv("CMSSW_BASE"); assert(PATH);
TString path(TString::Format("%s/src/MitPhysics/data/", PATH));
mymod->AddJetCorr(path + "Summer13_V1_MC_L1FastJet_AK5PF.txt");
mymod->AddJetCorr(path + "Summer13_V1_MC_L2Relative_AK5PF.txt");
mymod->AddJetCorr(path + "Summer13_V1_MC_L3Absolute_AK5PF.txt");
if(isData) {
mymod->AddJetCorr(path + "Summer13_V1_DATA_L1FastJet_AK5PF.txt");
mymod->AddJetCorr(path + "Summer13_V1_DATA_L2Relative_AK5PF.txt");
mymod->AddJetCorr(path + "Summer13_V1_DATA_L3Absolute_AK5PF.txt");
mymod->AddJetCorr(path + "Summer13_V1_DATA_L2L3Residual_AK5PF.txt");
}
//
// SingleMu
// these are examples of triggers with trigger objects
mymod->AddTrigger("HLT_IsoMu24_eta2p1_v11", kHLT_IsoMu24_eta2p1, "hltL3crIsoL1sMu16Eta2p1L1f0L2f16QL3f24QL3crIsoFiltered10", kHLT_IsoMu24_eta2p1Obj);
mymod->AddTrigger("HLT_IsoMu24_eta2p1_v12", kHLT_IsoMu24_eta2p1, "hltL3crIsoL1sMu16Eta2p1L1f0L2f16QL3f24QL3crIsoFiltered10", kHLT_IsoMu24_eta2p1Obj);
mymod->AddTrigger("HLT_IsoMu24_eta2p1_v13", kHLT_IsoMu24_eta2p1, "hltL3crIsoL1sMu16Eta2p1L1f0L2f16QL3f24QL3crIsoRhoFiltered0p15", kHLT_IsoMu24_eta2p1Obj);
mymod->AddTrigger("HLT_IsoMu24_eta2p1_v14", kHLT_IsoMu24_eta2p1, "hltL3crIsoL1sMu16Eta2p1L1f0L2f16QL3f24QL3crIsoRhoFiltered0p15", kHLT_IsoMu24_eta2p1Obj);
mymod->AddTrigger("HLT_IsoMu24_eta2p1_v15", kHLT_IsoMu24_eta2p1, "hltL3crIsoL1sMu16Eta2p1L1f0L2f16QL3f24QL3crIsoRhoFiltered0p15", kHLT_IsoMu24_eta2p1Obj);
//
// SingleElectron
// these are examples of triggers with trigger objects
mymod->AddTrigger("HLT_Ele27_WP80_v8", kHLT_Ele27_WP80, "hltEle27WP80TrackIsoFilter", kHLT_Ele27_WP80Obj);
mymod->AddTrigger("HLT_Ele27_WP80_v9", kHLT_Ele27_WP80, "hltEle27WP80TrackIsoFilter", kHLT_Ele27_WP80Obj);
mymod->AddTrigger("HLT_Ele27_WP80_v10", kHLT_Ele27_WP80, "hltEle27WP80TrackIsoFilter", kHLT_Ele27_WP80Obj);
mymod->AddTrigger("HLT_Ele27_WP80_v11", kHLT_Ele27_WP80, "hltEle27WP80TrackIsoFilter", kHLT_Ele27_WP80Obj);
//
// DoubleMu
// and these are just triggers -- no object matching
mymod->AddTrigger("HLT_Mu17_TkMu8_v9", kHLT_Mu17_TkMu8);
mymod->AddTrigger("HLT_Mu17_TkMu8_v10", kHLT_Mu17_TkMu8);
mymod->AddTrigger("HLT_Mu17_TkMu8_v11", kHLT_Mu17_TkMu8);
mymod->AddTrigger("HLT_Mu17_TkMu8_v12", kHLT_Mu17_TkMu8);
mymod->AddTrigger("HLT_Mu17_TkMu8_v13", kHLT_Mu17_TkMu8);
mymod->AddTrigger("HLT_Mu17_TkMu8_v14", kHLT_Mu17_TkMu8);
//
// DoubleEle
// and these are just triggers -- no object matching
mymod->AddTrigger("HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v15", kHLT_Ele17_CaloIdL_CaloIsoVL);
mymod->AddTrigger("HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v16", kHLT_Ele17_CaloIdL_CaloIsoVL);
mymod->AddTrigger("HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v17", kHLT_Ele17_CaloIdL_CaloIsoVL);
mymod->AddTrigger("HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v18", kHLT_Ele17_CaloIdL_CaloIsoVL);
mymod->AddTrigger("HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v19", kHLT_Ele17_CaloIdL_CaloIsoVL);
mymod->SetPrintHLT(kFALSE); // print HLT table at start of analysis? good for debugging.. also lots of spam
ana->AddSuperModule(mymod);
//
// run analysis after successful initialisation
//
ana->Run(!gROOT->IsBatch());
}
//==================================================================================================
void runSCNtupler(
const char *file = "root://xrootd.cmsaf.mit.edu//store/user/paus/filefi/029/r12a-sel-j22-v1/00176847-0073-E211-9FFE-0030487DE7C5.root",
const char *output = "/scratch/klawhorn/test_scntuple.root",
Bool_t isData = kTRUE,
Int_t useGen = 0,
Int_t fsrmode = 0,
Int_t nevents = -1,
Bool_t skipHLTFail = kFALSE
)
{
gDebugMask = Debug::kAnalysis; // debug message category
gDebugLevel = 0xFFFFFFFF; // higher level allows more messages to print
// muon kinematics
const Double_t muPtMin = 0;
const Double_t muPtMax = 7000;
const Double_t muEtaMin = -3;
const Double_t muEtaMax = 3;
// electron kinematics
const Double_t eleEtMin = 9;
const Double_t eleEtMax = 7000;
const Double_t eleEtaMin = -3;
const Double_t eleEtaMax = 3;
// jet requirements
const Double_t jetPtMin = 10;
// SC requirements
const Double_t scEtMin = 9;
// good PV requirements
const UInt_t minNTracksFit = 0;
const Double_t minNdof = 4;
const Double_t maxAbsZ = 24;
const Double_t maxRho = 2;
//
// setup analysis object
//
Analysis *ana = new Analysis;
ana->SetUseHLT(kTRUE);
if(nevents>0)
ana->SetProcessNEvents(nevents);
ana->AddFile(file);
//
// setup ntupler module
//
SCNtuplerMod *mymod = new SCNtuplerMod;
mymod->SetOutputName(output); // output ntuple file name
mymod->SetIsData(isData); // toggle data specific or MC specific procedures
mymod->SetUseGen(useGen); // use generator info
mymod->SetSkipIfHLTFail(skipHLTFail); // skip to next event if no HLT accept
mymod->SetFSRMode(fsrmode);
mymod->SetMuPtMin(muPtMin);
mymod->SetMuPtMax(muPtMax);
mymod->SetMuEtaMin(muEtaMin);
mymod->SetMuEtaMax(muEtaMax);
mymod->SetEleEtMin(eleEtMin);
mymod->SetEleEtMax(eleEtMax);
mymod->SetEleEtaMin(eleEtaMin);
mymod->SetEleEtaMax(eleEtaMax);
mymod->SetJetPtMin(jetPtMin);
mymod->SetSCEtMin(scEtMin);
mymod->SetMinNTracksFit(minNTracksFit);
mymod->SetMinNdof(minNdof);
mymod->SetMaxAbsZ(maxAbsZ);
mymod->SetMaxRho(maxRho);
// Jet corrections
char* PATH = getenv("CMSSW_BASE"); assert(PATH);
TString path(TString::Format("%s/src/MitPhysics/data/", PATH));
mymod->AddJetCorr(path+"Summer13_V1_MC_L1FastJet_AK5PF.txt");
mymod->AddJetCorr(path+"Summer13_V1_MC_L2Relative_AK5PF.txt");
mymod->AddJetCorr(path+"Summer13_V1_MC_L3Absolute_AK5PF.txt");
if(isData) {
mymod->AddJetCorr(path+"Summer13_V1_DATA_L1FastJet_AK5PF.txt");
mymod->AddJetCorr(path+"Summer13_V1_DATA_L2Relative_AK5PF.txt");
mymod->AddJetCorr(path+"Summer13_V1_DATA_L3Absolute_AK5PF.txt");
mymod->AddJetCorr(path+"Summer13_V1_DATA_L2L3Residual_AK5PF.txt");
}
//
// SingleMu
//
mymod->AddTrigger("HLT_IsoMu24_eta2p1_v11", kHLT_IsoMu24_eta2p1, "hltL3crIsoL1sMu16Eta2p1L1f0L2f16QL3f40QL3crIsoFiltered10", kHLT_IsoMu24_eta2p1Obj);
mymod->AddTrigger("HLT_IsoMu24_eta2p1_v12", kHLT_IsoMu24_eta2p1, "hltL3crIsoL1sMu16Eta2p1L1f0L2f16QL3f40QL3crIsoFiltered10", kHLT_IsoMu24_eta2p1Obj);
mymod->AddTrigger("HLT_IsoMu24_eta2p1_v13", kHLT_IsoMu24_eta2p1, "hltL3crIsoL1sMu16Eta2p1L1f0L2f16QL3f24QL3crIsoRhoFiltered0p15", kHLT_IsoMu24_eta2p1Obj);
mymod->AddTrigger("HLT_IsoMu24_eta2p1_v14", kHLT_IsoMu24_eta2p1, "hltL3crIsoL1sMu16Eta2p1L1f0L2f16QL3f24QL3crIsoRhoFiltered0p15", kHLT_IsoMu24_eta2p1Obj);
mymod->AddTrigger("HLT_IsoMu24_eta2p1_v15", kHLT_IsoMu24_eta2p1, "hltL3crIsoL1sMu16Eta2p1L1f0L2f16QL3f24QL3crIsoRhoFiltered0p15", kHLT_IsoMu24_eta2p1Obj);
//
// SingleElectron
//
mymod->AddTrigger("HLT_Ele27_WP80_v8", kHLT_Ele27_WP80, "hltEle27WP80TrackIsoFilter", kHLT_Ele27_WP80Obj);
mymod->AddTrigger("HLT_Ele27_WP80_v9", kHLT_Ele27_WP80, "hltEle27WP80TrackIsoFilter", kHLT_Ele27_WP80Obj);
mymod->AddTrigger("HLT_Ele27_WP80_v10", kHLT_Ele27_WP80, "hltEle27WP80TrackIsoFilter", kHLT_Ele27_WP80Obj);
mymod->AddTrigger("HLT_Ele27_WP80_v11", kHLT_Ele27_WP80, "hltEle27WP80TrackIsoFilter", kHLT_Ele27_WP80Obj);
//
// DoubleMu
//
mymod->AddTrigger("HLT_Mu17_TkMu8_v9", kHLT_Mu17_TkMu8);
mymod->AddTrigger("HLT_Mu17_TkMu8_v10", kHLT_Mu17_TkMu8);
mymod->AddTrigger("HLT_Mu17_TkMu8_v11", kHLT_Mu17_TkMu8);
mymod->AddTrigger("HLT_Mu17_TkMu8_v12", kHLT_Mu17_TkMu8);
mymod->AddTrigger("HLT_Mu17_TkMu8_v13", kHLT_Mu17_TkMu8);
mymod->AddTrigger("HLT_Mu17_TkMu8_v14", kHLT_Mu17_TkMu8);
//
// DoubleEle
//
mymod->AddTrigger("HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v15", kHLT_Ele17_CaloIdL_CaloIsoVL);
mymod->AddTrigger("HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v16", kHLT_Ele17_CaloIdL_CaloIsoVL);
mymod->AddTrigger("HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v17", kHLT_Ele17_CaloIdL_CaloIsoVL);
mymod->AddTrigger("HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v18", kHLT_Ele17_CaloIdL_CaloIsoVL);
mymod->AddTrigger("HLT_Ele17_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_Ele8_CaloIdT_CaloIsoVL_TrkIdVL_TrkIsoVL_v19", kHLT_Ele17_CaloIdL_CaloIsoVL);
mymod->SetPrintHLT(kFALSE); // print HLT table at start of analysis?
ana->AddSuperModule(mymod);
//
// run analysis after successful initialisation
//
ana->Run(!gROOT->IsBatch());
}
//--------------------------------------------------------------------------------------------------
void runMonoJetSkim(const char *fileset = "0000",
const char *skim = "noskim",
const char *dataset = "MET+Run2015B-PromptReco-v1+AOD",
const char *book = "t2mit/filefi/041",
const char *catalogDir = "/home/cmsprod/catalog",
const char *outputLabel = "monojet",
int nEvents = 1000)
{
float maxJetEta = 2.5;
float minMet = 100.;
float minLeadJetPt = 100.;
//------------------------------------------------------------------------------------------------
// 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;
}
Bool_t isData = (json != "~");
TString MitData(gSystem->Getenv("MIT_DATA"));
if (MitData.Length() == 0) {
printf(" MIT_DATA was not defined. EXIT!\n");
return;
}
TString jsonDir(gSystem->Getenv("MIT_JSON_DIR"));
if (jsonDir.Length() == 0) {
printf(" MIT_JSON_DIR was not defined. EXIT!\n");
return;
}
printf("\n Initialization worked: \n\n");
printf(" JSON : %s\n", json.Data());
printf(" isData : %d\n\n",isData);
//------------------------------------------------------------------------------------------------
// some global setups
//------------------------------------------------------------------------------------------------
using namespace mithep;
gDebugMask = Debug::kGeneral;
gDebugLevel = 3;
//------------------------------------------------------------------------------------------------
// set up information
//------------------------------------------------------------------------------------------------
std::vector<mithep::BaseMod*> modules;
if (isData) {
RunLumiSelectionMod* runLumiSel = new RunLumiSelectionMod;
// only select on run- and lumisection numbers when valid json file present
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
}
else if (json.CompareTo("~") != 0) {
printf("\n Json file added: %s \n\n", json.Data());
runLumiSel->AddJSONFile((jsonDir + "/" + json).Data());
}
modules.push_back(runLumiSel);
}
//-----------------------------------------------------------------------------------------------------------
// HLT information : trigger not applied (neither for data nor for MC, store info to apply selection offline
//-----------------------------------------------------------------------------------------------------------
HLTMod *hltMod = new HLTMod();
// monojet triggers
std::vector<TString> triggerNames[MonoJetAnalysisMod::nMonoJetCategories];
triggerNames[MonoJetAnalysisMod::kSignal].push_back("HLT_PFMETNoMu120_NoiseCleaned_PFMHTNoMu120_IDTight_v*");
triggerNames[MonoJetAnalysisMod::kSignal].push_back("HLT_PFMETNoMu90_NoiseCleaned_PFMHTNoMu90_IDTight_v*");
triggerNames[MonoJetAnalysisMod::kSingleMuon].push_back("HLT_PFMETNoMu120_NoiseCleaned_PFMHTNoMu120_IDTight_v*");
triggerNames[MonoJetAnalysisMod::kSingleMuon].push_back("HLT_PFMETNoMu90_NoiseCleaned_PFMHTNoMu90_IDTight_v*");
triggerNames[MonoJetAnalysisMod::kSingleMuon].push_back("HLT_IsoMu27_v*");
triggerNames[MonoJetAnalysisMod::kDimuon].push_back("HLT_PFMETNoMu120_NoiseCleaned_PFMHTNoMu120_IDTight_v*");
triggerNames[MonoJetAnalysisMod::kDimuon].push_back("HLT_PFMETNoMu90_NoiseCleaned_PFMHTNoMu90_IDTight_v*");
triggerNames[MonoJetAnalysisMod::kDimuon].push_back("HLT_Mu17_TrkIsoVVL_Mu8_TrkIsoVVL_DZ_v*");
triggerNames[MonoJetAnalysisMod::kSingleElectron].push_back("HLT_Ele27_eta2p1_WPLoose_Gsf_v*");
triggerNames[MonoJetAnalysisMod::kDielectron].push_back("HLT_Ele17_Ele12_CaloIdL_TrackIdL_IsoVL_DZ_v*");
triggerNames[MonoJetAnalysisMod::kPhoton].push_back("HLT_Photon175_v*");
for (auto& names : triggerNames) {
for (auto& name : names)
hltMod->AddTrigger(name);
}
hltMod->SetBitsName("HLTBits");
hltMod->SetTrigObjsName("MonoJetTriggerObjects");
hltMod->SetAbortIfNotAccepted(isData);
hltMod->SetAbortIfNoData(kFALSE);
modules.push_back(hltMod);
//------------------------------------------------------------------------------------------------
// 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->SetVertexesName("PrimaryVertexes");
modules.push_back(goodPvMod);
//------------------------------------------------------------------------------------------------
// split pfcandidates to PFPU and PFnoPU
//------------------------------------------------------------------------------------------------
SeparatePileUpMod* SepPUMod = new SeparatePileUpMod;
SepPUMod->SetPFNoPileUpName("pfnopileupcands");
SepPUMod->SetPFPileUpName("pfpileupcands");
SepPUMod->SetCheckClosestZVertex(kFALSE);
modules.push_back(SepPUMod);
//-----------------------------------
// Lepton Selection
//-----------------------------------
MuonIdMod *vetoMuonIdMod = new MuonIdMod("VetoMuonId");
vetoMuonIdMod->SetMuonClassType(mithep::MuonTools::kPFGlobalorTracker);
vetoMuonIdMod->SetIdType(mithep::MuonTools::kNoId);
vetoMuonIdMod->SetPFNoPileupCandidatesName(SepPUMod->GetPFNoPileUpName());
vetoMuonIdMod->SetPFPileupCandidatesName(SepPUMod->GetPFPileUpName());
vetoMuonIdMod->SetIsoType(mithep::MuonTools::kPFIsoBetaPUCorrected);
vetoMuonIdMod->SetApplyD0Cut(kTRUE);
vetoMuonIdMod->SetApplyDZCut(kTRUE);
vetoMuonIdMod->SetWhichVertex(0);
vetoMuonIdMod->SetPtMin(10.);
vetoMuonIdMod->SetEtaMax(2.4);
vetoMuonIdMod->SetOutputName("VetoMuons");
modules.push_back(vetoMuonIdMod);
MuonIdMod *muonIdMod = new MuonIdMod("GoodMuonId");
muonIdMod->SetInputName(vetoMuonIdMod->GetOutputName());
muonIdMod->SetMuonClassType(mithep::MuonTools::kPFGlobalorTracker);
muonIdMod->SetIdType(mithep::MuonTools::kMuonPOG2012CutBasedIdTight);
muonIdMod->SetPFNoPileupCandidatesName(SepPUMod->GetPFNoPileUpName());
muonIdMod->SetPFPileupCandidatesName(SepPUMod->GetPFPileUpName());
muonIdMod->SetIsoType(mithep::MuonTools::kPFIsoBetaPUCorrectedTight);
muonIdMod->SetApplyD0Cut(kTRUE);
muonIdMod->SetApplyDZCut(kTRUE);
muonIdMod->SetWhichVertex(0);
muonIdMod->SetPtMin(20.);
muonIdMod->SetEtaMax(2.4);
muonIdMod->SetIsFilterMode(kFALSE);
muonIdMod->SetOutputName("GoodMuons");
modules.push_back(muonIdMod);
ElectronIdMod* vetoEleIdMod = new ElectronIdMod("VetoElectronId");
vetoEleIdMod->SetPtMin(10.);
vetoEleIdMod->SetEtaMax(2.4);
vetoEleIdMod->SetApplyEcalFiducial(true);
vetoEleIdMod->SetIdType(mithep::ElectronTools::kPhys14Veto);
vetoEleIdMod->SetIsoType(mithep::ElectronTools::kPhys14VetoIso);
vetoEleIdMod->SetConversionsName("Conversions");
vetoEleIdMod->SetApplyConversionFilterType1(kTRUE);
vetoEleIdMod->SetApplyConversionFilterType2(kFALSE);
vetoEleIdMod->SetApplyD0Cut(kTRUE);
vetoEleIdMod->SetApplyDZCut(kTRUE);
vetoEleIdMod->SetWhichVertex(0);
vetoEleIdMod->SetOutputName("VetoElectrons");
modules.push_back(vetoEleIdMod);
ElectronIdMod* eleIdMod = new ElectronIdMod("GoodElectronId");
eleIdMod->SetInputName(vetoEleIdMod->GetOutputName());
eleIdMod->SetPtMin(20.);
eleIdMod->SetEtaMax(2.4);
eleIdMod->SetApplyEcalFiducial(true);
eleIdMod->SetIdType(mithep::ElectronTools::kPhys14Medium);
eleIdMod->SetIsoType(mithep::ElectronTools::kPhys14MediumIso);
eleIdMod->SetConversionsName("Conversions");
eleIdMod->SetApplyConversionFilterType1(kTRUE);
eleIdMod->SetApplyConversionFilterType2(kFALSE);
eleIdMod->SetApplyD0Cut(kTRUE);
eleIdMod->SetApplyDZCut(kTRUE);
eleIdMod->SetWhichVertex(0);
eleIdMod->SetIsFilterMode(kFALSE);
eleIdMod->SetOutputName("GoodElectrons");
modules.push_back(eleIdMod);
//-----------------------------------
// Photon Id
//-----------------------------------
PhotonIdMod *vetoPhotonIdMod = new PhotonIdMod("VetoPhotonId");
vetoPhotonIdMod->SetPtMin(15.);
vetoPhotonIdMod->SetOutputName("VetoPhotons");
vetoPhotonIdMod->SetIdType(mithep::PhotonTools::kPhys14Loose);
vetoPhotonIdMod->SetIsoType(mithep::PhotonTools::kPhys14LooseIso);
vetoPhotonIdMod->SetApplyElectronVeto(kTRUE);
modules.push_back(vetoPhotonIdMod);
PhotonIdMod *photonIdMod = new PhotonIdMod("GoodPhotonId");
photonIdMod->SetInputName(vetoPhotonIdMod->GetOutputName());
photonIdMod->SetPtMin(minMet);
photonIdMod->SetOutputName("GoodPhotons");
photonIdMod->SetIdType(mithep::PhotonTools::kPhys14Medium);
photonIdMod->SetIsoType(mithep::PhotonTools::kPhys14MediumIso);
photonIdMod->SetApplyElectronVeto(kTRUE);
photonIdMod->SetIsFilterMode(kFALSE);
modules.push_back(photonIdMod);
PFTauIdMod *pfTauIdMod = new PFTauIdMod;
pfTauIdMod->SetPtMin(18.);
pfTauIdMod->SetEtaMax(2.3);
pfTauIdMod->SetInputName("HPSTaus");
pfTauIdMod->AddDiscriminator(mithep::PFTau::kDiscriminationByDecayModeFindingNewDMs);
pfTauIdMod->AddCutDiscriminator(mithep::PFTau::kDiscriminationByRawCombinedIsolationDBSumPtCorr3Hits, 5., kFALSE);
pfTauIdMod->SetOutputName("LooseTaus");
modules.push_back(pfTauIdMod);
PFTauCleaningMod* pfTauCleaningMod = new PFTauCleaningMod;
pfTauCleaningMod->SetOutputName("LooseCleanTaus");
pfTauCleaningMod->SetGoodPFTausName(pfTauIdMod->GetOutputName());
pfTauCleaningMod->SetCleanElectronsName(vetoEleIdMod->GetOutputName());
pfTauCleaningMod->SetCleanMuonsName(vetoMuonIdMod->GetOutputName());
modules.push_back(pfTauCleaningMod);
// in principle can cut here with nTau == 0 but for now passing
JetCorrectionMod *jetCorr = new JetCorrectionMod;
if (isData){
jetCorr->AddCorrectionFromFile((MitData+TString("/74X_dataRun2_Prompt_v1_L1FastJet_AK4PFchs.txt")).Data());
jetCorr->AddCorrectionFromFile((MitData+TString("/74X_dataRun2_Prompt_v1_L2Relative_AK4PFchs.txt")).Data());
jetCorr->AddCorrectionFromFile((MitData+TString("/74X_dataRun2_Prompt_v1_L3Absolute_AK4PFchs.txt")).Data());
jetCorr->AddCorrectionFromFile((MitData+TString("/74X_dataRun2_Prompt_v1_L2L3Residual_AK4PFchs.txt")).Data());
}
else {
jetCorr->AddCorrectionFromFile((MitData+TString("/MCRUN2_74_V9_L1FastJet_AK4PFchs.txt")).Data());
jetCorr->AddCorrectionFromFile((MitData+TString("/MCRUN2_74_V9_L2Relative_AK4PFchs.txt")).Data());
jetCorr->AddCorrectionFromFile((MitData+TString("/MCRUN2_74_V9_L3Absolute_AK4PFchs.txt")).Data());
}
jetCorr->SetInputName("AKt4PFJetsCHS");
jetCorr->SetCorrectedName("CorrectedJets");
modules.push_back(jetCorr);
JetIdMod *jetId = new JetIdMod;
jetId->SetInputName(jetCorr->GetOutputName());
jetId->SetOutputName("GoodJets");
jetId->SetPtMin(30.0);
jetId->SetEtaMax(2.5);
jetId->SetApplyPFLooseId(kTRUE);
jetId->SetMVATrainingSet(JetIDMVA::k53BDTCHSFullPlusRMS);
jetId->SetMVACutWP(JetIDMVA::kLoose);
jetId->SetMVACutsFile(MitData + "/jetIDCuts_121221.dat");
jetId->SetMVAWeightsFile(MitData + "/TMVAClassification_5x_BDT_chsFullPlusRMS.weights.xml");
modules.push_back(jetId);
MetCorrectionMod *type1MetCorr = new MetCorrectionMod;
type1MetCorr->SetInputName("PFMet");
type1MetCorr->SetOutputName("PFType1CorrectedMet");
type1MetCorr->SetJetsName("AKt4PFJets");
type1MetCorr->SetRhoAlgo(PileupEnergyDensity::kFixedGridFastjetAll);
type1MetCorr->SetMaxEMFraction(0.9);
type1MetCorr->SetSkipMuons(kTRUE);
type1MetCorr->ApplyType0(kFALSE);
type1MetCorr->ApplyType1(kTRUE);
type1MetCorr->ApplyShift(kFALSE);
if (isData) {
type1MetCorr->AddJetCorrectionFromFile(MitData + "/74X_dataRun2_Prompt_v1_L1FastJet_AK4PF.txt");
type1MetCorr->AddJetCorrectionFromFile(MitData + "/74X_dataRun2_Prompt_v1_L2Relative_AK4PF.txt");
type1MetCorr->AddJetCorrectionFromFile(MitData + "/74X_dataRun2_Prompt_v1_L3Absolute_AK4PF.txt");
type1MetCorr->AddJetCorrectionFromFile(MitData + "/74X_dataRun2_Prompt_v1_L2L3Residual_AK4PF.txt");
}
else {
type1MetCorr->AddJetCorrectionFromFile(MitData + "/MCRUN2_74_V9_L1FastJet_AK4PF.txt");
type1MetCorr->AddJetCorrectionFromFile(MitData + "/MCRUN2_74_V9_L2Relative_AK4PF.txt");
type1MetCorr->AddJetCorrectionFromFile(MitData + "/MCRUN2_74_V9_L3Absolute_AK4PF.txt");
}
type1MetCorr->IsData(isData);
modules.push_back(type1MetCorr);
//------------------------------------------------------------------------------------------------
// select events
//------------------------------------------------------------------------------------------------
MonoJetAnalysisMod *monojetSel = new MonoJetAnalysisMod("MonoJetSelector");
monojetSel->SetMetName(type1MetCorr->GetOutputName());
monojetSel->SetJetsName(jetId->GetOutputName());
monojetSel->SetVetoElectronsName(vetoEleIdMod->GetOutputName());
monojetSel->SetElectronMaskName(eleIdMod->GetOutputName());
monojetSel->SetVetoMuonsName(vetoMuonIdMod->GetOutputName());
monojetSel->SetMuonMaskName(muonIdMod->GetOutputName());
monojetSel->SetVetoTausName(pfTauCleaningMod->GetOutputName());
monojetSel->SetVetoPhotonsName(vetoPhotonIdMod->GetOutputName());
monojetSel->SetPhotonMaskName(photonIdMod->GetOutputName());
monojetSel->SetCategoryFlagsName("MonoJetEventCategories");
// Using uniform setup for all categories
for (unsigned iCat = 0; iCat != MonoJetAnalysisMod::nMonoJetCategories; ++iCat) {
monojetSel->SetCategoryActive(iCat, kTRUE);
for (auto& name : triggerNames[iCat])
monojetSel->AddTriggerName(iCat, name);
monojetSel->SetMaxNumJets(iCat, 0xffffffff);
monojetSel->SetMaxJetEta(iCat, maxJetEta);
monojetSel->SetMinChargedHadronFrac(iCat, 0.2);
monojetSel->SetMaxNeutralHadronFrac(iCat, 0.7);
monojetSel->SetMaxNeutralEmFrac(iCat, 0.7);
monojetSel->SetIgnoreTrigger(!isData);
switch (iCat) {
case MonoJetAnalysisMod::kDielectron:
case MonoJetAnalysisMod::kDimuon:
monojetSel->SetMinNumJets(iCat, 0);
monojetSel->SetMinMetPt(iCat, 0.);
monojetSel->SetVetoPhotons(iCat, false);
break;
default:
monojetSel->SetMinNumJets(iCat, 1);
monojetSel->SetMinLeadJetPt(iCat, minLeadJetPt);
monojetSel->SetMinMetPt(iCat, minMet);
break;
}
}
modules.push_back(monojetSel);
//------------------------------------------------------------------------------------------------
// 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->Keep("*");
skimOutput->Drop("L1TechBits*");
skimOutput->Drop("L1AlgoBits*");
skimOutput->Drop("MCVertexes");
skimOutput->Drop("PFEcal*SuperClusters");
skimOutput->Drop("*Tracks");
skimOutput->Drop("StandaloneMuonTracksWVtxConstraint");
skimOutput->Drop("PrimaryVertexesBeamSpot");
skimOutput->Drop("InclusiveSecondaryVertexes");
skimOutput->Drop("CosmicMuons");
skimOutput->Drop("MergedElectronsStable");
skimOutput->Drop("MergedConversions*");
skimOutput->Drop("AKT8GenJets");
skimOutput->Drop("AKt4PFJets");
skimOutput->Drop("DCASig");
skimOutput->AddNewBranch(type1MetCorr->GetOutputName());
skimOutput->AddNewBranch(monojetSel->GetCategoryFlagsName());
skimOutput->SetMaxFileSize(10 * 1024); // 10 GB - should never exceed
skimOutput->SetFileName(outputName);
skimOutput->SetPathName(".");
skimOutput->SetCheckTamBr(false);
skimOutput->SetKeepTamBr(false);
skimOutput->SetCheckBrDep(true);
skimOutput->SetUseBrDep(true);
skimOutput->AddCondition(monojetSel);
//------------------------------------------------------------------------------------------------
// making the analysis chain
//------------------------------------------------------------------------------------------------
auto mItr(modules.begin());
while (true) {
auto* mod = *(mItr++);
if (mItr == modules.end())
break;
mod->Add(*mItr);
}
//------------------------------------------------------------------------------------------------
// setup analysis
//------------------------------------------------------------------------------------------------
Analysis *ana = new Analysis;
ana->SetUseCacher(1);
ana->SetUseHLT(kTRUE);
ana->SetAllowNoHLTTree(kTRUE); // for private MC with no HLT info
ana->SetKeepHierarchy(kFALSE);
ana->SetPrintScale(100);
ana->SetOutputName(outputName + "_hist.root");
if (nEvents >= 0)
ana->SetProcessNEvents(nEvents);
ana->AddSuperModule(modules.front());
ana->AddOutputMod(skimOutput);
//------------------------------------------------------------------------------------------------
// 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);
//------------------------------------------------------------------------------------------------
// Say what we are doing
//------------------------------------------------------------------------------------------------
printf("\n==== PARAMETER SUMMARY FOR THIS JOB ====\n");
printf("\n JSON file: %s\n", json.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");
std::cout << std::endl;
std::cout << "+++++ ANALYSIS FLOW +++++" << std::endl;
ana->PrintModuleTree();
std::cout << std::endl;
std::cout << "+++++++++++++++++++++++++" << std::endl;
//------------------------------------------------------------------------------------------------
// 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;
}
