//-------------------------------------------------------------------------------------------------- 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 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; }