/* For 3DNow!, the operand byte goes at the end. Format is:
* 0F 0F [ModRM] [SIB] [displacement] imm8_opcode
* See AMD doc 24594, page 435.
*/
static void TestAll3DNow(const unsigned int prefix,
const size_t prefix_length,
const char* print_prefix) {
const size_t kInstByteCount = NACL_ENUM_MAX_INSTRUCTION_BYTES;
const size_t kIterByteCount = 3;
InstByteArray itext;
size_t i;
int op, modrm, sib;
if ((gPrefix > 0) && (gPrefix != prefix)) return;
PrintProgress("TestAll3DNow(%s)\n", print_prefix);
/* set up prefix */
memcpy(itext, &prefix, prefix_length);
/* set up filler bytes */
for (i = prefix_length + kIterByteCount; i < kInstByteCount; i++) {
itext[i] = (uint8_t)i;
}
for (op = 0; op < 256; op++) {
if (!gEasyDiffMode) PrintProgress("%02x 00 00\n", op);
/* Use opcode as fill byte, forcing iteration through 3DNow opcodes. */
for (i = prefix_length + 2; i < kIterByteCount; i++) itext[i] = op;
for (modrm = 0; modrm < 256; modrm++) {
itext[prefix_length] = modrm;
for (sib = 0; sib < 256; sib++) {
itext[prefix_length + 1] = sib;
TryOneInstruction(itext, kInstByteCount);
}
}
}
}
void SpectralStatistics(std::vector<PointSet> &sets, int npoints, Statistics *stats) {
// We need the full radial power spectrum, so for performance reasons, we
// derive the radial power spectrum directly from full RDFs here
const int nsets = (int) sets.size();
const int nbins = 100 * sqrtf(npoints);
Curve avgrp(nbins, 0, 0.5f * npoints);
Curve rdf(nbins, 0, 0.5f);
Curve rp(nbins, 0, 0.5f * npoints);
if (nsets > 1) PrintProgress("Stats", 0);
for (int i = 0; i < nsets; ++i) {
rdf.SetZero();
sets[i].RDF(&rdf);
rp.SetZero();
RDFtoRP(rdf, npoints, &rp);
avgrp.Accumulate(rp);
if (nsets > 1) PrintProgress("Stats", (i+1) / (float) nsets);
}
avgrp.Divide(sets.size());
if (nsets > 1) std::cout << std::endl;
stats->effnyquist = EffectiveNyquist(avgrp, npoints);
stats->oscillations = OscillationsMetric(avgrp, npoints);
}
void ConsoleUpdater::OnProgressChange(const ProgressInfo& info)
{
switch (info.type)
{
case ProgressInfo::FileDownload:
// Download progress
if (!_info.file.empty() && !info.file.empty() && info.file != _info.file)
{
// New file, finish the current download
_info.progressFraction = 1.0f;
PrintProgress();
// Add a line break when a new file starts
TraceLog::WriteLine(LOG_PROGRESS, "");
TraceLog::WriteLine(LOG_PROGRESS,
(boost::format(" Downloading from Mirror %s: %s") % info.mirrorDisplayName % info.file.string()).str());
}
else if (_info.file.empty())
{
// First file
TraceLog::WriteLine(LOG_PROGRESS,
(boost::format(" Downloading from Mirror %s: %s") % info.mirrorDisplayName % info.file.string()).str());
}
_info = info;
// Print the new info
PrintProgress();
// Add a new line if we're done here
if (info.progressFraction >= 1)
{
TraceLog::WriteLine(LOG_PROGRESS, "");
}
break;
case ProgressInfo::FileOperation:
_info = info;
// Print the new info
PrintProgress();
// Add a new line if we're done here
if (info.progressFraction >= 1)
{
TraceLog::WriteLine(LOG_PROGRESS, "");
}
break;
};
}
void h10looper::Loop(Long64_t ntoproc /* = -1 */, Bool_t fastcount /* =kTRUE */, TEntryList *elist /* = 0 */)
{
if (fChain == 0) return;
if (ntoproc == -1) {
if (fastcount) ntoproc = fChain->GetEntriesFast();
else ntoproc = elist ? elist->GetN() : fChain->GetEntries();
}
std::cout << "ntoproc = " << ntoproc << std::endl;
_ntoprocess = ntoproc;
//Long64_t nbytes = 0, nb = 0;
_swmain.Start();
_swgroup.Start();
for (Long64_t jentry_el=0; jentry_el<ntoproc; jentry_el++) {
jentry = elist ? elist->GetEntry(jentry_el) : jentry_el;
Long64_t ientry = LoadTree(jentry);
if (ientry < 0) break;
PrintProgress(jentry);
//data->CheapPop(ientry);
GetEntry(jentry);
fHandlerChain->Process(data);
}
fHandlerChain->Finalize(data);
Float_t ttime = _swmain.RealTime();
Float_t percentProcessed = (Float_t)eventnum/_ntoprocess*100;
printf("Total: (%.2f) %lld/%.2f = %i events/sec\n",percentProcessed,eventnum,ttime,(Int_t)(eventnum/ttime));
}
Result DownloadFile_Internal(const char *url, void *out, bool bProgress,
void (*write)(void* out, unsigned char* buffer, u32 readSize))
{
httpcContext context;
u32 fileSize = 0;
u32 procSize = 0;
Result ret = 0;
Result dlret = HTTPC_RESULTCODE_DOWNLOADPENDING;
u32 status;
u32 bufSize = 0x100000;
u32 readSize = 0;
httpcOpenContext(&context, HTTPC_METHOD_GET, (char*)url, 1);
ret = httpcBeginRequest(&context);
if (ret != 0) goto _out;
ret = httpcGetResponseStatusCode(&context, &status, 0);
if (ret != 0) goto _out;
if (status != 200)
{
ret = status;
goto _out;
}
ret = httpcGetDownloadSizeState(&context, NULL, &fileSize);
if (ret != 0) goto _out;
{
unsigned char *buffer = (unsigned char *)linearAlloc(bufSize);
if (buffer == NULL)
{
printf("Error allocating download buffer\n");
ret = -1;
goto _out;
}
while (dlret == (s32)HTTPC_RESULTCODE_DOWNLOADPENDING)
{
memset(buffer, 0, bufSize);
dlret = httpcDownloadData(&context, buffer, bufSize, &readSize);
write(out, buffer, readSize);
procSize += readSize;
if (bProgress)
{
PrintProgress(fileSize, procSize);
}
}
linearFree(buffer);
}
_out:
httpcCloseContext(&context);
return ret;
}
/* Enumerate and test all 24-bit opcode+modrm+sib patterns for a
* particular prefix.
*/
static void TestAllWithPrefix(const unsigned int prefix,
const size_t prefix_length,
const char* print_prefix) {
const size_t kInstByteCount = NACL_ENUM_MAX_INSTRUCTION_BYTES;
const size_t kIterByteCount = 3;
InstByteArray itext;
size_t i;
int op, modrm, sib;
int min_op;
int max_op;
if ((gPrefix > 0) && (gPrefix != prefix)) return;
PrintProgress("TestAllWithPrefix(%s)\n", print_prefix);
/* set up prefix */
memcpy(itext, &prefix, prefix_length);
/* set up filler bytes */
for (i = prefix_length + kIterByteCount; i < kInstByteCount; i++) {
itext[i] = (uint8_t)i;
}
if (gOpcode < 0) {
min_op = 0;
max_op = 256;
} else {
min_op = gOpcode;
max_op = gOpcode + 1;
}
for (op = min_op; op < max_op; op++) {
itext[prefix_length] = op;
if (!gEasyDiffMode) PrintProgress("%02x 00 00\n", op);
for (modrm = 0; modrm < 256; modrm++) {
itext[prefix_length + 1] = modrm;
for (sib = 0; sib < 256; sib++) {
itext[prefix_length + 2] = sib;
TryOneInstruction(itext, kInstByteCount);
}
}
}
}
int main(int argc, char **argv){
S_LOG("main");
logxx::GlobalLogLevel(logxx::warning);
EncodingConverter converter;
if (argc < 2){
log(logxx::error) << "A path with dicom files should be specified" << logxx::endl;
return 1;
} else {
std::string path(argv[1]);
if (path[path.length()-1] != '/')
path += '/';
std::string csvFile = path + "out.csv";
std::ofstream out(csvFile);
if (out.good()){
Dir dir(path, true, ".dcm");
if (dir.Ok()) {
std::string fName;
while ((fName = dir.Read()).empty() == false) {
log(logxx::debug) << "{" << fName << "}" << logxx::endl;
Dicom dicom(path + fName);
if (dicom.Parse(converter)){
// cppcheck-suppress constStatement
log(logxx::notice) << "{" << fName << "} Parsed" << logxx::endl;
out << fName << "," << dicom << std::endl;
} else {
// cppcheck-suppress constStatement
log(logxx::notice) << "{" << fName << "} Not parsed" << logxx::endl;
}
PrintProgress();
}
return 0;
} else {
log(logxx::error) << "Can't open path {" << path << "}" << logxx::endl;
return 1;
}
} else {
log(logxx::error) << "Can't open file {" << csvFile << "} for writing" << logxx::endl;
return 1;
}
}
}
void CClassifyGrid::Classify()
{
CParamManager * manager = CParamManager::GetParamManager();
CTimeMeter timer;
timer.Start();
fprintf_s( stderr, "==================== Classify points ====================\n" );
Init();
fprintf_s( stderr, "Initialize ... finished.\n" );
fprintf_s( stderr, "Processing progress ... " );
InitPrintProgress();
int index;
while ( ( index = ReadNextChunk() ) != -1 ) {
PrintProgress( );
CClassifyChunk * chunk = m_vecPointer[ index ];
chunk->BuildGridIndex();
// check neighborhood of index chunk
m_vecState[ chunk->m_iIndex ] = CClassifyChunk::CCS_Read;
NotifyCCSRead( chunk->m_iX, chunk->m_iY );
if ( manager->m_bDebugPrintOut ) {
PrintGridState( manager->m_pDebugPrintOutFile );
}
}
fprintf_s( stderr, " ... done!\n" );
Fin();
timer.End();
timer.Print();
fprintf_s( stderr, ".\n" );
}
static void PR_CALLBACK Thread(void *null)
{
void *pd;
PRStatus rv;
PRUintn keys;
char *key_string[] = {
"Key #0", "Key #1", "Key #2", "Key #3",
"Bogus #5", "Bogus #6", "Bogus #7", "Bogus #8"};
did = should = PR_FALSE;
for (keys = 0; keys < 8; ++keys)
{
pd = PR_GetThreadPrivate(key[keys]);
MY_ASSERT(NULL == pd);
}
PrintProgress(__LINE__);
did = should = PR_FALSE;
for (keys = 0; keys < 4; ++keys)
{
rv = PR_SetThreadPrivate(key[keys], key_string[keys]);
MY_ASSERT(PR_SUCCESS == rv);
}
PrintProgress(__LINE__);
did = should = PR_FALSE;
for (keys = 4; keys < 8; ++keys)
{
rv = PR_SetThreadPrivate(key[keys], key_string[keys]);
MY_ASSERT(PR_FAILURE == rv);
}
PrintProgress(__LINE__);
did = PR_FALSE; should = PR_TRUE;
for (keys = 0; keys < 4; ++keys)
{
rv = PR_SetThreadPrivate(key[keys], key_string[keys]);
MY_ASSERT(PR_SUCCESS == rv);
}
PrintProgress(__LINE__);
did = PR_FALSE; should = PR_TRUE;
for (keys = 0; keys < 4; ++keys)
{
rv = PR_SetThreadPrivate(key[keys], NULL);
MY_ASSERT(PR_SUCCESS == rv);
}
PrintProgress(__LINE__);
did = should = PR_FALSE;
for (keys = 0; keys < 4; ++keys)
{
rv = PR_SetThreadPrivate(key[keys], NULL);
MY_ASSERT(PR_SUCCESS == rv);
}
PrintProgress(__LINE__);
did = should = PR_FALSE;
for (keys = 8; keys < 127; ++keys)
{
rv = PR_SetThreadPrivate(key[keys], "EXTENSION");
MY_ASSERT(PR_SUCCESS == rv);
}
PrintProgress(__LINE__);
did = PR_FALSE; should = PR_TRUE;
for (keys = 8; keys < 127; ++keys)
{
rv = PR_SetThreadPrivate(key[keys], NULL);
MY_ASSERT(PR_SUCCESS == rv);
}
PrintProgress(__LINE__);
did = should = PR_FALSE;
for (keys = 8; keys < 127; ++keys)
{
rv = PR_SetThreadPrivate(key[keys], NULL);
MY_ASSERT(PR_SUCCESS == rv);
}
/* put in keys and leave them there for thread exit */
did = should = PR_FALSE;
for (keys = 0; keys < 4; ++keys)
{
rv = PR_SetThreadPrivate(key[keys], key_string[keys]);
MY_ASSERT(PR_SUCCESS == rv);
}
PrintProgress(__LINE__);
did = PR_FALSE; should = PR_TRUE;
} /* Thread */
//------------------------------------------------------------------------------
// Loop
//------------------------------------------------------------------------------
void AnalysisMonoH::Loop(TString analysis, TString filename, float luminosity)
{
if (fChain == 0) return;
Setup(analysis, filename, luminosity);
// Define histograms
//----------------------------------------------------------------------------
for (int j=0; j<ncut; j++) {
for (int k=0; k<=njetbin; k++) {
TString sbin = (k < njetbin) ? Form("/%djet", k) : "";
TString directory = scut[j] + sbin;
root_output->cd();
if (k < njetbin) gDirectory->mkdir(directory);
root_output->cd(directory);
for (int i=ee; i<=ll; i++) {
TString suffix = "_" + schannel[i];
DefineHistograms(i, j, k, suffix);
h_fullpmet [i][j][k] = new TH1D("h_fullpmet" + suffix, "", 1000, 0., 1000);
h_trkpmet [i][j][k] = new TH1D("h_trkpmet" + suffix, "", 1000, 0., 1000);
h_deltarl1met [i][j][k] = new TH1D("h_deltarl1met" + suffix, "", 100, 0., 5);
h_deltarl2met [i][j][k] = new TH1D("h_deltarl2met" + suffix, "", 100, 0., 5);
h_deltarllmet [i][j][k] = new TH1D("h_deltarllmet" + suffix, "", 100, 0., 5);
h_deltarjet1met [i][j][k] = new TH1D("h_deltarjet1met" + suffix, "", 100, 0., 5);
h_deltarjet2met [i][j][k] = new TH1D("h_deltarjet2met" + suffix, "", 100, 0., 5);
h_deltarjj [i][j][k] = new TH1D("h_deltarjj" + suffix, "", 100, 0., 5);
h_deltarjjmet [i][j][k] = new TH1D("h_deltarjjmet" + suffix, "", 100, 0., 5);
h_deltarlep1jet1 [i][j][k] = new TH1D("h_deltarlep1jet1" + suffix, "", 100, 0., 5);
h_deltarlep1jet2 [i][j][k] = new TH1D("h_deltarlep1jet2" + suffix, "", 100, 0., 5);
h_deltarlep2jet1 [i][j][k] = new TH1D("h_deltarlep2jet1" + suffix, "", 100, 0., 5);
h_deltarlep2jet2 [i][j][k] = new TH1D("h_deltarlep2jet2" + suffix, "", 100, 0., 5);
h_mllstar [i][j][k] = new TH1D("h_mllstar" + suffix, "", 3000, 0., 3000);
//h_mnunu [i][j][k] = new TH1D("h_mnunu" + suffix, "", 10, 0., 10);
h_mr [i][j][k] = new TH1D("h_mr" + suffix, "", 2000, 0., 2000);
//h_met_m2l [i][j][k] = new TH2D("h_met_m2l" + suffix, "", 200, 0, 2000, 100, 0, 200);
//h_met_deltaphill [i][j][k] = new TH2D("h_met_deltaphill" + suffix, "", 200, 0, 2000, 100, 0, 5);
}
}
}
root_output->cd();
// Loop over events
//----------------------------------------------------------------------------
for (Long64_t jentry=0; jentry<_nentries;jentry++) {
Long64_t ientry = LoadTree(jentry);
if (ientry < 0) break;
fChain->GetEntry(jentry);
PrintProgress(jentry, _nentries);
EventSetup();
// Analysis
//--------------------------------------------------------------------------
//if (Lepton1.flavour * Lepton2.flavour > 0) continue;
//if (Lepton1.v.Pt() < 20.) continue;
//if (Lepton2.v.Pt() < 20.) continue;
// Let's trust our ntuples
//--------------------------------------------------------------------------
if (std_vector_lepton_flavour->at(0)*std_vector_lepton_flavour->at(1) > 0) continue;
if (std_vector_lepton_pt->at(0) < 20.) continue;
if (std_vector_lepton_pt->at(1) < 20.) continue;
if (std_vector_lepton_pt->at(2) > 10.) continue;
_nelectron = 0;
if (abs(Lepton1.flavour) == ELECTRON_FLAVOUR) _nelectron++;
if (abs(Lepton2.flavour) == ELECTRON_FLAVOUR) _nelectron++;
if (_nelectron == 2) _channel = ee;
else if (_nelectron == 1) _channel = em;
else if (_nelectron == 0) _channel = mm;
_m2l = mll;
_pt2l = ptll;
// Fill histograms
//--------------------------------------------------------------------------
bool pass = true;
// WW cuts
FillLevelHistograms(MonoH_00_Has2Leptons, pass);
pass &= (mll > 12.);
FillLevelHistograms(MonoH_01_Mll, pass);
pass &= (MET.Et() > 20.);
FillLevelHistograms(MonoH_02_PfMet, pass);
bool pass_zveto = (_nelectron == 1 || fabs(mll - Z_MASS) > 15.);
FillLevelHistograms(MonoH_03_ZVeto, pass && pass_zveto);
pass &= (mpmet > 45. || (_nelectron == 1 && mpmet > 45.));
FillLevelHistograms(MonoH_04_MpMet, pass && pass_zveto);
pass &= (_passdphiveto);
FillLevelHistograms(MonoH_05_DPhiVeto, pass && pass_zveto);
pass &= (_nelectron == 1 && ptll > 30. || _nelectron != 1 && ptll > 45.);
FillLevelHistograms(MonoH_06_Ptll, pass && pass_zveto);
bool passTopCR = pass && _nbjet20cmvav2l == 1;
pass &= (_nbjet20cmvav2l == 0);
FillLevelHistograms(MonoH_07_BVeto, pass && pass_zveto);
if (_saveminitree && pass && pass_zveto) minitree->Fill();
//ZH->4l Control Region
if (AnalysisLeptons[2].v.Pt() > 0 || AnalysisLeptons[3].v.Pt() > 0 ){
//cout<<"I passed! :)"<<endl;
bool passZHCR = ( (fabs(_mll13 - Z_MASS) < 15. || fabs(_mll23 - Z_MASS) < 15. || fabs(_mll14 - Z_MASS) < 15. || fabs(_mll24 - Z_MASS) < 15. || fabs(_mll34 - Z_MASS) < 15.) && AnalysisLeptons[2].v.Pt() > 20. && AnalysisLeptons[3].v.Pt() > 20.);
FillLevelHistograms(MonoH_08_ZHCR, passZHCR);
// cout<<"Lepton 3 pT = "<<std_vector_lepton_pt->at(2)<<endl;
// cout<<"Lepton 4 pT = "<<std_vector_lepton_pt->at(3)<<endl;
// cout<<"-------------------------------------------"<<endl;
}
FillLevelHistograms(MonoH_09_TopCR, passTopCR && pass_zveto);
// pass &= (!_foundsoftmuon);
// FillLevelHistograms(MonoH_08_SoftMu, pass && pass_zveto);
// monoH cuts
// bool pass_monoh = (pass && pass_zveto);
// bool pass_drll = (Lepton1.v.DeltaR(Lepton2.v) < 1.5);
// FillLevelHistograms(MonoH_103_CR, pass_monoh && !pass_drll);
// pass_monoh &= (_mc < 100.);
// FillLevelHistograms(MonoH_100_Mc, pass_monoh);
// pass_monoh &= pass_drll;
// FillLevelHistograms(MonoH_101_DRll, pass_monoh);
// pass_monoh &= (mpmet > 60.);
// FillLevelHistograms(MonoH_102_MpMet, pass_monoh);
// pass_monoh &= (mpmet > 100.);
// FillLevelHistograms(MonoH_09_mpmet100, pass_monoh);
// pass_monoh &= (mth > 200.);
// FillLevelHistograms(MonoH_10_mth200, pass_monoh);
// pass_monoh &= (Lepton1.v.DeltaPhi(MET) > 2.6);
// FillLevelHistograms(MonoH_11_dphil1met, pass_monoh);
// pass_monoh &= (Lepton2.v.DeltaPhi(MET) > 2.6);
// FillLevelHistograms(MonoH_12_dphil2met, pass_monoh);
// pass_monoh &= (drll < 0.8);
// FillLevelHistograms(MonoH_13_deltarll, pass_monoh);
// pass_monoh &= (mtw1 > 160.);
// FillLevelHistograms(MonoH_14_mtw1, pass_monoh);
// pass_monoh &= (mtw2 > 100.);
// FillLevelHistograms(MonoH_15_mtw2, pass_monoh);
// pass_monoh &= (metTtrk > 100.);
// FillLevelHistograms(MonoH_16_trkmet, pass_monoh);
}
EndJob();
}
std::string ProgressBar::Update(double progress) {
progress_ = progress;
double elapsed = timer_.Toc();
return PrintProgress(elapsed);
}
//------------------------------------------------------------------------------
// Loop
//------------------------------------------------------------------------------
void AnalysisControl::Loop(TString analysis, TString filename, float luminosity)
{
if (fChain == 0) return;
Setup(analysis, filename, luminosity);
// Define histograms
//----------------------------------------------------------------------------
root_output->cd();
for (int j=0; j<ncut; j++) {
for (int k=0; k<=njetbin; k++) {
TString sbin = (k < njetbin) ? Form("/%djet", k) : "";
TString directory = scut[j] + sbin;
root_output->cd();
if (k < njetbin) gDirectory->mkdir(directory);
root_output->cd(directory);
for (int i=ee; i<=ll; i++) {
TString suffix = "_" + schannel[i];
DefineHistograms(i, j, k, suffix);
}
}
}
root_output->cd();
// Loop over events
//----------------------------------------------------------------------------
for (Long64_t jentry=0; jentry<_nentries;jentry++) {
Long64_t ientry = LoadTree(jentry);
if (ientry < 0) break;
fChain->GetEntry(jentry);
PrintProgress(jentry, _nentries);
EventSetup();
// Analysis
//--------------------------------------------------------------------------
_nelectron = 0;
if (abs(Lepton1.flavour) == ELECTRON_FLAVOUR) _nelectron++;
if (abs(Lepton2.flavour) == ELECTRON_FLAVOUR) _nelectron++;
if (_nelectron == 2) _channel = ee;
else if (_nelectron == 1) _channel = em;
else if (_nelectron == 0) _channel = mm;
_m2l = mll; // Needs l2Sel
_pt2l = ptll; // Needs l2Sel
bool pass_2l = (Lepton1.flavour * Lepton2.flavour < 0);
pass_2l &= (Lepton1.v.Pt() > 25.);
pass_2l &= (Lepton2.v.Pt() > 20.);
pass_2l &= (std_vector_lepton_pt->at(2) < 10.);
pass_2l &= (_m2l > 20.);
bool pass;
// No cuts
//--------------------------------------------------------------------------
pass = true;
FillLevelHistograms(Control_00_NoCuts, pass);
// Has 2 tight leptons
//--------------------------------------------------------------------------
pass = pass_2l;
FillLevelHistograms(Control_01_TwoLeptons, pass);
if (_saveminitree && pass) minitree->Fill();
// R out/in
//--------------------------------------------------------------------------
pass = pass_2l;
pass &= (_nbjet30csvv2m > 0);
FillLevelHistograms(Control_02_Routin, pass);
// WW
// https://github.com/latinos/PlotsConfigurations/blob/master/Configurations/ControlRegions/WW/Full2016/cuts.py
//--------------------------------------------------------------------------
pass =
mll > 80 &&
std_vector_lepton_pt->at(0) > 25 &&
std_vector_lepton_pt->at(1) > 13 &&
std_vector_lepton_pt->at(2) < 10 &&
metPfType1 > 20 &&
ptll > 30 &&
mth >= 60 &&
(std_vector_jet_pt->at(0) < 20 || std_vector_jet_cmvav2->at(0) < -0.5884) &&
(std_vector_jet_pt->at(1) < 20 || std_vector_jet_cmvav2->at(1) < -0.5884) &&
(std_vector_jet_pt->at(2) < 20 || std_vector_jet_cmvav2->at(2) < -0.5884) &&
(std_vector_jet_pt->at(3) < 20 || std_vector_jet_cmvav2->at(3) < -0.5884) &&
(std_vector_jet_pt->at(4) < 20 || std_vector_jet_cmvav2->at(4) < -0.5884) &&
(std_vector_jet_pt->at(5) < 20 || std_vector_jet_cmvav2->at(5) < -0.5884) &&
(std_vector_jet_pt->at(6) < 20 || std_vector_jet_cmvav2->at(6) < -0.5884) &&
(std_vector_jet_pt->at(7) < 20 || std_vector_jet_cmvav2->at(7) < -0.5884) &&
(std_vector_jet_pt->at(8) < 20 || std_vector_jet_cmvav2->at(8) < -0.5884) &&
(std_vector_jet_pt->at(9) < 20 || std_vector_jet_cmvav2->at(9) < -0.5884);
FillLevelHistograms(Control_03_WW, pass);
if (pass) EventDump();
// Top
//--------------------------------------------------------------------------
pass = pass_2l;
pass &= (_njet > 1);
pass &= (_nbjet30csvv2m > 0);
pass &= (_channel == em || fabs(_m2l - Z_MASS) > 15.);
pass &= (MET.Et() > 45.);
FillLevelHistograms(Control_04_Top, pass);
}
EndJob();
}
//------------------------------------------------------------------------------
// Loop
//------------------------------------------------------------------------------
void AnalysisFR::Loop(TString analysis, TString filename, float luminosity)
{
if (fChain == 0) return;
Setup(analysis, filename, luminosity);
// Define fake rate histograms
//----------------------------------------------------------------------------
for (int i=0; i<ncut; i++) {
TString directory = scut[i];
root_output->cd();
gDirectory->mkdir(directory);
root_output->cd(directory);
for (int j=0; j<njetet; j++) {
TString muonsuffix = Form("_%.0fGeV", muonjetet[j]);
TString elesuffix = Form("_%.0fGeV", elejetet[j]);
h_Muon_loose_pt_eta_bin[i][j] = new TH2D("h_Muon_loose_pt_eta_bin" + muonsuffix, "", nptbin, ptbins, netabin, etabins);
h_Muon_tight_pt_eta_bin[i][j] = new TH2D("h_Muon_tight_pt_eta_bin" + muonsuffix, "", nptbin, ptbins, netabin, etabins);
h_Ele_loose_pt_eta_bin [i][j] = new TH2D("h_Ele_loose_pt_eta_bin" + elesuffix, "", nptbin, ptbins, netabin, etabins);
h_Ele_tight_pt_eta_bin [i][j] = new TH2D("h_Ele_tight_pt_eta_bin" + elesuffix, "", nptbin, ptbins, netabin, etabins);
h_Muon_loose_pt_bin[i][j] = new TH1D("h_Muon_loose_pt_bin" + muonsuffix, "", nptbin, ptbins);
h_Muon_tight_pt_bin[i][j] = new TH1D("h_Muon_tight_pt_bin" + muonsuffix, "", nptbin, ptbins);
h_Ele_loose_pt_bin [i][j] = new TH1D("h_Ele_loose_pt_bin" + elesuffix, "", nptbin, ptbins);
h_Ele_tight_pt_bin [i][j] = new TH1D("h_Ele_tight_pt_bin" + elesuffix, "", nptbin, ptbins);
h_Muon_loose_eta_bin[i][j] = new TH1D("h_Muon_loose_eta_bin" + muonsuffix, "", netabin, etabins);
h_Muon_tight_eta_bin[i][j] = new TH1D("h_Muon_tight_eta_bin" + muonsuffix, "", netabin, etabins);
h_Ele_loose_eta_bin [i][j] = new TH1D("h_Ele_loose_eta_bin" + elesuffix, "", netabin, etabins);
h_Ele_tight_eta_bin [i][j] = new TH1D("h_Ele_tight_eta_bin" + elesuffix, "", netabin, etabins);
h_Muon_loose_pt[i][j] = new TH1D("h_Muon_loose_pt" + muonsuffix, "", 1000, 0, 200);
h_Muon_tight_pt[i][j] = new TH1D("h_Muon_tight_pt" + muonsuffix, "", 1000, 0, 200);
h_Ele_loose_pt [i][j] = new TH1D("h_Ele_loose_pt" + elesuffix, "", 1000, 0, 200);
h_Ele_tight_pt [i][j] = new TH1D("h_Ele_tight_pt" + elesuffix, "", 1000, 0, 200);
h_Muon_loose_mtw[i][j] = new TH1D("h_Muon_loose_mtw" + muonsuffix, "", 1000, 0, 200);
h_Muon_tight_mtw[i][j] = new TH1D("h_Muon_tight_mtw" + muonsuffix, "", 1000, 0, 200);
h_Ele_loose_mtw [i][j] = new TH1D("h_Ele_loose_mtw" + elesuffix, "", 1000, 0, 200);
h_Ele_tight_mtw [i][j] = new TH1D("h_Ele_tight_mtw" + elesuffix, "", 1000, 0, 200);
h_Muon_loose_m2l[i][j] = new TH1D("h_Muon_loose_m2l" + muonsuffix, "", 1000, 0, 200);
h_Muon_tight_m2l[i][j] = new TH1D("h_Muon_tight_m2l" + muonsuffix, "", 1000, 0, 200);
h_Ele_loose_m2l [i][j] = new TH1D("h_Ele_loose_m2l" + elesuffix, "", 1000, 0, 200);
h_Ele_tight_m2l [i][j] = new TH1D("h_Ele_tight_m2l" + elesuffix, "", 1000, 0, 200);
// Define effective luminosity estimation histograms
//------------------------------------------------------------------------
h_Muon_loose_pt_m2l[i][j] = new TH2D("h_Muon_loose_pt_m2l" + muonsuffix, "", 200, 0, 200, nptbin, ptbins);
h_Muon_tight_pt_m2l[i][j] = new TH2D("h_Muon_tight_pt_m2l" + muonsuffix, "", 200, 0, 200, nptbin, ptbins);
h_Ele_loose_pt_m2l [i][j] = new TH2D("h_Ele_loose_pt_m2l" + elesuffix, "", 200, 0, 200, nptbin, ptbins);
h_Ele_tight_pt_m2l [i][j] = new TH2D("h_Ele_tight_pt_m2l" + elesuffix, "", 200, 0, 200, nptbin, ptbins);
}
}
root_output->cd();
// Loop over events
//----------------------------------------------------------------------------
for (Long64_t jentry=0; jentry<_nentries;jentry++) {
Long64_t ientry = LoadTree(jentry);
if (ientry < 0) break;
fChain->GetEntry(jentry);
PrintProgress(jentry, _nentries);
EventSetup();
_channel = (abs(Lepton1.flavour) == ELECTRON_FLAVOUR) ? e : m;
_leptonPtMin = (_channel == e) ? 13 : 10;
_leptonEtaMax = (_channel == e) ? 2.5 : 2.4;
if (Lepton1.v.Pt() < _leptonPtMin) continue;
if (fabs(Lepton1.v.Eta()) > _leptonEtaMax) continue;
// Get the event weight
//--------------------------------------------------------------------------
bool passTrigger;
if (_ismc) {
passTrigger = true;
Float_t corrected_baseW = baseW;
if (_sample.Contains("DYJetsToLL_M-10to50")) corrected_baseW = 0.829752445221;
if (_sample.Contains("DYJetsToLL_M-50")) corrected_baseW = 0.318902641535;
_base_weight = (corrected_baseW / 1e3) * puW6p3 * GEN_weight_SM / abs(GEN_weight_SM);
_event_weight = _base_weight;
// Muons
//------------------------------------------------------------------------
if (_channel == m)
{
(Lepton1.v.Pt() <= 20.) ? _event_weight *= 5.86 : _event_weight *= 163.84;
}
// Electrons
//------------------------------------------------------------------------
if (_channel == e)
{
(Lepton1.v.Pt() <= 25.) ? _event_weight *= 8.51 : _event_weight *= 42.34;
}
} else {
_event_weight = 1.0;
passTrigger = false;
// Muons
//------------------------------------------------------------------------
if (_sample.Contains("DoubleMuon") && _channel == m) {
if (Lepton1.v.Pt() <= 20. && std_vector_trigger->at(22)) { // HLT_Mu8_TrkIsoVVL_v*
passTrigger = true;
} else if (Lepton1.v.Pt() > 20. && std_vector_trigger->at(23)) { // HLT_Mu17_TrkIsoVVL_v*
passTrigger = true;
}
}
// Electrons
//------------------------------------------------------------------------
if (_sample.Contains("DoubleEG") && _channel == e) {
if (Lepton1.v.Pt() <= 25. && std_vector_trigger->at(31)) { // HLT_Ele12_CaloIdL_TrackIdL_IsoVL_PFJet30_v*
passTrigger = true;
} else if (Lepton1.v.Pt() > 25. && std_vector_trigger->at(33)) { // HLT_Ele23_CaloIdL_TrackIdL_IsoVL_PFJet30_v*
passTrigger = true;
}
}
}
// Get the jets and the W transverse mass
//--------------------------------------------------------------------------
GetAwayJets();
GetMt(Lepton1, _mtw);
// Preselection
//--------------------------------------------------------------------------
if (!passTrigger) continue;
if (AnalysisJets.size() < 1) continue;
// Get histograms for different jet pt thresholds
//--------------------------------------------------------------------------
for (int i=0; i<njetet; i++) {
_inputJetEt = (_channel == e) ? elejetet[i] : muonjetet[i];
if (AnalysisJets[0].v.Pt() < _inputJetEt) continue;
// QCD region
//------------------------------------------------------------------------
bool pass;
pass = (_nlepton == 1);
FillLevelHistograms(FR_00_QCD, i, pass);
}
}
EndJob();
}
static PRIntn PR_CALLBACK Tpd(PRIntn argc, char **argv)
{
void *pd;
PRStatus rv;
PRUintn keys;
PRThread *thread;
char *key_string[] = {
"Key #0", "Key #1", "Key #2", "Key #3",
"Bogus #5", "Bogus #6", "Bogus #7", "Bogus #8"};
fout = PR_STDOUT;
did = should = PR_FALSE;
for (keys = 0; keys < 4; ++keys)
{
rv = PR_NewThreadPrivateIndex(&key[keys], Destructor);
MY_ASSERT(PR_SUCCESS == rv);
}
PrintProgress(__LINE__);
did = should = PR_FALSE;
for (keys = 0; keys < 8; ++keys)
{
pd = PR_GetThreadPrivate(key[keys]);
MY_ASSERT(NULL == pd);
}
PrintProgress(__LINE__);
did = should = PR_FALSE;
for (keys = 0; keys < 4; ++keys)
{
rv = PR_SetThreadPrivate(key[keys], key_string[keys]);
MY_ASSERT(PR_SUCCESS == rv);
}
PrintProgress(__LINE__);
for (keys = 4; keys < 8; ++keys)
key[keys] = 4096; /* set to invalid value */
did = should = PR_FALSE;
for (keys = 4; keys < 8; ++keys)
{
rv = PR_SetThreadPrivate(key[keys], key_string[keys]);
MY_ASSERT(PR_FAILURE == rv);
}
PrintProgress(__LINE__);
did = PR_FALSE; should = PR_TRUE;
for (keys = 0; keys < 4; ++keys)
{
rv = PR_SetThreadPrivate(key[keys], key_string[keys]);
MY_ASSERT(PR_SUCCESS == rv);
}
PrintProgress(__LINE__);
did = PR_FALSE; should = PR_TRUE;
for (keys = 0; keys < 4; ++keys)
{
rv = PR_SetThreadPrivate(key[keys], NULL);
MY_ASSERT(PR_SUCCESS == rv);
}
PrintProgress(__LINE__);
did = should = PR_FALSE;
for (keys = 0; keys < 4; ++keys)
{
rv = PR_SetThreadPrivate(key[keys], NULL);
MY_ASSERT(PR_SUCCESS == rv);
}
PrintProgress(__LINE__);
did = should = PR_FALSE;
for (keys = 8; keys < 127; ++keys)
{
rv = PR_NewThreadPrivateIndex(&key[keys], Destructor);
MY_ASSERT(PR_SUCCESS == rv);
rv = PR_SetThreadPrivate(key[keys], "EXTENSION");
MY_ASSERT(PR_SUCCESS == rv);
}
PrintProgress(__LINE__);
did = PR_FALSE; should = PR_TRUE;
for (keys = 8; keys < 127; ++keys)
{
rv = PR_SetThreadPrivate(key[keys], NULL);
MY_ASSERT(PR_SUCCESS == rv);
}
PrintProgress(__LINE__);
did = should = PR_FALSE;
for (keys = 8; keys < 127; ++keys)
{
rv = PR_SetThreadPrivate(key[keys], NULL);
MY_ASSERT(PR_SUCCESS == rv);
}
thread = PR_CreateThread(
PR_USER_THREAD, Thread, NULL, PR_PRIORITY_NORMAL,
PR_LOCAL_THREAD, PR_JOINABLE_THREAD, 0);
(void)PR_JoinThread(thread);
PrintProgress(__LINE__);
#if defined(WIN16)
printf(
"%s\n",((PR_TRUE == failed) ? "FAILED" : "PASSED"));
#else
(void)PR_fprintf(
fout, "%s\n",((PR_TRUE == failed) ? "FAILED" : "PASSED"));
#endif
return 0;
} /* Tpd */
void MyThread::RootFunction()
{
PRStatus rv;
PRUintn keys;
const RCThreadPrivateData *pd;
MyPrivateData extension = MyPrivateData("EXTENSION");
MyPrivateData key_string[] = {
"Key #0", "Key #1", "Key #2", "Key #3",
"Bogus #5", "Bogus #6", "Bogus #7", "Bogus #8"};
did = should = PR_FALSE;
for (keys = 0; keys < 8; ++keys)
{
pd = GetPrivateData(key[keys]);
MY_ASSERT(NULL == pd);
}
PrintProgress(__LINE__);
did = should = PR_FALSE;
for (keys = 0; keys < 4; ++keys)
{
rv = SetPrivateData(keys, &key_string[keys]);
MY_ASSERT(PR_SUCCESS == rv);
}
PrintProgress(__LINE__);
#if !defined(DEBUG)
did = should = PR_FALSE;
for (keys = 4; keys < 8; ++keys)
{
rv = SetPrivateData(keys, &key_string[keys]);
MY_ASSERT(PR_FAILURE == rv);
}
PrintProgress(__LINE__);
#endif
did = PR_FALSE; should = PR_TRUE;
for (keys = 0; keys < 4; ++keys)
{
rv = SetPrivateData(key[keys], &key_string[keys]);
MY_ASSERT(PR_SUCCESS == rv);
}
PrintProgress(__LINE__);
did = PR_FALSE; should = PR_TRUE;
for (keys = 0; keys < 4; ++keys)
{
rv = SetPrivateData(key[keys]);
MY_ASSERT(PR_SUCCESS == rv);
}
PrintProgress(__LINE__);
did = should = PR_FALSE;
for (keys = 0; keys < 4; ++keys)
{
rv = SetPrivateData(key[keys]);
MY_ASSERT(PR_SUCCESS == rv);
}
PrintProgress(__LINE__);
did = should = PR_FALSE;
for (keys = 8; keys < 127; ++keys)
{
rv = SetPrivateData(key[keys], &extension);
MY_ASSERT(PR_SUCCESS == rv);
}
PrintProgress(__LINE__);
did = PR_FALSE; should = PR_TRUE;
for (keys = 8; keys < 127; ++keys)
{
rv = SetPrivateData(key[keys]);
MY_ASSERT(PR_SUCCESS == rv);
}
PrintProgress(__LINE__);
did = should = PR_FALSE;
for (keys = 8; keys < 127; ++keys)
{
rv = SetPrivateData(key[keys]);
MY_ASSERT(PR_SUCCESS == rv);
}
} /* MyThread::RootFunction */
int main(PRIntn argc, char *argv[])
{
PRStatus rv;
PRUintn keys;
MyThread *thread;
const RCThreadPrivateData *pd;
PLOptStatus os;
PLOptState *opt = PL_CreateOptState(argc, argv, "d");
RCThread *primordial = RCThread::WrapPrimordialThread();
while (PL_OPT_EOL != (os = PL_GetNextOpt(opt)))
{
if (PL_OPT_BAD == os) continue;
switch (opt->option)
{
case 'd': /* debug mode */
debug = PR_TRUE;
break;
default:
break;
}
}
PL_DestroyOptState(opt);
fout = PR_STDOUT;
MyPrivateData extension = MyPrivateData("EXTENSION");
MyPrivateData key_string[] = {
"Key #0", "Key #1", "Key #2", "Key #3",
"Bogus #5", "Bogus #6", "Bogus #7", "Bogus #8"};
did = should = PR_FALSE;
for (keys = 0; keys < 4; ++keys)
{
rv = RCThread::NewPrivateIndex(&key[keys]);
key[keys + 4] = key[keys] + 4;
MY_ASSERT(PR_SUCCESS == rv);
}
PrintProgress(__LINE__);
/* the first four should be bu null, the last four undefined and null */
did = should = PR_FALSE;
for (keys = 0; keys < 8; ++keys)
{
pd = RCThread::GetPrivateData(key[keys]);
MY_ASSERT(NULL == pd);
}
PrintProgress(__LINE__);
/* initially set private data for new keys */
did = should = PR_FALSE;
for (keys = 0; keys < 4; ++keys)
{
rv = RCThread::SetPrivateData(key[keys], &key_string[keys]);
MY_ASSERT(PR_SUCCESS == rv);
}
PrintProgress(__LINE__);
/* re-assign the private data, albeit the same content */
did = PR_FALSE; should = PR_TRUE;
for (keys = 0; keys < 4; ++keys)
{
pd = RCThread::GetPrivateData(key[keys]);
PR_ASSERT(NULL != pd);
rv = RCThread::SetPrivateData(key[keys], &key_string[keys]);
MY_ASSERT(PR_SUCCESS == rv);
}
PrintProgress(__LINE__);
/* set private to <empty> */
did = PR_FALSE; should = PR_TRUE;
for (keys = 0; keys < 4; ++keys)
{
rv = RCThread::SetPrivateData(key[keys]);
MY_ASSERT(PR_SUCCESS == rv);
}
PrintProgress(__LINE__);
/* should all be null now */
did = should = PR_FALSE;
for (keys = 0; keys < 4; ++keys)
{
pd = RCThread::GetPrivateData(key[keys]);
PR_ASSERT(NULL == pd);
}
PrintProgress(__LINE__);
/* allocate another batch of keys and assign data to them */
did = should = PR_FALSE;
for (keys = 8; keys < 127; ++keys)
{
rv = RCThread::NewPrivateIndex(&key[keys]);
MY_ASSERT(PR_SUCCESS == rv);
rv = RCThread::SetPrivateData(key[keys], &extension);
MY_ASSERT(PR_SUCCESS == rv);
}
PrintProgress(__LINE__);
/* set all the extended slots to <empty> */
did = PR_FALSE; should = PR_TRUE;
for (keys = 8; keys < 127; ++keys)
{
rv = RCThread::SetPrivateData(key[keys]);
MY_ASSERT(PR_SUCCESS == rv);
}
PrintProgress(__LINE__);
/* set all the extended slots to <empty> again (noop) */
did = should = PR_FALSE;
for (keys = 8; keys < 127; ++keys)
{
rv = RCThread::SetPrivateData(key[keys]);
MY_ASSERT(PR_SUCCESS == rv);
}
if (debug) PR_fprintf(fout, "Creating thread\n");
thread = new MyThread();
if (debug) PR_fprintf(fout, "Starting thread\n");
thread->Start();
if (debug) PR_fprintf(fout, "Joining thread\n");
(void)thread->Join();
if (debug) PR_fprintf(fout, "Joined thread\n");
failed |= (PR_FAILURE == RCPrimordialThread::Cleanup());
(void)PR_fprintf(
fout, "%s\n",((PR_TRUE == failed) ? "FAILED" : "PASSED"));
return (failed) ? 1 : 0;
} /* main */
//------------------------------------------------------------------------------
// Loop
//------------------------------------------------------------------------------
void AnalysisPR::Loop(TString analysis, TString filename, float luminosity)
{
if (fChain == 0) return;
Setup(analysis, filename, luminosity);
root_output->cd();
// Define prompt rate histograms
//----------------------------------------------------------------------------
h_Muon_loose_pt_eta_PR = new TH2D("h_Muon_loose_pt_eta_PR", "", nptbin, ptbins, netabin, etabins);
h_Muon_tight_pt_eta_PR = new TH2D("h_Muon_tight_pt_eta_PR", "", nptbin, ptbins, netabin, etabins);
h_Ele_loose_pt_eta_PR = new TH2D("h_Ele_loose_pt_eta_PR", "", nptbin, ptbins, netabin, etabins);
h_Ele_tight_pt_eta_PR = new TH2D("h_Ele_tight_pt_eta_PR", "", nptbin, ptbins, netabin, etabins);
h_Muon_loose_pt_PR = new TH1D("h_Muon_loose_pt_PR", "", nptbin, ptbins);
h_Muon_tight_pt_PR = new TH1D("h_Muon_tight_pt_PR", "", nptbin, ptbins);
h_Ele_loose_pt_PR = new TH1D("h_Ele_loose_pt_PR", "", nptbin, ptbins);
h_Ele_tight_pt_PR = new TH1D("h_Ele_tight_pt_PR", "", nptbin, ptbins);
h_Muon_loose_eta_PR = new TH1D("h_Muon_loose_eta_PR", "", netabin, etabins);
h_Muon_tight_eta_PR = new TH1D("h_Muon_tight_eta_PR", "", netabin, etabins);
h_Ele_loose_eta_PR = new TH1D("h_Ele_loose_eta_PR", "", netabin, etabins);
h_Ele_tight_eta_PR = new TH1D("h_Ele_tight_eta_PR", "", netabin, etabins);
// Loop over events
//----------------------------------------------------------------------------
for (Long64_t jentry=0; jentry<_nentries;jentry++) {
Long64_t ientry = LoadTree(jentry);
if (ientry < 0) break;
fChain->GetEntry(jentry);
PrintProgress(jentry, _nentries);
EventSetup();
_channel = (abs(Lepton1.flavour) == ELECTRON_FLAVOUR) ? e : m;
_leptonPtMin = (_channel == e) ? 13 : 10;
_leptonEtaMax = (_channel == e) ? 2.5 : 2.4;
if (Lepton1.v.Pt() < _leptonPtMin) continue;
if (fabs(Lepton1.v.Eta()) > _leptonEtaMax) continue;
// Make Z candidate
//--------------------------------------------------------------------------
_Zlepton1type = Loose;
_Zlepton2type = Loose;
_m2l = -999;
if (AnalysisLeptons.size() >= 2) {
for (int iLep1=0; iLep1<AnalysisLeptons.size(); iLep1++) {
if (AnalysisLeptons[iLep1].v.Pt() < 10.) continue;
for (int iLep2=iLep1+1; iLep2<AnalysisLeptons.size(); iLep2++) {
if (AnalysisLeptons[iLep2].v.Pt() < 10.) continue;
if ((AnalysisLeptons[iLep1].flavour + AnalysisLeptons[iLep2].flavour) != 0.) continue;
float inv_mass = (AnalysisLeptons[iLep1].v + AnalysisLeptons[iLep2].v).M();
if (_m2l < 0 || fabs(inv_mass - Z_MASS) < fabs(_m2l - Z_MASS)) {
_m2l = inv_mass;
// Is the first Z lepton tight?
if (AnalysisLeptons[iLep1].type > 0.5 && AnalysisLeptons[iLep1].flavour == ELECTRON_FLAVOUR)
{
_Zlepton1type = Tight;
_Zdecayflavour = ELECTRON_FLAVOUR;
}
else if (AnalysisLeptons[iLep1].type > 0.5 && AnalysisLeptons[iLep1].flavour == MUON_FLAVOUR)
{
_Zlepton1type = Tight;
_Zdecayflavour = MUON_FLAVOUR;
}
// Is the second Z lepton tight?
if (AnalysisLeptons[iLep2].type > 0.5 && AnalysisLeptons[iLep2].flavour == ELECTRON_FLAVOUR)
{
_Zlepton2type = Tight;
}
else if (AnalysisLeptons[iLep2].type > 0.5 && AnalysisLeptons[iLep2].flavour == MUON_FLAVOUR)
{
_Zlepton2type = Tight;
}
}
}
}
}
// Get the event weight
//--------------------------------------------------------------------------
bool passTrigger;
if (_ismc) {
passTrigger = true;
_event_weight = (baseW / 1e3) * puW;
if (GEN_weight_SM) _event_weight *= GEN_weight_SM / abs(GEN_weight_SM);
// Muons
//------------------------------------------------------------------------
if (_channel == m)
{
(Lepton1.v.Pt() <= 20.) ? _event_weight *= 7.339 : _event_weight *= 217.553; // For 36/fb
}
// Electrons
//------------------------------------------------------------------------
if (_channel == e)
{
(Lepton1.v.Pt() <= 25.) ? _event_weight *= 14.888 : _event_weight *= 63.046;
}
} else {
_event_weight = 1.0;
passTrigger = false;
// Muons
//------------------------------------------------------------------------
if (_sample.Contains("DoubleMuon") && _channel == m) {
if (Lepton1.v.Pt() <= 20. && std_vector_trigger->at(22)) { // HLT_Mu8_TrkIsoVVL_v*
passTrigger = true;
} else if (Lepton1.v.Pt() > 20. && std_vector_trigger->at(23)) { // HLT_Mu17_TrkIsoVVL_v*
passTrigger = true;
}
}
// Electrons
//------------------------------------------------------------------------
if (_sample.Contains("DoubleEG") && _channel == e) {
if (Lepton1.v.Pt() <= 25. && std_vector_trigger->at(31)) { // HLT_Ele12_CaloIdL_TrackIdL_IsoVL_PFJet30_v*
passTrigger = true;
} else if (Lepton1.v.Pt() > 25. && std_vector_trigger->at(33)) { // HLT_Ele23_CaloIdL_TrackIdL_IsoVL_PFJet30_v*
passTrigger = true;
}
}
}
// Prompt rate from MC
//--------------------------------------------------------------------------
bool pass = true;
pass &= (76. < _m2l && 106. > _m2l);
pass &= (_mtw < 20.);
if (pass && _sample.Contains("DYJetsToLL") && _Zlepton1type == Tight) {
float Zlep2pt = std_vector_lepton_pt->at(1);
float Zlep2eta = fabs(std_vector_lepton_eta->at(1));
if (fabs(_Zdecayflavour) == ELECTRON_FLAVOUR) {
h_Ele_loose_pt_eta_PR->Fill(Zlep2pt, Zlep2eta, _event_weight);
h_Ele_loose_pt_PR ->Fill(Zlep2pt, _event_weight);
h_Ele_loose_eta_PR ->Fill(Zlep2eta, _event_weight);
if (_Zlepton2type == Tight) {
h_Ele_tight_pt_eta_PR->Fill(Zlep2pt, Zlep2eta, _event_weight);
h_Ele_tight_pt_PR ->Fill(Zlep2pt, _event_weight);
h_Ele_tight_eta_PR ->Fill(Zlep2eta, _event_weight);
}
} else if (fabs(_Zdecayflavour) == MUON_FLAVOUR) {
h_Muon_loose_pt_eta_PR->Fill(Zlep2pt, Zlep2eta, _event_weight);
h_Muon_loose_pt_PR ->Fill(Zlep2pt, _event_weight);
h_Muon_loose_eta_PR ->Fill(Zlep2eta, _event_weight);
if (_Zlepton2type == Tight) {
h_Muon_tight_pt_eta_PR->Fill(Zlep2pt, Zlep2eta, _event_weight);
h_Muon_tight_pt_PR ->Fill(Zlep2pt, _event_weight);
h_Muon_tight_eta_PR ->Fill(Zlep2eta, _event_weight);
}
}
}
}
EndJob();
}