/*
-- FUNCTION: receiveFile
--
-- DATE: September 23, 2011
--
-- REVISIONS:
--
-- DESIGNER: Karl Castillo
--
-- PROGRAMMER: Karl Castillo
--
-- INTERFACE: void receiveFile(int port, const char* fileName)
-- socket - the current socket the client is connected as
-- fileName - the name of the file to be received/downloaded
--
-- RETURNS: void
--
-- NOTES:
-- This function sends the receive command and waits for the reply of the
-- transfer server. The transfer server will reply with the contents of the
-- file. If the file is not present, the server will return an error message.
-- This error message will be printed out.
--
-- Once all the contents of the file are received and written to a file, the
-- program will print out a success message.
*/
void receiveFile(int port, const char* fileName)
{
char* buffer = (char*)malloc(sizeof(char) * BUFFER_LENGTH);
FILE* file = NULL;
off_t fileSize = 0;
int bytesRead = 0;
int count = 0;
int transferSocket = 0;
char* fileNamePath = (char*)malloc(sizeof(char) * FILENAME_MAX);
initalizeServer(&port, &transferSocket);
// Get Size of file
readData(&transferSocket, buffer, BUFFER_LENGTH);
memmove((void*)&fileSize, buffer, sizeof(off_t));
printf("Size of File: %d\n", (int)fileSize);
// Create file path
sprintf(fileNamePath, "%s%s", DEF_DIR, fileName);
printf("Save Path: %s\n", fileNamePath);
// Opening file for writing
if((file = fopen(fileNamePath, "wb")) == NULL) {
fprintf(stderr, "Error opening file: %s\n", fileName);
return;
}
// Hide Cursor
fprintf(stderr, "\033[?25l");
// Start Reading from socket
while (count < (fileSize - BUFFER_LENGTH)) {
bytesRead = readData(&transferSocket, buffer, BUFFER_LENGTH);
fwrite(buffer, sizeof(char), bytesRead, file);
count += bytesRead;
printProgressBar(fileSize, count);
}
bytesRead = readData(&transferSocket, buffer, fileSize - count);
printProgressBar(fileSize, count + bytesRead);
fwrite(buffer, sizeof(char), bytesRead, file);
// End Reading from socket
// Show Cursor
fprintf(stderr, "\033[?25h\n");
// Close file
fclose(file);
chmod(fileName, 00400 | 00200 | 00100);
// Free memory allocated for buffer
free(buffer);
// Print Success message
printf("Transfer Complete!\n");
}
int readFile(int port)
{
ControlPacket packet;
while(!getControlPacket(port, &packet)){}
//puts("\nGot beginning packet");
if(packet.end != CONTROL_PACKET_BEGIN){
printf("Error: didn't receive expected start control package\n");
return -1;
}
int file = open(packet.filename+1, O_CREAT|O_TRUNC|O_WRONLY, 0666);
free(packet.filename);
DataPacket dataPacket;
unsigned char expectedSequenceNumber = 0;
float percentage;
int acum = 0;
char * proBar = updateProgressBar(0, packet.size, &percentage);
while(getDataPacket(port, &dataPacket) != E_NOTDATA){
if (expectedSequenceNumber != dataPacket.sequenceNumber){
printf("Error in packet sequence: expected packet no %u and got packet no %u\n", expectedSequenceNumber, dataPacket.sequenceNumber);
exit(-1);
}
expectedSequenceNumber++;
expectedSequenceNumber %= 255;
//printf("Received data packet with size %d\n", dataPacket.size);
write(file, dataPacket.data, dataPacket.size);
acum += dataPacket.size;
proBar = updateProgressBar(acum, packet.size, &percentage);
if(visMode != 0)
printProgressBar(proBar, percentage);
free(dataPacket.data);
}
printf("\n");
unsigned char* dump;
while(llread(port, &dump) != E_CLOSED){}
//puts("discei");
return 0;
}
int main (int argc, char *argv[])
{
printBoxedMessage("Starting plot generation");
// ####################
// ## Init tools ##
// ####################
// Create a sonic Screwdriver
SonicScrewdriver screwdriver;
// ##########################
// ## Create Variables ##
// ##########################
screwdriver.AddVariable("MT", "M_{T}", "GeV", 40,0,400, &(myEvent.MT), "logY");
// #########################################################
// ## Create ProcessClasses (and associated datasets) ##
// #########################################################
screwdriver.AddProcessClass("1ltop", "1l top", "background",kRed-7);
#ifdef USING_TTBAR_POWHEG
screwdriver.AddDataset("ttbar_powheg", "1ltop", 0, 0);
#endif
#ifdef USING_TTBAR_MADGRAPH
screwdriver.AddDataset("ttbar_madgraph_1l", "1ltop", 0, 0);
#endif
//screwdriver.AddDataset("ttbar_madgraph_scaledown", "1ltop", 0, 0);
//screwdriver.AddDataset("ttbar_madgraph_scaleup", "1ltop", 0, 0);
//screwdriver.AddDataset("ttbar_madgraph_matchingdown", "1ltop", 0, 0);
//screwdriver.AddDataset("ttbar_madgraph_matchingup", "1ltop", 0, 0);
//screwdriver.AddDataset("ttbar_madgraph_mass166-5", "1ltop", 0, 0);
//screwdriver.AddDataset("ttbar_madgraph_mass178-5", "1ltop", 0, 0);
screwdriver.AddDataset("singleTop_st", "1ltop", 0, 0);
screwdriver.AddProcessClass("ttbar_2l", "t#bar{t} #rightarrow l^{+}l^{-}", "background",kCyan-3);
#ifdef USING_TTBAR_MADGRAPH
screwdriver.AddDataset("ttbar_madgraph_2l", "ttbar_2l", 0, 0);
#endif
screwdriver.AddProcessClass("W+jets", "W+jets", "background",kOrange-2);
screwdriver.AddDataset("W+jets", "W+jets", 0, 0);
screwdriver.AddProcessClass("rare", "rare", "background",kMagenta-5);
screwdriver.AddDataset("rare", "rare", 0, 0);
screwdriver.AddProcessClass("data", "data", "data",COLORPLOT_BLACK);
screwdriver.AddDataset("SingleElec", "data", 0, 0);
screwdriver.AddDataset("SingleMuon", "data", 0, 0);
screwdriver.AddDataset("DoubleElec", "data", 0, 0);
screwdriver.AddDataset("DoubleMuon", "data", 0, 0);
screwdriver.AddDataset("MuEl", "data", 0, 0);
// ##########################
// ## Create Regions ##
// ##########################
screwdriver.AddRegion("0btag_noMTCut", "Preselection;0 b-tag Control Region, no M_{T} cut", &goesIn0BtagControlRegion );
// ##########################
// ## Create Channels ##
// ##########################
screwdriver.AddChannel("singleLepton", "e/#mu-channels", &goesInSingleLeptonChannel);
// ########################################
// ## Create histograms and ##
// ## schedule type of plots to produce ##
// ########################################
// Create histograms
screwdriver.Create1DHistos();
// Schedule plots
screwdriver.SchedulePlots("1DDataMCComparison");
// Config plots
screwdriver.SetGlobalStringOption("DataMCComparison", "includeSignal", "stack");
screwdriver.SetGlobalFloatOption ("DataMCComparison", "factorSignal", 1.0 );
screwdriver.SetGlobalStringOption("Plot", "infoTopRight", "CMS Preliminary");
screwdriver.SetGlobalStringOption("Plot", "infoTopLeft", "#sqrt{s} = 8 TeV, L = 19.5 fb^{-1}");
screwdriver.SetGlobalBoolOption("Plot", "exportPdf", true);
screwdriver.SetGlobalBoolOption("Plot", "exportEps", false);
screwdriver.SetGlobalBoolOption("Plot", "exportPng", false);
// ########################################
// ## Run over the datasets ##
// ########################################
vector<string> datasetsList;
screwdriver.GetDatasetList(&datasetsList);
cout << " > Reading datasets... " << endl;
cout << endl;
Table scaleFactors = Table("../prediction/scaleFactors/preselection.tab");
Figure SF_pre = scaleFactors.Get("value","SF_pre");
Figure SF_post = scaleFactors.Get("value","SF_post");
Figure SF_0btag = scaleFactors.Get("value","SF_0btag");
Figure SF_vetopeak = scaleFactors.Get("value","SF_vetopeak");
Figure SF_MTtail_1ltop = scaleFactors.Get("value","SF_MTtail_1ltop");
Figure SF_MTtail_Wjets = scaleFactors.Get("value","SF_MTtail_Wjets");
for (unsigned int d = 0 ; d < datasetsList.size() ; d++)
{
string currentDataset = datasetsList[d];
string currentProcessClass = screwdriver.GetProcessClass(currentDataset);
sampleName = currentDataset;
sampleType = screwdriver.GetProcessClassType(currentProcessClass);
// Open the tree
TFile f((string(FOLDER_BABYTUPLES)+currentDataset+".root").c_str());
TTree* theTree = (TTree*) f.Get("babyTuple");
intermediatePointers pointers;
InitializeBranchesForReading(theTree,&myEvent,&pointers);
myEvent.mStop = -1;
myEvent.mNeutralino = -1;
// ########################################
// ## Run over the events ##
// ########################################
bool ttbarDatasetToBeSplitted = false;
if (findSubstring(currentDataset,"ttbar")
&& (currentDataset != "ttbar_madgraph_1l")
&& (currentDataset != "ttbar_madgraph_2l"))
ttbarDatasetToBeSplitted = true;
int nEntries = theTree->GetEntries();
for (int i = 0 ; i < nEntries ; i++)
{
if (i % (nEntries / 50) == 0) printProgressBar(i,nEntries,currentDataset);
// Get the i-th entry
ReadEvent(theTree,i,&pointers,&myEvent);
float weight = getWeight();
// Split 1-lepton ttbar and 2-lepton ttbar
string currentProcessClass_ = currentProcessClass;
if (ttbarDatasetToBeSplitted && (myEvent.numberOfGenLepton == 2))
currentProcessClass_ = "ttbar_2l";
if (myEvent.MT > 100)
{
if (currentProcessClass_ == "1ltop" ) weight *= SF_MTtail_1ltop.value();
else if (currentProcessClass_ == "W+jets") weight *= SF_MTtail_Wjets.value();
}
screwdriver.AutoFillProcessClass(currentProcessClass_,weight);
}
printProgressBar(nEntries,nEntries,currentDataset);
cout << endl;
f.Close();
}
// #############################
// ## Apply scale factors ##
// #############################
screwdriver.ApplyScaleFactor("W+jets", "0btag_noMTCut", "singleLepton", SF_0btag);
screwdriver.ApplyScaleFactor("1ltop", "0btag_noMTCut", "singleLepton", SF_0btag);
// ###################################
// ## Make plots and write them ##
// ###################################
cout << endl;
cout << " > Making plots..." << endl;
screwdriver.MakePlots();
cout << " > Saving plots..." << endl;
screwdriver.WritePlots("./plots/fullMTwithSFRinTail/");
printBoxedMessage("Plot generation completed");
// #############################
// ## Post-plotting tests ##
// #############################
printBoxedMessage("Program done.");
return (0);
}
int main (int argc, char *argv[])
{
//loadBDTSignalRegions();
printBoxedMessage("Starting tables generation");
// ####################
// ## Init tools ##
// ####################
// Create a sonic Screwdriver
SonicScrewdriver screwdriver;
// #########################################################
// ## Create ProcessClasses (and associated datasets) ##
// #########################################################
/*
screwdriver.AddProcessClass("1ltop", "1l top", "background",kRed-7);
#ifdef USING_TTBAR_POWHEG
screwdriver.AddDataset("ttbar_powheg", "1ltop", 0, 0);
#endif
#ifdef USING_TTBAR_MADGRAPH
screwdriver.AddDataset("ttbar_madgraph_1l", "1ltop", 0, 0);
#endif
screwdriver.AddDataset("singleTop_st", "1ltop", 0, 0);
screwdriver.AddProcessClass("ttbar_2l", "t#bar{t} #rightarrow l^{+}l^{-}", "background",kCyan-3);
#ifdef USING_TTBAR_MADGRAPH
screwdriver.AddDataset("ttbar_madgraph_2l", "ttbar_2l", 0, 0);
#endif
screwdriver.AddProcessClass("W+jets", "W+jets", "background",kOrange-2);
screwdriver.AddDataset("W+jets", "W+jets", 0, 0);
screwdriver.AddProcessClass("rare", "rare", "background",kMagenta-5);
screwdriver.AddDataset("rare", "rare", 0, 0);
screwdriver.AddProcessClass("data", "data", "data",COLORPLOT_BLACK);
screwdriver.AddDataset("SingleElec", "data", 0, 0);
screwdriver.AddDataset("SingleMuon", "data", 0, 0);
screwdriver.AddDataset("DoubleElec", "data", 0, 0);
screwdriver.AddDataset("DoubleMuon", "data", 0, 0);
screwdriver.AddDataset("MuEl", "data", 0, 0);
*/
//screwdriver.AddProcessClass("signal", "signal", "background",kMagenta-5);
// screwdriver.AddDataset("T2tt_650_325", "signal", 0, 0);
screwdriver.AddProcessClass("W+jets", "W+jets", "background",kOrange-2);
screwdriver.AddDataset("T2tt_650_325", "W+jets", 0, 0);
// ##########################
// ## Create Regions ##
// ##########################
screwdriver.AddRegion("presel_MTpeak", "Preselection (MT peak)", &goesInMTpeak);
screwdriver.AddRegion("presel_MTtail", "Preselection (MT peak)", &goesInMTtail);
// ##########################
// ## Create Channels ##
// ##########################
//screwdriver.AddChannel("singleLepton", "e/#mu-channels", &goesInSingleLeptonChannel);
screwdriver.AddChannel("singleElec", "e-channel", &goesInSingleElecChannel );
screwdriver.AddChannel("singleMuon", "#mu-channel", &goesInSingleMuonChannel );
/*
screwdriver.AddChannel("doubleLepton", "2l-channel", &goesInDoubleLeptonChannel);
screwdriver.AddChannel("doubleElec", "ee-channel", &goesInDoubleElecChannel );
screwdriver.AddChannel("doubleMuon", "#mu#mu-channel", &goesInDoubleMuonChannel );
screwdriver.AddChannel("emu", "e#mu-channel", &goesInMuonElecChannel );
*/
screwdriver.AddChannel("allChannels", "", &goesInAnyChannel );
// ########################################
// ## Create histograms and ##
// ## schedule type of plots to produce ##
// ########################################
// Create histograms
screwdriver.Create1DHistos();
// ########################################
// ## Run over the datasets ##
// ########################################
vector<string> datasetsList;
screwdriver.GetDatasetList(&datasetsList);
cout << " > Reading datasets... " << endl;
cout << endl;
for (unsigned int d = 0 ; d < datasetsList.size() ; d++)
{
string currentDataset = datasetsList[d];
string currentProcessClass = screwdriver.GetProcessClass(currentDataset);
sampleName = currentDataset;
sampleType = screwdriver.GetProcessClassType(currentProcessClass);
// Open the tree
string treePath = string(FOLDER_BABYTUPLES)+currentDataset+".root";
TFile f(treePath.c_str());
TTree* theTree = (TTree*) f.Get("babyTuple");
InitializeBranchesForReading(theTree,&myEvent);
// ########################################
// ## Run over the events ##
// ########################################
bool ttbarDatasetToBeSplitted = false;
if (findSubstring(currentDataset,"ttbar")
&& (currentDataset != "ttbar_madgraph_1l")
&& (currentDataset != "ttbar_madgraph_2l"))
ttbarDatasetToBeSplitted = true;
int nEntries = theTree->GetEntries();
for (int i = 0 ; i < nEntries ; i++)
{
if (i % (nEntries / 50) == 0) printProgressBar(i,nEntries,currentDataset);
// Get the i-th entry
//ReadEvent(theTree,i,&pointers,&myEvent);
//cout<<"can I read the event ?"<<endl;
ReadEvent(theTree,i,&myEvent);
//cout<<"> Yes I can !"<<endl;
if(goesInPreselection() && goesInAnyChannel()){
cout<<myEvent.MT<<" "<<myEvent.pfmet<<" "<<myEvent.ngoodleps<<" "<<myEvent.ngoodjets<<endl;
cout<<"preselection: "<<goesInPreselection()<<endl;
cout<<"all channel"<< goesInAnyChannel() << endl;
}
//cout<<""<< << endl;
//cout<<""<< << endl;
//cout<<""<< << endl;
float weight = getWeight();
// Split 1-lepton ttbar and 2-lepton ttbar
string currentProcessClass_ = currentProcessClass;
if (ttbarDatasetToBeSplitted && (myEvent.genlepsfromtop == 2))
currentProcessClass_ = "ttbar_2l";
screwdriver.AutoFillProcessClass(currentProcessClass_,weight);
}
printProgressBar(nEntries,nEntries,currentDataset);
cout << endl;
f.Close();
}
// ####################################
// ## Write the table ##
// ####################################
printBoxedMessage("Writing the table ... ");
vector<string> regions = {
"presel_MTpeak", "presel_MTtail",
/*
"preveto_MTpeak", "preveto_MTtail",
"signalRegion_MTpeak", "signalRegion_MTtail",
"0btag_MTpeak", "0btag_MTtail",
"reversedVeto_MTpeak", "reversedVeto_MTtail",
"2leptons", "2leptons_MTpeak", "2leptons_MTtail",
*/};
string exportFile = "rawYieldTables/"+string(SIGNAL_REGION_TAG)+".tab";
TableDataMC(&screwdriver,regions,"allChannels").Print(exportFile,4);
vector<string> secondLeptonInAcceptanceRegions = {
"preveto_MTtail",
"secondLeptonInAcceptance",
"singleTrack",
"hadronicTau"
};
//string exportFile2 = "secondLeptonInAcceptance/"+string(SIGNAL_REGION_TAG)+".tab";
//TableDataMC(&screwdriver,secondLeptonInAcceptanceRegions,"allChannels").Print(exportFile2,4);
printBoxedMessage("Table generation completed");
return (0);
}
int main (int argc, char *argv[])
{
printBoxedMessage("Starting plot generation");
// ####################
// ## Init tools ##
// ####################
string signalCategory = "T2bw-025";
// Create a sonic Screwdriver
SonicScrewdriver screwdriver;
// ##########################
// ## Create Variables ##
// ##########################
screwdriver.AddVariable("METoverSqrtHT", "MET / #sqrt{H_{T}}", "", 32,0,32, &(myEvent.METoverSqrtHT), "");
screwdriver.AddVariable("MET", "MET", "GeV", 15,50,500, &(myEvent.MET), "logY=true");
screwdriver.AddVariable("MT", "MT", "GeV", 20,0,400, &(myEvent.MT), "logY=true");
screwdriver.AddVariable("leadingBPt", "p_{T}(leading b jet)", "GeV", 20,0,200, &(myEvent.leadingBPt), "logY=true");
screwdriver.AddVariable("mStop", "m_{#tilde{t}}", "GeV", 28,112.5,812.5, &(myEvent.mStop), "");
screwdriver.AddVariable("mNeutralino", "m_{#chi^{0}}", "GeV", 16,-12.5,387.5, &(myEvent.mNeutralino), "noOverflowInLastBin");
// #########################################################
// ## Create ProcessClasses (and associated datasets) ##
// #########################################################
screwdriver.AddProcessClass("1ltop", "1l top", "background",kRed-7);
#ifdef USING_TTBAR_POWHEG
screwdriver.AddDataset("ttbar_powheg", "1ltop", 0, 0);
#endif
#ifdef USING_TTBAR_MADGRAPH
screwdriver.AddDataset("ttbar_madgraph_1l", "1ltop", 0, 0);
#endif
screwdriver.AddDataset("singleTop_st", "1ltop", 0, 0);
screwdriver.AddProcessClass("ttbar_2l", "t#bar{t} #rightarrow l^{+}l^{-}", "background",kCyan-3);
#ifdef USING_TTBAR_MADGRAPH
screwdriver.AddDataset("ttbar_madgraph_2l", "ttbar_2l", 0, 0);
#endif
screwdriver.AddProcessClass("W+jets", "W+jets", "background", kOrange-2);
screwdriver.AddDataset("W+jets", "W+jets", 0, 0);
screwdriver.AddProcessClass("rare", "rare", "background", kMagenta-5);
screwdriver.AddDataset("rare", "rare", 0, 0);
screwdriver.AddProcessClass(signalCategory, signalCategory, "signal", kViolet-1);
screwdriver.AddDataset(signalCategory, signalCategory, 0, 0);
screwdriver.AddProcessClass("signal_250_100", signalCategory+" (250/100)", "signal",COLORPLOT_BLUE );
screwdriver.AddProcessClass("signal_450_100", signalCategory+" (450/100)", "signal",COLORPLOT_GREEN2 );
screwdriver.AddProcessClass("signal_400_175", signalCategory+" (400/175)", "signal",COLORPLOT_GREEN2 );
screwdriver.AddProcessClass("signal_650_100", signalCategory+" (650/100)", "signal",COLORPLOT_GREEN );
// ##########################
// ## Create Regions ##
// ##########################
screwdriver.AddRegion("presel", "Preselection", &goesInPreselectionMTtail);
/*
screwdriver.AddRegion("veryOffShell_loose", "Cut-and-count;Very off-shell (loose)", &Selector_veryOffShell_loose);
screwdriver.AddRegion("offShell_loose", "Cut-and-count;Off-shell (loose)", &Selector_offShell_loose );
screwdriver.AddRegion("lowDeltaM_tight", "Cut-and-count;Low #DeltaM (tight)", &Selector_lowDeltaM_tight );
screwdriver.AddRegion("highDeltaM", "Cut-and-count;High #DeltaM", &Selector_highDeltaM );
*/
screwdriver.AddRegion("offshell", "Cut-and-count;Off-shell", &Selector_offShell);
screwdriver.AddRegion("lowMasses", "Cut-and-count;Low masses", &Selector_lowMasses);
screwdriver.AddRegion("highMasses", "Cut-and-count;High masses", &Selector_highMasses);
// ##########################
// ## Create Channels ##
// ##########################
screwdriver.AddChannel("singleLepton", "e/#mu-channels", &goesInSingleLeptonChannel);
// ########################################
// ## Create histograms and ##
// ## schedule type of plots to produce ##
// ########################################
screwdriver.SetLumi(20000);
// Create histograms
screwdriver.Create1DHistos();
screwdriver.Add2DHisto("mStop","mNeutralino");
screwdriver.SetGlobalBoolOption ("1DSuperimposed", "includeSignal", true );
screwdriver.SetGlobalStringOption("1DStack", "includeSignal", "stack");
screwdriver.SetGlobalFloatOption ("1DStack", "factorSignal", 1.0 );
screwdriver.SetGlobalStringOption("DataMCComparison", "includeSignal", "stack");
screwdriver.SetGlobalFloatOption ("DataMCComparison", "factorSignal", 1.0 );
// Schedule plots
screwdriver.SchedulePlots("1DSuperimposed");
screwdriver.SchedulePlots("1DStack");
screwdriver.SchedulePlots("2D");
screwdriver.SchedulePlots("2DSuperimposed");
// Config plots
screwdriver.SetGlobalStringOption("Plot", "infoTopRight", "CMS Internal");
screwdriver.SetGlobalStringOption("Plot", "infoTopLeft", "#sqrt{s} = 8 TeV, L = 20 fb^{-1}");
screwdriver.SetGlobalBoolOption("Plot", "exportPdf", true);
screwdriver.SetGlobalBoolOption("Plot", "exportEps", false);
screwdriver.SetGlobalBoolOption("Plot", "exportPng", false);
// ########################################
// ## Run over the datasets ##
// ########################################
vector<string> datasetsList;
screwdriver.GetDatasetList(&datasetsList);
cout << " > Reading datasets... " << endl;
cout << endl;
for (unsigned int d = 0 ; d < datasetsList.size() ; d++)
{
string currentDataset = datasetsList[d];
string currentProcessClass = screwdriver.GetProcessClass(currentDataset);
// Open the tree
TFile f((string(FOLDER_BABYTUPLES)+currentDataset+".root").c_str());
TTree* theTree = (TTree*) f.Get("babyTuple");
intermediatePointers pointers;
InitializeBranchesForReading(theTree,&myEvent,&pointers);
sampleName = currentDataset;
sampleType = screwdriver.GetProcessClassType(currentProcessClass);
if (currentDataset == signalCategory)
{
theTree->SetBranchAddress("mStop", &(myEvent.mStop));
theTree->SetBranchAddress("mNeutralino", &(myEvent.mNeutralino));
}
else
{
myEvent.mStop = -1;
myEvent.mNeutralino = -1;
}
// ########################################
// ## Run over the events ##
// ########################################
int nEntries = theTree->GetEntries();
for (int i = 0 ; i < nEntries ; i++)
//for (int i = 0 ; i < min(200000, (int) theTree->GetEntries()); i++)
{
if (i % (theTree->GetEntries() / 50) == 0)
printProgressBar(i,nEntries,currentDataset);
// Get the i-th entry
ReadEvent(theTree,i,&pointers,&myEvent);
// Split 1-lepton ttbar and 2-lepton ttbar
string currentProcessClass_ = currentProcessClass;
if ((currentDataset == "ttbar_powheg") && (myEvent.numberOfGenLepton == 2))
currentProcessClass_ = "ttbar_2l";
screwdriver.AutoFillProcessClass(currentProcessClass_,getWeight());
if ((myEvent.mStop == 250) && (myEvent.mNeutralino == 100))
screwdriver.AutoFillProcessClass("signal_250_100",getWeight());
if ((myEvent.mStop == 450) && (myEvent.mNeutralino == 100))
screwdriver.AutoFillProcessClass("signal_450_100",getWeight());
if ((myEvent.mStop == 400) && (myEvent.mNeutralino == 175))
screwdriver.AutoFillProcessClass("signal_400_175",getWeight());
if ((myEvent.mStop == 650) && (myEvent.mNeutralino == 100))
screwdriver.AutoFillProcessClass("signal_650_100",getWeight());
}
printProgressBar(nEntries,nEntries,currentDataset);
cout << endl;
f.Close();
}
// ###################################
// ## Make plots and write them ##
// ###################################
cout << endl;
cout << " > Making plots..." << endl;
screwdriver.MakePlots();
cout << " > Saving plots..." << endl;
screwdriver.WritePlots("../plots/cutAndCount_performances/"+signalCategory+"/");
printBoxedMessage("Plot generation completed");
// #############################
// ## Post-plotting tests ##
// #############################
printBoxedMessage("Now computing misc tests ... ");
/*
vector<string> cutAndCountRegions =
{
"veryOffShell_loose",
"offShell_loose",
"lowDeltaM_tight",
"highDeltaM"
};
float SF_1ltop_and_Wjets = 2;
float SF_allOthers = 1.3;
vector<float> globalBackgroundUncertainty =
{
0.2,
0.2,
0.2,
0.4
};
*/
vector<string> cutAndCountRegions =
{
"presel",
"offshell",
"lowMasses",
"highMasses"
};
float SF_1ltop_and_Wjets = 2;
float SF_allOthers = 1.3;
vector<float> globalBackgroundUncertainty =
{
0.2,
0.2,
0.2
};
TableBackgroundSignal(&screwdriver,cutAndCountRegions,"singleLepton").Print();
TableBackgroundSignal(&screwdriver,cutAndCountRegions,"singleLepton").PrintLatex();
// ##########################
// ## Compute FOM maps ##
// ##########################
vector<TH2F*> signalMaps;
vector<TH2F*> FOMdiscoveryMaps;
vector<TH2F*> FOMexclusionMaps;
vector<TH2F*> efficiencies;
int nBinsX = -1;
int nBinsY = -1;
TH2F* signalMapPresel = screwdriver.get2DHistoClone("mStop","mNeutralino",signalCategory,"presel","singleLepton");
TH2F* backgroundPresel = screwdriver.get2DCompositeHistoClone("mStop","mNeutralino","2DSumBackground","presel","singleLepton","");
if (nBinsX == -1) nBinsX = signalMapPresel->GetNbinsX();
if (nBinsY == -1) nBinsY = signalMapPresel->GetNbinsY();
// Store background eff in (mStop,mLSP) = (200,300)
int backgroundBin = signalMapPresel->FindBin(200,300);
float backgroundYieldPresel = backgroundPresel->Integral(0,nBinsX+1,0,nBinsY+1);
for (unsigned int i = 0 ; i < cutAndCountRegions.size() ; i++)
{
signalMaps.push_back(screwdriver.get2DHistoClone("mStop","mNeutralino",signalCategory,cutAndCountRegions[i],"singleLepton"));
signalMaps[i]->SetName((string("signalMap_")+cutAndCountRegions[i]).c_str());
float B = screwdriver.GetYieldAndError("1ltop", cutAndCountRegions[i],"singleLepton").value() * SF_1ltop_and_Wjets
+ screwdriver.GetYieldAndError("ttbar_2l", cutAndCountRegions[i],"singleLepton").value() * SF_allOthers
+ screwdriver.GetYieldAndError("W+jets", cutAndCountRegions[i],"singleLepton").value() * SF_1ltop_and_Wjets
+ screwdriver.GetYieldAndError("rare", cutAndCountRegions[i],"singleLepton").value() * SF_allOthers;
// Apply scale factor from background prediction
float f_B = globalBackgroundUncertainty[i];
//float f_B = 0.15;
if (B < 1.0) B = 1.0;
efficiencies.push_back((TH2F*) signalMaps[i]->Clone());
efficiencies[i]->SetName((string("eff_")+cutAndCountRegions[i]).c_str());
efficiencies[i]->Divide(signalMapPresel);
efficiencies[i]->SetBinContent(backgroundBin,B/backgroundYieldPresel);
FOMdiscoveryMaps.push_back((TH2F*) signalMaps[i]->Clone());
FOMdiscoveryMaps[i]->SetName((string("FOMdisco_")+cutAndCountRegions[i]).c_str());
FOMexclusionMaps.push_back((TH2F*) signalMaps[i]->Clone());
FOMexclusionMaps[i]->SetName((string("FOMexclu_")+cutAndCountRegions[i]).c_str());
for (int x = 1 ; x <= nBinsX ; x++)
for (int y = 1 ; y <= nBinsY ; y++)
{
float S = signalMaps[i]->GetBinContent(x,y);
float FOMdiscovery = figureOfMerit(S,B,"discovery",false,f_B);
FOMdiscoveryMaps[i]->SetBinContent(x,y,FOMdiscovery);
float FOMexclusion = figureOfMerit(S,B,"exclusion",false,f_B);
FOMexclusionMaps[i]->SetBinContent(x,y,FOMexclusion);
}
}
// ################################
// ## Compute "best" FOM map ##
// ################################
TH2F* bestDiscoFOMMap = (TH2F*) signalMaps[0]->Clone(); bestDiscoFOMMap->SetName("bestDiscoFOM");
TH2F* bestDiscoSetMap = (TH2F*) signalMaps[0]->Clone(); bestDiscoSetMap->SetName("bestDiscoSet");
TH2F* bestDiscoSigEff = (TH2F*) signalMaps[0]->Clone(); bestDiscoSigEff->SetName("bestDiscoSigEff");
TH2F* bestDiscoBkgEff = (TH2F*) signalMaps[0]->Clone(); bestDiscoBkgEff->SetName("bestDiscoBkgEff");
TH2F* bestExcluFOMMap = (TH2F*) signalMaps[0]->Clone(); bestExcluFOMMap->SetName("bestExcluFOM");
TH2F* bestExcluSetMap = (TH2F*) signalMaps[0]->Clone(); bestExcluSetMap->SetName("bestExcluSet");
TH2F* bestExcluSigEff = (TH2F*) signalMaps[0]->Clone(); bestExcluSigEff->SetName("bestExcluSigEff");
TH2F* bestExcluBkgEff = (TH2F*) signalMaps[0]->Clone(); bestExcluBkgEff->SetName("bestExcluBkgEff");
for (int x = 1 ; x <= nBinsX ; x++)
for (int y = 1 ; y <= nBinsY ; y++)
{
float bestDiscoFOM = -1.0;
int bestDiscoSet = 0;
float bestDiscoSigEff_ = -1.0;
float bestDiscoBkgEff_ = -1.0;
for (unsigned int i = 0 ; i < cutAndCountRegions.size() ; i++)
{
float DiscoFOM = FOMdiscoveryMaps[i]->GetBinContent(x,y);
if (bestDiscoFOM < DiscoFOM)
{
bestDiscoFOM = DiscoFOM;
if (bestDiscoFOM > 0) bestDiscoSet = i+1;
bestDiscoSigEff_ = efficiencies[i]->GetBinContent(x,y);
bestDiscoBkgEff_ = efficiencies[i]->GetBinContent(backgroundBin);
}
}
bestDiscoFOMMap->SetBinContent(x,y,bestDiscoFOM);
bestDiscoSetMap->SetBinContent(x,y,bestDiscoSet);
bestDiscoSigEff->SetBinContent(x,y,bestDiscoSigEff_);
bestDiscoBkgEff->SetBinContent(x,y,bestDiscoBkgEff_);
float bestExcluFOM = -1.0;
int bestExcluSet = 0;
float bestExcluSigEff_ = -1.0;
float bestExcluBkgEff_ = -1.0;
for (unsigned int i = 0 ; i < cutAndCountRegions.size() ; i++)
{
float ExcluFOM = FOMexclusionMaps[i]->GetBinContent(x,y);
if (bestExcluFOM < ExcluFOM)
{
bestExcluFOM = ExcluFOM;
if (bestExcluFOM > 0) bestExcluSet = i+1;
bestExcluSigEff_ = efficiencies[i]->GetBinContent(x,y);
bestExcluBkgEff_ = efficiencies[i]->GetBinContent(backgroundBin);
}
}
bestExcluFOMMap->SetBinContent(x,y,bestExcluFOM);
bestExcluSetMap->SetBinContent(x,y,bestExcluSet);
bestExcluSigEff->SetBinContent(x,y,bestExcluSigEff_);
bestExcluBkgEff->SetBinContent(x,y,bestExcluBkgEff_);
}
// #########################
// ## Save those maps ##
// #########################
float lineOffset = 0.0;
string label;
if (signalCategory == "T2tt" ) { lineOffset = 172; label = "T2tt;"; }
if (signalCategory == "T2bw-025") { lineOffset = 320; label = "T2bw (x = 0.25);"; }
if (signalCategory == "T2bw-050") { lineOffset = 160; label = "T2bw (x = 0.50);"; }
if (signalCategory == "T2bw-075") { lineOffset = 105; label = "T2bw (x = 0.75);"; }
TFile fOutput(("../plots/cutAndCount_performances/"+signalCategory+"/custom.root").c_str(),"RECREATE");
string pathExport = "../plots/cutAndCount_performances/"+signalCategory+"/";
gStyle->SetPaintTextFormat("4.0f");
formatAndWriteMapPlot(&screwdriver,bestDiscoSetMap,bestDiscoSetMap->GetName(),label+"Best set of cuts;(for discovery)",pathExport,lineOffset);
formatAndWriteMapPlot(&screwdriver,bestExcluSetMap,bestExcluSetMap->GetName(),label+"Best set of cuts;(for exclusion)",pathExport,lineOffset);
gStyle->SetPaintTextFormat("4.1f");
for (unsigned int i = 0 ; i < cutAndCountRegions.size() ; i++)
{
FOMdiscoveryMaps[i]->SetMaximum(5.0);
formatAndWriteMapPlot(&screwdriver,FOMdiscoveryMaps[i],FOMdiscoveryMaps[i]->GetName(),string("Discovery FOM for ")+cutAndCountRegions[i], pathExport,lineOffset);
formatAndWriteMapPlot(&screwdriver, efficiencies[i], efficiencies[i]->GetName(),string("Efficiencies for " )+cutAndCountRegions[i], pathExport,lineOffset);
}
bestDiscoFOMMap->SetMaximum(5.0);
bestExcluFOMMap->SetMaximum(5.0);
formatAndWriteMapPlot(&screwdriver,bestDiscoFOMMap,bestDiscoFOMMap->GetName(),label+"Best FOM;(for discovery)" ,pathExport,lineOffset);
formatAndWriteMapPlot(&screwdriver,bestDiscoSigEff,bestDiscoSigEff->GetName(),label+"Best signal efficiency;(for discovery)",pathExport,lineOffset);
formatAndWriteMapPlot(&screwdriver,bestDiscoBkgEff,bestDiscoBkgEff->GetName(),label+"Best backgr efficiency;(for discovery)",pathExport,lineOffset);
formatAndWriteMapPlot(&screwdriver,bestExcluFOMMap,bestExcluFOMMap->GetName(),label+"Best FOM;(for exclusion)" ,pathExport,lineOffset);
formatAndWriteMapPlot(&screwdriver,bestExcluSigEff,bestExcluSigEff->GetName(),label+"Best signal efficiency;(for exclusion)",pathExport,lineOffset);
formatAndWriteMapPlot(&screwdriver,bestExcluBkgEff,bestExcluBkgEff->GetName(),label+"Best backgr efficiency;(for exclusion)",pathExport,lineOffset);
fOutput.Close();
printBoxedMessage("Program done.");
return (0);
}
int main (int argc, char *argv[])
{
// Loading standard BDT cuts
loadBDTSignalRegions();
// Replacing standard BDT cuts with cut allowing >=25% efficiency on the background
// (goal is to have enough stat to perform the template fit)
loadBDTCutsWithCustomRequirement("25percentEfficiency");
printBoxedMessage("Starting plot generation");
// ####################
// ## Init tools ##
// ####################
// Create a sonic Screwdriver
SonicScrewdriver screwdriver;
// ##########################
// ## Create Variables ##
// ##########################
screwdriver.AddVariable("Mlb", "M'(lb)", "GeV", 40,0,600, &(myEvent.Mlb), "");
float Mlb_customBinning[3] = {0,150,600};
screwdriver.AddVariable("Mlb_small", "M'(lb)", "GeV", 2, Mlb_customBinning, &(myEvent.Mlb), "");
screwdriver.AddVariable("M3b", "M3b", "GeV", 40,0,1000, &(myEvent.M3b), "");
// To perform systematic study
// (Note : JESup/down are not in skimmed babyTuples as for now)
/*
screwdriver.AddVariable("M3b_JESup", "M3b_JESup", "GeV", 40,0,1000, &(myEvent.M3b_JESup), "");
screwdriver.AddVariable("M3b_JESdown", "M3b_JESdown", "GeV", 40,0,1000, &(myEvent.M3b_JESdown), "");
screwdriver.AddVariable("Mlb_JESup", "Mlb_JESup", "GeV", 40,0,1000, &(myEvent.Mlb_JESup), "");
screwdriver.AddVariable("Mlb_JESdown", "Mlb_JESdown", "GeV", 40,0,1000, &(myEvent.Mlb_JESdown), "");
*/
int nJets;
screwdriver.AddVariable("nJets", "Number of selected jets", "", 4, 4, 7, &(nJets), "");
// #########################################################
// ## Create ProcessClasses (and associated datasets) ##
// #########################################################
screwdriver.AddProcessClass("1ltop", "1l top", "background",kRed-7);
#ifdef USING_TTBAR_POWHEG
screwdriver.AddDataset("ttbar_powheg", "1ltop", 0, 0);
#endif
#ifdef USING_TTBAR_MADGRAPH
screwdriver.AddDataset("ttbar_madgraph_1l", "1ltop", 0, 0);
#endif
//screwdriver.AddDataset("ttbar_madgraph_scaledown", "1ltop", 0, 0);
//screwdriver.AddDataset("ttbar_madgraph_scaleup", "1ltop", 0, 0);
//screwdriver.AddDataset("ttbar_madgraph_matchingdown", "1ltop", 0, 0);
//screwdriver.AddDataset("ttbar_madgraph_matchingup", "1ltop", 0, 0);
//screwdriver.AddDataset("ttbar_madgraph_mass166-5", "1ltop", 0, 0);
//screwdriver.AddDataset("ttbar_madgraph_mass178-5", "1ltop", 0, 0);
screwdriver.AddDataset("singleTop_st", "1ltop", 0, 0);
screwdriver.AddProcessClass("ttbar_2l", "t#bar{t} #rightarrow l^{+}l^{-}", "background",kCyan-3);
#ifdef USING_TTBAR_MADGRAPH
screwdriver.AddDataset("ttbar_madgraph_2l", "ttbar_2l", 0, 0);
#endif
screwdriver.AddProcessClass("W+jets", "W+jets", "background",kOrange-2);
screwdriver.AddDataset("W+jets", "W+jets", 0, 0);
screwdriver.AddProcessClass("rare", "rare", "background",kMagenta-5);
screwdriver.AddDataset("rare", "rare", 0, 0);
//screwdriver.AddDataset(SIGNAL_CONTAMINATION_INPUT, "rare", 0, 0);
screwdriver.AddProcessClass("data", "data", "data",COLORPLOT_BLACK);
screwdriver.AddDataset("SingleElec", "data", 0, 0);
screwdriver.AddDataset("SingleMuon", "data", 0, 0);
// ##########################
// ## Create Regions ##
// ##########################
screwdriver.AddRegion("MTpeak", "MT peak Control Region;No b-tag requirement", &goesInPreselNoBRequirementControlRegionMTinverted);
screwdriver.AddRegion("presel_MTinverted", "Preselection (MT < 100 GeV)", &goesInPreselectionMTinverted);
screwdriver.AddRegion("presel_MTpeak", "Preselection (MT peak)", &goesInPreselectionMTpeak);
screwdriver.AddRegion("0btag", "0 b-tag Control Region", &goesIn0BtagControlRegion);
screwdriver.AddRegion("0btag_MTpeak", "0 b-tag Control Region;MT peak", &goesIn0BtagControlRegionMTpeak);
screwdriver.AddRegion("0btag_MTinverted", "0 b-tag Control Region;MT < 100 GeV", &goesIn0BtagControlRegionMTinverted);
screwdriver.AddRegion("0btag_MTtail", "0 b-tag Control Region;MT tail", &goesIn0BtagControlRegionMTtail);
string rebinning;
rebinning="rebin=2";
screwdriver.AddRegion("BDT_MTtail_T2tt_1", "", &BDT_MTtail_T2tt_1, rebinning);
screwdriver.AddRegion("BDT_MTtail_T2tt_2", "", &BDT_MTtail_T2tt_2, rebinning);
screwdriver.AddRegion("BDT_MTtail_T2tt_5", "", &BDT_MTtail_T2tt_5, rebinning);
screwdriver.AddRegion("BDT_MTtail_T2bw075_1", "", &BDT_MTtail_T2bw075_1, rebinning);
screwdriver.AddRegion("BDT_MTtail_T2bw075_2", "", &BDT_MTtail_T2bw075_2, rebinning);
screwdriver.AddRegion("BDT_MTtail_T2bw075_3", "", &BDT_MTtail_T2bw075_3, rebinning);
screwdriver.AddRegion("BDT_MTtail_T2bw075_5", "", &BDT_MTtail_T2bw075_5, rebinning);
screwdriver.AddRegion("BDT_MTtail_T2bw050_1", "", &BDT_MTtail_T2bw050_1, rebinning);
screwdriver.AddRegion("BDT_MTtail_T2bw050_3", "", &BDT_MTtail_T2bw050_3, rebinning);
screwdriver.AddRegion("BDT_MTtail_T2bw050_4", "", &BDT_MTtail_T2bw050_4, rebinning);
screwdriver.AddRegion("BDT_MTtail_T2bw050_5", "", &BDT_MTtail_T2bw050_5, rebinning);
screwdriver.AddRegion("BDT_MTtail_T2bw050_6", "", &BDT_MTtail_T2bw050_6, rebinning);
screwdriver.AddRegion("BDT_MTtail_T2bw025_1", "", &BDT_MTtail_T2bw025_1, rebinning);
screwdriver.AddRegion("BDT_MTtail_T2bw025_3", "", &BDT_MTtail_T2bw025_3, rebinning);
screwdriver.AddRegion("BDT_MTtail_T2bw025_4", "", &BDT_MTtail_T2bw025_4, rebinning);
screwdriver.AddRegion("BDT_MTtail_T2bw025_6", "", &BDT_MTtail_T2bw025_6, rebinning);
rebinning="rebin=4";
screwdriver.AddRegion("BDT_MTpeak_T2tt_1", "", &BDT_MTpeak_T2tt_1 , rebinning);
screwdriver.AddRegion("BDT_MTpeak_T2tt_2", "", &BDT_MTpeak_T2tt_2 , rebinning);
screwdriver.AddRegion("BDT_MTpeak_T2tt_5", "", &BDT_MTpeak_T2tt_5 , rebinning);
screwdriver.AddRegion("BDT_MTpeak_T2bw075_1", "", &BDT_MTpeak_T2bw075_1, rebinning);
screwdriver.AddRegion("BDT_MTpeak_T2bw075_2", "", &BDT_MTpeak_T2bw075_2, rebinning);
screwdriver.AddRegion("BDT_MTpeak_T2bw075_3", "", &BDT_MTpeak_T2bw075_3, rebinning);
screwdriver.AddRegion("BDT_MTpeak_T2bw075_5", "", &BDT_MTpeak_T2bw075_5, rebinning);
screwdriver.AddRegion("BDT_MTpeak_T2bw050_1", "", &BDT_MTpeak_T2bw050_1, rebinning);
screwdriver.AddRegion("BDT_MTpeak_T2bw050_3", "", &BDT_MTpeak_T2bw050_3, rebinning);
screwdriver.AddRegion("BDT_MTpeak_T2bw050_4", "", &BDT_MTpeak_T2bw050_4, rebinning);
screwdriver.AddRegion("BDT_MTpeak_T2bw050_5", "", &BDT_MTpeak_T2bw050_5, rebinning);
screwdriver.AddRegion("BDT_MTpeak_T2bw050_6", "", &BDT_MTpeak_T2bw050_6, rebinning);
screwdriver.AddRegion("BDT_MTpeak_T2bw025_1", "", &BDT_MTpeak_T2bw025_1, rebinning);
screwdriver.AddRegion("BDT_MTpeak_T2bw025_3", "", &BDT_MTpeak_T2bw025_3, rebinning);
screwdriver.AddRegion("BDT_MTpeak_T2bw025_4", "", &BDT_MTpeak_T2bw025_4, rebinning);
screwdriver.AddRegion("BDT_MTpeak_T2bw025_6", "", &BDT_MTpeak_T2bw025_6, rebinning);
screwdriver.AddRegion("BDT_MTPeakNoBtag_T2tt_1", "", &BDT_MTPeakNoBtag_T2tt_1 , rebinning);
screwdriver.AddRegion("BDT_MTPeakNoBtag_T2tt_2", "", &BDT_MTPeakNoBtag_T2tt_2 , rebinning);
screwdriver.AddRegion("BDT_MTPeakNoBtag_T2tt_5", "", &BDT_MTPeakNoBtag_T2tt_5 , rebinning);
screwdriver.AddRegion("BDT_MTPeakNoBtag_T2bw075_1", "", &BDT_MTPeakNoBtag_T2bw075_1, rebinning);
screwdriver.AddRegion("BDT_MTPeakNoBtag_T2bw075_2", "", &BDT_MTPeakNoBtag_T2bw075_2, rebinning);
screwdriver.AddRegion("BDT_MTPeakNoBtag_T2bw075_3", "", &BDT_MTPeakNoBtag_T2bw075_3, rebinning);
screwdriver.AddRegion("BDT_MTPeakNoBtag_T2bw075_5", "", &BDT_MTPeakNoBtag_T2bw075_5, rebinning);
screwdriver.AddRegion("BDT_MTPeakNoBtag_T2bw050_1", "", &BDT_MTPeakNoBtag_T2bw050_1, rebinning);
screwdriver.AddRegion("BDT_MTPeakNoBtag_T2bw050_3", "", &BDT_MTPeakNoBtag_T2bw050_3, rebinning);
screwdriver.AddRegion("BDT_MTPeakNoBtag_T2bw050_4", "", &BDT_MTPeakNoBtag_T2bw050_4, rebinning);
screwdriver.AddRegion("BDT_MTPeakNoBtag_T2bw050_5", "", &BDT_MTPeakNoBtag_T2bw050_5, rebinning);
screwdriver.AddRegion("BDT_MTPeakNoBtag_T2bw050_6", "", &BDT_MTPeakNoBtag_T2bw050_6, rebinning);
screwdriver.AddRegion("BDT_MTPeakNoBtag_T2bw025_1", "", &BDT_MTPeakNoBtag_T2bw025_1, rebinning);
screwdriver.AddRegion("BDT_MTPeakNoBtag_T2bw025_3", "", &BDT_MTPeakNoBtag_T2bw025_3, rebinning);
screwdriver.AddRegion("BDT_MTPeakNoBtag_T2bw025_4", "", &BDT_MTPeakNoBtag_T2bw025_4, rebinning);
screwdriver.AddRegion("BDT_MTPeakNoBtag_T2bw025_6", "", &BDT_MTPeakNoBtag_T2bw025_6, rebinning);
screwdriver.AddRegion("BDT_MTPeakOneBtag_T2tt_1", "", &BDT_MTPeakOneBtag_T2tt_1 , rebinning);
screwdriver.AddRegion("BDT_MTPeakOneBtag_T2tt_2", "", &BDT_MTPeakOneBtag_T2tt_2 , rebinning);
screwdriver.AddRegion("BDT_MTPeakOneBtag_T2tt_5", "", &BDT_MTPeakOneBtag_T2tt_5 , rebinning);
screwdriver.AddRegion("BDT_MTPeakOneBtag_T2bw075_1", "", &BDT_MTPeakOneBtag_T2bw075_1 , rebinning);
screwdriver.AddRegion("BDT_MTPeakOneBtag_T2bw075_2", "", &BDT_MTPeakOneBtag_T2bw075_2 , rebinning);
screwdriver.AddRegion("BDT_MTPeakOneBtag_T2bw075_3", "", &BDT_MTPeakOneBtag_T2bw075_3 , rebinning);
screwdriver.AddRegion("BDT_MTPeakOneBtag_T2bw075_5", "", &BDT_MTPeakOneBtag_T2bw075_5 , rebinning);
screwdriver.AddRegion("BDT_MTPeakOneBtag_T2bw050_1", "", &BDT_MTPeakOneBtag_T2bw050_1 , rebinning);
screwdriver.AddRegion("BDT_MTPeakOneBtag_T2bw050_3", "", &BDT_MTPeakOneBtag_T2bw050_3 , rebinning);
screwdriver.AddRegion("BDT_MTPeakOneBtag_T2bw050_4", "", &BDT_MTPeakOneBtag_T2bw050_4 , rebinning);
screwdriver.AddRegion("BDT_MTPeakOneBtag_T2bw050_5", "", &BDT_MTPeakOneBtag_T2bw050_5 , rebinning);
screwdriver.AddRegion("BDT_MTPeakOneBtag_T2bw050_6", "", &BDT_MTPeakOneBtag_T2bw050_6 , rebinning);
screwdriver.AddRegion("BDT_MTPeakOneBtag_T2bw025_1", "", &BDT_MTPeakOneBtag_T2bw025_1 , rebinning);
screwdriver.AddRegion("BDT_MTPeakOneBtag_T2bw025_3", "", &BDT_MTPeakOneBtag_T2bw025_3 , rebinning);
screwdriver.AddRegion("BDT_MTPeakOneBtag_T2bw025_4", "", &BDT_MTPeakOneBtag_T2bw025_4 , rebinning);
screwdriver.AddRegion("BDT_MTPeakOneBtag_T2bw025_6", "", &BDT_MTPeakOneBtag_T2bw025_6 , rebinning);
screwdriver.AddRegion("CR0btag_MTtail_MT_100", "", &goesIn0BtagControlRegionMTtail100);
screwdriver.AddRegion("CR0btag_MTtail_MT_120", "", &goesIn0BtagControlRegionMTtail120);
screwdriver.AddRegion("CR0btag_MTtail_MT_125", "", &goesIn0BtagControlRegionMTtail125);
screwdriver.AddRegion("CR0btag_MTtail_MT_130", "", &goesIn0BtagControlRegionMTtail130);
screwdriver.AddRegion("CR0btag_MTtail_MT_135", "", &goesIn0BtagControlRegionMTtail135);
screwdriver.AddRegion("CR0btag_MTtail_MT_140", "", &goesIn0BtagControlRegionMTtail140);
screwdriver.AddRegion("CR0btag_MTpeak_MET_200", "", &CR0btag_MTpeak_MET_200 );
screwdriver.AddRegion("CR0btag_MTpeak_MET_250", "", &CR0btag_MTpeak_MET_250 );
screwdriver.AddRegion("CR0btag_MTpeak_MET_300", "", &CR0btag_MTpeak_MET_300 );
screwdriver.AddRegion("CR0btag_MTpeak_MET_350", "", &CR0btag_MTpeak_MET_350 );
screwdriver.AddRegion("CR0btag_MTtail_MET_200", "", &CR0btag_MTtail_MET_200 );
screwdriver.AddRegion("CR0btag_MTtail_MET_250", "", &CR0btag_MTtail_MET_250 );
screwdriver.AddRegion("CR0btag_MTtail_MET_300", "", &CR0btag_MTtail_MET_300 );
screwdriver.AddRegion("CR0btag_MTtail_MET_350", "", &CR0btag_MTtail_MET_350 );
screwdriver.AddRegion("CR0btag_MTpeak_METoverSqrtHT_6" , "", &CR0btag_MTpeak_METoverSqrtHT_6 );
screwdriver.AddRegion("CR0btag_MTpeak_METoverSqrtHT_7" , "", &CR0btag_MTpeak_METoverSqrtHT_7 );
screwdriver.AddRegion("CR0btag_MTpeak_METoverSqrtHT_8" , "", &CR0btag_MTpeak_METoverSqrtHT_8 );
screwdriver.AddRegion("CR0btag_MTpeak_METoverSqrtHT_9" , "", &CR0btag_MTpeak_METoverSqrtHT_9 );
screwdriver.AddRegion("CR0btag_MTpeak_METoverSqrtHT_10", "", &CR0btag_MTpeak_METoverSqrtHT_10);
screwdriver.AddRegion("CR0btag_MTpeak_METoverSqrtHT_12", "", &CR0btag_MTpeak_METoverSqrtHT_12);
screwdriver.AddRegion("CR0btag_MTtail_METoverSqrtHT_6" , "", &CR0btag_MTtail_METoverSqrtHT_6 );
screwdriver.AddRegion("CR0btag_MTtail_METoverSqrtHT_7" , "", &CR0btag_MTtail_METoverSqrtHT_7 );
screwdriver.AddRegion("CR0btag_MTtail_METoverSqrtHT_8" , "", &CR0btag_MTtail_METoverSqrtHT_8 );
screwdriver.AddRegion("CR0btag_MTtail_METoverSqrtHT_9" , "", &CR0btag_MTtail_METoverSqrtHT_9 );
screwdriver.AddRegion("CR0btag_MTtail_METoverSqrtHT_10", "", &CR0btag_MTtail_METoverSqrtHT_10);
screwdriver.AddRegion("CR0btag_MTtail_METoverSqrtHT_12", "", &CR0btag_MTtail_METoverSqrtHT_12);
screwdriver.AddRegion("CR0btag_MTpeak_BPt_100" , "", &CR0btag_MTpeak_BPt_100 );
screwdriver.AddRegion("CR0btag_MTpeak_BPt_150" , "", &CR0btag_MTpeak_BPt_150 );
screwdriver.AddRegion("CR0btag_MTpeak_BPt_180" , "", &CR0btag_MTpeak_BPt_180 );
screwdriver.AddRegion("CR0btag_MTtail_BPt_100" , "", &CR0btag_MTtail_BPt_100 );
screwdriver.AddRegion("CR0btag_MTtail_BPt_180" , "", &CR0btag_MTtail_BPt_180 );
screwdriver.AddRegion("CR0btag_MTpeak_DPhi_02" , "", &CR0btag_MTpeak_DPhi_02 );
screwdriver.AddRegion("CR0btag_MTpeak_DPhi_08" , "", &CR0btag_MTpeak_DPhi_08 );
screwdriver.AddRegion("CR0btag_MTtail_DPhi_02" , "", &CR0btag_MTtail_DPhi_02 );
screwdriver.AddRegion("CR0btag_MTtail_DPhi_08" , "", &CR0btag_MTtail_DPhi_08 );
screwdriver.AddRegion("CR0btag_MTpeak_ISRJet" , "", &CR0btag_MTpeak_ISRJet );
screwdriver.AddRegion("CR0btag_MTtail_ISRJet" , "", &CR0btag_MTtail_ISRJet );
screwdriver.AddRegion("CR0btag_MTpeak_MT2W_180", "", &CR0btag_MTpeak_MT2W_180 );
screwdriver.AddRegion("CR0btag_MTpeak_MT2W_190", "", &CR0btag_MTpeak_MT2W_190 );
screwdriver.AddRegion("CR0btag_MTpeak_MT2W_200", "", &CR0btag_MTpeak_MT2W_200 );
screwdriver.AddRegion("CR0btag_MTtail_MT2W_180", "", &CR0btag_MTtail_MT2W_180 );
screwdriver.AddRegion("CR0btag_MTtail_MT2W_190", "", &CR0btag_MTtail_MT2W_190 );
screwdriver.AddRegion("CR0btag_MTtail_MT2W_200", "", &CR0btag_MTtail_MT2W_200 );
// ##########################
// ## Create Channels ##
// ##########################
screwdriver.AddChannel("singleLepton", "e/#mu-channels", &goesInSingleLeptonChannel);
// ########################################
// ## Create histograms and ##
// ## schedule type of plots to produce ##
// ########################################
// Create histograms
screwdriver.Create1DHistos();
// Schedule plots
screwdriver.SchedulePlots("1DDataMCComparison");
screwdriver.SchedulePlots("1DSuperimposed");
// Config plots
screwdriver.SetGlobalStringOption("Plot", "infoTopRight", "CMS Internal");
screwdriver.SetGlobalStringOption("Plot", "infoTopLeft", "#sqrt{s} = 8 TeV, L = 19.5 fb^{-1}");
screwdriver.SetGlobalBoolOption("Plot", "exportPdf", true);
screwdriver.SetGlobalBoolOption("Plot", "exportEps", false);
screwdriver.SetGlobalBoolOption("Plot", "exportPng", false);
// ########################################
// ## Run over the datasets ##
// ########################################
vector<string> datasetsList;
screwdriver.GetDatasetList(&datasetsList);
cout << " > Reading datasets... " << endl;
cout << endl;
for (unsigned int d = 0 ; d < datasetsList.size() ; d++)
{
string currentDataset = datasetsList[d];
string currentProcessClass = screwdriver.GetProcessClass(currentDataset);
sampleName = currentDataset;
sampleType = screwdriver.GetProcessClassType(currentProcessClass);
// Open the tree
TFile f((string(FOLDER_BABYTUPLES)+currentDataset+".root").c_str());
TTree* theTree = (TTree*) f.Get("babyTuple");
intermediatePointers pointers;
InitializeBranchesForReading(theTree,&myEvent,&pointers);
// ########################################
// ## Run over the events ##
// ########################################
bool ttbarDatasetToBeSplitted = false;
if (findSubstring(currentDataset,"ttbar")
&& (currentDataset != "ttbar_madgraph_1l")
&& (currentDataset != "ttbar_madgraph_2l"))
ttbarDatasetToBeSplitted = true;
int nEntries = theTree->GetEntries();
for (int i = 0 ; i < nEntries ; i++)
{
if (i % (nEntries / 50) == 0) printProgressBar(i,nEntries,currentDataset);
// Get the i-th entry
ReadEvent(theTree,i,&pointers,&myEvent);
float weight = getWeight();
// Split 1-lepton ttbar and 2-lepton ttbar
string currentProcessClass_ = currentProcessClass;
if (ttbarDatasetToBeSplitted && (myEvent.numberOfGenLepton == 2))
currentProcessClass_ = "ttbar_2l";
// FIXME Why managing overflow this way ?
// It's already done on the plot automatically...
nJets = myEvent.nJets;
if(myEvent.nJets >6 ) nJets = 6;
screwdriver.AutoFillProcessClass(currentProcessClass_,weight);
}
printProgressBar(nEntries,nEntries,currentDataset);
cout << endl;
f.Close();
}
// ###################################
// ## Make plots and write them ##
// ###################################
cout << endl;
cout << " > Making plots..." << endl;
screwdriver.MakePlots();
cout << " > Saving plots..." << endl;
// TODO : if we need to redo tests for different ttbar sample,
// move the plots to a separate folder with the name of the alternative sample
screwdriver.WritePlots(string("./inputPlots/"));
printBoxedMessage("Plot generation completed");
// #############################
// ## Post-plotting tests ##
// #############################
printBoxedMessage("Program done.");
return (0);
}
int sendFile(int port, int fd, char *filePath)
{
int size = getSize(fd);
unsigned char* buffer = (unsigned char*) mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);
if(buffer == MAP_FAILED){
//printf("did not mmap\n");
exit(-1);
}
unsigned char *bufferBckup = buffer;
int length;
unsigned char* packet = makeControlPacket(size , filePath, 1, &length);
//printf("gonna send following packet of length %d: \n", length);
/*int j;
for(j = 0; j < length; j++){
//printf("%d: 0x%02x - %c\n", j, packet[j], packet[j]);
}*/
if(llwrite(port, packet, length) < 0 )
return -1;
int i = 0;
int acum = 0;
float percentage;
char *proBar = updateProgressBar(acum, size, &percentage);
for(i = 0; i < (size/PACKET_SIZE); i++){
/*//printf("gonna send following packet of length %d: \n", length);
int j;
for(j = 0; j < length; j++){
//printf("%d: 0x%02x - %c\n", j, packet[j], packet[j]);
}*/
packet = makeDataPacket(PACKET_SIZE, buffer, &length);
if(llwrite(port, packet, length) < 0 )
return -1;
buffer += PACKET_SIZE;
acum += PACKET_SIZE;
proBar = updateProgressBar(acum, size, &percentage);
if(visMode != 0)
printProgressBar(proBar, percentage);
}
if((size % PACKET_SIZE) != 0){
packet = makeDataPacket((size % PACKET_SIZE), buffer, &length);
/*//printf("gonna send following packet of length %d: \n", length);
int j;
for(j = 0; j < length; j++){
//printf("%d: 0x%02x - %c\n", j, packet[j], packet[j]);
}*/
if(llwrite(port, packet, length) < 0 )
return -1;
acum += (size % PACKET_SIZE);
proBar = updateProgressBar(acum, size, &percentage);
if(visMode != 0)
printProgressBar(proBar, percentage);
}
printf("\n");
packet = makeControlPacket(size, filePath, 2, &length);
llwrite(port, packet, length);
llclose(port);
if(munmap(bufferBckup, size) == -1)
perror("failed to unmap the file");
return 0;
}
int main (int argc, char *argv[])
{
printBoxedMessage("Starting plot generation");
// ####################
// ## Init tools ##
// ####################
// Create a sonic Screwdriver
SonicScrewdriver screwdriver;
// Create a container for the event
babyEvent myEvent;
myEventPointer = &myEvent;
// ##########################
// ## Create Variables ##
// ##########################
screwdriver.AddVariable("MET", "MET", "GeV", 15,50,500, &(myEvent.MET), "logY");
// #########################################################
// ## Create ProcessClasses (and associated datasets) ##
// #########################################################
screwdriver.AddProcessClass("ttbar_1l", "t#bar{t} #rightarrow l+jets","background",kRed-7);
screwdriver.AddProcessClass("ttbar_2l", "t#bar{t} #rightarrow l^{+}l^{-}", "background",kCyan-3);
screwdriver.AddDataset("ttbar", "ttbar_1l", 0, 0);
screwdriver.AddProcessClass("W+jets", "W+jets", "background",kOrange-2);
screwdriver.AddDataset("Wjets", "W+jets", 0, 0);
screwdriver.AddProcessClass("others", "others", "background",kMagenta-5);
screwdriver.AddDataset("others", "others", 0, 0);
/*
screwdriver.AddProcessClass("T2tt", "T2tt", "signal",kViolet-1);
screwdriver.AddDataset("T2tt", "T2tt", 0, 0);
screwdriver.AddProcessClass("signal_250_50", "T2tt (250/50)", "signal",COLORPLOT_AZURE);
screwdriver.AddProcessClass("signal_450_50", "T2tt (450/50)", "signal",kCyan-3);
screwdriver.AddProcessClass("signal_650_50", "T2tt (650/50)", "signal",COLORPLOT_GREEN);
*/
// ##########################
// ## Create Regions ##
// ##########################
screwdriver.AddRegion("LM150", "LM 150", &Selector_LM150);
// ##########################
// ## Create Channels ##
// ##########################
screwdriver.AddChannel("singleLepton", "e/#mu-channels", &singleLeptonChannelSelector);
screwdriver.AddChannel("singleElec", "e-channel", &singleElecChannelSelector );
screwdriver.AddChannel("singleMuon", "#mu-channel", &singleMuonChannelSelector );
// ########################################
// ## Create histograms and ##
// ## schedule type of plots to produce ##
// ########################################
screwdriver.SetLumi(20000);
// Create histograms
screwdriver.Create1DHistos();
screwdriver.SetGlobalBoolOption ("1DSuperimposed", "includeSignal", true );
screwdriver.SetGlobalStringOption("1DStack", "includeSignal", "stack");
screwdriver.SetGlobalFloatOption ("1DStack", "factorSignal", 1.0 );
screwdriver.SetGlobalStringOption("DataMCComparison", "includeSignal", "stack");
screwdriver.SetGlobalFloatOption ("DataMCComparison", "factorSignal", 1.0 );
screwdriver.SetGlobalFloatOption ("FigureOfMerit", "backgroundSystematicUncertainty", 0.15 );
// Schedule plots
screwdriver.SchedulePlots("1DSuperimposed");
screwdriver.SchedulePlots("1DStack");
// Config plots
screwdriver.SetGlobalStringOption("Plot", "infoTopRight", "CMS Internal");
screwdriver.SetGlobalStringOption("Plot", "infoTopLeft", "#sqrt{s} = 8 TeV, L = 19.5 fb^{-1}");
screwdriver.SetGlobalBoolOption("Plot", "exportPdf", true);
screwdriver.SetGlobalBoolOption("Plot", "exportEps", false);
screwdriver.SetGlobalBoolOption("Plot", "exportPng", false);
// ########################################
// ## Run over the datasets ##
// ########################################
vector<string> datasetsList;
screwdriver.GetDatasetList(&datasetsList);
cout << " > Reading datasets... " << endl;
cout << endl;
for (unsigned int d = 0 ; d < datasetsList.size() ; d++)
{
string currentDataset = datasetsList[d];
string currentProcessClass = screwdriver.GetProcessClass(currentDataset);
pCurrentDataset = ¤tDataset;
pCurrentDatasetType = ¤tProcessClass;
// Open the tree
TFile f((string(FOLDER_BABYTUPLES)+currentDataset+".root").c_str());
TTree* theTree = (TTree*) f.Get("babyTuple");
intermediatePointers pointers;
InitializeBranches(theTree,&myEvent,&pointers);
// ########################################
// ## Run over the events ##
// ########################################
int nEntries = theTree->GetEntries();
for (int i = 0 ; i < nEntries ; i++)
{
if (i % (nEntries / 50) == 0) printProgressBar(i,nEntries,currentDataset);
//if (i > 0.03 * nEntries) break;
// Get the i-th entry
ReadEvent(theTree,i,&pointers,&myEvent);
float weight = 1.0;
// For MC, apply weights
/*
float lumi;
if (singleElecChannelSelector()) lumi = 19154.0;
else if (singleMuonChannelSelector()) lumi = 19096.0;
else lumi = 0.0;
*/
float lumi = 19500;
// Normalize to cross section times lumi
weight *= myEvent.weightCrossSection * lumi;
// Apply trigger efficiency weights for singleLepton channels
if (myEvent.numberOfLepton == 1) weight *= myEvent.weightTriggerEfficiency;
// Apply pile-up weight except for signal
if (currentDataset != "T2tt") weight *= myEvent.weightPileUp;
// For signal, apply ISR reweighting
if (currentDataset == "T2tt") weight *= myEvent.weightISRmodeling;
// For ttbar, apply topPt reweighting
//if (currentDataset == "ttbar") weight *= myEvent.weightTopPt;
// Split 1-lepton ttbar and 2-lepton ttbar
string currentProcessClass_ = currentProcessClass;
if ((currentDataset == "ttbar") && (myEvent.numberOfGenLepton == 2))
currentProcessClass_ = "ttbar_2l";
screwdriver.AutoFillProcessClass(currentProcessClass_,weight);
if ((myEvent.mStop == 250) && (myEvent.mNeutralino == 50))
screwdriver.AutoFillProcessClass("signal_250_50",weight);
if ((myEvent.mStop == 450) && (myEvent.mNeutralino == 50))
screwdriver.AutoFillProcessClass("signal_450_50",weight);
if ((myEvent.mStop == 650) && (myEvent.mNeutralino == 50))
screwdriver.AutoFillProcessClass("signal_650_50",weight);
}
printProgressBar(nEntries,nEntries,currentDataset);
cout << endl;
cout << "Reading " << f.GetBytesRead() << " bytes in " << f.GetReadCalls() << " transactions" << endl;
f.Close();
}
// ###################################
// ## Make plots and write them ##
// ###################################
cout << endl;
cout << " > Making plots..." << endl;
screwdriver.MakePlots();
cout << " > Saving plots..." << endl;
screwdriver.WritePlots("../plots/dataMCChecks/");
printBoxedMessage("Plot generation completed");
// #############################
// ## Post-plotting tests ##
// #############################
printBoxedMessage("Now computing misc tests ... ");
// Print yield tables for the signal region LM150
vector<string> tableRegions = { "LM150" };
TableBackgroundSignal(&screwdriver,tableRegions,"singleLepton").PrintTable();
printBoxedMessage("Program done.");
return (0);
}
int main (int argc, char *argv[])
{
//loadBDTSignalRegions();
if(argc == 2){
cout<<"load"<<endl;
default_param2(topness2_param_);
LoadParam2(string(argv[1]));
}
else{
cout<<"You shoul provide the name of the config file !"<<endl;
return -1;
}
printBoxedMessage("Starting tables generation");
// ####################
// ## Init tools ##
// ####################
// Create a sonic Screwdriver
SonicScrewdriver screwdriver;
// ##########################
// ## Create Variables ##
// ##########################
vector<string> colTags = {"default","resMass", "aCM", "allTerms","allTermsBias"};
vector<string> colLabels = {"default","reso mass", "aCM terms", "all terms", "id + bias"};
vector<string> rowTags = {"purity"};
vector<string> rowLabels = {"purity"};
Table table_topness_purity(colTags,rowTags,colLabels,rowLabels);
int n_tt2l_sel = 0;
int n_tt2l_sel_matchable = 0;
int n_topness_var = 5;
vector< vector< int > > topness_purity;
topness_purity.resize(n_topness_var);
for(int i=0;i<n_topness_var;i++) topness_purity[i].resize(2);
//tt2l_mc_info mcinfo;
//tt2l_reso res;
float d_met;
float topness_def;
float topness_m1; // change the resolution term for Invis.
float topness_m2; // change the resolution term for aCM
float topness_m3; // change the resolution term for all
float topness_m4; // change the resolution term for all
float topness_m5; // m3 + correct for MET bias
float topness_m6; // m3 + correct for MET bias
float topness_m7; // m3 + correct for MET bias
float topness_m8; // m3 + correct for MET bias
float topness_m9; // m3 + correct for MET bias
float topness_m10; // m3 + correct for MET bias
float topness_m11; // m3 + correct for MET bias
float topness_m12; // m3 + correct for MET bias
float topness_m13; // m3 + correct for MET bias
screwdriver.AddVariable("MT2W", "MT2W", "GeV", 40,0,400, &(myEvent.MT2W), "");
//screwdriver.AddVariable("lostLeptonEta", "Eta of lost lepton", "", 40, -6, 6, &(res.lost_eta), "");
// topness
screwdriver.AddVariable("topness", "topness - reference", "", 80, -5, 15, &(topness_def), "");
/*
screwdriver.AddVariable("topness_m12", "topness - resolution modified", "", 40, -20, 20, &(topness_m12), "");
screwdriver.AddVariable("topness_m13", "topness - resolution modified", "", 40, -20, 20, &(topness_m13), "");
*/
//int index_b; //
//int index_bbar; //
// vector<int> index_isr;
// #########################################################
// ## Create ProcessClasses (and associated datasets) ##
// #########################################################
screwdriver.AddProcessClass("ttbar_1l", "t#bar{t} #rightarrow l+jets", "background",kRed-7);
screwdriver.AddDataset("ttbar-madgraph", "ttbar_1l", 0, 0);
screwdriver.AddProcessClass("ttbar_2l", "t#bar{t} #rightarrow l^{+}l^{-}", "background",kCyan-3);
///*
screwdriver.AddProcessClass("single_top", "single top", "background",kRed-5);
screwdriver.AddDataset("singleTopbar_s", "single_top", 0, 0);
screwdriver.AddDataset("singleTopbar_t", "single_top", 0, 0);
screwdriver.AddDataset("singleTop_s", "single_top", 0, 0);
screwdriver.AddDataset("singleTop_t", "single_top", 0, 0);
screwdriver.AddProcessClass("W+jets", "W+jets", "background",kOrange-2);
screwdriver.AddDataset("Wjets", "W+jets", 0, 0);
screwdriver.AddProcessClass("VV", "di-boson", "background",kOrange-3);
//screwdriver.AddDataset("ZZ", "ZZ", 0, 0);
screwdriver.AddDataset("WZ", "WZ", 0, 0);
screwdriver.AddProcessClass("ttV", "ttV", "background",kOrange-4);
screwdriver.AddDataset("ttW", "ttV", 0, 0);
screwdriver.AddDataset("ttZ", "ttV", 0, 0);
// */
screwdriver.AddProcessClass("T2tt_850_100", "T2tt_850_100", "signal",kGreen+2);
screwdriver.AddDataset("T2tt_850_100", "T2tt_850_100", 0, 0);
screwdriver.AddProcessClass("T2tt_650_100", "T2tt_650_100", "signal",kGreen+3);
screwdriver.AddDataset("T2tt_650_100", "T2tt_650_100", 0, 0);
// screwdriver.AddProcessClass("T2tt_500_325", "T2tt_500_325", "signal",kGreen+4);
// screwdriver.AddDataset("T2tt_500_325", "T2tt_500_325", 0, 0);
// ##########################
// ## Create Regions ##
// ##########################
//screwdriver.AddRegion("presel_MTpeak", "Preselection (MT peak)", &goesInMTpeak);
//screwdriver.AddRegion("presel_MTtail", "Preselection (MT peak)", &goesInMTtail);
screwdriver.AddRegion("baseline", "Baseline selection", &goesInBaselineSearchSR);
screwdriver.AddRegion("baslineLargeDM", "Baseline S.R. - Large #DeltaM", &goesInLargeDMSR);
screwdriver.AddRegion("baselineSmallDM", "Baseline S.R. - Small #DeltaM", &goesInSmallDMSR);
screwdriver.AddRegion("baseline2b", "Baseline selection", &goesInBaselineSearchSR2b);
screwdriver.AddRegion("baselineSmallDM2b", "Baseline S.R. - Small #DeltaM", &goesInSmallDMSR2b);
// ##########################
// ## Create Channels ##
// ##########################
//screwdriver.AddChannel("singleLepton", "e/#mu-channels", &goesInSingleLeptonChannel);
//screwdriver.AddChannel("singleElec", "e-channel", &goesInSingleElecChannel );
//screwdriver.AddChannel("singleMuon", "#mu-channel", &goesInSingleMuonChannel );
screwdriver.AddChannel("allChannels", "", &goesInAnyChannel );
// ########################################
// ## Create histograms and ##
// ## schedule type of plots to produce ##
// ########################################
// Create histograms
screwdriver.Create1DHistos();
// Create 2D histos
// #########################################################
// Schedule plots
screwdriver.SchedulePlots("1DDataMCComparison");
screwdriver.SchedulePlots("1DStack");
screwdriver.SchedulePlots("1DSuperimposed");
//screwdriver.SchedulePlots("2D");
// Config plots
screwdriver.SetGlobalStringOption("DataMCComparison", "includeSignal", "stack");
screwdriver.SetGlobalFloatOption ("DataMCComparison", "factorSignal", 1.0 );
screwdriver.SetGlobalStringOption("1DStack", "includeSignal", "superimposed");
screwdriver.SetGlobalFloatOption ("1DStack", "factorSignal", 1.0 );
screwdriver.SetGlobalStringOption("Plot", "infoTopRight", "CMS Preliminary");
screwdriver.SetGlobalStringOption("Plot", "infoTopLeft", "#sqrt{s} = 8 TeV, L = 10 fb^{-1}");
screwdriver.SetGlobalBoolOption("Plot", "exportPdf", true);
screwdriver.SetGlobalBoolOption("Plot", "exportEps", false);
screwdriver.SetGlobalBoolOption("Plot", "exportPng", false);
// ########################################
// ## Run over the datasets ##
// ########################################
vector<string> datasetsList;
screwdriver.GetDatasetList(&datasetsList);
cout << " > Reading datasets... " << endl;
cout << endl;
for (unsigned int d = 0 ; d < datasetsList.size() ; d++)
{
string currentDataset = datasetsList[d];
string currentProcessClass = screwdriver.GetProcessClass(currentDataset);
sampleName = currentDataset;
sampleType = screwdriver.GetProcessClassType(currentProcessClass);
// Open the tree
string treePath = string(FOLDER_BABYTUPLES_SKIM)+currentDataset+".root";
TFile f(treePath.c_str());
TTree* theTree = (TTree*) f.Get("babyTuple");
//cout<<"v1"<<endl;
InitializeBranchesForReading(theTree,&myEvent);
//cout<<"v2"<<endl;
// ########################################
// ## Run over the events ##
// ########################################
bool ttbarDatasetToBeSplitted = false;
if (findSubstring(currentDataset,"ttbar")
&& (currentDataset != "ttbar_madgraph_1l")
&& (currentDataset != "ttbar_madgraph_2l"))
ttbarDatasetToBeSplitted = true;
int nEntries = theTree->GetEntries();
//if(nEntries>10000000) nEntries = 10000000;
//if(nEntries>5000000) nEntries = 5000000;
//if(nEntries>500000) nEntries = 500000;
double tWL, tTL, tTM;
float sf_fracEvent = (float)nEntries/theTree->GetEntries();
for (int i = 0 ; i < nEntries ; i++)
{
if (i % (nEntries / 50) == 0) printProgressBar(i,nEntries,currentDataset);
// Get the i-th entry
ReadEvent(theTree,i,&myEvent);
string currentProcessClass_ = currentProcessClass;
float weight = getWeight(currentDataset,theTree->GetEntries(), sf_fracEvent);
//Compute Delta MET
d_met = myEvent.pfmet-myEvent.genMET;
//Topness study
bool is_tt2l = false;
if(myEvent.ttbar_decay == 2){
is_tt2l = true;
n_tt2l_sel++;
if(myEvent.matched == true) n_tt2l_sel_matchable++;
}
#ifdef topness_computation
int index_b1 = -1;
int index_b2 = -1;
//cout<<topness_param_.use_cox_box<<endl;
//cout<<topness_param_.aW<<endl;
//default_param(topness_param_);
//DumpParam();
topness_def = ComputeTopness(index_b1,index_b2, tWL, tTL, tTM);
//cout<<"topness = "<<topness_def<<endl;
if(TopnessMatched(index_b1, index_b2)) topness_purity[0][0]++;
// changing the resolution terms
/*
// default computation
// -- load default parameter s
default_param(topness_param_);
topness_def = ComputeTopness(index_b1,index_b2);
if(TopnessMatched(index_b1, index_b2)) topness_purity[0][0]++;
// changing the resolution terms
default_param(topness_param_);
topness_param_.aW = 40;
topness_param_.aT = 50;
topness_m1 = ComputeTopness(index_b1,index_b2);
if(TopnessMatched(index_b1, index_b2)) topness_purity[0][1]++;
//
default_param(topness_param_);
topness_param_.aCM = 70;
topness_param_.aCM_mean = 500;
topness_m2 = ComputeTopness(index_b1,index_b2);
if(TopnessMatched(index_b1, index_b2)) topness_purity[0][2]++;
//
default_param(topness_param_);
topness_param_.aW = 40;
topness_param_.aT = 50;
topness_param_.aCM = 200;
topness_param_.aCM_mean = 650;
topness_m3 = ComputeTopness(index_b1,index_b2);
if(TopnessMatched(index_b1, index_b2)) topness_purity[0][3]++;
//
default_param(topness_param_);
topness_param_.aCM = 250;
topness_param_.aCM_mean = 670;
topness_m4 = ComputeTopness(index_b1,index_b2);
if(TopnessMatched(index_b1, index_b2)) topness_purity[0][4]++;
//correct for MET bias
topness_param_.aW = 40;
topness_param_.aT = 50;
topness_param_.aCM = 200;
topness_param_.aCM_mean =670;
topness_m7 = ComputeTopness(index_b1,index_b2);
//if(TopnessMatched(index_b1, index_b2)) topness_purity[0][5]++;
//correct for MET bias
//if(myEvent.pfmet>80) myEvent.pfmet = myEvent.pfmet - 50;
default_param(topness_param_);
topness_param_.aW = 80;
topness_param_.aT = 100;
topness_param_.aCM = 200;
topness_param_.aCM_mean = 670;
topness_m8 = ComputeTopness(index_b1,index_b2);
//if(TopnessMatched(index_b1, index_b2)) topness_purity[0][5]++;
//correct for MET bias
//if(myEvent.pfmet>80) myEvent.pfmet = myEvent.pfmet - 50;
default_param(topness_param_);
//topness_param_.aW = 80;
//topness_param_.aT = 100;
topness_param_.aCM = 65;
topness_param_.aCM_mean = 650;
topness_param_.use_cox_box = true;
topness_m9 = ComputeTopness(index_b1,index_b2);
//if(TopnessMatched(index_b1, index_b2)) topness_purity[0][5]++;
//correct for MET bias
//if(myEvent.pfmet>80) myEvent.pfmet = myEvent.pfmet - 50;
default_param(topness_param_);
topness_param_.aW = 40;
topness_param_.aT = 50;
topness_param_.aCM = 65;
topness_param_.aCM_mean = 650;
topness_param_.use_cox_box = true;
topness_m10 = ComputeTopness(index_b1,index_b2);
//correct for MET bias
//if(myEvent.pfmet>80) myEvent.pfmet = myEvent.pfmet - 50;
default_param(topness_param_);
topness_param_.aW = 40;
topness_param_.aT = 50;
topness_param_.aCM = 80;
topness_param_.aCM_mean = 800;
topness_param_.use_cox_box = true;
topness_m11 = ComputeTopness(index_b1,index_b2);
//correct for MET bias
//if(myEvent.pfmet>80) myEvent.pfmet = myEvent.pfmet - 50;
default_param(topness_param_);
//topness_param_.aW = 40;
//topness_param_.aT = 50;
//topness_param_.aCM = 80;
//topness_param_.aCM_mean = 800;
//topness_param_.use_cox_box = true;
topness_param_.usePtPz = true;
topness_m12 = ComputeTopness(index_b1,index_b2);
*/
//correct for MET bias
//if(myEvent.pfmet>80) myEvent.pfmet = myEvent.pfmet - 50;
/*
default_param(topness_param_);
topness_param_.aW = 40;
topness_param_.aT = 50;
//topness_param_.aCM = 80;
//topness_param_.aCM_mean = 800;
//topness_param_.use_cox_box = true;
topness_param_.usePtPz = true;
topness_m13 = ComputeTopness(index_b1,index_b2);
*/
/*
//correct for MET bias
//if(myEvent.pfmet>80) myEvent.pfmet = myEvent.pfmet - 50;
default_param(topness_param_);
topness_param_.aW = 40;
topness_param_.aT = 50;
topness_param_.aCM = 350;
topness_param_.aCM_mean = 850;
topness_m6 = ComputeTopness(index_b1,index_b2);
//if(TopnessMatched(index_b1, index_b2, res)) topness_purity[0][5]++;
//correct for MET bias
//cout<<myEvent.pfmet<<endl;
//if(myEvent.pfmet>80) myEvent.pfmet = myEvent.pfmet - 50;
if(myEvent.pfmet>80) myEvent.pfmet = myEvent.pfmet*0.70;// - 50;
//cout<<myEvent.pfmet<<endl;
default_param(topness_param_);
topness_param_.aW = 40;
topness_param_.aT = 50;
topness_param_.aCM = 300;
topness_param_.aCM_mean = 650;
topness_m5 = ComputeTopness(index_b1,index_b2);
//if(TopnessMatched(index_b1, index_b2, res)) topness_purity[0][5]++;
*/
#endif
// Split 1-lepton ttbar and 2-lepton ttbar
//if (ttbarDatasetToBeSplitted && (myEvent.genlepsfromtop == 2))
if (ttbarDatasetToBeSplitted && is_tt2l)
currentProcessClass_ = "ttbar_2l";
screwdriver.AutoFillProcessClass(currentProcessClass_,weight);
}
printProgressBar(nEntries,nEntries,currentDataset);
cout << endl;
f.Close();
}
// ###################################
// ## Make plots and write them ##
// ###################################
cout << endl;
cout << " > Making plots..." << endl;
screwdriver.MakePlots();
cout << " > Saving plots..." << endl;
//string output_dir = %./plots/"+string(argv[1])+"/pow2/";
string output_dir = "./plots/"+string(argv[1])+"/comb3_4/";
//string output_dir = "./plots/"+string(argv[1])+"/pow2/loopnonb_all/";
//string output_dir = "./plots/topness2/"+string(argv[1])+"/";
//screwdriver.WritePlots(string("./plots/plotsProducer/"));
screwdriver.WritePlots(output_dir);
printBoxedMessage("Plot generation completed");
printBoxedMessage("Writing the table ... ");
vector<string> regions = {
"presel_MTtail", "baseline", "baslineLargeDM", "baselineSmallDM"
//"presel_MTpeak", "presel_MTtail",
/*
"preveto_MTpeak", "preveto_MTtail",
"signalRegion_MTpeak", "signalRegion_MTtail",
"0btag_MTpeak", "0btag_MTtail",
"reversedVeto_MTpeak", "reversedVeto_MTtail",
"2leptons", "2leptons_MTpeak", "2leptons_MTtail",
*/};
//string exportFile = "rawYieldTables/prediction.tab";
//TableDataMC(&screwdriver,regions,"allChannels").Print(exportFile,4);
// #############################
// ## Post-plotting tests ##
// #############################
//Table topness - purity
for(int i=0;i<n_topness_var;i++){
table_topness_purity.Set(0,i, Figure(topness_purity[i][0],sqrt(topness_purity[i][0]))/Figure(n_tt2l_sel,sqrt(n_tt2l_sel)));
table_topness_purity.Set(1,i, Figure(topness_purity[i][0],sqrt(topness_purity[i][0]))/Figure(n_tt2l_sel_matchable,sqrt(n_tt2l_sel_matchable)));
}
table_topness_purity.Print(output_dir+"purity.dat");
printBoxedMessage("Program done.");
/*
string region = "baseline";
string channel = "allChannels";
string var;
var = "topness_m5";
//loop over the backgroumd
vector<string> processClassList;
//GetProcessClassTagList()
screwdriver.GetProcessClassTagList(&processClassList);
TH1F* h_Eff_Bkg = 0;
TH1F* h_Eff_Sig = 0;
bool first = true;
for(unsigned int i=0;i<processClassList.size();i++){
string proc = processClassList[i];
if(scredrive.GetProcessClassType(proc) == "background"){
TH1F* h = screewdriver.Get1DHistoClone(var , processClass, region, channel);
if(first){
h_Eff_Bkg = (TH1F*) h->Clone("");
first = false;
}
for(int i=1;i<h->GetNBinsX();i++){
h_Eff_Bkgh->Integral(i,h->GetNBinsX()+1);
}
}
}
*/
return (0);
}
int main(int argc, char** argv) {
if(argc < 4) {
printUsageAndDie();
}
FileHashGrouper fileHashGrouper;
bool enableHtmlOutput = false;
char* targetFolder;
char* algoArg;
char* thresholdArg;
float threshold = -1.0f;
HashAlgorithm selectedAlgorithm = DCT;
#ifdef DEBUG
std::cout << "Running in debug mode" << std::endl;
#endif
if(*argv[1] == '-') {
if(argc < 5)
printUsageAndDie();
targetFolder = argv[4];
algoArg = argv[2];
thresholdArg = argv[3];
if(argv[1][1] == 'a') {
#ifndef DEBUG
fileHashGrouper.thresholdRequiredForAll = false;
std::cout << "Threshold will be required to be satisfied for only ONE hash." << std::endl;
#else
std::cout << "Threshold behaviour argument ignored because of debug mode." << std::endl;
#endif
}
} else {
targetFolder = argv[3];
algoArg = argv[1];
thresholdArg = argv[2];
}
enableHtmlOutput = true;
std::cout << "HTML Output enabled." << std::endl;
std::string tmpSelectedAlgorithm(algoArg);
boost::algorithm::to_lower(tmpSelectedAlgorithm);
if(boost::iequals(tmpSelectedAlgorithm, "dct"))
selectedAlgorithm = DCT;
if(boost::iequals(tmpSelectedAlgorithm, "mh"))
selectedAlgorithm = MH;
if(boost::iequals(tmpSelectedAlgorithm, "radish"))
selectedAlgorithm = RADISH;
if(boost::iequals(tmpSelectedAlgorithm, "all"))
selectedAlgorithm = ALL;
fileHashGrouper.algorithm = selectedAlgorithm;
try {
threshold = boost::lexical_cast<int>(thresholdArg);
if(threshold > 100.0f || threshold < 1.0f)
throw 33; //No specific reason for 33, just felt like it
} catch (std::exception& e) {
std::cout << "error : threshold must be between 1 and 100\n\n";
printUsageAndDie();
}
std::cout << "Algorithm : " << tmpSelectedAlgorithm;
std::cout << ", Threshold : " << threshold << " %" << std::endl;
fileHashGrouper.threshold = 1-threshold/100;
std::cout << "Scanning target folder : " << targetFolder << std::endl;
std::vector<FileHash> fileList;
listImages(bf::path(targetFolder), fileList);
std::cout << "Done. " << fileList.size() << " file(s) to scan.\nScanning ...\n";
int scanned = 0;
for(int i = 0; i < fileList.size(); i++) {
fileList[i].compute(selectedAlgorithm);
printProgressBar(std::floor(((i+1)/static_cast<float>(fileList.size()))*100));
}
std::cout << std::endl;
ofstream outputHtml;
if(enableHtmlOutput) {
outputHtml.open("results.html");
if(!outputHtml.is_open()) {
std::cout << "Error : Could not open 'result.html' for writing, disabling HTML output.";
std::cout << std::endl;
enableHtmlOutput = false;
}
outputHtml << "<!DOCTYPE html>\n";
outputHtml << "<html>\n\t<head>\n\t\t<title>Image comparaison result</title>\n";
outputHtml << "\t\t<link href='style.css' rel='stylesheet' type='text/css'>\n\t</head>\n";
outputHtml << "\t<body>\n";
outputHtml << "\t\t<h1>Image comparaison result for " << targetFolder << "</h1>\n";
outputHtml << "\t\t<h2>" << fileList.size() << " image(s)</h2>\n";
outputHtml << "\t\t<table>\n";
}
std::vector<FileHashGroup> groups = fileHashGrouper.computeGroups(fileList);
for(int i = 0; i < groups.size(); i++) {
if(enableHtmlOutput) {
outputHtml << "\t\t\t<tr>\n";
outputHtml << "\t\t\t\t<td>\n";
groups[i][0].file.printHtml(outputHtml, 4);
outputHtml << "\t\t\t\t</td>\n";
}
#ifdef DEBUG
std::cout << groups[i][0].file.path() << " ";
#endif
for(int j = 1; j < groups[i].elements().size(); j++) {
if(enableHtmlOutput) {
outputHtml << "\t\t\t\t<td>\n";
groups[i][j].file.printHtml(outputHtml, 5);
outputHtml << "\t\t\t\t<br/><span class='similarity'>";
outputHtml << groups[i][j].similarity.percentage();
outputHtml << " %</span>\n";
outputHtml << "\t\t\t\t</td>\n";
}
#ifdef DEBUG
std::cout << groups[i][j].file.path() << " ";
std::cout << "dct : " << groups[i][j].similarity.dct << " | ";
std::cout << "mh : " << groups[i][j].similarity.mh << " | ";
std::cout << "radish : " << groups[i][j].similarity.radish << " | ";
std::cout << std::endl;
#endif
}
if(enableHtmlOutput)
outputHtml << "\t\t\t</tr>\n";
}
if(enableHtmlOutput) {
outputHtml << "\t\t</table>\n\t</body>\n</html>";
outputHtml.close();
std::cout << "Results saved to 'results.html'" << std::endl;
}
std::cout << "Done." << std::endl;
return 0;
}
/**
* print the provided string and draw the bar with provided percent
*
* @param string: the string to write to
* @param y: the y postion of the screen
* @param color: the color for the string
*/
void PrettyBoot::updateStatus(const char *string, int percent, uint8_t color)
{
printCentered(KERNEL_NAME, 0, 32);
printProgressBar(percent, color);
printCentered(string, 20, 0x07);
}
/**
* called in case of fail, print a red bar
*
* @param string: the error string to print
*/
void PrettyBoot::fail(const char *string)
{
printCentered(KERNEL_NAME, 0, 32);
printProgressBar(100, 0xC0);
printCentered(string, 20, RED);
}
int main (int argc, char *argv[])
{
printBoxedMessage("Starting plot generation");
// ####################
// ## Init tools ##
// ####################
// Create a sonic Screwdriver
SonicScrewdriver s;
// ##########################
// ## Create Variables ##
// ##########################
s.AddVariable("MET", "MET", "GeV", 16,50,530, &(myEvent.MET), "logY");
s.AddVariable("METPhi", "METPhi", "GeV", 16,50,530, &(myEvent.METPhi), "");
s.AddVariable("MT", "M_{T}", "GeV", 40,0,400, &(myEvent.MT), "");
/*
s.AddVariable("MTpeak", "M_{T}", "GeV", 20,0,100, &(myEvent.MT), "noOverflowInLastBin");
s.AddVariable("MTtail", "M_{T}", "GeV", 30,100,400, &(myEvent.MT), "logY,noUnderflowInFirstBin");
s.AddVariable("deltaPhiMETJets","#Delta#Phi(MET,j_{1,2})", "rad", 16,0,3.2, &(myEvent.deltaPhiMETJets), "");
s.AddVariable("MT2W", "M_{T2}^{W}", "GeV", 20,0,500, &(myEvent.MT2W), "");
s.AddVariable("HTratio", "H_{T}^{ratio}", "", 20,0,1.2, &(myEvent.HTRatio), "");
s.AddVariable("HadronicChi2", "Hadronic #chi^{2}", "", 20,0,20, &(myEvent.hadronicChi2), "logY");
s.AddVariable("leadingBPt", "p_{T}(leading b-jet)", "GeV", 20,0,400, &(myEvent.leadingBPt), "");
s.AddVariable("leadingJetPt", "p_{T}(leading jet)", "GeV", 20,0,600, &(myEvent.leadingJetPt), "");
s.AddVariable("leptonPt", "p_{T}(lepton)", "GeV", 28,20,300, &(myEvent.leadingLeptonPt), "");
s.AddVariable("Mlb", "M'(lb)", "GeV", 20,0,500, &(myEvent.Mlb), "");
s.AddVariable("Mlb_hemi", "M(lb)", "GeV", 20,0,500, &(myEvent.Mlb_hemi), "");
s.AddVariable("M3b", "M3b", "GeV", 20,0,1000, &(myEvent.M3b), "");
s.AddVariable("deltaRLeptonB", "#DeltaR(l,leading b)", "", 20,0,5, &(myEvent.deltaRLeptonLeadingB), "");
s.AddVariable("HTLeptonPtMET", "HT + MET + p_{T}(lepton)","GeV", 20,100,2100, &(myEvent.HTPlusLeptonPtPlusMET),"");
*/
s.AddVariable("HT", "H_{T}", "", 46,120,1500, &(myEvent.HT), "");
s.AddVariable("METoverSqrtHT", "MET / #sqrt{H_{T}}", "", 32,0,32, &(myEvent.METoverSqrtHT), "");
float leadingNonBPtN4;
s.AddVariable("leadingNonBPt", "p_{T}(leading nonb-jet)", "GeV", 20,0,500, &(leadingNonBPtN4), "");
float leadingNonBPtN5;
s.AddVariable("leadingNonBPtN5", "p_{T}(leading nonb-jet) (Njet>4)", "GeV", 20,0,500, &(leadingNonBPtN5), "noUnderflowInFirstBin");
int nJets, nBtag;
s.AddVariable("nJets", "Number of selected jets", "", 11,0,10, &(nJets), "");
s.AddVariable("nBtag", "Number of selected b-tagged jets", "", 5, 0,4, &(nBtag), "");
s.AddVariable("numberOfPrimaryVertices", "Number of primary vertices", "", 41, 0,40, &(myEvent.numberOfPrimaryVertices), "");
float METPtReso;
float METdPhiReso;
s.AddVariable("METPtReso", "MET p_{T} rel. resolution", "GeV", 50, 0,5, &(METPtReso), "");
s.AddVariable("METdPhiReso", "MET #Delta #Phi rel. resolution", "rad", 50, 0,2, &(METdPhiReso), "");
// #########################################################
// ## Create ProcessClasses (and associated datasets) ##
// #########################################################
s.AddProcessClass("1ltop", "1l top", "background",kRed-7);
s.AddDataset("ttbar_powheg", "1ltop", 0, 0);
s.AddDataset("singleTop_st", "1ltop", 0, 0);
s.AddProcessClass("ttbar_2l", "t#bar{t} #rightarrow l^{+}l^{-}", "background",kCyan-3);
s.AddProcessClass("W+jets", "W+jets", "background",kOrange-2);
s.AddDataset("W+jets", "W+jets", 0, 0);
s.AddProcessClass("rare", "rare", "background",kMagenta-5);
s.AddDataset("rare", "rare", 0, 0);
/*
s.AddProcessClass("T2tt", "T2tt (450, 50)", "signal", COLORPLOT_GREEN );
s.AddDataset("T2tt", "T2tt", 0, 0);
s.AddProcessClass("T2bw", "T2bw, x = 0.50 (450, 50)", "signal", COLORPLOT_MAGENTA );
s.AddDataset("T2bw-050", "T2bw", 0, 0);
*/
/*
s.AddProcessClass("data", "data", "data",COLORPLOT_BLACK);
s.AddDataset("SingleElec", "data", 0, 0);
s.AddDataset("SingleMuon", "data", 0, 0);
s.AddDataset("DoubleElec", "data", 0, 0);
s.AddDataset("DoubleMuon", "data", 0, 0);
s.AddDataset("MuEl", "data", 0, 0);
*/
// ##########################
// ## Create Regions ##
// ##########################
s.AddRegion("preselection", "Preselection", &goesInPreselection );
s.AddRegion("preselection_MTtail", "Preselection;M_{T} tail", &goesInPreselectionMTtail );
// ##########################
// ## Create Channels ##
// ##########################
s.AddChannel("singleLepton", "e/#mu-channels", &goesInSingleLeptonChannel);
// ########################################
// ## Create histograms and ##
// ## schedule type of plots to produce ##
// ########################################
// Create histograms
s.Create1DHistos();
s.Add2DHisto("MET","HT");
s.Add2DHisto("MT","METPtReso");
s.Add2DHisto("MT","METdPhiReso");
s.Add2DHisto("MT","numberOfPrimaryVertices");
s.Add2DHisto("numberOfPrimaryVertices","METdPhiReso");
s.Add2DHisto("numberOfPrimaryVertices","METPtReso");
// Schedule plots
//s.SchedulePlots("1DDataMCComparison");
s.SchedulePlots("1DStack");
s.SchedulePlots("1DSuperimposed");
s.SchedulePlots("2D");
s.SchedulePlots("1DFrom2DProjection","varX=MT,varY=METPtReso,projectionType=mean,labelY=MET Pt rel. resolution");
s.SchedulePlots("1DFrom2DProjection","varX=MT,varY=METdPhiReso,projectionType=mean,labelY=MET #Delta #Phi rel. resolution");
s.SchedulePlots("1DFrom2DProjection","varX=MT,varY=numberOfPrimaryVertices,projectionType=mean,labelY=Number of vertices");
s.SchedulePlots("1DFrom2DProjection","varX=numberOfPrimaryVertices,varY=METdPhiReso,projectionType=mean,labelY=MET #Delta #Phi rel. resolution");
s.SchedulePlots("1DFrom2DProjection","varX=numberOfPrimaryVertices,varY=METPtReso,projectionType=mean,labelY=MET Pt rel. resolution");
// Config plots
s.SetGlobalBoolOption ("1DSuperimposed", "includeSignal", true );
s.SetGlobalStringOption("DataMCComparison", "includeSignal", "superimposed");
s.SetGlobalFloatOption ("DataMCComparison", "factorSignal", 100.0 );
s.SetGlobalStringOption("1DStack", "includeSignal", "superimposed");
s.SetGlobalFloatOption ("1DStack", "factorSignal", 100.0 );
s.SetGlobalFloatOption ("DataMCRatio", "min", 0.0 );
s.SetGlobalFloatOption ("DataMCRatio", "max", 2.0 );
s.SetGlobalStringOption("Plot", "infoTopRight", "CMS Preliminary");
s.SetGlobalStringOption("Plot", "infoTopLeft", "#sqrt{s} = 8 TeV, L = 19.5 fb^{-1}");
s.SetGlobalBoolOption ("Plot", "exportPdf", true);
s.SetGlobalBoolOption ("Plot", "exportEps", false);
s.SetGlobalBoolOption ("Plot", "exportPng", false);
// ########################################
// ## Run over the datasets ##
// ########################################
vector<string> datasetsList;
s.GetDatasetList(&datasetsList);
cout << " > Reading datasets... " << endl;
cout << endl;
for (unsigned int d = 0 ; d < datasetsList.size() ; d++)
{
string currentDataset = datasetsList[d];
string currentProcessClass = s.GetProcessClass(currentDataset);
sampleName = currentDataset;
sampleType = s.GetProcessClassType(currentProcessClass);
// Open the tree
TFile f((string(FOLDER_BABYTUPLES)+currentDataset+".root").c_str());
TTree* theTree = (TTree*) f.Get("babyTuple");
intermediatePointers pointers;
InitializeBranchesForReading(theTree,&myEvent,&pointers);
if (sampleType == "signal")
{
theTree->SetBranchAddress("mStop", &(myEvent.mStop));
theTree->SetBranchAddress("mNeutralino", &(myEvent.mNeutralino));
}
else
{
myEvent.mStop = -1;
myEvent.mNeutralino = -1;
}
// ########################################
// ## Run over the events ##
// ########################################
bool ttbarDatasetToBeSplitted = false;
if (findSubstring(currentDataset,"ttbar"))
ttbarDatasetToBeSplitted = true;
int nEntries = theTree->GetEntries();
for (int i = 0 ; i < nEntries ; i++)
{
//if (i > float(nEntries) * 0.1) break;
if (i % (nEntries / 50) == 0) printProgressBar(i,nEntries,currentDataset);
// Get the i-th entry
ReadEvent(theTree,i,&pointers,&myEvent);
nJets = myEvent.nJets;
nBtag = myEvent.nBTag;
float weight = getWeight();
// Split 1-lepton ttbar and 2-lepton ttbar
string currentProcessClass_ = currentProcessClass;
if (ttbarDatasetToBeSplitted && (myEvent.numberOfGenLepton == 2))
currentProcessClass_ = "ttbar_2l";
#ifdef LEADING_NON_B_PT_ALREADY_COMPUTED
leadingNonBPtN4= myEvent.leadingNonBPt;
#else
leadingNonBPtN4= leadingNonBPt();
#endif
leadingNonBPtN5=-1;
if (nJets>4) leadingNonBPtN5= leadingNonBPtN4;
if ((currentProcessClass_ == "T2tt") && ((myEvent.mStop != 450) || (myEvent.mNeutralino != 50))) continue;
if ((currentProcessClass_ == "T2bw") && ((myEvent.mStop != 450) || (myEvent.mNeutralino != 50))) continue;
computeGenInfo();
METPtReso = myEvent.MET / myEvent.genMET;
METdPhiReso = abs(Phi_mpi_pi(myEvent.METPhi - myEvent.leadingLepton.Phi())) / myEvent.genMETdPhi;
s.AutoFillProcessClass(currentProcessClass_,weight);
}
printProgressBar(nEntries,nEntries,currentDataset);
cout << endl;
f.Close();
}
/*
// #############################
// ## Apply scale factors ##
// #############################
Table scaleFactors = Table("../prediction/scaleFactors/preselection.tab");
Figure SF_pre = scaleFactors.Get("value","SF_pre");
Figure SF_post = scaleFactors.Get("value","SF_post");
Figure SF_0btag = scaleFactors.Get("value","SF_0btag");
Figure SF_vetopeak = scaleFactors.Get("value","SF_vetopeak");
Figure SF_MTtail_1ltop = scaleFactors.Get("value","SF_MTtail_1ltop");
Figure SF_MTtail_Wjets = scaleFactors.Get("value","SF_MTtail_Wjets");
s.ApplyScaleFactor("ttbar_2l", "preselection_MTtail_withCorr", "singleLepton", SF_pre);
s.ApplyScaleFactor("1ltop", "preselection_MTtail_withCorr", "singleLepton", SF_post * SF_MTtail_1ltop);
s.ApplyScaleFactor("W+jets", "preselection_MTtail_withCorr", "singleLepton", SF_post * SF_MTtail_Wjets);
*/
// ###################################
// ## Make plots and write them ##
// ###################################
cout << endl;
cout << " > Making plots..." << endl;
s.MakePlots();
cout << " > Saving plots..." << endl;
s.WritePlots("./plots/METresolution/");
printBoxedMessage("Plot generation completed");
// #############################
// ## Post-plotting tests ##
// #############################
printBoxedMessage("Program done.");
return (0);
}
/**
* Main method (Duh ;) ) Runs the whole simulation. Main loop runs in this method
*
* @param argc number of command line arguments
* @param argsv[] command line parameters. Several Config file parameters can be overriden by setting them here. "--visualize" is especially cool, as it shows an OpenGL live view
*
* @return 0 if successful
*/
int main(int argc, char* argsv[]) {
if (argc > 1 && (!strcmp(argsv[1], "-?") || !strcmp(argsv[1], "help") || !strcmp(argsv[1], "--help"))) {
std::cout << "This is the NUKULAR Simulator" << std::endl;
std::cout << "Authors: " << std::endl;
std::cout << "\tLeonhard Rannabauer" << std::endl;
std::cout << "\tJakob Weiss" << std::endl;
std::cout << "\tAlexander Winkler" << std::endl;
std::cout << std::endl;
std::cout << "By default, configuration will be loaded from a configuration file." << std::endl;
std::cout << "The CWD will be searched for \"config.cfg\". Override this by specifying the" << std::endl;
std::cout << "\t-configFile command line parameter with the path to your own configuration" << std::endl;
std::cout << "\t(either .xml or .cfg format)" << std::endl;
std::cout << std::endl;
std::cout << "EXAMPLE: ./MolSim -configFile simulationConfig.xml -outputFilePrefix MD_sim -endTime 10" << std::endl;
std::cout << std::endl;
std::cout << "\t will load Settings from simulationConfig.xml, simulate the world for 10 seconds" << std::endl;
std::cout << "\t and output the files with a prefix of \"MD_sim\", which will lead to files like" << std::endl;
std::cout << "\t\"MD_sim_0010.vtu\"" << std::endl;
return 0;
}
std::cout << "Initializing the logger..." << std::endl << std::flush;
//Initialize the logging stuff
initializeLogger();
Settings::initSettings(argc, argsv);
LOG4CXX_TRACE(rootLogger, "Settings initialized!");
#ifdef _OPENMP
if(Settings::numThreads > 0) {
LOG4CXX_INFO(rootLogger, "Setting OpenMP Threads to " << Settings::numThreads);
omp_set_num_threads(Settings::numThreads);
}
else {
LOG4CXX_INFO(rootLogger, "Running on " << omp_get_max_threads() << " threads");
Settings::numThreads = omp_get_max_threads();
}
#else
Settings::numThreads = 1;
LOG4CXX_INFO(rootLogger, "Running serial version!");
#endif
#ifdef PAPI_BENCH
for(int i=0; i < Settings::numThreads; i++) {
char fileName[200];
sprintf(fileName, "CalcF #%i.txt", i);
papiCalcFCounters[i] = new PapiEnv(fileName);
sprintf(fileName, "CalcX #%i.txt", i);
papiCalcXCounters[i] = new PapiEnv(fileName);
}
#endif
//Check if we should be executing some unit tests
if(!Settings::testCase.empty()) {
return executeTests();
}
LOG4CXX_TRACE(rootLogger, "Creating Simulator instance...");
Simulator *sim = new Simulator();
#ifndef NOGLVISUALIZER
outputWriter::theSimulator = sim;
#endif
//Check if we should initialize with old state file
if(Settings::inputFile.size() !=0){
std::cout << "state found"<<std::endl;
}
double current_time = Settings::startTime;
int iteration = 0;
int benchmarkStartTime = getMilliCount();
double timeForOneIteration = 0;
// for this loop, we assume: current x, current f and current v are known
int maxIterations = (Settings::endTime - Settings::startTime) / Settings::deltaT;
int nextProgressBarDraw = 1;
int iterationsPerPercent = (maxIterations/100) + 1;
LOG4CXX_INFO(rootLogger, "Will calculate " << maxIterations << " iterations and output " << maxIterations/Settings::outputFrequency << " frames ");
while (current_time < Settings::endTime) {
if (iteration % Settings::outputFrequency == 0) {
sim->plotParticles(iteration + Settings::outputFileIterationOffset);
}
sim->nextTimeStep();
iteration++;
if(iteration == nextProgressBarDraw) {
nextProgressBarDraw+=iterationsPerPercent;
printProgressBar(100*iteration/maxIterations, -(benchmarkStartTime - getMilliCount()));
}
LOG4CXX_TRACE(rootLogger, "Iteration " << iteration << " finished.");
current_time += Settings::deltaT;
timeForOneIteration = ((double)(benchmarkStartTime - getMilliCount()))/iteration;
#ifndef NOGLVISUALIZER
while(outputWriter::renderingPaused) usleep(2000);
#endif
#ifdef PAPI_BENCH
for(int i=0; i < Settings::numThreads; i++) {
papiCalcFCounters[i]->printResults();
papiCalcXCounters[i]->printResults();
papiCalcFCounters[i]->reset();
papiCalcXCounters[i]->reset();
}
#endif
}
int benchmarkEndTime = getMilliCount();
if(Settings::saveLastState)
sim->exportPhaseSpace();
if(Settings::printStatistics)
sim->exportStatistics();
LOG4CXX_INFO(rootLogger, "Simulation finished. Took " << (benchmarkEndTime - benchmarkStartTime)/1000.0 << " seconds");
delete sim;
LOG4CXX_DEBUG(rootLogger, "Created " << Particle::createdInstances << " Particle instances (" << Particle::createdByCopy << " by copy)");
LOG4CXX_DEBUG(rootLogger, "Destroyed " << Particle::destroyedInstances << " Particle instances");
#ifdef PAPI_BENCH
for(int i=0; i < Settings::numThreads; i++) {
std::cout << "Writing PAPI output for thread " << i << std::endl;
papiCalcFCounters[i]->createResultFile();
papiCalcXCounters[i]->createResultFile();
delete papiCalcFCounters[i];
delete papiCalcXCounters[i];
}
#endif
//10 is arbitrarily chosen. there will always be some stray particles because of
//static instances that will be destroyed at program exit
#ifndef NOGLVISUALIZER
if(Particle::createdInstances - Particle::destroyedInstances - outputWriter::render3dParticles.size() > 10) {
#else
if(Particle::createdInstances - Particle::destroyedInstances > 10) {
#endif
LOG4CXX_WARN(rootLogger, "Significant mismatch between created and destroyed particle instances. This can be a memory leak! " << (Particle::createdInstances - Particle::destroyedInstances));
}
LOG4CXX_DEBUG(rootLogger, "output written. Terminating...");
return 0;
}
int executeTests() {
std::cout << "Running tests..." << std::endl;
CppUnit::TextUi::TestRunner runner;
bool all = !Settings::testCase.compare("all");
if(all || !Settings::testCase.compare("ParticleContainer"))
runner.addTest(ParticleContainerTests::suite());
if(all || !Settings::testCase.compare("ParticleGenerator"))
runner.addTest(ParticleGeneratorTests::suite());
// if(all || !Settings::testCase.compare("Settings"))
// runner.addTest(SettingsXsdTest::suite());
if(all || !Settings::testCase.compare("Matrix"))
runner.addTest(MatrixTests::suite());
runner.setOutputter( new CppUnit::CompilerOutputter( &runner.result(),
std::cerr ) );
// Run the tests.
bool wasSuccessful = runner.run();
// Return error code 1 if the one of test failed.
if(wasSuccessful) {
std::cout << "Tests ok!" << std::endl;
}
else {
std::cout << "Some tests failed!" << std::endl;
}
return wasSuccessful ? 0 : 1;
}