lbfgsfloatval_t RAE::decay()
{
lbfgsfloatval_t val = 0;
for(int row = 0; row < weights1.rows(); row++)
{
for(int col = 0; col < weights1.cols(); col++)
{
val += pow(weights1(row, col), 2)/2;
val += pow(weights2(col, row), 2)/2;
}
}
for(int col = 0; col < weights_b1.cols(); col++)
{
val += pow(weights_b1(0, col), 2)/2;
}
for(int col = 0; col < weights_b2.cols(); col++)
{
val += pow(weights_b2(0, col), 2)/2;
}
return val;
}
GPU_PERF_TEST(BlendLinear, cv::gpu::DeviceInfo, cv::Size, MatType)
{
cv::gpu::DeviceInfo devInfo = GET_PARAM(0);
cv::gpu::setDevice(devInfo.deviceID());
cv::Size size = GET_PARAM(1);
int type = GET_PARAM(2);
cv::Mat img1_host(size, type);
fill(img1_host, 0, 255);
cv::Mat img2_host(size, type);
fill(img2_host, 0, 255);
cv::gpu::GpuMat img1(img1_host);
cv::gpu::GpuMat img2(img2_host);
cv::gpu::GpuMat weights1(size, CV_32FC1, cv::Scalar::all(0.5));
cv::gpu::GpuMat weights2(size, CV_32FC1, cv::Scalar::all(0.5));
cv::gpu::GpuMat dst;
cv::gpu::blendLinear(img1, img2, weights1, weights2, dst);
TEST_CYCLE()
{
cv::gpu::blendLinear(img1, img2, weights1, weights2, dst);
}
}
OCL_PERF_TEST_P(BlendLinearFixture, BlendLinear, ::testing::Combine(OCL_TEST_SIZES, OCL_TEST_TYPES_134))
{
Size_MatType_t params = GetParam();
const Size srcSize = get<0>(params);
const int srcType = get<1>(params);
const double eps = CV_MAT_DEPTH(srcType) <= CV_32S ? 1.0 : 0.2;
checkDeviceMaxMemoryAllocSize(srcSize, srcType);
UMat src1(srcSize, srcType), src2(srcSize, srcType), dst(srcSize, srcType);
UMat weights1(srcSize, CV_32FC1), weights2(srcSize, CV_32FC1);
declare.in(src1, src2, WARMUP_RNG).in(weights1, weights2, WARMUP_READ).out(dst);
randu(weights1, 0, 1);
randu(weights2, 0, 1);
OCL_TEST_CYCLE() cv::blendLinear(src1, src2, weights1, weights2, dst);
SANITY_CHECK(dst, eps);
}
void RAE::loadWeights(Parameter* para)
{
string filename;
if(RAEType == SL)
{
filename = para->getPara("srcRAEWeightsLogFile");
}
else
{
filename = para->getPara("tgtRAEWeightsLogFile");
}
ifstream in(filename.c_str(), ios::in);
bool rae_w1 = false;
bool rae_b1 = false;
bool rae_w2 = false;
bool rae_b2 = false;
int row = 0;
string line;
while(getline(in, line))
{
if(line.find("W1") == 0)
{
row = 0;
rae_w1 = true;
continue;
}
if(line.find("W2") == 0)
{
row = 0;
rae_b1 = false;
rae_w2 = true;
continue;
}
if(line.find("B1") == 0)
{
row = 0;
rae_w1 = false;
rae_b1 = true;
continue;
}
if(line.find("B2") == 0)
{
row = 0;
rae_w2 = false;
rae_b2 = true;
continue;
}
if(rae_w1)
{
stringstream ss(line);
for(int col = 0; col < weights1.cols(); col++)
{
ss >> weights1(row, col);
}
}
if(rae_w2)
{
stringstream ss(line);
for(int col = 0; col < weights2.cols(); col++)
{
ss >> weights2(row, col);
}
}
if(rae_b2)
{
stringstream ss(line);
for(int col = 0; col < weights_b2.cols(); col++)
{
ss >> weights_b2(row, col);
}
}
if(rae_b1)
{
stringstream ss(line);
for(int col = 0; col < weights_b1.cols(); col++)
{
ss >> weights_b1(row, col);
}
}
row++;
}
}
void formatBoostedResonanceDataBkgPlots(const string& inputVersion, const string& outputVersion,
const string& MTBin, const unsigned int firstBinToBlind,
const string& HLTPath, const bool doNoHPSIsoCut = false)
{
//initial
gROOT->Reset();
//get CMSSW path
const char* CMSSWPathCString = gSystem->Getenv("CMSSW_BASE");
if (!CMSSWPathCString) {
CMSSWPathCString = "";
cout << "Error: environment variable CMSSW_BASE is not set. ";
cout << "Please run cmsenv from within your CMSSW project area.\n";
}
string CMSSWPathCPPString(CMSSWPathCString);
//load
string macroPath(CMSSWPathCPPString + "/src/BoostedTauAnalysis/TauAnalyzer/test/");
gROOT->ProcessLine("#include <utility>");
gSystem->Load((macroPath + "STLDictionary.so").c_str());
gSystem->Load((macroPath + "Miscellaneous_C.so").c_str());
gSystem->Load((macroPath + "Error_C.so").c_str());
gSystem->Load((macroPath + "Plot_C.so").c_str());
//ignore warnings
gErrorIgnoreLevel = kError;
//needed so vector<Color_t> and vector<Style_t> work
vector<short> dummy;
//set up canvas and graph names and blinded bins for data
vector<string> canvasNames1D;
canvasNames1D.push_back("hadTauAssociatedMuMultiplicityCanvas");
canvasNames1D.push_back("muHadMassCanvas");
canvasNames1D.push_back("muHadMassZMuCanvas");
canvasNames1D.push_back("muHadMassZTauMuCanvas");
canvasNames1D.push_back("muHadMassOtherTauMuCanvas");
canvasNames1D.push_back("muHadMassMuElseCanvas");
canvasNames1D.push_back("muHadMassNotMuElseCanvas");
canvasNames1D.push_back("muHadMass1ProngCanvas");
canvasNames1D.push_back("muHadMass1Prong1Pi0Canvas");
canvasNames1D.push_back("muHadMass1Prong2Pi0Canvas");
canvasNames1D.push_back("muHadMass3ProngCanvas");
canvasNames1D.push_back("muHadMass3MuShareTrackCanvas");
canvasNames1D.push_back("muHadMass3MuSoftMuCanvas");
canvasNames1D.push_back("muHadMass3MuSoftMu5GeVCanvas");
canvasNames1D.push_back("muHadMass3MuSoftMu15GeVCanvas");
canvasNames1D.push_back("muHadMass3MuSoftMu20GeVCanvas");
canvasNames1D.push_back("muHadMassReweightErrSqCanvas");
canvasNames1D.push_back("muHadChargeCanvas");
canvasNames1D.push_back("muHadDdxyCanvas");
canvasNames1D.push_back("muHadDdzCanvas");
canvasNames1D.push_back("WMuPVdzCanvas");
canvasNames1D.push_back("muPVdzCanvas");
canvasNames1D.push_back("hadPVdzCanvas");
canvasNames1D.push_back("METCanvas");
canvasNames1D.push_back("bTagDiscrimCanvas");
canvasNames1D.push_back("WMuIsoCanvas");
canvasNames1D.push_back("WMuMTCanvas");
canvasNames1D.push_back("tauMuMTCanvas");
canvasNames1D.push_back("tauHadMTCanvas");
canvasNames1D.push_back("dPhiWMuMETCanvas");
canvasNames1D.push_back("dPhiTauMuMETCanvas");
canvasNames1D.push_back("tauMuTauHadJetHTCanvas");
canvasNames1D.push_back("diJetHTCanvas");
canvasNames1D.push_back("jetTauJetHTCanvas");
canvasNames1D.push_back("tauMuTauHadJetWMuHTCanvas");
canvasNames1D.push_back("tauMuTauHadJetWMuMETHTCanvas");
canvasNames1D.push_back("diJetWMuHTCanvas");
canvasNames1D.push_back("jetTauJetWMuHTCanvas");
canvasNames1D.push_back("dRSoftMuTauHadCanvas");
canvasNames1D.push_back("HPTCanvas");
canvasNames1D.push_back("tauMuPTCanvas");
canvasNames1D.push_back("tauHadPTCanvas");
canvasNames1D.push_back("tauHadPT1ProngCanvas");
canvasNames1D.push_back("tauHadPT1Prong1Pi0Canvas");
canvasNames1D.push_back("tauHadPT1Prong2Pi0Canvas");
canvasNames1D.push_back("tauHadPT3ProngCanvas");
canvasNames1D.push_back("tauHadIsoCanvas");
canvasNames1D.push_back("WMuLeptonRelIsoCanvas");
canvasNames1D.push_back("tauHadEtaCanvas");
canvasNames1D.push_back("softMuPTOverMuHadMassCanvas");
canvasNames1D.push_back("muHadPTOverMuHadMassCanvas");
canvasNames1D.push_back("dRSoftMuNearestGenMuHistCanvas");
canvasNames1D.push_back("muHadPTCanvas");
canvasNames1D.push_back("muHadMultiplicityCanvas");
canvasNames1D.push_back("nGoodVtxCanvas");
canvasNames1D.push_back("mWMuTauMuCanvas");
canvasNames1D.push_back("PDGIDNearestStatus1GenParticleToSoftMuCanvas");
canvasNames1D.push_back("PDGIDMuSrcCanvas");
canvasNames1D.push_back("mSecondJetMuHadCanvas");
canvasNames1D.push_back("dPhiMuHadSecondJetCanvas");
canvasNames1D.push_back("muHadUncleanedJetPTRankCanvas");
canvasNames1D.push_back("nAddlHardMuonsCanvas");
canvasNames1D.push_back("nAddlJetsPTGeq20Canvas");
canvasNames1D.push_back("nAddlJetsPTGeq30Canvas");
canvasNames1D.push_back("nAddlJetsPTGeq40Canvas");
canvasNames1D.push_back("tauHadDecayModeCanvas");
canvasNames1D.push_back("dRSoftMuNearestGenZOrTTMuCanvas");
canvasNames1D.push_back("dRSoftMuNearestGenZOrTTMuFSRCanvas");
canvasNames1D.push_back("jet_pt_etacutCanvas");
canvasNames1D.push_back("jet_etaCanvas");
canvasNames1D.push_back("jet_phiCanvas");
canvasNames1D.push_back("jet_mass_etacutCanvas");
canvasNames1D.push_back("jet_ptmj_etacutCanvas");
canvasNames1D.push_back("muHad_t3t1Canvas");
canvasNames1D.push_back("muHad_t2t1Canvas");
canvasNames1D.push_back("muHad_t1t2Canvas");
canvasNames1D.push_back("muHad_t2t3Canvas");
canvasNames1D.push_back("muHad_t3t4Canvas");
canvasNames1D.push_back("muHad_t3t1_pT1020Canvas");
canvasNames1D.push_back("muHad_t3t1_pT2030Canvas");
canvasNames1D.push_back("muHad_t3t1_pT3040Canvas");
canvasNames1D.push_back("muHad_t3t1_pT4050Canvas");
canvasNames1D.push_back("muHad_t3t1_pT50UpCanvas");
canvasNames1D.push_back("muHad_t3t1_0JetsCanvas");
canvasNames1D.push_back("muHad_t3t1_1JetsCanvas");
canvasNames1D.push_back("muHad_t3t1_2JetsCanvas");
canvasNames1D.push_back("muHad_t3t1_3JetsCanvas");
canvasNames1D.push_back("muHad_t3t1_4JetsCanvas");
canvasNames1D.push_back("muHad_t3t1_5JetsCanvas");
canvasNames1D.push_back("muHad_t3t1_MoreJetsCanvas");
canvasNames1D.push_back("muHadNchtrk_0_Canvas");
canvasNames1D.push_back("muHadNchtrk_1_Canvas");
canvasNames1D.push_back("muHadNchtrk_10_Canvas");
canvasNames1D.push_back("muHadNchtrk_30_Canvas");
canvasNames1D.push_back("secondNchtrk_0_Canvas");
canvasNames1D.push_back("secondNchtrk_1_Canvas");
canvasNames1D.push_back("secondNchtrk_10_Canvas");
canvasNames1D.push_back("secondNchtrk_30_Canvas");
canvasNames1D.push_back("dRWMuSoftMuCanvas");
canvasNames1D.push_back("dRWMuTauHadCanvas");
canvasNames1D.push_back("dRTauMuTauHadCanvas");
canvasNames1D.push_back("dRWMuTauMuTauHadCanvas");
canvasNames1D.push_back("dPhiWMuSoftMuCanvas");
canvasNames1D.push_back("dPhiWMuSoftMuWithCutCanvas");
canvasNames1D.push_back("dPhiWMuSecJetCanvas");
canvasNames1D.push_back("WMu3rdTightMuChargeProductCanvas");
canvasNames1D.push_back("tauHadPhotonEnergyFractionCanvas");
canvasNames1D.push_back("dThetaPhotonOtherTauConstituentsCanvas");
canvasNames1D.push_back("hardestCorrJetEtaCanvas");
canvasNames1D.push_back("WMuPTCanvas");
vector<string> canvasNames2D;
canvasNames2D.push_back("muHadMassVsDRSoftMuTauCanvas");
canvasNames2D.push_back("tauHadIsoVsSoftMuPTCanvas");
canvasNames2D.push_back("cleanedJetPTVsCleanedTauPTCanvas");
canvasNames2D.push_back("uncleanedJetPTVsCleanedTauPTCanvas");
canvasNames2D.push_back("muHadMassVsSoftMuPTCanvas");
canvasNames2D.push_back("genMuExistsVsSoftMuNearestMuPropertiesCanvas");
canvasNames2D.push_back("muHadMassVsTauHadEtaCanvas");
canvasNames2D.push_back("muHadMassVsSoftMuEtaCanvas");
canvasNames2D.push_back("muHadMassVsTauHadIsoCanvas");
canvasNames2D.push_back("muHadMassVsTauHadPTCanvas");
canvasNames2D.push_back("tauHadIsoVsEtaCanvas");
canvasNames2D.push_back("tauHadEtaVsSoftMuEtaCanvas");
canvasNames2D.push_back("dEtaTauHadSoftMuVsDPhiTauHadSoftMuCanvas");
canvasNames2D.push_back("tauHadPTOverMuHadMassVsTauHadIsoCanvas");
canvasNames2D.push_back("softMuPTOverMuHadMassVsTauHadIsoCanvas");
canvasNames2D.push_back("avgTauHadSoftMuPTOverMuHadMassVsTauHadIsoCanvas");
canvasNames2D.push_back("muHadPTOverMuHadMassVsTauHadIsoCanvas");
canvasNames2D.push_back("WMuIsoVsTauHadIsoCanvas");
canvasNames2D.push_back("softMuPTVsTauHadPTCanvas");
canvasNames2D.push_back("muHadPTOverMuHadMassVsMWMuSoftMuCanvas");
canvasNames2D.push_back("softMuPFPTVsRECOPTCanvas");
canvasNames2D.push_back("softMuPFEtaVsRECOEtaCanvas");
canvasNames2D.push_back("mSecondJetMuHadVsMuHadMassCanvas");
canvasNames2D.push_back("muHadMassVsSecondJetMassCanvas");
canvasNames2D.push_back("muHadPTOverMVsSecondJetPTOverMCanvas");
canvasNames2D.push_back("muHadMassVsSecondJetPTOverMCanvas");
canvasNames2D.push_back("tauMuTauHadJetWMuHTVsMETCanvas");
canvasNames2D.push_back("mWMuTauMuVsMWMuTauMuTauHadCanvas");
canvasNames2D.push_back("mWMuTauMuVsMWMuTauMuTauHadGenFSRCanvas");
canvasNames2D.push_back("muHadMassVsMWMuTauMuTauHadCanvas");
canvasNames2D.push_back("WMuMTVsMETCanvas");
canvasNames2D.push_back("muHad_t3t1VsptmjCanvas");
canvasNames2D.push_back("muHad_t3t1VsDecayModeCanvas");
canvasNames2D.push_back("muHadMassVsNAddlJetsCanvas");
canvasNames2D.push_back("muHadMassVsCSVScoreCanvas");
canvasNames2D.push_back("muHadMassVsWMuMTCanvas");
canvasNames2D.push_back("tauHadJetEnergyFractionVsTauHadIsoCanvas");
canvasNames2D.push_back("tauHadCleanedJetEnergyFractionVsTauHadIsoCanvas");
canvasNames2D.push_back("mu1ProngMassVsMu1Prong1Pi0MassCanvas");
canvasNames2D.push_back("dPhiTauMuMETVsMuHadMassCanvas");
vector<string> graphNames1D;
graphNames1D.push_back("hadTauAssociatedMuMultiplicity");
graphNames1D.push_back("muHadMass");
graphNames1D.push_back("muHadMassZMu");
graphNames1D.push_back("muHadMassZTauMu");
graphNames1D.push_back("muHadMassOtherTauMu");
graphNames1D.push_back("muHadMassMuElse");
graphNames1D.push_back("muHadMassNotMuElse");
graphNames1D.push_back("muHadMass1Prong");
graphNames1D.push_back("muHadMass1Prong1Pi0");
graphNames1D.push_back("muHadMass1Prong2Pi0");
graphNames1D.push_back("muHadMass3Prong");
graphNames1D.push_back("muHadMass3MuShareTrack");
graphNames1D.push_back("muHadMass3MuSoftMu");
graphNames1D.push_back("muHadMass3MuSoftMu5GeV");
graphNames1D.push_back("muHadMass3MuSoftMu15GeV");
graphNames1D.push_back("muHadMass3MuSoftMu20GeV");
graphNames1D.push_back("muHadMassReweightErrSq");
graphNames1D.push_back("muHadCharge");
graphNames1D.push_back("muHadDdxy");
graphNames1D.push_back("muHadDdz");
graphNames1D.push_back("WMuPVdz");
graphNames1D.push_back("muPVdz");
graphNames1D.push_back("hadPVdz");
graphNames1D.push_back("MET");
graphNames1D.push_back("bTagDiscrim");
graphNames1D.push_back("WMuIso");
graphNames1D.push_back("WMuMT");
graphNames1D.push_back("tauMuMT");
graphNames1D.push_back("tauHadMT");
graphNames1D.push_back("dPhiWMuMET");
graphNames1D.push_back("dPhiTauMuMET");
graphNames1D.push_back("tauMuTauHadJetHT");
graphNames1D.push_back("diJetHT");
graphNames1D.push_back("jetTauJetHT");
graphNames1D.push_back("tauMuTauHadJetWMuHT");
graphNames1D.push_back("tauMuTauHadJetWMuMETHT");
graphNames1D.push_back("diJetWMuHT");
graphNames1D.push_back("jetTauJetWMuHT");
graphNames1D.push_back("dRSoftMuTauHad");
graphNames1D.push_back("HPT");
graphNames1D.push_back("tauMuPT");
graphNames1D.push_back("tauHadPT");
graphNames1D.push_back("tauHadPT1Prong");
graphNames1D.push_back("tauHadPT1Prong1Pi0");
graphNames1D.push_back("tauHadPT1Prong2Pi0");
graphNames1D.push_back("tauHadPT3Prong");
graphNames1D.push_back("tauHadIso");
graphNames1D.push_back("WMuLeptonRelIso");
graphNames1D.push_back("tauHadEta");
graphNames1D.push_back("softMuPTOverMuHadMass");
graphNames1D.push_back("muHadPTOverMuHadMass");
graphNames1D.push_back("dRSoftMuNearestGenMuHist");
graphNames1D.push_back("muHadPT");
graphNames1D.push_back("muHadMultiplicity");
graphNames1D.push_back("nGoodVtx");
graphNames1D.push_back("mWMuTauMu");
graphNames1D.push_back("PDGIDNearestStatus1GenParticleToSoftMu");
graphNames1D.push_back("PDGIDMuSrc");
graphNames1D.push_back("mSecondJetMuHad");
graphNames1D.push_back("dPhiMuHadSecondJet");
graphNames1D.push_back("muHadUncleanedJetPTRank");
graphNames1D.push_back("nAddlHardMuons");
graphNames1D.push_back("nAddlJetsPTGeq20");
graphNames1D.push_back("nAddlJetsPTGeq30");
graphNames1D.push_back("nAddlJetsPTGeq40");
graphNames1D.push_back("tauHadDecayMode");
graphNames1D.push_back("dRSoftMuNearestGenZOrTTMu");
graphNames1D.push_back("dRSoftMuNearestGenZOrTTMuFSR");
graphNames1D.push_back("jet_pt_etacut");
graphNames1D.push_back("jet_eta");
graphNames1D.push_back("jet_phi");
graphNames1D.push_back("jet_mass_etacut");
graphNames1D.push_back("jet_ptmj_etacut");
graphNames1D.push_back("muHad_t3t1");
graphNames1D.push_back("muHad_t2t1");
graphNames1D.push_back("muHad_t1t2");
graphNames1D.push_back("muHad_t2t3");
graphNames1D.push_back("muHad_t3t4");
graphNames1D.push_back("muHad_t3t1_pT1020");
graphNames1D.push_back("muHad_t3t1_pT2030");
graphNames1D.push_back("muHad_t3t1_pT3040");
graphNames1D.push_back("muHad_t3t1_pT4050");
graphNames1D.push_back("muHad_t3t1_pT50Up");
graphNames1D.push_back("muHad_t3t1_0Jets");
graphNames1D.push_back("muHad_t3t1_1Jets");
graphNames1D.push_back("muHad_t3t1_2Jets");
graphNames1D.push_back("muHad_t3t1_3Jets");
graphNames1D.push_back("muHad_t3t1_4Jets");
graphNames1D.push_back("muHad_t3t1_5Jets");
graphNames1D.push_back("muHad_t3t1_MoreJets");
graphNames1D.push_back("muHad_Nchtrk_0");
graphNames1D.push_back("muHad_Nchtrk_1");
graphNames1D.push_back("muHad_Nchtrk_10");
graphNames1D.push_back("muHad_Nchtrk_30");
graphNames1D.push_back("second_Nchtrk_0");
graphNames1D.push_back("second_Nchtrk_1");
graphNames1D.push_back("second_Nchtrk_10");
graphNames1D.push_back("second_Nchtrk_30");
graphNames1D.push_back("dRWMuSoftMu");
graphNames1D.push_back("dRWMuTauHad");
graphNames1D.push_back("dRTauMuTauHad");
graphNames1D.push_back("dRWMuTauMuTauHad");
graphNames1D.push_back("dPhiWMuSoftMu");
graphNames1D.push_back("dPhiWMuSoftMu_withCut");
graphNames1D.push_back("dPhiWMuSecJet");
graphNames1D.push_back("WMu3rdTightMuChargeProduct");
graphNames1D.push_back("tauHadPhotonEnergyFraction");
graphNames1D.push_back("dThetaPhotonOtherTauConstituents");
graphNames1D.push_back("hardestCorrJetEta");
graphNames1D.push_back("WMuPT");
vector<string> graphNames2D;
graphNames2D.push_back("muHadMassVsDRSoftMuTau");
graphNames2D.push_back("tauHadIsoVsSoftMuPT");
graphNames2D.push_back("cleanedJetPTVsCleanedTauPT");
graphNames2D.push_back("uncleanedJetPTVsCleanedTauPT");
graphNames2D.push_back("muHadMassVsSoftMuPT");
graphNames2D.push_back("genMuExistsVsSoftMuNearestMuProperties");
graphNames2D.push_back("muHadMassVsTauHadEta");
graphNames2D.push_back("muHadMassVsSoftMuEta");
graphNames2D.push_back("muHadMassVsTauHadIso");
graphNames2D.push_back("muHadMassVsTauHadPT");
graphNames2D.push_back("tauHadIsoVsEta");
graphNames2D.push_back("tauHadEtaVsSoftMuEta");
graphNames2D.push_back("dEtaTauHadSoftMuVsDPhiTauHadSoftMu");
graphNames2D.push_back("tauHadPTOverMuHadMassVsTauHadIso");
graphNames2D.push_back("softMuPTOverMuHadMassVsTauHadIso");
graphNames2D.push_back("avgTauHadSoftMuPTOverMuHadMassVsTauHadIso");
graphNames2D.push_back("muHadPTOverMuHadMassVsTauHadIso");
graphNames2D.push_back("WMuIsoVsTauHadIso");
graphNames2D.push_back("softMuPTVsTauHadPT");
graphNames2D.push_back("muHadPTOverMuHadMassVsMWMuSoftMu");
graphNames2D.push_back("softMuPFPTVsRECOPT");
graphNames2D.push_back("softMuPFEtaVsRECOEta");
graphNames2D.push_back("mSecondJetMuHadVsMuHadMass");
graphNames2D.push_back("muHadMassVsSecondJetMass");
graphNames2D.push_back("muHadPTOverMVsSecondJetPTOverM");
graphNames2D.push_back("muHadMassVsSecondJetPTOverM");
graphNames2D.push_back("tauMuTauHadJetWMuHTVsMET");
graphNames2D.push_back("mWMuTauMuVsMWMuTauMuTauHad");
graphNames2D.push_back("mWMuTauMuVsMWMuTauMuTauHadGenFSR");
graphNames2D.push_back("muHadMassVsMWMuTauMuTauHad");
graphNames2D.push_back("WMuMTVsMET");
graphNames2D.push_back("muHad_t3t1Vsptmj");
graphNames2D.push_back("muHad_t3t1VsDecayMode");
graphNames2D.push_back("muHadMassVsNAddlJets");
graphNames2D.push_back("muHadMassVsCSVScore");
graphNames2D.push_back("muHadMassVsWMuMT");
graphNames2D.push_back("tauHadJetEnergyFractionVsTauHadIso");
graphNames2D.push_back("tauHadCleanedJetEnergyFractionVsTauHadIso");
graphNames2D.push_back("mu1ProngMassVsMu1Prong1Pi0Mass");
graphNames2D.push_back("dPhiTauMuMETVsMuHadMass");
//blind the data mu+X mass histograms above 2 GeV
vector<Int_t> nullBlindLow(canvasNames1D.size(), 0);
vector<Int_t> nullBlindHigh(canvasNames1D.size(), -2);
vector<Int_t> dataBlindLow(canvasNames1D.size(), 0);
for (unsigned int iPlot = 1; iPlot <= 11; ++iPlot) { dataBlindLow[iPlot] = firstBinToBlind; }
vector<Int_t> dataBlindHigh(canvasNames1D.size(), -1);
//set up plot style options
vector<string> legendHeaders19p7InvFb(canvasNames1D.size(), "Normalized to 19.7 fb^{-1}");
vector<string> legendHeaders1(canvasNames1D.size(), "Normalized to 1");
vector<string> legendHeaders1DYJetsToLL(canvasNames1D.size(),
"Drell-Yan + jets normalized to 1");
vector<string> legendHeaders1TTJets(canvasNames1D.size(), "t#bar{t} + jets normalized to 1");
vector<string> legendHeaders1T(canvasNames1D.size(), "t/#bar{t} normalized to 1");
vector<string> legendHeaders1WNJetsToLNu(canvasNames1D.size(), "W + #geq1 jet normalized to 1");
vector<string> legendHeaders1WJetsToLNu(canvasNames1D.size(), "W + jets normalized to 1");
vector<string> legendHeaders1WZ(canvasNames1D.size(), "WZ normalized to 1");
vector<string> legendHeaders1ZZ(canvasNames1D.size(), "ZZ normalized to 1");
vector<string> legendHeaders1WW(canvasNames1D.size(), "WW normalized to 1");
vector<string> legendHeaders1NonIsoWData(canvasNames1D.size(),
"Non-isolated W data normalized to 1");
vector<Color_t> colorsMCData;
colorsMCData.push_back(kBlack); //data
colorsMCData.push_back(kMagenta + 2); //WW
colorsMCData.push_back(kCyan + 2); //ZZ
colorsMCData.push_back(kRed + 2); //WZ
colorsMCData.push_back(kYellow); //W + jets
colorsMCData.push_back(kViolet - 7); //single top
colorsMCData.push_back(kSpring + 4); //tt
colorsMCData.push_back(kBlue + 1); //Drell-Yan
colorsMCData.push_back(kGray + 2); //QCD
colorsMCData.push_back(kMagenta - 2);
colorsMCData.push_back(kGreen + 3);
colorsMCData.push_back(kRed);
vector<Color_t> colorsNonIsoWMCData;
colorsNonIsoWMCData.push_back(kBlack); //data
colorsNonIsoWMCData.push_back(kBlue + 1); //Drell-Yan
colorsNonIsoWMCData.push_back(kSpring + 4); //tt
colorsNonIsoWMCData.push_back(kYellow); //W + jets
vector<Style_t> styles;
styles.push_back(20); //data
styles.push_back(21); //WW
styles.push_back(22); //ZZ
styles.push_back(23); //WZ
styles.push_back(24); //W + jets
styles.push_back(25); //single top
styles.push_back(26); //tt
styles.push_back(27); //Drell-Yan
styles.push_back(28); //QCD
styles.push_back(29);
styles.push_back(30);
styles.push_back(31);
styles.push_back(32);
styles.push_back(33);
styles.push_back(34);
vector<string> legendEntriesMCData;
legendEntriesMCData.push_back("Data 19.7 fb^{-1}");
legendEntriesMCData.push_back("WW");
legendEntriesMCData.push_back("ZZ");
legendEntriesMCData.push_back("WZ");
legendEntriesMCData.push_back("W + #geq1 jet");
legendEntriesMCData.push_back("t/#bar{t}");
legendEntriesMCData.push_back("t#bar{t} + jets");
legendEntriesMCData.push_back("Drell-Yan + jets");
vector<string> legendEntriesMCDataQCDFromData(legendEntriesMCData);
legendEntriesMCDataQCDFromData.push_back("QCD (from data)");
vector<string> legendEntriesSearchVsControl;
legendEntriesSearchVsControl.push_back("Isolated #tau leptons");
legendEntriesSearchVsControl.push_back("Non-isolated #tau leptons");
vector<string> legendEntriesNonIsoWMCData;
legendEntriesNonIsoWMCData.push_back("Data 19.7 fb^{-1}");
legendEntriesNonIsoWMCData.push_back("Drell-Yan + jets");
legendEntriesNonIsoWMCData.push_back("t#bar{t} + jets");
legendEntriesNonIsoWMCData.push_back("W + #geq1 jet");
const bool setLogY = true;
const bool setLinY = false;
const bool drawStack = true;
const bool drawSame = false;
const bool dataMC = true;
const bool sigBkg = false;
//best available weights according to Dropbox spreadsheet
vector<float> weights1(15, 0.0);
vector<float> weightsMCData(8, 1.0); //MC samples already properly weighted during hadding
vector<float> weightsMCDataQCDFromData(9, 1.0);
vector<float> weightsNonIsoWMCData(4, 1.0);
vector<float> QCDRelXSecWeights; //weighted to 19.7 fb^-1 using PREP cross sections
QCDRelXSecWeights.push_back(4330.24221789241); // Pt 20-30
QCDRelXSecWeights.push_back(1661.46760576197); // Pt 30-50
QCDRelXSecWeights.push_back(334.859498535006); // Pt 50-80
QCDRelXSecWeights.push_back(86.2492128172084); // Pt 80-120
QCDRelXSecWeights.push_back(17.2948414684422); // Pt 120-170
QCDRelXSecWeights.push_back(5.90683539273479); // Pt 170-300
QCDRelXSecWeights.push_back(0.381825191984792); // Pt 300-470
QCDRelXSecWeights.push_back(0.061429134916651); // Pt 470-600
QCDRelXSecWeights.push_back(0.0136978188679245); // Pt 600-800
QCDRelXSecWeights.push_back(0.00176856029171443); // Pt 800-1000
QCDRelXSecWeights.push_back(0.000431775067953546); // Pt 1000
vector<float> QCDBRelXSecWeights; //weighted to 19.7 fb^-1 using PREP cross sections
QCDBRelXSecWeights.push_back(265005.9602); // Pt 15-30
QCDBRelXSecWeights.push_back(21786.76565); // Pt 30-50
QCDBRelXSecWeights.push_back(7109.004289); // Pt 50-150
QCDBRelXSecWeights.push_back(352.2478877); // Pt 150
vector<float> QCDBMuRelXSecWeights; /*weighted to 19.7 fb^-1 using cross sections from J.
Antonelli's e-mail*/
QCDBMuRelXSecWeights.push_back(282.0); // Pt 15-30
QCDBMuRelXSecWeights.push_back(163.0); // Pt 30-50
QCDBMuRelXSecWeights.push_back(91.2); // Pt 50-150
QCDBMuRelXSecWeights.push_back(2.22); // Pt 150
vector<float> DYJetsToLLRelXSecWeights; //weighted to 19.7 fb^-1
DYJetsToLLRelXSecWeights.push_back(7.65500977593); /*(10 < m < 50) GeV using ttH cross section*/
DYJetsToLLRelXSecWeights.push_back(2.26606084150487); //m > 50 GeV using SM@8TeV Twiki
vector<float> TRelXSecWeights; //weighted to 19.7 fb^-1 using SM@8TeV Twiki
TRelXSecWeights.push_back(0.287208465885267); //t s-channel
//TRelXSecWeights.push_back(0.34672); //tbar s-channel
//TRelXSecWeights.push_back(0.321286023155796); //t t-channel
TRelXSecWeights.push_back(0.2477031449); //tbar s-channel
TRelXSecWeights.push_back(0.2956394066); //t t-channel
TRelXSecWeights.push_back(0.312541342130939); //tbar t-channel
vector<float> WNJetsToLNuRelXSecWeights; //weighted to 19.7 fb^-1 using PREP cross sections
WNJetsToLNuRelXSecWeights.push_back(5.61973075498071); //W + 1 jet
// WNJetsToLNuRelXSecWeights.push_back(1.22833526483929); //W + 2 jets
WNJetsToLNuRelXSecWeights.push_back(1.2211192971); //W + 2 jets
// WNJetsToLNuRelXSecWeights.push_back(0.819050332546934); //W + 3 jets
WNJetsToLNuRelXSecWeights.push_back(0.8032380444); //W + 3 jets
WNJetsToLNuRelXSecWeights.push_back(0.31501621894905); //W + 4 jets
//space-saving constant definitions
string user(gSystem->GetFromPipe("whoami").Data());
const string analysisFilePath("/data1/" + user + "/");
const string fileExt(".root");
const string tag19p7InvFb("_19p7fb-1");
const string tag1("_normalizedTo1");
//version tags
const string outputVTag("_" + outputVersion);
const string dataVTag("_" + inputVersion);
const string nonIsoWDataVTag("_" + inputVersion);
const string DYJetsToLLVTag("_" + inputVersion);
const string TTJetsVTag("_" + inputVersion);
const string TVTag("_" + inputVersion);
const string WNJetsToLNuVTag("_" + inputVersion);
const string WJetsToLNuVTag("_" + inputVersion);
const string WZVTag("_" + inputVersion);
const string ZZVTag("_" + inputVersion);
const string WWVTag("_" + inputVersion);
const string NonIsoWDYJetsToLLVTag("_" + inputVersion);
const string NonIsoWTTJetsVTag("_" + inputVersion);
const string NonIsoWWNJetsToLNuVTag("_" + inputVersion);
cout << "Begin hadding...\n";
//hadd data samples from different eras
cout << "...data\n";
string dataSuffix(dataVTag + fileExt);
string dataIsoPrefix(analysisFilePath + "data/analysis/muHadIsoAnalysis" + MTBin + "_SingleMu");
string dataIsoHaddOutputFile(dataIsoPrefix + dataSuffix); //BLINDED!!!
string dataNonIsoPrefix(analysisFilePath + "data/analysis/muHadNonIsoAnalysis" + MTBin +
"_SingleMu");
string dataNonIsoHaddOutputFile(dataNonIsoPrefix + dataSuffix);
string dataAllPrefix(analysisFilePath + "data/analysis/muHadAnalysis" + MTBin + "_SingleMu");
string dataAllHaddOutputFile(dataAllPrefix + dataSuffix); //BLINDED!!!
vector<string> dataIsoHaddInputFiles; //BLINDED!!!
vector<string> dataNonIsoHaddInputFiles;
vector<string> dataAllHaddInputFiles; //BLINDED!!!
vector<string> runEras;
runEras.push_back("_Run2012A");
runEras.push_back("_Run2012B");
runEras.push_back("_Run2012C");
runEras.push_back("_Run2012D");
vector<string> subJobs;
subJobs.push_back("_0");
subJobs.push_back("_1");
subJobs.push_back("_2");
subJobs.push_back("_3");
subJobs.push_back("_4");
subJobs.push_back("_5");
subJobs.push_back("_6");
subJobs.push_back("_7");
for (vector<string>::const_iterator iRunEra = runEras.begin(); iRunEra != runEras.end();
++iRunEra) {
for (vector<string>::const_iterator iSubJob = subJobs.begin(); iSubJob != subJobs.end();
++iSubJob) {
stringstream dataIsoName;
dataIsoName << dataIsoPrefix << *iRunEra << *iSubJob << dataSuffix;
dataIsoHaddInputFiles.push_back(dataIsoName.str());
stringstream dataNonIsoName;
dataNonIsoName << dataNonIsoPrefix << *iRunEra << *iSubJob << dataSuffix;
dataNonIsoHaddInputFiles.push_back(dataNonIsoName.str());
stringstream dataAllName;
dataAllName << dataAllPrefix << *iRunEra << *iSubJob << dataSuffix;
dataAllHaddInputFiles.push_back(dataAllName.str());
}
}
haddCanvases(dataIsoHaddOutputFile, dataIsoHaddInputFiles, vector<float>(32, 1.0),
canvasNames1D, graphNames1D, canvasNames2D, graphNames2D, dataBlindLow,
dataBlindHigh); //BLINDED!!!
haddCanvases(dataNonIsoHaddOutputFile, dataNonIsoHaddInputFiles, vector<float>(32, 1.0),
canvasNames1D, graphNames1D, canvasNames2D, graphNames2D, nullBlindLow,
nullBlindHigh);
if (doNoHPSIsoCut) {
haddCanvases(dataAllHaddOutputFile, dataAllHaddInputFiles,
vector<float>(32, 1.0), canvasNames1D, graphNames1D, canvasNames2D,
graphNames2D, dataBlindLow, dataBlindHigh); //BLINDED!!!
}
//hadd non-isolated W data samples from different eras
cout << "...non-isolated W data\n";
string nonIsoWDataSuffix(nonIsoWDataVTag + fileExt);
string nonIsoWDataIsoPrefix(analysisFilePath +
"nonIsoWData/analysis/nonIsoW_muHadIsoAnalysis" + MTBin +
"_SingleMu");
string nonIsoWDataIsoHaddOutputFile(nonIsoWDataIsoPrefix + nonIsoWDataSuffix);
string nonIsoWDataNonIsoPrefix(analysisFilePath +
"nonIsoWData/analysis/nonIsoW_muHadNonIsoAnalysis" + MTBin +
"_SingleMu");
string nonIsoWDataNonIsoHaddOutputFile(nonIsoWDataNonIsoPrefix + nonIsoWDataSuffix);
string nonIsoWDataAllPrefix(analysisFilePath +
"nonIsoWData/analysis/nonIsoW_muHadAnalysis" + MTBin + "_SingleMu");
string nonIsoWDataAllHaddOutputFile(nonIsoWDataAllPrefix + nonIsoWDataSuffix);
vector<string> nonIsoWDataIsoHaddInputFiles;
vector<string> nonIsoWDataNonIsoHaddInputFiles;
vector<string> nonIsoWDataAllHaddInputFiles;
for (vector<string>::const_iterator iRunEra = runEras.begin(); iRunEra != runEras.end();
++iRunEra) {
stringstream nonIsoWDataIsoName;
nonIsoWDataIsoName << nonIsoWDataIsoPrefix << *iRunEra << nonIsoWDataSuffix;
nonIsoWDataIsoHaddInputFiles.push_back(nonIsoWDataIsoName.str());
stringstream nonIsoWDataNonIsoName;
nonIsoWDataNonIsoName << nonIsoWDataNonIsoPrefix << *iRunEra << nonIsoWDataSuffix;
nonIsoWDataNonIsoHaddInputFiles.push_back(nonIsoWDataNonIsoName.str());
stringstream nonIsoWDataAllName;
nonIsoWDataAllName << nonIsoWDataAllPrefix << *iRunEra << nonIsoWDataSuffix;
nonIsoWDataAllHaddInputFiles.push_back(nonIsoWDataAllName.str());
}
haddCanvases(nonIsoWDataIsoHaddOutputFile, nonIsoWDataIsoHaddInputFiles,
vector<float>(4, 1.0), canvasNames1D, graphNames1D, canvasNames2D, graphNames2D,
nullBlindLow, nullBlindHigh);
haddCanvases(nonIsoWDataNonIsoHaddOutputFile, nonIsoWDataNonIsoHaddInputFiles,
vector<float>(4, 1.0), canvasNames1D, graphNames1D, canvasNames2D, graphNames2D,
nullBlindLow, nullBlindHigh);
if (doNoHPSIsoCut) {
haddCanvases(nonIsoWDataAllHaddOutputFile, nonIsoWDataAllHaddInputFiles,
vector<float>(4, 1.0), canvasNames1D, graphNames1D, canvasNames2D,
graphNames2D, nullBlindLow, nullBlindHigh);
}
//hadd Drell-Yan+jets ml+l- binned samples
cout << "...Drell-Yan\n";
string DYJetsToLLSuffix(DYJetsToLLVTag + fileExt);
string DYJetsToLLIsoPrefix(analysisFilePath + "DYJetsToLL/analysis/muHadIsoAnalysis" + MTBin +
"_DYJetsToLL");
string DYJetsToLLIsoHaddOutputFile(DYJetsToLLIsoPrefix + DYJetsToLLSuffix);
string DYJetsToLLNonIsoPrefix(analysisFilePath +
"DYJetsToLL/analysis/muHadNonIsoAnalysis" + MTBin + "_DYJetsToLL");
string DYJetsToLLNonIsoHaddOutputFile(DYJetsToLLNonIsoPrefix + DYJetsToLLSuffix);
string DYJetsToLLAllPrefix(analysisFilePath + "DYJetsToLL/analysis/muHadAnalysis" + MTBin +
"_DYJetsToLL");
string DYJetsToLLAllHaddOutputFile(DYJetsToLLAllPrefix + DYJetsToLLSuffix);
vector<string> DYJetsToLLIsoHaddInputFiles;
vector<string> DYJetsToLLNonIsoHaddInputFiles;
vector<string> DYJetsToLLAllHaddInputFiles;
vector<string> massBins;
massBins.push_back("_M-10To50");
massBins.push_back("_M-50");
for (vector<string>::const_iterator iMassBin = massBins.begin(); iMassBin != massBins.end();
++iMassBin) {
stringstream DYJetsToLLIsoName;
DYJetsToLLIsoName << DYJetsToLLIsoPrefix << *iMassBin << DYJetsToLLSuffix;
DYJetsToLLIsoHaddInputFiles.push_back(DYJetsToLLIsoName.str());
stringstream DYJetsToLLNonIsoName;
DYJetsToLLNonIsoName << DYJetsToLLNonIsoPrefix << *iMassBin << DYJetsToLLSuffix;
DYJetsToLLNonIsoHaddInputFiles.push_back(DYJetsToLLNonIsoName.str());
stringstream DYJetsToLLAllName;
DYJetsToLLAllName << DYJetsToLLAllPrefix << *iMassBin << DYJetsToLLSuffix;
DYJetsToLLAllHaddInputFiles.push_back(DYJetsToLLAllName.str());
}
haddCanvases(DYJetsToLLIsoHaddOutputFile, DYJetsToLLIsoHaddInputFiles,
DYJetsToLLRelXSecWeights, canvasNames1D, graphNames1D, canvasNames2D,
graphNames2D, nullBlindLow, nullBlindHigh);
haddCanvases(DYJetsToLLNonIsoHaddOutputFile, DYJetsToLLNonIsoHaddInputFiles,
DYJetsToLLRelXSecWeights, canvasNames1D, graphNames1D, canvasNames2D,
graphNames2D, nullBlindLow, nullBlindHigh);
if (doNoHPSIsoCut) {
haddCanvases(DYJetsToLLAllHaddOutputFile, DYJetsToLLAllHaddInputFiles,
DYJetsToLLRelXSecWeights, canvasNames1D, graphNames1D, canvasNames2D,
graphNames2D, nullBlindLow, nullBlindHigh);
}
//"hadd" ttbar sample just to get the formatting of the 2D plots the same
cout << "...ttbar\n";
string TTJetsSuffix(TTJetsVTag + fileExt);
string TTJetsIsoPrefix(analysisFilePath + "TTJets/analysis/muHadIsoAnalysis" + MTBin +
"_TTJets");
string TTJetsIsoHaddOutputFile(TTJetsIsoPrefix + "_hadd" + TTJetsSuffix);
string TTJetsNonIsoPrefix(analysisFilePath + "TTJets/analysis/muHadNonIsoAnalysis" + MTBin +
"_TTJets");
string TTJetsNonIsoHaddOutputFile(TTJetsNonIsoPrefix + "_hadd" + TTJetsSuffix);
string TTJetsAllPrefix(analysisFilePath + "TTJets/analysis/muHadAnalysis" + MTBin + "_TTJets");
string TTJetsAllHaddOutputFile(TTJetsAllPrefix + "_hadd" + TTJetsSuffix);
vector<string> TTJetsIsoHaddInputFiles;
vector<string> TTJetsNonIsoHaddInputFiles;
vector<string> TTJetsAllHaddInputFiles;
stringstream TTJetsIsoName;
TTJetsIsoName << TTJetsIsoPrefix << TTJetsSuffix;
TTJetsIsoHaddInputFiles.push_back(TTJetsIsoName.str());
stringstream TTJetsNonIsoName;
TTJetsNonIsoName << TTJetsNonIsoPrefix << TTJetsSuffix;
TTJetsNonIsoHaddInputFiles.push_back(TTJetsNonIsoName.str());
stringstream TTJetsAllName;
TTJetsAllName << TTJetsAllPrefix << TTJetsSuffix;
TTJetsAllHaddInputFiles.push_back(TTJetsAllName.str());
haddCanvases(TTJetsIsoHaddOutputFile, TTJetsIsoHaddInputFiles,
vector<float>(1, 3.54800726562391), canvasNames1D, graphNames1D,
canvasNames2D, graphNames2D, nullBlindLow, nullBlindHigh);
haddCanvases(TTJetsNonIsoHaddOutputFile, TTJetsNonIsoHaddInputFiles,
vector<float>(1, 3.54800726562391), canvasNames1D, graphNames1D,
canvasNames2D, graphNames2D, nullBlindLow, nullBlindHigh);
if (doNoHPSIsoCut) {
haddCanvases(TTJetsAllHaddOutputFile, TTJetsAllHaddInputFiles,
vector<float>(1, 3.54800726562391), canvasNames1D, graphNames1D,
canvasNames2D, graphNames2D, nullBlindLow, nullBlindHigh);
}
//hadd single top samples
cout << "...single top\n";
string TSuffix(TVTag + fileExt);
string TIsoPrefix(analysisFilePath + "SingleTop/analysis/muHadIsoAnalysis" + MTBin + "_T");
string TIsoHaddOutputFile(TIsoPrefix + TSuffix);
string TNonIsoPrefix(analysisFilePath + "SingleTop/analysis/muHadNonIsoAnalysis" + MTBin + "_T");
string TNonIsoHaddOutputFile(TNonIsoPrefix + TSuffix);
string TAllPrefix(analysisFilePath + "SingleTop/analysis/muHadAnalysis" + MTBin + "_T");
string TAllHaddOutputFile(TAllPrefix + TSuffix);
vector<string> TIsoHaddInputFiles;
vector<string> TNonIsoHaddInputFiles;
vector<string> TAllHaddInputFiles;
vector<string> singleTopSamples;
singleTopSamples.push_back("_s-channel");
singleTopSamples.push_back("bar_s-channel");
singleTopSamples.push_back("_t-channel");
singleTopSamples.push_back("bar_t-channel");
for (vector<string>::const_iterator iSample = singleTopSamples.begin();
iSample != singleTopSamples.end(); ++iSample) {
stringstream TIsoName;
TIsoName << TIsoPrefix << *iSample << TSuffix;
TIsoHaddInputFiles.push_back(TIsoName.str());
stringstream TNonIsoName;
TNonIsoName << TNonIsoPrefix << *iSample << TSuffix;
TNonIsoHaddInputFiles.push_back(TNonIsoName.str());
stringstream TAllName;
TAllName << TAllPrefix << *iSample << TSuffix;
TAllHaddInputFiles.push_back(TAllName.str());
}
haddCanvases(TIsoHaddOutputFile, TIsoHaddInputFiles, TRelXSecWeights, canvasNames1D,
graphNames1D, canvasNames2D, graphNames2D, nullBlindLow, nullBlindHigh);
haddCanvases(TNonIsoHaddOutputFile, TNonIsoHaddInputFiles, TRelXSecWeights, canvasNames1D,
graphNames1D, canvasNames2D, graphNames2D, nullBlindLow, nullBlindHigh);
if (doNoHPSIsoCut) {
haddCanvases(TAllHaddOutputFile, TAllHaddInputFiles, TRelXSecWeights, canvasNames1D,
graphNames1D, canvasNames2D, graphNames2D, nullBlindLow, nullBlindHigh);
}
//hadd W+>=1 jet samples
cout << "...W+>=1 jet\n";
string WNJetsToLNuSuffix("JetsToLNu" + WNJetsToLNuVTag + fileExt);
string WNJetsToLNuIsoPrefix(analysisFilePath + "WNJetsToLNu/analysis/muHadIsoAnalysis" + MTBin +
"_W");
string WNJetsToLNuIsoHaddOutputFile(WNJetsToLNuIsoPrefix + "N" + WNJetsToLNuSuffix);
string WNJetsToLNuNonIsoPrefix(analysisFilePath + "WNJetsToLNu/analysis/muHadNonIsoAnalysis" +
MTBin + "_W");
string WNJetsToLNuNonIsoHaddOutputFile(WNJetsToLNuNonIsoPrefix + "N" + WNJetsToLNuSuffix);
string WNJetsToLNuAllTauPrefix(analysisFilePath + "WNJetsToLNu/analysis/muHadAnalysis" + MTBin +
"_W");
string WNJetsToLNuAllTauHaddOutputFile(WNJetsToLNuAllTauPrefix + "N" + WNJetsToLNuSuffix);
vector<string> WNJetsToLNuIsoHaddInputFiles;
vector<string> WNJetsToLNuNonIsoHaddInputFiles;
vector<string> WNJetsToLNuAllTauHaddInputFiles;
for (unsigned int iNJets = 1; iNJets <= 4; ++iNJets) {
stringstream WNJetsToLNuIsoName;
WNJetsToLNuIsoName << WNJetsToLNuIsoPrefix << iNJets << WNJetsToLNuSuffix;
WNJetsToLNuIsoHaddInputFiles.push_back(WNJetsToLNuIsoName.str());
stringstream WNJetsToLNuNonIsoName;
WNJetsToLNuNonIsoName << WNJetsToLNuNonIsoPrefix << iNJets << WNJetsToLNuSuffix;
WNJetsToLNuNonIsoHaddInputFiles.push_back(WNJetsToLNuNonIsoName.str());
stringstream WNJetsToLNuAllTauName;
WNJetsToLNuAllTauName << WNJetsToLNuAllTauPrefix << iNJets << WNJetsToLNuSuffix;
WNJetsToLNuAllTauHaddInputFiles.push_back(WNJetsToLNuAllTauName.str());
}
haddCanvases(WNJetsToLNuIsoHaddOutputFile, WNJetsToLNuIsoHaddInputFiles,
WNJetsToLNuRelXSecWeights, canvasNames1D, graphNames1D, canvasNames2D,
graphNames2D, nullBlindLow, nullBlindHigh);
haddCanvases(WNJetsToLNuNonIsoHaddOutputFile, WNJetsToLNuNonIsoHaddInputFiles,
WNJetsToLNuRelXSecWeights, canvasNames1D, graphNames1D, canvasNames2D,
graphNames2D, nullBlindLow, nullBlindHigh);
if (doNoHPSIsoCut) {
haddCanvases(WNJetsToLNuAllTauHaddOutputFile, WNJetsToLNuAllTauHaddInputFiles,
WNJetsToLNuRelXSecWeights, canvasNames1D, graphNames1D, canvasNames2D,
graphNames2D, nullBlindLow, nullBlindHigh);
}
//"hadd" WZ sample just to get the formatting of the 2D plots the same
cout << "...WZ\n";
string WZSuffix(WZVTag + fileExt);
string WZIsoPrefix(analysisFilePath + "WZ/analysis/muHadIsoAnalysis" + MTBin + "_WZ");
string WZIsoHaddOutputFile(WZIsoPrefix + "_hadd" + WZSuffix);
string WZNonIsoPrefix(analysisFilePath + "WZ/analysis/muHadNonIsoAnalysis" + MTBin + "_WZ");
string WZNonIsoHaddOutputFile(WZNonIsoPrefix + "_hadd" + WZSuffix);
string WZAllPrefix(analysisFilePath + "WZ/analysis/muHadAnalysis" + MTBin + "_WZ");
string WZAllHaddOutputFile(WZAllPrefix + "_hadd" + WZSuffix);
vector<string> WZIsoHaddInputFiles;
vector<string> WZNonIsoHaddInputFiles;
vector<string> WZAllHaddInputFiles;
stringstream WZIsoName;
WZIsoName << WZIsoPrefix << WZSuffix;
WZIsoHaddInputFiles.push_back(WZIsoName.str());
stringstream WZNonIsoName;
WZNonIsoName << WZNonIsoPrefix << WZSuffix;
WZNonIsoHaddInputFiles.push_back(WZNonIsoName.str());
stringstream WZAllName;
WZAllName << WZAllPrefix << WZSuffix;
WZAllHaddInputFiles.push_back(WZAllName.str());
haddCanvases(WZIsoHaddOutputFile, WZIsoHaddInputFiles,
vector<float>(1, 0.0667569497737973), canvasNames1D, graphNames1D,
canvasNames2D, graphNames2D, nullBlindLow, nullBlindHigh);
haddCanvases(WZNonIsoHaddOutputFile, WZNonIsoHaddInputFiles,
vector<float>(1, 0.0667569497737973), canvasNames1D, graphNames1D,
canvasNames2D, graphNames2D, nullBlindLow, nullBlindHigh);
if (doNoHPSIsoCut) {
haddCanvases(WZAllHaddOutputFile, WZAllHaddInputFiles,
vector<float>(1, 0.0667569497737973), canvasNames1D, graphNames1D,
canvasNames2D, graphNames2D, nullBlindLow, nullBlindHigh);
}
//"hadd" ZZ sample just to get the formatting of the 2D plots the same
cout << "...ZZ\n";
string ZZSuffix(ZZVTag + fileExt);
string ZZIsoPrefix(analysisFilePath + "ZZ/analysis/muHadIsoAnalysis" + MTBin + "_ZZ");
string ZZIsoHaddOutputFile(ZZIsoPrefix + "_hadd" + ZZSuffix);
string ZZNonIsoPrefix(analysisFilePath + "ZZ/analysis/muHadNonIsoAnalysis" + MTBin + "_ZZ");
string ZZNonIsoHaddOutputFile(ZZNonIsoPrefix + "_hadd" + ZZSuffix);
string ZZAllPrefix(analysisFilePath + "ZZ/analysis/muHadAnalysis" + MTBin + "_ZZ");
string ZZAllHaddOutputFile(ZZAllPrefix + "_hadd" + ZZSuffix);
vector<string> ZZIsoHaddInputFiles;
vector<string> ZZNonIsoHaddInputFiles;
vector<string> ZZAllHaddInputFiles;
stringstream ZZIsoName;
ZZIsoName << ZZIsoPrefix << ZZSuffix;
ZZIsoHaddInputFiles.push_back(ZZIsoName.str());
stringstream ZZNonIsoName;
ZZNonIsoName << ZZNonIsoPrefix << ZZSuffix;
ZZNonIsoHaddInputFiles.push_back(ZZNonIsoName.str());
stringstream ZZAllName;
ZZAllName << ZZAllPrefix << ZZSuffix;
ZZAllHaddInputFiles.push_back(ZZAllName.str());
haddCanvases(ZZIsoHaddOutputFile, ZZIsoHaddInputFiles,
vector<float>(1, 0.0377509625152821), canvasNames1D, graphNames1D,
canvasNames2D, graphNames2D, nullBlindLow, nullBlindHigh);
haddCanvases(ZZNonIsoHaddOutputFile, ZZNonIsoHaddInputFiles,
vector<float>(1, 0.0377509625152821), canvasNames1D, graphNames1D,
canvasNames2D, graphNames2D, nullBlindLow, nullBlindHigh);
if (doNoHPSIsoCut) {
haddCanvases(ZZAllHaddOutputFile, ZZAllHaddInputFiles,
vector<float>(1, 0.0377509625152821), canvasNames1D, graphNames1D,
canvasNames2D, graphNames2D, nullBlindLow, nullBlindHigh);
}
//"hadd" WW sample just to get the formatting of the 2D plots the same
cout << "...WW\n";
string WWSuffix(WWVTag + fileExt);
string WWIsoPrefix(analysisFilePath + "WW/analysis/muHadIsoAnalysis" + MTBin + "_WW");
string WWIsoHaddOutputFile(WWIsoPrefix + "_hadd" + WWSuffix);
string WWNonIsoPrefix(analysisFilePath + "WW/analysis/muHadNonIsoAnalysis" + MTBin + "_WW");
string WWNonIsoHaddOutputFile(WWNonIsoPrefix + "_hadd" + WWSuffix);
string WWAllPrefix(analysisFilePath + "WW/analysis/muHadAnalysis" + MTBin + "_WW");
string WWAllHaddOutputFile(WWAllPrefix + "_hadd" + WWSuffix);
vector<string> WWIsoHaddInputFiles;
vector<string> WWNonIsoHaddInputFiles;
vector<string> WWAllHaddInputFiles;
stringstream WWIsoName;
WWIsoName << WWIsoPrefix << WWSuffix;
WWIsoHaddInputFiles.push_back(WWIsoName.str());
stringstream WWNonIsoName;
WWNonIsoName << WWNonIsoPrefix << WWSuffix;
WWNonIsoHaddInputFiles.push_back(WWNonIsoName.str());
stringstream WWAllName;
WWAllName << WWAllPrefix << WWSuffix;
WWAllHaddInputFiles.push_back(WWAllName.str());
haddCanvases(WWIsoHaddOutputFile, WWIsoHaddInputFiles,
vector<float>(1, 0.124167251024691), canvasNames1D,
graphNames1D, canvasNames2D, graphNames2D, nullBlindLow, nullBlindHigh);
haddCanvases(WWNonIsoHaddOutputFile, WWNonIsoHaddInputFiles,
vector<float>(1, 0.124167251024691), canvasNames1D,
graphNames1D, canvasNames2D, graphNames2D, nullBlindLow, nullBlindHigh);
if (doNoHPSIsoCut) {
haddCanvases(WWAllHaddOutputFile, WWAllHaddInputFiles,
vector<float>(1, 0.124167251024691), canvasNames1D,
graphNames1D, canvasNames2D, graphNames2D, nullBlindLow, nullBlindHigh);
}
cout << endl;
//compare data to MC in control region and compute data - MC for data-driven QCD shape
string dataVsMCOutputFile(analysisFilePath + "results/dataVsMC_muHadNonIsoAnalysis" + MTBin +
tag19p7InvFb + outputVTag + fileExt);
string dataVsMCOutputDiff(analysisFilePath + "results/dataVsMC_muHadNonIsoDifference" + MTBin +
tag19p7InvFb + outputVTag + fileExt);
vector<string> dataVsMCInputFiles;
dataVsMCInputFiles.push_back(dataNonIsoHaddOutputFile);
dataVsMCInputFiles.push_back(WWNonIsoHaddOutputFile);
dataVsMCInputFiles.push_back(ZZNonIsoHaddOutputFile);
dataVsMCInputFiles.push_back(WZNonIsoHaddOutputFile);
dataVsMCInputFiles.push_back(WNJetsToLNuNonIsoHaddOutputFile);
dataVsMCInputFiles.push_back(TNonIsoHaddOutputFile);
dataVsMCInputFiles.push_back(TTJetsNonIsoHaddOutputFile);
dataVsMCInputFiles.push_back(DYJetsToLLNonIsoHaddOutputFile);
cout << "\nPlot data vs. MC normalized to data luminosity\n---\n";
drawMultipleEfficiencyGraphsOn1Canvas(dataVsMCOutputFile, dataVsMCInputFiles,
canvasNames1D, graphNames1D, legendHeaders19p7InvFb,
colorsMCData, styles, legendEntriesMCData,
weightsMCData, setLogY, drawStack, dataMC);
cout << "\nPlot data minus MC normalized to data luminosity\n---\n";
drawDifferenceGraphsOn1Canvas(dataVsMCOutputDiff, dataVsMCInputFiles,
canvasNames1D, graphNames1D, legendHeaders19p7InvFb,
colorsMCData, styles, legendEntriesMCData, weightsMCData,
setLogY, sigBkg);
//conservative estimate of the J/psi-->mumu or upsilon-->mumu/tautau background from region C
//compute data-driven QCD estimate in signal (i.e. isolated W muon + isolated tau) region:
//region C - resonance estimate
const pair<Int_t, Int_t> normReg(1, 12);
const string resBkgOutputFileNoRebin(analysisFilePath + "results/resBkg_noRebin" + MTBin +
tag19p7InvFb + outputVTag + fileExt);
vector<Double_t> nominalBinEdges;
cout << "\nEstimate boosted resonance background with narrow bins\n---\n";
estimateBoostedResonanceBackground(resBkgOutputFileNoRebin, dataVsMCOutputDiff, /*first, no
rebinning*/
nonIsoWDataIsoHaddOutputFile,
nonIsoWDataNonIsoHaddOutputFile, normReg, HLTPath, MTBin,
nominalBinEdges.size() - 1, nominalBinEdges);
nominalBinEdges.push_back(0.0);
nominalBinEdges.push_back(1.0);
nominalBinEdges.push_back(2.0);
nominalBinEdges.push_back(3.0);
nominalBinEdges.push_back(4.0);
nominalBinEdges.push_back(11.0);
const string resBkgOutputFile(analysisFilePath + "results/resBkg" + MTBin + tag19p7InvFb +
outputVTag + fileExt);
cout << "\nEstimate boosted resonance background and rebin to match nominal binning\n---\n";
estimateBoostedResonanceBackground(resBkgOutputFile, dataVsMCOutputDiff, //rebin
nonIsoWDataIsoHaddOutputFile,
nonIsoWDataNonIsoHaddOutputFile, normReg, HLTPath, MTBin,
nominalBinEdges.size() - 1, nominalBinEdges);
//compute data-driven QCD estimate in control (i.e. isolated W muon + non-isolated tau) region
string outputFileNameB(analysisFilePath + "results/dataVsMC_RegionBQCDEstimate" + MTBin +
dataVTag + fileExt);
string inputFileNameC(dataVsMCOutputDiff); // Region B
string inputFileNameD(nonIsoWDataNonIsoHaddOutputFile); // Region D
const pair<Double_t, Double_t> SFAndErrTotInt =
normFactorAndError(pair<string, string>(inputFileNameC, "muHadMass"),
pair<string, string>(inputFileNameD, "muHadMass"),
pair<Int_t, Int_t>(0, -1));
cout << "\nPlot data-driven QCD estimate for region B\n---\n";
drawQCDRegionAHistograms(outputFileNameB,inputFileNameD,canvasNames1D, graphNames1D,
legendHeaders19p7InvFb,colorsMCData, styles, legendEntriesMCData,
weightsMCData, setLogY, sigBkg, SFAndErrTotInt);
//compare region C data to region D data
const string variable("muHadMass");
const string theunit("m_{#mu+X} (GeV)");
string inputFileNameB(nonIsoWDataIsoHaddOutputFile); // Region C
vector<string> compRegCDataToRegDDataInputFiles;
compRegCDataToRegDDataInputFiles.push_back(inputFileNameD);
compRegCDataToRegDDataInputFiles.push_back(inputFileNameB);
string compRegCDataToRegDDataOutputFile(analysisFilePath + "results/regCDataVsRegDData" +
MTBin + tag19p7InvFb + outputVTag + fileExt);
QCDVsMCClosurePlots(compRegCDataToRegDDataInputFiles, variable, theunit,
pair<string, string>("Region D data", "Region C data"), 1, 12, 0.0, 3.75,
compRegCDataToRegDDataOutputFile, "RECREATE");
QCDVsMCClosurePlots(compRegCDataToRegDDataInputFiles, "muHadMass1Prong", theunit,
pair<string, string>("Region D data", "Region C data"), 1, 12, 0.0, 3.75,
compRegCDataToRegDDataOutputFile, "UPDATE");
QCDVsMCClosurePlots(compRegCDataToRegDDataInputFiles, "muHadMass1Prong1Pi0", theunit,
pair<string, string>("Region D data", "Region C data"), 1, 12, 0.0, 3.75,
compRegCDataToRegDDataOutputFile, "UPDATE");
QCDVsMCClosurePlots(compRegCDataToRegDDataInputFiles, "muHadMass1Prong2Pi0", theunit,
pair<string, string>("Region D data", "Region C data"), 1, 12, 0.0, 3.75,
compRegCDataToRegDDataOutputFile, "UPDATE");
QCDVsMCClosurePlots(compRegCDataToRegDDataInputFiles, "muHadMass3Prong", theunit,
pair<string, string>("Region D data", "Region C data"), 1, 12, 0.0, 3.75,
compRegCDataToRegDDataOutputFile, "UPDATE");
}
