void cheat_manager::load_cheats(const char *filename)
{
std::string searchstr(machine().options().cheat_path());
std::string curpath;
for (path_iterator path(searchstr); path.next(curpath); )
{
searchstr.append(";").append(curpath).append(PATH_SEPARATOR).append("cheat");
}
emu_file cheatfile(std::move(searchstr), OPEN_FLAG_READ);
try
{
// loop over all instrances of the files found in our search paths
for (osd_file::error filerr = cheatfile.open(filename, ".xml"); filerr == osd_file::error::NONE; filerr = cheatfile.open_next())
{
osd_printf_verbose("Loading cheats file from %s\n", cheatfile.fullpath());
// read the XML file into internal data structures
xml_parse_options options = { nullptr };
xml_parse_error error;
options.error = &error;
std::unique_ptr<xml_data_node, void (*)(xml_data_node *)> rootnode(xml_data_node::file_read(cheatfile, &options), [] (xml_data_node *node) { node->file_free(); });
// if unable to parse the file, just bail
if (rootnode == nullptr)
throw emu_fatalerror("%s.xml(%d): error parsing XML (%s)\n", filename, error.error_line, error.error_message);
// find the layout node
xml_data_node *mamecheatnode = rootnode->get_child("mamecheat");
if (mamecheatnode == nullptr)
throw emu_fatalerror("%s.xml: missing mamecheatnode node", filename);
// validate the config data version
int version = mamecheatnode->get_attribute_int("version", 0);
if (version != CHEAT_VERSION)
throw emu_fatalerror("%s.xml(%d): Invalid cheat XML file: unsupported version", filename, mamecheatnode->line);
// parse all the elements
for (xml_data_node const *cheatnode = mamecheatnode->get_child("cheat"); cheatnode != nullptr; cheatnode = cheatnode->get_next_sibling("cheat"))
{
// load this entry
auto curcheat = std::make_unique<cheat_entry>(*this, m_symtable, filename, *cheatnode);
// make sure we're not a duplicate
if (REMOVE_DUPLICATE_CHEATS && curcheat->is_duplicate())
{
osd_printf_verbose("Ignoring duplicate cheat '%s' from file %s\n", curcheat->description(), cheatfile.fullpath());
}
else // add to the end of the list
m_cheatlist.push_back(std::move(curcheat));
}
}
}
// handle errors cleanly
catch (emu_fatalerror &err)
{
osd_printf_error("%s\n", err.string());
m_cheatlist.clear();
}
}
engine_factory( const std::string &name )
{
if (is_duplicate(name)) {
return;
}
factory_ptr ptr_to_this(this);
get_list().insert(make_pair(name,ptr_to_this));
}
goal_factory( const std::string &name )
{
if (is_duplicate(name)) {
return;
}
factory_ptr ptr_to_this(this);
get_list().emplace(name,ptr_to_this);
}
static int add_scan_param(gchar *hex_ssid, char *raw_ssid, int ssid_len,
int freq, GSupplicantScanParams *scan_data,
int driver_max_scan_ssids, char *ssid_name)
{
unsigned int i;
struct scan_ssid *scan_ssid;
if (driver_max_scan_ssids > scan_data->num_ssids &&
(hex_ssid != NULL || raw_ssid != NULL)) {
gchar *ssid;
unsigned int j = 0, hex;
if (hex_ssid != NULL) {
size_t hex_ssid_len = strlen(hex_ssid);
ssid = g_try_malloc0(hex_ssid_len / 2);
if (ssid == NULL)
return -ENOMEM;
for (i = 0; i < hex_ssid_len; i += 2) {
sscanf(hex_ssid + i, "%02x", &hex);
ssid[j++] = hex;
}
} else {
ssid = raw_ssid;
j = ssid_len;
}
/*
* If we have already added hidden AP to the list,
* then do not do it again. This might happen if you have
* used or are using multiple wifi cards, so in that case
* you might have multiple service files for same AP.
*/
if (is_duplicate(scan_data->ssids, ssid, j) == TRUE)
return 0;
scan_ssid = g_try_new(struct scan_ssid, 1);
if (scan_ssid == NULL) {
g_free(ssid);
return -ENOMEM;
}
memcpy(scan_ssid->ssid, ssid, j);
scan_ssid->ssid_len = j;
scan_data->ssids = g_slist_prepend(scan_data->ssids,
scan_ssid);
scan_data->num_ssids++;
DBG("SSID %s added to scanned list of %d entries", ssid_name,
scan_data->num_ssids);
if (hex_ssid != NULL)
g_free(ssid);
} else
static void
local_lock(cfglockd_t type, struct lock_msg *msg, daemonaddr_t *client)
{
if (is_duplicate(type, msg->pid, msg->seq)) {
if (the_lock.remote_daemon == NULL &&
(the_lock.type == LOCK_WRITE ||
the_lock.type == LOCK_READ) &&
the_lock.holding_pid[0] == msg->pid) {
send_lockmsg(LOCK_LOCKED, (pid_t)0, client, msg->seq);
}
} else {
queue_lock(type, msg, client);
}
}
void Dict::store_words()
{
//cout << "Store words called successfully" << endl;
int current_size = INIT_SIZE;
int current_count = 0;
for(int i = 0; i < current_size && !reference.eof(); i++)
{
reference >> words[i];
if(reference.eof()) break; // may need to move this further down
if(!isalpha(words[i][words[i].length() - 1]))
words[i].resize(words[i].length() - 1); // get rid of punctuation
if(is_duplicate(words, i))
{
// pretend it never happened...
i--;
continue;
} // if
current_count++;
////cout << i << ": " << words[i] << endl;
if(current_count == current_size)
resize(words, current_size);
} // for i
// clear ifstream object and set it back to the start
reference.clear(); // reset eof value and stuff
reference.seekg(0, std::ios::beg); // move back to start of file
word_count = current_count;
//cout << "Current count (words): " << current_count << endl;
//cout << "done" << endl;
} // store_words()
static void
local_unlock(pid_t pid, uint8_t seq, int method)
{
struct lockdaemon *ldp;
int i;
if (method == NORMAL_UNLOCK && is_duplicate(LOCK_NOTLOCKED, pid, seq)) {
return;
}
if (the_lock.type == LOCK_READ) {
/* delete reference to pid of reading process */
for (i = 0; i < the_lock.nholders; i++) {
if (the_lock.holding_pid[i] == pid) {
DPF((stderr, "decrement lockers from %d\n",
the_lock.nholders));
--the_lock.nholders;
break;
}
}
for (; i < the_lock.nholders; i++) {
the_lock.holding_pid[i] = the_lock.holding_pid[i+1];
}
if (the_lock.nholders > 0)
return;
} else {
/* LOCK_WRITE */
if (pid != the_lock.holding_pid[0])
return;
the_lock.holding_pid[0] = (pid_t)0;
for (i = 0, ldp = daemon_list; i < MAX_DAEMONS; i++, ldp++) {
if (ldp->inuse == 0)
break;
if (ldp->up)
send_lockmsg(UNLOCK, (pid_t)0, &(ldp->host), 0);
}
}
xxunlock();
}
/* Print or prepare for printing addresses from InternetAddressList. */
static void
process_address_list (const search_context_t *ctx,
InternetAddressList *list)
{
InternetAddress *address;
int i;
for (i = 0; i < internet_address_list_length (list); i++) {
address = internet_address_list_get_address (list, i);
if (INTERNET_ADDRESS_IS_GROUP (address)) {
InternetAddressGroup *group;
InternetAddressList *group_list;
group = INTERNET_ADDRESS_GROUP (address);
group_list = internet_address_group_get_members (group);
if (group_list == NULL)
continue;
process_address_list (ctx, group_list);
} else {
InternetAddressMailbox *mailbox = INTERNET_ADDRESS_MAILBOX (address);
mailbox_t mbx = {
.name = internet_address_get_name (address),
.addr = internet_address_mailbox_get_addr (mailbox),
};
/* OUTPUT_COUNT only works with deduplication */
if (ctx->dedup != DEDUP_NONE &&
is_duplicate (ctx, mbx.name, mbx.addr))
continue;
/* OUTPUT_COUNT and DEDUP_ADDRESS require a full pass. */
if (ctx->output & OUTPUT_COUNT || ctx->dedup == DEDUP_ADDRESS)
continue;
print_mailbox (ctx, &mbx);
}
}
}
int uniformize_catalog(fitstable_t* intable, fitstable_t* outtable,
const char* racol, const char* deccol,
const char* sortcol, anbool sort_ascending,
double sort_min_cut,
// ? Or do this cut in a separate process?
int bighp, int bignside,
int nmargin,
// uniformization nside.
int Nside,
double dedup_radius,
int nsweeps,
char** args, int argc) {
anbool allsky;
intmap_t* starlists;
int NHP;
anbool dense = FALSE;
double dedupr2 = 0.0;
tfits_type dubl;
int N;
int* inorder = NULL;
int* outorder = NULL;
int outi;
double *ra = NULL, *dec = NULL;
il* myhps = NULL;
int i,j,k;
int nkeep = nsweeps;
int noob = 0;
int ndup = 0;
struct oh_token token;
int* npersweep = NULL;
qfits_header* outhdr = NULL;
double *sortval = NULL;
if (bignside == 0)
bignside = 1;
allsky = (bighp == -1);
if (Nside % bignside) {
ERROR("Fine healpixelization Nside must be a multiple of the coarse healpixelization Nside");
return -1;
}
if (Nside > HP_MAX_INT_NSIDE) {
ERROR("Error: maximum healpix Nside = %i", HP_MAX_INT_NSIDE);
return -1;
}
NHP = 12 * Nside * Nside;
logverb("Healpix Nside: %i, # healpixes on the whole sky: %i\n", Nside, NHP);
if (!allsky) {
logverb("Creating index for healpix %i, nside %i\n", bighp, bignside);
logverb("Number of healpixes: %i\n", ((Nside/bignside)*(Nside/bignside)));
}
logverb("Healpix side length: %g arcmin.\n", healpix_side_length_arcmin(Nside));
dubl = fitscolumn_double_type();
if (!racol)
racol = "RA";
ra = fitstable_read_column(intable, racol, dubl);
if (!ra) {
ERROR("Failed to find RA column (%s) in table", racol);
return -1;
}
if (!deccol)
deccol = "DEC";
dec = fitstable_read_column(intable, deccol, dubl);
if (!dec) {
ERROR("Failed to find DEC column (%s) in table", deccol);
free(ra);
return -1;
}
N = fitstable_nrows(intable);
logverb("Have %i objects\n", N);
// FIXME -- argsort and seek around the input table, and append to
// starlists in order; OR read from the input table in sequence and
// sort in the starlists?
if (sortcol) {
logverb("Sorting by %s...\n", sortcol);
sortval = fitstable_read_column(intable, sortcol, dubl);
if (!sortval) {
ERROR("Failed to read sorting column \"%s\"", sortcol);
free(ra);
free(dec);
return -1;
}
inorder = permuted_sort(sortval, sizeof(double),
sort_ascending ? compare_doubles_asc : compare_doubles_desc,
NULL, N);
if (sort_min_cut > -HUGE_VAL) {
logverb("Cutting to %s > %g...\n", sortcol, sort_min_cut);
// Cut objects with sortval < sort_min_cut.
if (sort_ascending) {
// skipped objects are at the front -- find the first obj
// to keep
for (i=0; i<N; i++)
if (sortval[inorder[i]] > sort_min_cut)
break;
// move the "inorder" indices down.
if (i)
memmove(inorder, inorder+i, (N-i)*sizeof(int));
N -= i;
} else {
// skipped objects are at the end -- find the last obj to keep.
for (i=N-1; i>=0; i--)
if (sortval[inorder[i]] > sort_min_cut)
break;
N = i+1;
}
logverb("Cut to %i objects\n", N);
}
//free(sortval);
}
token.nside = bignside;
token.finenside = Nside;
token.hp = bighp;
if (!allsky && nmargin) {
int bigbighp, bighpx, bighpy;
//int ninside;
il* seeds = il_new(256);
logverb("Finding healpixes in range...\n");
healpix_decompose_xy(bighp, &bigbighp, &bighpx, &bighpy, bignside);
//ninside = (Nside/bignside)*(Nside/bignside);
// Prime the queue with the fine healpixes that are on the
// boundary of the big healpix.
for (i=0; i<((Nside / bignside) - 1); i++) {
// add (i,0), (i,max), (0,i), and (0,max) healpixes
int xx = i + bighpx * (Nside / bignside);
int yy = i + bighpy * (Nside / bignside);
int y0 = bighpy * (Nside / bignside);
// -1 prevents us from double-adding the corners.
int y1 =(1 + bighpy)* (Nside / bignside) - 1;
int x0 = bighpx * (Nside / bignside);
int x1 =(1 + bighpx)* (Nside / bignside) - 1;
assert(xx < Nside);
assert(yy < Nside);
assert(x0 < Nside);
assert(x1 < Nside);
assert(y0 < Nside);
assert(y1 < Nside);
il_append(seeds, healpix_compose_xy(bigbighp, xx, y0, Nside));
il_append(seeds, healpix_compose_xy(bigbighp, xx, y1, Nside));
il_append(seeds, healpix_compose_xy(bigbighp, x0, yy, Nside));
il_append(seeds, healpix_compose_xy(bigbighp, x1, yy, Nside));
}
logmsg("Number of boundary healpixes: %zu (Nside/bignside = %i)\n", il_size(seeds), Nside/bignside);
myhps = healpix_region_search(-1, seeds, Nside, NULL, NULL,
outside_healpix, &token, nmargin);
logmsg("Number of margin healpixes: %zu\n", il_size(myhps));
il_free(seeds);
il_sort(myhps, TRUE);
// DEBUG
il_check_consistency(myhps);
il_check_sorted_ascending(myhps, TRUE);
}
dedupr2 = arcsec2distsq(dedup_radius);
starlists = intmap_new(sizeof(int32_t), nkeep, 0, dense);
logverb("Placing stars in grid cells...\n");
for (i=0; i<N; i++) {
int hp;
bl* lst;
int32_t j32;
anbool oob;
if (inorder) {
j = inorder[i];
//printf("Placing star %i (%i): sort value %s = %g, RA,Dec=%g,%g\n", i, j, sortcol, sortval[j], ra[j], dec[j]);
} else
j = i;
hp = radecdegtohealpix(ra[j], dec[j], Nside);
//printf("HP %i\n", hp);
// in bounds?
oob = FALSE;
if (myhps) {
oob = (outside_healpix(hp, &token) && !il_sorted_contains(myhps, hp));
} else if (!allsky) {
oob = (outside_healpix(hp, &token));
}
if (oob) {
//printf("out of bounds.\n");
noob++;
continue;
}
lst = intmap_find(starlists, hp, TRUE);
/*
printf("list has %i existing entries.\n", bl_size(lst));
for (k=0; k<bl_size(lst); k++) {
bl_get(lst, k, &j32);
printf(" %i: index %i, %s = %g\n", k, j32, sortcol, sortval[j32]);
}
*/
// is this list full?
if (nkeep && (bl_size(lst) >= nkeep)) {
// Here we assume we're working in sorted order: once the list is full we're done.
//printf("Skipping: list is full.\n");
continue;
}
if ((dedupr2 > 0.0) &&
is_duplicate(hp, ra[j], dec[j], Nside, starlists, ra, dec, dedupr2)) {
//printf("Skipping: duplicate\n");
ndup++;
continue;
}
// Add the new star (by index)
j32 = j;
bl_append(lst, &j32);
}
logverb("%i outside the healpix\n", noob);
logverb("%i duplicates\n", ndup);
il_free(myhps);
myhps = NULL;
free(inorder);
inorder = NULL;
free(ra);
ra = NULL;
free(dec);
dec = NULL;
outorder = malloc(N * sizeof(int));
outi = 0;
npersweep = calloc(nsweeps, sizeof(int));
for (k=0; k<nsweeps; k++) {
int starti = outi;
int32_t j32;
for (i=0;; i++) {
bl* lst;
int hp;
if (!intmap_get_entry(starlists, i, &hp, &lst))
break;
if (bl_size(lst) <= k)
continue;
bl_get(lst, k, &j32);
outorder[outi] = j32;
//printf("sweep %i, cell #%i, hp %i, star %i, %s = %g\n", k, i, hp, j32, sortcol, sortval[j32]);
outi++;
}
logmsg("Sweep %i: %i stars\n", k+1, outi - starti);
npersweep[k] = outi - starti;
if (sortcol) {
// Re-sort within this sweep.
permuted_sort(sortval, sizeof(double),
sort_ascending ? compare_doubles_asc : compare_doubles_desc,
outorder + starti, npersweep[k]);
/*
for (i=0; i<npersweep[k]; i++) {
printf(" within sweep %i: star %i, j=%i, %s=%g\n",
k, i, outorder[starti + i], sortcol, sortval[outorder[starti + i]]);
}
*/
}
}
intmap_free(starlists);
starlists = NULL;
//////
free(sortval);
sortval = NULL;
logmsg("Total: %i stars\n", outi);
N = outi;
outhdr = fitstable_get_primary_header(outtable);
if (allsky)
qfits_header_add(outhdr, "ALLSKY", "T", "All-sky catalog.", NULL);
BOILERPLATE_ADD_FITS_HEADERS(outhdr);
qfits_header_add(outhdr, "HISTORY", "This file was generated by the command-line:", NULL, NULL);
fits_add_args(outhdr, args, argc);
qfits_header_add(outhdr, "HISTORY", "(end of command line)", NULL, NULL);
fits_add_long_history(outhdr, "uniformize-catalog args:");
fits_add_long_history(outhdr, " RA,Dec columns: %s,%s", racol, deccol);
fits_add_long_history(outhdr, " sort column: %s", sortcol);
fits_add_long_history(outhdr, " sort direction: %s", sort_ascending ? "ascending" : "descending");
if (sort_ascending)
fits_add_long_history(outhdr, " (ie, for mag-like sort columns)");
else
fits_add_long_history(outhdr, " (ie, for flux-like sort columns)");
fits_add_long_history(outhdr, " uniformization nside: %i", Nside);
fits_add_long_history(outhdr, " (ie, side length ~ %g arcmin)", healpix_side_length_arcmin(Nside));
fits_add_long_history(outhdr, " deduplication scale: %g arcsec", dedup_radius);
fits_add_long_history(outhdr, " number of sweeps: %i", nsweeps);
fits_header_add_int(outhdr, "NSTARS", N, "Number of stars.");
fits_header_add_int(outhdr, "HEALPIX", bighp, "Healpix covered by this catalog, with Nside=HPNSIDE");
fits_header_add_int(outhdr, "HPNSIDE", bignside, "Nside of HEALPIX.");
fits_header_add_int(outhdr, "CUTNSIDE", Nside, "uniformization scale (healpix nside)");
fits_header_add_int(outhdr, "CUTMARG", nmargin, "margin size, in healpixels");
//qfits_header_add(outhdr, "CUTBAND", cutband, "band on which the cut was made", NULL);
fits_header_add_double(outhdr, "CUTDEDUP", dedup_radius, "deduplication radius [arcsec]");
fits_header_add_int(outhdr, "CUTNSWEP", nsweeps, "number of sweeps");
//fits_header_add_double(outhdr, "CUTMINMG", minmag, "minimum magnitude");
//fits_header_add_double(outhdr, "CUTMAXMG", maxmag, "maximum magnitude");
for (k=0; k<nsweeps; k++) {
char key[64];
sprintf(key, "SWEEP%i", (k+1));
fits_header_add_int(outhdr, key, npersweep[k], "# stars added");
}
free(npersweep);
if (fitstable_write_primary_header(outtable)) {
ERROR("Failed to write primary header");
return -1;
}
// Write output.
fitstable_add_fits_columns_as_struct2(intable, outtable);
if (fitstable_write_header(outtable)) {
ERROR("Failed to write output table header");
return -1;
}
logmsg("Writing output...\n");
logverb("Row size: %i\n", fitstable_row_size(intable));
if (fitstable_copy_rows_data(intable, outorder, N, outtable)) {
ERROR("Failed to copy rows from input table to output");
return -1;
}
if (fitstable_fix_header(outtable)) {
ERROR("Failed to fix output table header");
return -1;
}
free(outorder);
return 0;
}
//
// Functions
//
int looper( sampleInfo::ID sampleID, std::vector<analyzer*> analyzers, int nEvents, bool readFast ) {
//
// Intro
//
cout << "====================================================" << endl;
cout << endl;
cout << " WELCOME TO STOP BABY ANALYZER! " << endl;
cout << endl;
cout << "====================================================" << endl;
cout << endl;
//
// Benchmark
//
TBenchmark *bmark = new TBenchmark();
bmark->Start("benchmark");
//
// Input SampleInfo
//
sampleInfo::sampleUtil sample( sampleID );
bool sampleIsTTbar = false;
if( sample.id == sampleInfo::k_ttbar_powheg_pythia8 ||
sample.id == sampleInfo::k_ttbar_powheg_pythia8_ext4 ||
sample.id == sampleInfo::k_ttbar_singleLeptFromT_madgraph_pythia8 ||
sample.id == sampleInfo::k_ttbar_singleLeptFromT_madgraph_pythia8_ext1 ||
sample.id == sampleInfo::k_ttbar_singleLeptFromTbar_madgraph_pythia8 ||
sample.id == sampleInfo::k_ttbar_singleLeptFromTbar_madgraph_pythia8_ext1 ||
sample.id == sampleInfo::k_ttbar_diLept_madgraph_pythia8 ||
sample.id == sampleInfo::k_ttbar_diLept_madgraph_pythia8_ext1 ) {
sampleIsTTbar = true;
}
//
// Input chain
//
TChain *chain = new TChain("t");
cout << " Processing the following: " << endl;
for(int iFile=0; iFile<(int)sample.inputBabies.size(); iFile++) {
// input directory
string input = sample.baby_i_o.first;
// input file
input += sample.inputBabies[iFile];
chain->Add( input.c_str() );
cout << " " << input << endl;
}
cout << endl;
//
// Output File
//
// output dir
string f_output_name = "";
f_output_name += sample.baby_i_o.second;
// output name
f_output_name += sample.label;
f_output_name += ".root";
// output file
TFile *f_output = new TFile( f_output_name.c_str(), "recreate" );
// print output location
cout << " Output Written to: " << endl;
cout << " " << f_output_name << endl;
cout << endl;
//
// JSON File Tools
//
const char* json_file = "../StopCORE/inputs/json_files/Cert_271036-284044_13TeV_23Sep2016ReReco_Collisions16_JSON.txt"; // 35.876fb final 2016 run
if( sample.isData ) set_goodrun_file_json(json_file);
//
// Event Weight Utilities
//
cout << " Loading eventWeight Utilities..." << endl << endl;
wgtInfo.setUp( sample.id, useBTagSFs_fromFiles_, useLepSFs_fromFiles_, add2ndLepToMet_ );
wgtInfo.apply_cr2lTrigger_sf = (apply_cr2lTrigger_sf_ && add2ndLepToMet_);
wgtInfo.apply_bTag_sf = apply_bTag_sf_;
wgtInfo.apply_lep_sf = apply_lep_sf_;
wgtInfo.apply_vetoLep_sf = apply_vetoLep_sf_;
wgtInfo.apply_tau_sf = apply_tau_sf_;
wgtInfo.apply_lepFS_sf = apply_lepFS_sf_;
wgtInfo.apply_topPt_sf = apply_topPt_sf_;
wgtInfo.apply_metRes_sf = apply_metRes_sf_;
wgtInfo.apply_metTTbar_sf = apply_metTTbar_sf_;
wgtInfo.apply_ttbarSysPt_sf = apply_ttbarSysPt_sf_;
wgtInfo.apply_ISR_sf = apply_ISR_sf_;
wgtInfo.apply_pu_sf = apply_pu_sf_;
wgtInfo.apply_sample_sf = apply_sample_sf_;
//
// Declare genClassification list
//
cout << " Loading genClassyList: ";
std::vector< genClassyInfo::Util > genClassyList;
if( sample.isData ) {
genClassyList.push_back(genClassyInfo::Util(genClassyInfo::k_incl));
}
else{
for(int iGenClassy=0; iGenClassy<genClassyInfo::k_nGenClassy; iGenClassy++) {
genClassyList.push_back( genClassyInfo::Util(genClassyInfo::ID(iGenClassy)) );
}
}
const int nGenClassy=(int)genClassyList.size();
cout << nGenClassy << " genClassifications" << endl << endl;
//
// Declare Systematics
//
cout << " Loading systematicList: ";
std::vector< sysInfo::Util > systematicList;
if( sample.isData || analyzeFast_ ) {
systematicList.push_back(sysInfo::Util(sysInfo::k_nominal));
}
else{
for(int iSys=0; iSys<sysInfo::k_nSys; iSys++) {
systematicList.push_back( sysInfo::Util(sysInfo::ID(iSys)) );
}
}
const int nSystematics = (int)systematicList.size();
cout << nSystematics << " systematics" << endl << endl;
// Count number of analyzers in the list
const int nAnalyzers = analyzers.size();
////////////////////////
// //
// Declare Histograms //
// //
////////////////////////
//
//
// For Using DownStream Scripts, please adhere to the conventions:
//
//
// histogram_name = "your_name_here"+"__"+regionList[i]+"__genClassy_"+genClassyObject.label+"__systematic_"+sysInfoObject.label;
//
//
// Where regionList is the list of "SR", "CR0b", "CR0b_tightBTagHighMlb" or "CR2l"
//
// And systematicList[0] is the nominal selection
//
// And if there is andditional selection involved in this histogram, please refer to it in "you name here"
//
cout << " Preparing histograms" << endl << endl;
//
// Declare yield histograms
//
f_output->cd(); // All yield histos will belong to the output file
for( analyzer* thisAnalyzer : analyzers ) {
TH1D* h_template = thisAnalyzer->GetYieldTemplate();
TH3D* h_template_signal = thisAnalyzer->GetYieldTemplateSignal();
for( int iClassy=0; iClassy<nGenClassy; iClassy++ ) {
for( int iSys=0; iSys<nSystematics; iSys++ ) {
int histIndex = iClassy*nSystematics + iSys;
// Gen and Systematic String
TString reg_gen_sys_name = "__";
reg_gen_sys_name += thisAnalyzer->GetLabel();
reg_gen_sys_name += "__genClassy_";
reg_gen_sys_name += genClassyList[iClassy].label;
reg_gen_sys_name += "__systematic_";
reg_gen_sys_name += systematicList[iSys].label;
TH1* h_tmp = 0;
TString yieldname = "h_yields";
yieldname += reg_gen_sys_name;
if( sample.isSignalScan ) h_tmp = (TH3D*)h_template_signal->Clone( yieldname );
else h_tmp = (TH1D*)h_template->Clone( yieldname );
thisAnalyzer->SetYieldHistogram( histIndex, h_tmp );
} // End loop over systematics
} // End loop over genClassys
} // End loop over analyzers
//
// Declare non-yield histograms
//
int nMassPts = 1;
if( sample.isSignalScan ) nMassPts = (int)sample.massPtList.size();
const int nHistosVars = nAnalyzers*nGenClassy*nMassPts;
// nJets
TH1D *h_nJets[nHistosVars];
// nBTags
TH1D *h_nBTags[nHistosVars];
// lep1 pT
TH1D *h_lep1Pt_incl[nHistosVars];
// lep2 pT
TH1D *h_lep2Pt_incl[nHistosVars];
// jet pT
TH1D *h_jetPt_incl[nHistosVars];
// jet1 pT
TH1D *h_jet1Pt_incl[nHistosVars];
// jet2 pT
TH1D *h_jet2Pt_incl[nHistosVars];
// DeepCSV jet1 pT
TH1D *h_deepcsvJet1Pt_incl[nHistosVars];
// DeepCSV jet2 pT
TH1D *h_deepcsvJet2Pt_incl[nHistosVars];
// met
TH1D *h_met_incl[nHistosVars];
TH1D *h_met_lt4j[nHistosVars];
TH1D *h_met_ge4j[nHistosVars];
// lep1lep2bbMetPt
TH1D *h_lep1lep2bbMetPt_incl[nHistosVars];
TH1D *h_lep1lep2bbMetPt_lt4j[nHistosVars];
TH1D *h_lep1lep2bbMetPt_ge4j[nHistosVars];
// mt
TH1D *h_mt_incl[nHistosVars];
// modTopness
TH1D *h_modTopness_incl[nHistosVars];
TH1D *h_modTopness_lt4j[nHistosVars];
TH1D *h_modTopness_ge4j[nHistosVars];
// mlb
TH1D *h_mlb_incl[nHistosVars];
TH1D *h_mlb_lt4j[nHistosVars];
TH1D *h_mlb_ge4j[nHistosVars];
// mlb
TH1D *h_mlb_lt0modTopness[nHistosVars];
TH1D *h_mlb_ge0modTopness[nHistosVars];
TH1D *h_mlb_ge10modTopness[nHistosVars];
// mlb, met sideband CR
TH1D *h_mlb_150to250met_incl[nHistosVars];
TH1D *h_mlb_150to250met_lt4j[nHistosVars];
TH1D *h_mlb_150to250met_ge4j[nHistosVars];
// ml2b
TH1D *h_mlb_lep2_incl[nHistosVars];
TH1D *h_mlb_lep2_lt4j[nHistosVars];
TH1D *h_mlb_lep2_ge4j[nHistosVars];
// ml2b
TH1D *h_mlb_lep2_150to250met_incl[nHistosVars];
TH1D *h_mlb_lep2_150to250met_lt4j[nHistosVars];
TH1D *h_mlb_lep2_150to250met_ge4j[nHistosVars];
// Gen ttbar system pT
TH1D *h_gen_ttbarPt_incl[nHistosVars];
TH1D *h_gen_ttbarPt_lt4j[nHistosVars];
TH1D *h_gen_ttbarPt_ge4j[nHistosVars];
// Gen 2nd lepton ID
TH1D *h_gen_lep2_id_incl[nHistosVars];
TH1D *h_gen_lep2_id_lt4j[nHistosVars];
TH1D *h_gen_lep2_id_ge4j[nHistosVars];
f_output->cd(); // All non-yield histos will belong to the output file
for(int iReg=0; iReg<nAnalyzers; iReg++) {
for(int iGen=0; iGen<nGenClassy; iGen++) {
for(int iMassPt=0; iMassPt<nMassPts; iMassPt++) {
// Histo Index
int iHisto = iReg*nGenClassy*nMassPts + iGen*nMassPts + iMassPt;
int mStop = 0;
int mLSP = 0;
if(sample.isSignalScan) {
mStop = sample.massPtList[iMassPt].first;
mLSP = sample.massPtList[iMassPt].second;
}
TString hName = "";
TString reg_gen_sys_name = "__";
reg_gen_sys_name += analyzers.at(iReg)->GetLabel();
reg_gen_sys_name += "__genClassy_";
reg_gen_sys_name += genClassyList[iGen].label;
reg_gen_sys_name += "__systematic_";
reg_gen_sys_name += systematicList[0].label;
if( sample.isSignalScan ) {
reg_gen_sys_name += "__mStop_";
reg_gen_sys_name += mStop;
reg_gen_sys_name += "__mLSP_";
reg_gen_sys_name += mLSP;
}
//
// Njets
//
hName = "h_nJets" + reg_gen_sys_name;
h_nJets[iHisto] = new TH1D( hName, "Number of Selected Jets;nJets", 11, -0.5, 10.5);
//
// nBTags
//
hName = "h_nBTags" + reg_gen_sys_name;
h_nBTags[iHisto] = new TH1D( hName, "Number of b-Tagged Jets;nBTags", 5, -0.5, 4.5);
//
// lep1Pt
//
// Incl Selection
hName = "h_lep1Pt__inclSelection" + reg_gen_sys_name;
h_lep1Pt_incl[iHisto] = new TH1D( hName, "Lepton p_{T};p_{T} [GeV]", 20.0, 0.0, 200.0 );
//
// lep2Pt
//
// Incl Selection
hName = "h_lep2Pt__inclSelection" + reg_gen_sys_name;
h_lep2Pt_incl[iHisto] = new TH1D( hName, "Trailing Lepton p_{T};p_{T} [GeV]", 20.0, 0.0, 200.0 );
//
// jetPt
//
// Incl Selection
hName = "h_jetPt__inclSelection" + reg_gen_sys_name;
h_jetPt_incl[iHisto] = new TH1D( hName, "Jet p_{T};p_{T} [GeV]", 24, 0.0, 600.0 );
//
// jet1Pt
//
// Incl Selection
hName = "h_jet1Pt__inclSelection" + reg_gen_sys_name;
h_jet1Pt_incl[iHisto] = new TH1D( hName, "Leading Jet p_{T};p_{T} [GeV]", 24, 0.0, 600.0 );
//
// jet2Pt
//
// Incl Selection
hName = "h_jet2Pt__inclSelection" + reg_gen_sys_name;
h_jet2Pt_incl[iHisto] = new TH1D( hName, "2nd Leading Jet p_{T};p_{T} [GeV]", 24, 0.0, 600.0 );
//
// DeepCSVJet1Pt
//
// Incl Selection
hName = "h_deepcsvJet1Pt__inclSelection" + reg_gen_sys_name;
h_deepcsvJet1Pt_incl[iHisto] = new TH1D( hName, "Leading DeepCSV Jet p_{T};p_{T} [GeV]", 24, 0.0, 600.0 );
//
// DeepCSVJet2Pt
//
// Incl Selection
hName = "h_deepcsvJet2Pt__inclSelection" + reg_gen_sys_name;
h_deepcsvJet2Pt_incl[iHisto] = new TH1D( hName, "2nd Leading DeepCSV Jet p_{T};p_{T} [GeV]", 24, 0.0, 600.0 );
//
// met
//
// Incl Selection
hName = "h_met__inclSelection" + reg_gen_sys_name;
h_met_incl[iHisto] = new TH1D( hName, "MET;MET [GeV]", 32, 0.0, 800.0 );
// <4j Selection
hName = "h_met__lt4jSelection" + reg_gen_sys_name;
h_met_lt4j[iHisto] = new TH1D( hName, "MET;MET [GeV]", 32, 0.0, 800.0 );
// >=4j Selection
hName = "h_met__ge4jSelection" + reg_gen_sys_name;
h_met_ge4j[iHisto] = new TH1D( hName, "MET;MET [GeV]", 32, 0.0, 800.0 );
//
// lep1lep2bbMetPt
//
// Incl Selection
hName = "h_lep1lep2bbMetPt__inclSelection" + reg_gen_sys_name;
h_lep1lep2bbMetPt_incl[iHisto] = new TH1D( hName, "lep1(lep2)bbMet system p_{T};p_{T} [GeV]", 24, 0.0, 600.0 );
// <4j Selection
hName = "h_lep1lep2bbMetPt__lt4jSelection" + reg_gen_sys_name;
h_lep1lep2bbMetPt_lt4j[iHisto] = new TH1D( hName, "lep1(lep2)bbMet system p_{T};p_{T} [GeV]", 24, 0.0, 600.0 );
// >=4j Selection
hName = "h_lep1lep2bbMetPt__ge4jSelection" + reg_gen_sys_name;
h_lep1lep2bbMetPt_ge4j[iHisto] = new TH1D( hName, "lep1(lep2)bbMet system p_{T};p_{T} [GeV]", 24, 0.0, 600.0 );
//
// mt
//
// Incl Selection
hName = "h_mt__inclSelection" + reg_gen_sys_name;
h_mt_incl[iHisto] = new TH1D( hName, "M_{T};M_{T} [GeV]", 24, 0.0, 600.0 );
//
// modTopness
//
// Incl Selection
hName = "h_modTopness__inclSelection" + reg_gen_sys_name;
h_modTopness_incl[iHisto] = new TH1D( hName, "Modified Topness;Modified Topness", 20, -20.0, 20.0 );
// <4j Selection
hName = "h_modTopness__lt4jSelection" + reg_gen_sys_name;
h_modTopness_lt4j[iHisto] = new TH1D( hName, "Modified Topness;Modified Topness", 20, -20.0, 20.0 );
// >=4j Selection
hName = "h_modTopness__ge4jSelection" + reg_gen_sys_name;
h_modTopness_ge4j[iHisto] = new TH1D( hName, "Modified Topness;Modified Topness", 20, -20.0, 20.0 );
//
// mlb
//
// Incl Selection
hName = "h_mlb__inclSelection" + reg_gen_sys_name;
h_mlb_incl[iHisto] = new TH1D( hName, "M_{lb};M_{lb} [GeV]", 24, 0.0, 600.0 );
// <4j Selection
hName = "h_mlb__lt4jSelection" + reg_gen_sys_name;
h_mlb_lt4j[iHisto] = new TH1D( hName, "M_{lb};M_{lb} [GeV]", 24, 0.0, 600.0 );
// >=4j Selection
hName = "h_mlb__ge4jSelection" + reg_gen_sys_name;
h_mlb_ge4j[iHisto] = new TH1D( hName, "M_{lb};M_{lb} [GeV]", 24, 0.0, 600.0 );
//
// mlb, inclusive nJets, modTopness bins
//
// <0 modTopness Selection
hName = "h_mlb__lt0modTopnessSelection" + reg_gen_sys_name;
h_mlb_lt0modTopness[iHisto] = new TH1D( hName, "M_{lb};M_{lb} [GeV]", 24, 0.0, 600.0 );
// >=0 modTopness Selection
hName = "h_mlb__ge0modTopnessSelection" + reg_gen_sys_name;
h_mlb_ge0modTopness[iHisto] = new TH1D( hName, "M_{lb};M_{lb} [GeV]", 24, 0.0, 600.0 );
// >=10 modTopness Selection
hName = "h_mlb__ge10modTopnessSelection" + reg_gen_sys_name;
h_mlb_ge10modTopness[iHisto] = new TH1D( hName, "M_{lb};M_{lb} [GeV]", 24, 0.0, 600.0 );
//
// mlb, met sideband CR
//
// Incl Selection
hName = "h_mlb_150to250met__inclSelection" + reg_gen_sys_name;
h_mlb_150to250met_incl[iHisto] = new TH1D( hName, "M_{lb};M_{lb} [GeV]", 24, 0.0, 600.0 );
// <4j Selection
hName = "h_mlb_150to250met__lt4jSelection" + reg_gen_sys_name;
h_mlb_150to250met_lt4j[iHisto] = new TH1D( hName, "M_{lb};M_{lb} [GeV]", 24, 0.0, 600.0 );
// >=4j Selection
hName = "h_mlb_150to250met__ge4jSelection" + reg_gen_sys_name;
h_mlb_150to250met_ge4j[iHisto] = new TH1D( hName, "M_{lb};M_{lb} [GeV]", 24, 0.0, 600.0 );
//
// mlb_lep2
//
// Incl Selection
hName = "h_mlb_lep2__inclSelection" + reg_gen_sys_name;
h_mlb_lep2_incl[iHisto] = new TH1D( hName, "M_{l2b};M_{l2b} [GeV]", 24, 0.0, 600.0 );
// <4j Selection
hName = "h_mlb_lep2__lt4jSelection" + reg_gen_sys_name;
h_mlb_lep2_lt4j[iHisto] = new TH1D( hName, "M_{l2b};M_{l2b} [GeV]", 24, 0.0, 600.0 );
// >=4j Selection
hName = "h_mlb_lep2__ge4jSelection" + reg_gen_sys_name;
h_mlb_lep2_ge4j[iHisto] = new TH1D( hName, "M_{l2b};M_{l2b} [GeV]", 24, 0.0, 600.0 );
//
// mlb_lep2, met CR sideband
//
// Incl Selection
hName = "h_mlb_lep2_150to250met__inclSelection" + reg_gen_sys_name;
h_mlb_lep2_150to250met_incl[iHisto] = new TH1D( hName, "M_{l2b};M_{l2b} [GeV]", 24, 0.0, 600.0 );
// <4j Selection
hName = "h_mlb_lep2_150to250met__lt4jSelection" + reg_gen_sys_name;
h_mlb_lep2_150to250met_lt4j[iHisto] = new TH1D( hName, "M_{l2b};M_{l2b} [GeV]", 24, 0.0, 600.0 );
// >=4j Selection
hName = "h_mlb_lep2_150to250met__ge4jSelection" + reg_gen_sys_name;
h_mlb_lep2_150to250met_ge4j[iHisto] = new TH1D( hName, "M_{l2b};M_{l2b} [GeV]", 24, 0.0, 600.0 );
//
// Gen ttbar pT
//
if( !sample.isData ) {
// Incl Selection
hName = "h_gen_ttbarPt__inclSelection" + reg_gen_sys_name;
h_gen_ttbarPt_incl[iHisto] = new TH1D( hName, "Gen t#bar{t} system p_{T};p_{T} [GeV]", 24, 0.0, 600.0 );
// <4j Selection
hName = "h_gen_ttbarPt__lt4jSelection" + reg_gen_sys_name;
h_gen_ttbarPt_lt4j[iHisto] = new TH1D( hName, "Gen t#bar{t} system p_{T};p_{T} [GeV]", 24, 0.0, 600.0 );
// >=4j Selection
hName = "h_gen_ttbarPt__ge4jSelection" + reg_gen_sys_name;
h_gen_ttbarPt_ge4j[iHisto] = new TH1D( hName, "Gen t#bar{t} system p_{T};p_{T} [GeV]", 24, 0.0, 600.0 );
//
// Gen Lep2 ID
//
// Incl Selection
hName = "h_gen_lep2_id__inclSelection" + reg_gen_sys_name;
h_gen_lep2_id_incl[iHisto] = new TH1D( hName, "Gen 2nd Lepton ID;ID", 7, 1.0, 8.0 );
h_gen_lep2_id_incl[iHisto]->GetXaxis()->SetBinLabel(1, "ele");
h_gen_lep2_id_incl[iHisto]->GetXaxis()->SetBinLabel(2, "mu");
h_gen_lep2_id_incl[iHisto]->GetXaxis()->SetBinLabel(3, "lep tau, ele");
h_gen_lep2_id_incl[iHisto]->GetXaxis()->SetBinLabel(4, "lep tau, mu");
h_gen_lep2_id_incl[iHisto]->GetXaxis()->SetBinLabel(5, "had tau, 1 prong");
h_gen_lep2_id_incl[iHisto]->GetXaxis()->SetBinLabel(6, "had tau, 3 prong");
h_gen_lep2_id_incl[iHisto]->GetXaxis()->SetBinLabel(7, "\"other\" tau");
// <4j Selection
hName = "h_gen_lep2_id__lt4jSelection" + reg_gen_sys_name;
h_gen_lep2_id_lt4j[iHisto] = new TH1D( hName, "Gen 2nd Lepton ID;ID", 7, 1.0, 8.0 );
h_gen_lep2_id_lt4j[iHisto]->GetXaxis()->SetBinLabel(1, "ele");
h_gen_lep2_id_lt4j[iHisto]->GetXaxis()->SetBinLabel(2, "mu");
h_gen_lep2_id_lt4j[iHisto]->GetXaxis()->SetBinLabel(3, "lep tau, ele");
h_gen_lep2_id_lt4j[iHisto]->GetXaxis()->SetBinLabel(4, "lep tau, mu");
h_gen_lep2_id_lt4j[iHisto]->GetXaxis()->SetBinLabel(5, "had tau, 1 prong");
h_gen_lep2_id_lt4j[iHisto]->GetXaxis()->SetBinLabel(6, "had tau, 3 prong");
h_gen_lep2_id_lt4j[iHisto]->GetXaxis()->SetBinLabel(7, "\"other\" tau");
// >=4j Selection
hName = "h_gen_lep2_id__ge4jSelection" + reg_gen_sys_name;
h_gen_lep2_id_ge4j[iHisto] = new TH1D( hName, "Gen 2nd Lepton ID;ID", 7, 1.0, 8.0 );
h_gen_lep2_id_ge4j[iHisto]->GetXaxis()->SetBinLabel(1, "ele");
h_gen_lep2_id_ge4j[iHisto]->GetXaxis()->SetBinLabel(2, "mu");
h_gen_lep2_id_ge4j[iHisto]->GetXaxis()->SetBinLabel(3, "lep tau, ele");
h_gen_lep2_id_ge4j[iHisto]->GetXaxis()->SetBinLabel(4, "lep tau, mu");
h_gen_lep2_id_ge4j[iHisto]->GetXaxis()->SetBinLabel(5, "had tau, 1 prong");
h_gen_lep2_id_ge4j[iHisto]->GetXaxis()->SetBinLabel(6, "had tau, 3 prong");
h_gen_lep2_id_ge4j[iHisto]->GetXaxis()->SetBinLabel(7, "\"other\" tau");
} // end if sample is ttbar
} // end loop over mass pts (1 pt only if not signal scan)
} // end loop over genClassifications for histogram arrays
} // end loop over analyzers/regions for histogram arrays
// Set up cutflow histograms
TH1D* h_cutflow[nAnalyzers];
for( int iAna=0; iAna<nAnalyzers; iAna++ ) {
analyzer* thisAnalyzer = analyzers.at(iAna);
std::string histName = "h_cutflow_";
std::string histTitle = "Cutflow histogram ";
histName += thisAnalyzer->GetLabel();
histTitle += thisAnalyzer->GetLabel();
h_cutflow[iAna] = selectionInfo::get_cutflowHistoTemplate( thisAnalyzer->GetSelections(), histName, histTitle );
}
//////////////////////
// //
// Loop Over Events //
// //
//////////////////////
// Event Counters
cout << " Loading files to loop over" << endl << endl;
unsigned int nEventsTotal = 0;
unsigned int nEventsChain = chain->GetEntries();
if( nEvents >= 0 ) nEventsChain = nEvents;
// Grab list of files
TObjArray *listOfFiles = chain->GetListOfFiles();
TIter fileIter(listOfFiles);
TFile *currentFile = 0;
while ( (currentFile = (TFile*)fileIter.Next()) ) {
//////////////////////
// //
// Get File Content //
// //
//////////////////////
// Open File and Get Tree
TFile *file = new TFile( currentFile->GetTitle(), "read" );
TTree *tree = (TTree*)file->Get("t");
if(readFast) TTreeCache::SetLearnEntries(10);
if(readFast) tree->SetCacheSize(128*1024*1024);
babyAnalyzer.Init(tree);
// Get weight histogram from baby
wgtInfo.getWeightHistogramFromBaby( file );
// Loop over Events in current file
if( nEventsTotal >= nEventsChain ) continue;
unsigned int nEventsTree = tree->GetEntriesFast();
for( unsigned int event = 0; event < nEventsTree; ++event) {
///////////////////////
// //
// Get Event Content //
// //
///////////////////////
// Read Tree
if( nEventsTotal >= nEventsChain ) continue;
if(readFast) tree->LoadTree(event);
babyAnalyzer.GetEntry(event);
++nEventsTotal;
// Progress
stop_1l_babyAnalyzer::progress( nEventsTotal, nEventsChain );
/////////////////////
// //
// Check Selection //
// //
/////////////////////
// Check JSON
if( sample.isData && applyjson ) {
if( !goodrun(run(),ls()) ) continue;
}
// Check duplicate event
if( sample.isData ) {
duplicate_removal::DorkyEventIdentifier id(run(), evt(), ls());
if( is_duplicate(id) ) continue;
}
// Check WNJets genPt
if( sample.id == sampleInfo::k_W1JetsToLNu_madgraph_pythia8 ||
sample.id == sampleInfo::k_W2JetsToLNu_madgraph_pythia8 ||
sample.id == sampleInfo::k_W3JetsToLNu_madgraph_pythia8 ||
sample.id == sampleInfo::k_W4JetsToLNu_madgraph_pythia8 ) {
if( nupt()>200.0 ) continue;
}
// Pre-calculate all the event weights
wgtInfo.getEventWeights();
/////////////////////////////
// //
// Compute Event Variables //
// //
/////////////////////////////
// Find the gen pT of the ttbar system
double ttbarPt = -99.9;
LorentzVector genTTbar_LV;
int nFoundGenTop=0;
if( sampleIsTTbar ) {
for(int iGen=0; iGen<(int)genqs_p4().size(); iGen++) {
if( abs(genqs_id().at(iGen))==6 && genqs_isLastCopy().at(iGen) ) {
genTTbar_LV += genqs_p4().at(iGen);
nFoundGenTop++;
} // end if last copy of top
} // end loop over gen quarks
if( nFoundGenTop == 2 ) ttbarPt = genTTbar_LV.Pt();
} // end if sample is ttbar
// Find the gen ID of the 2nd lepton
double matched_lep_dr = 0.1;
int gen2ndLep__idx = -1;
int gen2ndLep__id = -99;
int gen2ndLep__tauDecay = -1;
int fill_bin_genLep2ID = -1;
if( !sample.isData && is2lep() ) {
// match leading lepton first
int genLep_matchedTo_selLep__idx = -1;
for(int iGen=0; iGen<(int)genleps_p4().size(); iGen++) {
if( abs(genleps_id().at(iGen)) != abs(lep1_pdgid()) ) continue;
if( !genleps_isLastCopy().at(iGen) ) continue;
if( !genleps_fromHardProcessFinalState().at(iGen) &&
!genleps_fromHardProcessDecayed().at(iGen) ) continue;
if( ROOT::Math::VectorUtil::DeltaR(genleps_p4().at(iGen), lep1_p4()) < matched_lep_dr ) {
genLep_matchedTo_selLep__idx = iGen;
break;
}
}
// If matched selected lepton, find lost gen lepton
if( genLep_matchedTo_selLep__idx>0 ) {
for(int iGen=0; iGen<(int)genleps_p4().size(); iGen++) {
if( iGen == genLep_matchedTo_selLep__idx ) continue;
if( !genleps_isLastCopy().at(iGen) ) continue;
if( !genleps_fromHardProcessFinalState().at(iGen) &&
!genleps_fromHardProcessDecayed().at(iGen) ) continue;
gen2ndLep__idx = iGen;
gen2ndLep__id = genleps_id().at(iGen);
gen2ndLep__tauDecay = genleps_gentaudecay().at(iGen);
}
// If found second lep
if( gen2ndLep__idx>=0 ) {
if( abs(gen2ndLep__id)==11 ) fill_bin_genLep2ID = 1; // "ele";
if( abs(gen2ndLep__id)==13 ) fill_bin_genLep2ID = 2; // "mu";
if( abs(gen2ndLep__id)==15 ) {
if( gen2ndLep__tauDecay==1 ) fill_bin_genLep2ID = 3; // "lep tau, ele";
if( gen2ndLep__tauDecay==2 ) fill_bin_genLep2ID = 4; // "lep tau, mu";
if( gen2ndLep__tauDecay==3 ) fill_bin_genLep2ID = 5; // "had tau, 1 prong";
if( gen2ndLep__tauDecay==4 ) fill_bin_genLep2ID = 6; // "had tau, 3 prong";
if( gen2ndLep__tauDecay==5 ) fill_bin_genLep2ID = 7; // "\"other\" tau";
} // end if 2nd lep is tau
} // end if found 2nd gen lep
} // end if found first gen lep, matched to selected lepton
} // end if 2lep event and not data
// Calculate p4 of (lep1 lep2 b b) system
LorentzVector lep1lep2bb_TLV(0.0,0.0,0.0,0.0);
LorentzVector lep1lep2bbMet_TLV(0.0,0.0,0.0,0.0);
double lep1lep2bbMet_pt = -99.9;
lep1lep2bb_TLV += lep1_p4();
if(nvetoleps()>1) lep1lep2bb_TLV += lep2_p4();
int jet1_idx = -1;
double max_deepcsv = -99.9;
for(int iJet=0; iJet<(int)ak4pfjets_p4().size(); iJet++) {
if( ak4pfjets_deepCSV().at(iJet) > max_deepcsv ) {
jet1_idx = iJet;
max_deepcsv = ak4pfjets_deepCSV().at(iJet);
}
}
if(jet1_idx>=0) lep1lep2bb_TLV += ak4pfjets_p4().at(jet1_idx);
int jet2_idx = -1;
max_deepcsv = -99.9;
for(int iJet=0; iJet<(int)ak4pfjets_p4().size(); iJet++) {
if( iJet==jet1_idx ) continue;
if( ak4pfjets_deepCSV().at(iJet) > max_deepcsv ) {
jet2_idx = iJet;
max_deepcsv = ak4pfjets_deepCSV().at(iJet);
}
}
if(jet2_idx>=0) lep1lep2bb_TLV += ak4pfjets_p4().at(jet2_idx);
// Calculate p4 of (lep1 lep2 b b MET) system
lep1lep2bbMet_TLV = lep1lep2bb_TLV;
LorentzVector met_TLV( pfmet()*cos(pfmet_phi()), pfmet()*sin(pfmet_phi()), 0.0, pfmet() );
lep1lep2bbMet_TLV += met_TLV;
lep1lep2bbMet_pt = lep1lep2bbMet_TLV.Pt();
// Calculate mlb using lep2 instead of lep1
LorentzVector lep2b_TLV(0.0,0.0,0.0,0.0);
double minDr = 99.9;
int minBJetIdx = -99;
if(nvetoleps()>1) {
lep2b_TLV += lep2_p4();
for(int iJet=0; iJet<(int)ak4pfjets_p4().size(); iJet++) {
if(!ak4pfjets_passMEDbtag().at(iJet)) continue;
if(ROOT::Math::VectorUtil::DeltaR(ak4pfjets_p4().at(iJet),lep2_p4())<minDr) {
minDr = ROOT::Math::VectorUtil::DeltaR(ak4pfjets_p4().at(iJet),lep2_p4());
minBJetIdx = iJet;
}
} // end loop over jets
if(minBJetIdx>=0) lep2b_TLV += ak4pfjets_p4().at(minBJetIdx);
} // end if nvetoleps>1
int mStop = mass_stop();
int mLSP = mass_lsp();
/////////////////////////////////////////////////////////////
// //
// Loop over all analyzers, genClassy's, systematics, etc. //
// //
/////////////////////////////////////////////////////////////
// Loop over all analyzers
for( int iAna=0; iAna<nAnalyzers; iAna++ ) {
analyzer* thisAnalyzer = analyzers.at(iAna);
// Make an array of which genClassy's this event passes
bool passedGenClassies[genClassyInfo::k_nGenClassy];
for( genClassyInfo::Util thisGenClassy : thisAnalyzer->GetGenClassifications() ) {
passedGenClassies[thisGenClassy.id] = thisGenClassy.eval_GenClassy();
// Manually correct the ZZto2L2Nu sample
if( sample.id==sampleInfo::k_ZZTo2L2Nu_powheg_pythia8 ) {
if( thisGenClassy.id == genClassyInfo::k_ge2lep ||
thisGenClassy.id == genClassyInfo::k_incl ) passedGenClassies[thisGenClassy.id] = true;
else passedGenClassies[thisGenClassy.id] = false;
}
}
// Check if this event passes selections with JES set to nominal
// (saves us having to evaluate this for every systematic)
thisAnalyzer->SetJesType( 0 );
bool pass_JESnominal = thisAnalyzer->PassSelections();
// Fill cutflow histogram
std::vector<bool> cutflow_results = selectionInfo::get_selectionResults( thisAnalyzer->GetSelections() );
for( uint i=0; i<cutflow_results.size(); i++ ) {
if( !cutflow_results.at(i) ) break;
h_cutflow[iAna]->Fill( i+1 );
}
// Loop over all systematics in the analyzer
for( sysInfo::Util thisSystematic : thisAnalyzer->GetSystematics() ) {
// Check if this event passes selections, and also set the appropriate JES type for future use
if( thisSystematic.id == sysInfo::k_JESUp ) {
thisAnalyzer->SetJesType( 1 );
if( !thisAnalyzer->PassSelections() ) continue;
}
else if( thisSystematic.id == sysInfo::k_JESDown ) {
thisAnalyzer->SetJesType( -1 );
if( !thisAnalyzer->PassSelections() ) continue;
}
else {
thisAnalyzer->SetJesType( 0 );
if( !pass_JESnominal ) continue;
}
// If we've passed selections, then get the event weight and the categories passed
double weight = thisAnalyzer->GetEventWeight( thisSystematic.id );
std::vector<int> categories_passed = thisAnalyzer->GetCategoriesPassed();
// Loop over all the gen classifications that we passed
for( genClassyInfo::Util thisGenClassy : thisAnalyzer->GetGenClassifications() ) {
int iGen = thisGenClassy.id;
if( !passedGenClassies[iGen] ) continue;
// Get the index for the histogram corresponding to this genClassy and systematic
int histIndex = iGen*nSystematics + thisSystematic.id;
// Fill yield histograms
for( int category : categories_passed ) {
if( sample.isSignalScan ) {
TH3D* yieldHisto = (TH3D*)thisAnalyzer->GetYieldHistogram( histIndex );
yieldHisto->Fill( mStop, mLSP, category, weight );
}
else thisAnalyzer->GetYieldHistogram( histIndex )->Fill( category, weight );
}
/////////////////////////////////////
// //
// Fill other non-yield histograms //
// //
/////////////////////////////////////
if( thisSystematic.id == sysInfo::k_nominal ) {
for(int iMassPt=0; iMassPt<nMassPts; iMassPt++) {
if( sample.isSignalScan && mStop!=sample.massPtList[iMassPt].first && mLSP!=sample.massPtList[iMassPt].second ) continue;
//if(!isnormal(wgt_nominal)) cout << "NaN/inf weight: nEntries=" << wgtInfo.nEvents << ", lepSF=" << wgtInfo.sf_lep << ", vetoLep="<< wgtInfo.sf_vetoLep << ", btagSF=" << wgtInfo.sf_bTag << endl;
// Histo Index
int iHisto = iAna*nGenClassy*nMassPts + iGen*nMassPts + iMassPt;
// Vars
double nGoodJets = ngoodjets();
bool add2ndLepToMet = thisAnalyzer->GetAdd2ndLep();
double mt = add2ndLepToMet ? mt_met_lep_rl() : mt_met_lep();
double modTopness = add2ndLepToMet ? topnessMod_rl() : topnessMod();
double met = add2ndLepToMet ? pfmet_rl() : pfmet();
double mlb = Mlb_closestb();
if( TString(thisAnalyzer->GetLabel()).Contains("CR0b") ) mlb = ( lep1_p4() + ak4pfjets_leadbtag_p4() ).M();
// Met Sideband CR area, met>=150
if( met>=150 && met<250 ) {
// mlb, met sideband CR
h_mlb_150to250met_incl[iHisto]->Fill( mlb, weight );
if( nGoodJets<4 ) h_mlb_150to250met_lt4j[iHisto]->Fill( mlb, weight );
if( nGoodJets>=4 ) h_mlb_150to250met_ge4j[iHisto]->Fill( mlb, weight );
// mlb_lep2, met sideband CR
if(nvetoleps()>1 && minBJetIdx>=0) {
h_mlb_lep2_150to250met_incl[iHisto]->Fill( lep2b_TLV.M(), weight );
if( nGoodJets<4 ) h_mlb_lep2_150to250met_lt4j[iHisto]->Fill( lep2b_TLV.M(), weight );
if( nGoodJets>=4 ) h_mlb_lep2_150to250met_ge4j[iHisto]->Fill( lep2b_TLV.M(), weight );
}
} // end if 150<met<250
// Signal Region Area, met>=250
if( met<250.0 ) continue;
// nJets
h_nJets[iHisto]->Fill( nGoodJets, weight );
// nBTags
h_nBTags[iHisto]->Fill( ngoodbtags(), weight );
// lep1 pT
h_lep1Pt_incl[iHisto]->Fill( lep1_p4().Pt(), weight );
// lep2 pT
if( nvetoleps()>1 ) h_lep2Pt_incl[iHisto]->Fill( lep2_p4().Pt(), weight );
// jet pT
for(int iJet=0; iJet<(int)ak4pfjets_p4().size(); iJet++) h_jetPt_incl[iHisto]->Fill( ak4pfjets_p4().at(iJet).Pt(), weight );
// jet1 pT
h_jet1Pt_incl[iHisto]->Fill( ak4pfjets_p4().at(0).Pt(), weight );
// jet2 pT
h_jet2Pt_incl[iHisto]->Fill( ak4pfjets_p4().at(1).Pt(), weight );
// DeepCSV jet1 pT
if(jet1_idx>=0) h_deepcsvJet1Pt_incl[iHisto]->Fill( ak4pfjets_p4().at(jet1_idx).Pt(), weight );
// DeepCSV jet2 pT
if(jet2_idx>=0) h_deepcsvJet2Pt_incl[iHisto]->Fill( ak4pfjets_p4().at(jet2_idx).Pt(), weight );
// met
h_met_incl[iHisto]->Fill( met, weight );
if( nGoodJets<4 ) h_met_lt4j[iHisto]->Fill( met, weight );
if( nGoodJets>=4 ) h_met_ge4j[iHisto]->Fill( met, weight );
// lep1lep2bbMetPt
h_lep1lep2bbMetPt_incl[iHisto]->Fill( lep1lep2bbMet_pt, weight );
if( nGoodJets<4 ) h_lep1lep2bbMetPt_lt4j[iHisto]->Fill( lep1lep2bbMet_pt, weight );
if( nGoodJets>=4 ) h_lep1lep2bbMetPt_ge4j[iHisto]->Fill( lep1lep2bbMet_pt, weight );
// mt
h_mt_incl[iHisto]->Fill( mt, weight );
// modTopness
h_modTopness_incl[iHisto]->Fill( modTopness, weight );
if( nGoodJets<4 ) h_modTopness_lt4j[iHisto]->Fill( modTopness, weight );
if( nGoodJets>=4 ) h_modTopness_ge4j[iHisto]->Fill( modTopness, weight );
// mlb
h_mlb_incl[iHisto]->Fill( mlb, weight );
if( nGoodJets<4 ) h_mlb_lt4j[iHisto]->Fill( mlb, weight );
if( nGoodJets>=4 ) h_mlb_ge4j[iHisto]->Fill( mlb, weight );
// mlb, modTopness bins
if(modTopness<0.0) h_mlb_lt0modTopness[iHisto]->Fill( mlb, weight );
if(modTopness>=0.0) h_mlb_ge0modTopness[iHisto]->Fill( mlb, weight );
if(modTopness>=10.0) h_mlb_ge10modTopness[iHisto]->Fill( mlb, weight );
// mlb_lep2
if(nvetoleps()>1 && minBJetIdx>=0) {
h_mlb_lep2_incl[iHisto]->Fill( lep2b_TLV.M(), weight );
if( nGoodJets<4 ) h_mlb_lep2_lt4j[iHisto]->Fill( lep2b_TLV.M(), weight );
if( nGoodJets>=4 ) h_mlb_lep2_ge4j[iHisto]->Fill( lep2b_TLV.M(), weight );
}
// Gen TTBar System
if( sampleIsTTbar ) {
h_gen_ttbarPt_incl[iHisto]->Fill( ttbarPt, weight );
if( nGoodJets<4 ) h_gen_ttbarPt_lt4j[iHisto]->Fill( ttbarPt, weight );
if( nGoodJets>=4 ) h_gen_ttbarPt_ge4j[iHisto]->Fill( ttbarPt, weight );
}
// Gen 2nd Lep ID
if( !sample.isData && is2lep() && gen2ndLep__idx>=0 ) {
h_gen_lep2_id_incl[iHisto]->Fill( fill_bin_genLep2ID, weight );
if( ngoodjets()<4 ) h_gen_lep2_id_lt4j[iHisto]->Fill( fill_bin_genLep2ID, weight );
if( ngoodjets()>=4 ) h_gen_lep2_id_ge4j[iHisto]->Fill( fill_bin_genLep2ID, weight );
}
} // end loop over mass points (1 if not signal scan)
} // End filling of non-yield histograms
} // End loop over genClassy's
} // End loop over systematics
} // End loop over analyzers
} // End loop over events in tree
//
// Clean Up
//
delete tree;
file->Close();
delete file;
} // end loop over file list
//
// Output Sanitation
//
if ( nEventsChain != nEventsTotal ) {
cout << Form( "ERROR: number of events from files (%d) is not equal to total number of events (%d)", nEventsChain, nEventsTotal ) << endl;
}
//
// Print Selection Cutflow
//
cout << "====================================================" << endl;
cout << endl;
for(int iAna=0; iAna<nAnalyzers; iAna++) {
cout << " " << analyzers.at(iAna)->GetLabel() << " Cutflow: " << endl;
for(int iCut=1; iCut<=(int)h_cutflow[iAna]->GetNbinsX(); iCut++) {
cout << " nEvents pass " << h_cutflow[iAna]->GetXaxis()->GetBinLabel(iCut) << " = " << h_cutflow[iAna]->GetBinContent(iCut) << endl;
}
cout << endl;
cout << endl;
}
cout << "====================================================" << endl;
//
// Clean stopCORE objects
//
wgtInfo.cleanUp();
//
// Close Output File
//
f_output->Write();
f_output->Close();
//
// Clean input chain
//
chain->~TChain();
if( sample.isData ) duplicate_removal::clear_list();
//
// Benchmark Reporting
//
bmark->Stop("benchmark");
cout << endl;
cout << nEventsTotal << " Events Processed" << endl;
cout << "------------------------------" << endl;
cout << "CPU Time: " << Form( "%.01f", bmark->GetCpuTime("benchmark") ) << endl;
cout << "Real Time: " << Form( "%.01f", bmark->GetRealTime("benchmark") ) << endl;
cout << endl;
delete bmark;
cout << "====================================================" << endl;
//fclose(f_evtList);
//
// Return!
//
return 0;
} // End of function "looper"
