void createInputs(int n = 2)
{
for(UInt_t i = 0; i < (UInt_t)n; ++i ) {
TFile *file = TFile::Open(TString::Format("input%d.root",i),"RECREATE");
TH1F * h = new TH1F("h1","",10,0,100);
h->Fill(10.5); h->Fill(20.5);
Int_t nbins[5];
Double_t xmin[5];
Double_t xmax[5];
for(UInt_t j = 0; j < 5; ++j) {
nbins[j] = 10; xmin[j] = 0; xmax[j] = 10;
}
THnSparseF *sparse = new THnSparseF("sparse", "sparse", 5, nbins, xmin, xmax);
Double_t coord[5] = {0.5, 1.5, 2.5, 3.5, 4.5};
sparse->Fill(coord);
sparse->Write();
THStack *stack = new THStack("stack","");
h = new TH1F("hs_1","",10,0,100);
h->Fill(10.5); h->Fill(20.5);
h->SetDirectory(0);
stack->Add(h);
h = new TH1F("hs_2","",10,0,100);
h->Fill(30.5); h->Fill(40.5);
h->SetDirectory(0);
stack->Add(h);
stack->Write();
TGraph *gr = new TGraph(3);
gr->SetName("exgraph");
gr->SetPoint(0,1,1);
gr->SetPoint(1,2,2);
gr->SetPoint(2,3,3);
gr->Write();
TTree *tree = new TTree("tree","simplistic tree");
Int_t data = 0;
tree->Branch("data",&data);
for(Int_t l = 0; l < 2; ++l) {
data = l;
tree->Fill();
}
file->Write();
delete file;
}
}
void PlotEnergySpecs(int num){
cout<<"Run is "<<num<<endl;
stringstream ss;
TH1F * currentHisto;
for (int i=0;i<40;i++){
ss.str("");
ss<<"Run"<<num<<"LA"<<i<<".root";
TFile f(ss.str().c_str());
currentHisto =(TH1F*)gDirectory->Get("ENoOverFlows1");
if (i==0)
currentHisto->Draw();
else if ( i==38)
currentHisto->Draw("same");
currentHisto->SetLineColor(i+1);
currentHisto->SetDirectory(0);
}
}
TH1F* getHisto(string filename, string directoryname, string histoname) {
TFile *file = new TFile(filename.c_str(),"READ");
if (!file) {
cout << "Could not open file " << filename << endl;
return 0;
}
TDirectory *dir = (TDirectory*)file->FindObjectAny(directoryname.c_str());
if (!dir) {
cout << "Could not find directory " << directoryname << endl;
delete file;
return 0;
}
TH1F *hist = (TH1F*)dir->Get(histoname.c_str());
if (!hist) {
cout << "Could not find histogram " << histoname << " in directory " << directoryname << endl;
delete dir;
delete file;
return 0;
}
hist->SetDirectory(0);
delete dir;
delete file;
return hist;
}
void beffAnalysis(const char* input, const char* output) {
// input
TFile* inputFile = TFile::Open(input);
TTree* btagEff = (TTree*)inputFile->Get("btagEff");
// output
TFile* outputFile = TFile::Open(output,"RECREATE");
// histogram with proper binning... cloned later on
Double_t binning[23] = {20,25,30,35,40,45,50,55,60,65,70,75,80,85,90,95,100,120,140,160,180,200,1000};
TH1F* ptSpectrum = new TH1F("PtSpectrum","PtSpectrum",22,binning);
ptSpectrum->Sumw2();
// produce the ratio plot for the 12 combinations of (CSVL,CSVM,CSVT),(Barrel,Endcap),(b,c,l)
TClonesArray algorithms("TCut",3);
new(algorithms[0]) TCut("CSVL","csv>0.244");
new(algorithms[1]) TCut("CSVM","csv>0.679");
new(algorithms[2]) TCut("CSVT","csv>0.898");
TClonesArray etaRegions("TCut",2);
new(etaRegions[0]) TCut("Barrel","abs(eta)<=1.2");
new(etaRegions[1]) TCut("Endcaps","abs(eta)>1.2");
TClonesArray flavor("TCut",3);
new(flavor[0]) TCut("l","abs(flavor)!=4 && abs(flavor)!=5");
new(flavor[1]) TCut("c","abs(flavor)==4");
new(flavor[2]) TCut("b","abs(flavor)==5");
for(int i=0; i< algorithms.GetEntries() ; ++i) {
outputFile->mkdir(((TCut*)algorithms.At(i))->GetName());
outputFile->cd(((TCut*)algorithms.At(i))->GetName());
for(int j=0; j< etaRegions.GetEntries() ; ++j) {
for(int k=0; k< flavor.GetEntries() ; ++k) {
// histogram before tagging
TH1F* pretag = ptSpectrum->Clone("pretag");
btagEff->Draw("pt>>pretag",((*(TCut*)etaRegions.At(j))&&(*(TCut*)flavor.At(k)))*"eventWeight");
// histogram after tagging
TH1F* posttag = ptSpectrum->Clone("posttag");
btagEff->Draw("pt>>posttag",((*(TCut*)algorithms.At(i))&&(*(TCut*)etaRegions.At(j))&&(*(TCut*)flavor.At(k)))*"eventWeight");
// ratio
TH1F* ratio = posttag->Clone(Form("h_eff_bTagOverGoodJet_pt%s_%s",((TCut*)flavor.At(k))->GetName(),
((TCut*)etaRegions.At(j))->GetName()));
ratio->Divide(pretag);
// cleanup
delete pretag;
delete posttag;
}
}
}
// cleanup
algorithms.Delete();
etaRegions.Delete();
flavor.Delete();
ptSpectrum->SetDirectory(0);
outputFile->Write();
outputFile->Close();
inputFile->Close();
}
void Histogrammer::make_hist(const char* hname, const char* htitle, int nbins, double xlow, double xhigh, const char* xlabel, const char* ylabel){
TH1F* h = new TH1F(hname, htitle, nbins, xlow, xhigh);
h->GetXaxis()->SetTitle(xlabel);
h->GetYaxis()->SetTitle(ylabel);
h->SetDirectory(0);
//h->Sumw2();
hists[hname] = h;
}
Hists(std::string name)
{
title = name;
h1McPt = new TH1F(Form("h1McPt_%s",name.c_str()),";mcP_{T}(GeV/c)",40,1,5);
h1HftMatchedMcPt = new TH1F(Form("h1HftMatchedMcPt_%s",name.c_str()),";mcP_{T}(GeV/c)",40,1,5);
h1TpcMcPt = new TH1F(Form("h1TpcMcPt_%s",name.c_str()),";mcP_{T}(GeV/c)",40,1,5);
gTpcEff = new TGraphAsymmErrors; gTpcEff->SetName(Form("gTpcEff_%s",name.c_str()));
gHftEff = new TGraphAsymmErrors; gHftEff->SetName(Form("gHftEff_%s",name.c_str()));
h1DcaZPosEta = new TH1F(Form("h1DcaZPosEta_%s",name.c_str()),";dcaZ(cm)",400,-1,1);
h1DcaZNegEta = new TH1F(Form("h1DcaZNegEta_%s",name.c_str()),";dcaZ(cm)",400,-1,1);
h1DcaZ = new TH1F(Form("h1DcaZ_%s",name.c_str()),";dcaZ(cm)",400,-1,1);
h1McPt->SetDirectory(0);
h1HftMatchedMcPt->SetDirectory(0);
h1TpcMcPt->SetDirectory(0);
h1DcaZ->SetDirectory(0);
}
TH1F* LikelihoodSpace::get_projection(std::string name) {
int default_nbins = 100;
gEnv->GetValue("Hist.Binning.1D.x", default_nbins);
gEnv->SetValue("Hist.Binning.1D.x", 10000);
this->samples->Draw((name + ">>_hp").c_str(), "", "goff");
gEnv->SetValue("Hist.Binning.1D.x", default_nbins);
TH1F* hp = dynamic_cast<TH1F*>(gDirectory->FindObject("_hp"));
assert(hp);
hp->SetDirectory(NULL);
return hp;
}
TH1F* loadHistogram1D(
const std::vector<std::string>& fileList,
const std::string& histName,
const std::string& sys,
double scale,
int rebin
)
{
TH1F* result = nullptr;
for (const std::string& file: fileList)
{
TFile input(file.c_str(),"r");
TH1F* hist=nullptr;
if ((sys=="" or sys=="nominal") and input.FindKey(histName.c_str()))
{
hist = static_cast<TH1F*>(input.Get(histName.c_str()));
}
else if (input.FindKey((histName+"__"+sys).c_str()))
{
hist = static_cast<TH1F*>(input.Get((histName+"__"+sys).c_str()));
}
else if (input.FindKey(histName.c_str()))
{
log(WARNING,"using fallback '%s' for '%s'\n",histName.c_str(),(histName+"__"+sys).c_str());
hist = static_cast<TH1F*>(input.Get(histName.c_str()));
}
else
{
log(ERROR,"neither '%s' nor '%s' found in file '%s'\n",histName.c_str(),(histName+"__"+sys).c_str(),file.c_str());
continue;
}
hist->Scale(scale);
hist->Rebin(hist->GetNbinsX()/rebin);
if (!result)
{
result = new TH1F(*hist);
result->Sumw2();
result->SetDirectory(0);
}
else
{
result->Add(hist);
}
}
if (!result)
{
log(CRITICAL,"Error while finding histogram '"+histName+"' with sys '"+sys+"' in given files");
throw std::string("Error while finding histogram '"+histName+"' with sys '"+sys+"' in given files");
}
return result;
}
//*************************************************************************************************
//Function to create a distribution histogram for the signal for the variable given
//*************************************************************************************************
TH1F* makeSignalDistributionHistogram ( int variableIndex, MitNtupleEvent* event , Int_t nentries, TLegend *legend, int OnlyThisFinalState = -1) {
assert(variableIndex >= 0 && variableIndex < NVARIABLES);
string label = "NSignalEventsPass";
string histName = "h" + fVariableNames[variableIndex] + "_" + label;
string axisLabel = ";" + fVariableNames[variableIndex] + ";Number of Events";
TH1F *histogram = new TH1F(histName.c_str(),axisLabel.c_str(),NBINS,
fVariableRangeMin[variableIndex], fVariableRangeMax[variableIndex]);
histogram->SetDirectory(0);
for (int n=0;n<nentries;n++) {
event->GetEntry(n);
float eventweight = event->H_weight;
int finalstatetype = (int)event->H_ltype;
//only look at events with the given finalstatetype
if (OnlyThisFinalState >= 0 && OnlyThisFinalState != finalstatetype)
continue;
Float_t cutAboveValues[NVARIABLES];
Float_t cutBelowValues[NVARIABLES];
Float_t variableValues[NVARIABLES];
//only look at events with the given finalstatetype
//convert finalstatetype into the array index
int fs;
if (finalstatetype == 10)
fs = 0;
else if (finalstatetype == 11)
fs = 1;
else if (finalstatetype == 12)
fs = 2;
else {
fs = -1;
continue;
}
for (int j=0;j<NVARIABLES;j++) {
cutAboveValues[j] = fCutAboveInitialValue[fs][j];
cutBelowValues[j] = fCutBelowInitialValue[fs][j];
variableValues[j] = GetVariableValue(j, event);
}
//for N-1 distribution
//if (passCut(event,variableValues, cutAboveValues, cutBelowValues, variableIndex)) {
if (passCut(event,variableValues, cutAboveValues, cutBelowValues)) {
histogram->Fill(variableValues[variableIndex], eventweight);
}
}
legend->AddEntry(histogram, "signal", "LP");
return histogram;
}
int ScanChain( TChain* chain, int nEvents = -1, std::string skimFilePrefix="") {
TObjArray *listOfFiles = chain->GetListOfFiles();
unsigned int nEventsChain=0;
if(nEvents==-1)
nEvents = chain->GetEntries();
nEventsChain = nEvents;
unsigned int nEventsTotal = 0;
TDirectory *rootdir = gDirectory->GetDirectory("Rint:");
TH1F *samplehisto = new TH1F("samplehisto", "Example histogram", 200,0,200);
samplehisto->SetDirectory(rootdir);
// file loop
TIter fileIter(listOfFiles);
TFile *currentFile = 0;
while ( currentFile = (TFile*)fileIter.Next() ) {
TFile f(currentFile->GetTitle());
TTree *tree = (TTree*)f.Get("Events");
cms2.Init(tree);
//Event Loop
unsigned int nEvents = tree->GetEntries();
for( unsigned int event = 0; event < nEvents; ++event) {
cms2.GetEntry(event);
++nEventsTotal;
// Progress feedback to the user
if(nEventsTotal%1000 == 0) {
// xterm magic from L. Vacavant and A. Cerri
if (isatty(1)) {
printf("\015\033[32m ---> \033[1m\033[31m%4.1f%%"
"\033[0m\033[32m <---\033[0m\015", (float)nEventsTotal/(nEventsChain*0.01));
fflush(stdout);
}
}//if(nEventsTotal%20000 == 0) {
}
delete tree;
f.Close();
}
if ( nEventsChain != nEventsTotal ) {
std::cout << "ERROR: number of events from files is not equal to total number of events" << std::endl;
}
samplehisto->Draw();
return 0;
}
void make(TDirectory & out, TObject * o) {
TDirectory * dir;
TH1F * th1f;
TH1D * th1d;
TH2F * th2f;
TH2D * th2d;
out.cd();
if((dir = dynamic_cast<TDirectory*>(o)) != 0) {
TDirectory * outDir = out.mkdir(dir->GetName(), dir->GetTitle());
TIter next(dir->GetListOfKeys());
TKey *key;
while( (key = dynamic_cast<TKey*>(next())) ) {
string className(key->GetClassName());
string name(key->GetName());
TObject * obj = dir->Get(name.c_str());
if(obj == 0) {
cerr <<"error: key " << name << " not found in directory " << dir->GetName() << endl;
exit(-1);
}
make(*outDir, obj);
}
} else if((th1f = dynamic_cast<TH1F*>(o)) != 0) {
TH1F *h = (TH1F*) th1f->Clone();
h->Reset();
h->Sumw2();
h->SetDirectory(&out);
} else if((th1d = dynamic_cast<TH1D*>(o)) != 0) {
TH1D *h = (TH1D*) th1d->Clone();
h->Reset();
h->Sumw2();
h->SetDirectory(&out);
} else if((th2f = dynamic_cast<TH2F*>(o)) != 0) {
TH2F *h = (TH2F*) th2f->Clone();
h->Reset();
h->Sumw2();
h->SetDirectory(&out);
} else if((th2d = dynamic_cast<TH2D*>(o)) != 0) {
TH2D *h = (TH2D*) th2d->Clone();
h->Reset();
h->Sumw2();
h->SetDirectory(&out);
}
}
PUReweight::PUReweight(int nFiles, char** fileNames, std::string PUfilename){
PUweightSum = 0.0;
events = 0;
TFile* pileupFile = new TFile(PUfilename.c_str(),"READ");
PUweightHist = (TH1D*)pileupFile->Get("pileup");
PUweightHist->SetDirectory(0);
pileupFile->Close();
TH1D* PUbackup;
if(PUweightHist->GetNbinsX() != 100){
std::cout << "Wrong number of bins in the pileup histogram" << std::endl;
PUbackup = new TH1D("pileup_new","pileup_new",100,0,100);
for(int ibin=1; ibin <= PUweightHist->GetNbinsX(); ibin++){
PUbackup->SetBinContent(ibin, PUweightHist->GetBinContent(ibin));
// assuming the same scale
}
PUweightHist = PUbackup;
}
double PUweightInt = PUweightHist->Integral();
TH1F* mcPU = NULL;
for(int nmcfile = 0; nmcfile<nFiles; nmcfile++){
std::cout << "reading file " << std::string(fileNames[nmcfile]) << std::endl;
TFile* mcFile = new TFile(fileNames[nmcfile],"READ");
if(!(mcFile->Get("ggNtuplizer/hPU"))) {
std::cout << "no hPU histogram here!" << std::endl;
delete PUweightHist;
PUweightHist = NULL;
return;
}
if( mcPU==NULL) mcPU = (TH1F*)mcFile->Get("ggNtuplizer/hPU");
else mcPU->Add((TH1F*)mcFile->Get("ggNtuplizer/hPU"));
mcPU->SetDirectory(0);
mcFile->Close();
}
mcPU->Scale(1.0/mcPU->Integral());
PUweightHist->Divide(mcPU);
PUweightHist->Scale(1.0/PUweightInt);
delete mcPU;
}
void SignfificanceT2tt(bool pval, int exp=0){
TFile *f = TFile::Open("Significances2DHistograms_T2tt.root");
TH2F *h;
if(pval){
if(exp==0) h = (TH2F*)f->Get("hpObs");
else if(exp==1) h = (TH2F*)f->Get("hpExpPosteriori");
else if(exp==2) h = (TH2F*)f->Get("hpExpPriori");
}
else {
if(exp==0) h = (TH2F*)f->Get("hObs");
else if(exp==1) h = (TH2F*)f->Get("hExpPosteriori");
else if(exp==2) h = (TH2F*)f->Get("hExpPriori");
}
h->GetXaxis()->SetTitle("m_{#tilde{t}} [GeV]");
h->GetXaxis()->SetLabelFont(42);
h->GetXaxis()->SetLabelSize(0.035);
h->GetXaxis()->SetTitleSize(0.05);
h->GetXaxis()->SetTitleOffset(1.2);
h->GetXaxis()->SetTitleFont(42);
h->GetYaxis()->SetTitle("m_{#tilde{#chi}_{1}^{0}} [GeV]");
h->GetYaxis()->SetLabelFont(42);
h->GetYaxis()->SetLabelSize(0.035);
h->GetYaxis()->SetTitleSize(0.05);
h->GetYaxis()->SetTitleOffset(1.35);
h->GetYaxis()->SetTitleFont(42);
double maximum = h->GetMaximum();
double minimum = h->GetMinimum();
double sigmin = 99; int sigminx=-1; int sigminy=-1; if(pval) sigmin = -99;
h->GetZaxis()->SetRangeUser(minimum,maximum);
for(int x = 1; x<=h->GetNbinsX();++x){
for(int y = 1; y<=h->GetNbinsX();++y){
if(!pval&&h->GetBinContent(x,y)<sigmin){ sigmin =h->GetBinContent(x,y); sigminx = x; sigminy = y; }
if( pval&&h->GetBinContent(x,y)>sigmin){ sigmin =h->GetBinContent(x,y); sigminx = x; sigminy = y; }
if(!pval&&h->GetXaxis()->GetBinLowEdge(x)<h->GetYaxis()->GetBinLowEdge(y)+75) h->SetBinContent(x,y,-999);
if(h->GetXaxis()->GetBinLowEdge(x)<374) continue;
if(h->GetXaxis()->GetBinLowEdge(x)>424) continue;
if(h->GetYaxis()->GetBinLowEdge(y)<199) continue;
if(h->GetYaxis()->GetBinLowEdge(y)>249) continue;
if(!pval&&h->GetBinContent(x,y)>0.3) h->SetBinContent(x,y,0.05);
}
}
h->GetZaxis()->SetRangeUser(minimum,maximum);
if(!pval) cout << "minimal significance " << sigmin << " at " << h->GetXaxis()->GetBinLowEdge(sigminx) << "-" << h->GetYaxis()->GetBinLowEdge(sigminy) << endl;
else cout << "maximal p- value " << sigmin << " at " << h->GetXaxis()->GetBinLowEdge(sigminx) << "-" << h->GetYaxis()->GetBinLowEdge(sigminy) << endl;
TCanvas *c1 = new TCanvas("c1", "c1",50,50,600,600);
gStyle->SetOptFit(1);
gStyle->SetOptStat(0);
gStyle->SetOptTitle(0);
gStyle->SetErrorX(0.5);
//c1->Range(-6.311689,-1.891383,28.75325,4.56342);
c1->SetFillColor(0);
c1->SetBorderMode(0);
c1->SetBorderSize(2);
//c1->SetLogy();
c1->SetTickx(1);
c1->SetTicky(1);
c1->SetLeftMargin(0.15);
// c1->SetRightMargin(0.05);
c1->SetRightMargin(0.15);
c1->SetTopMargin(0.07);
c1->SetBottomMargin(0.15);
c1->SetFrameFillStyle(0);
c1->SetFrameBorderMode(0);
c1->SetFrameFillStyle(0);
c1->SetFrameBorderMode(0);
gStyle->SetHatchesLineWidth(0);
TH1F *hSum = new TH1F("hSum","",10,100,900);
hSum->SetMinimum(0.);
hSum->SetMaximum(550);
hSum->SetDirectory(0);
hSum->SetStats(0);
hSum->Draw();
hSum->GetYaxis()->SetRangeUser(0,500);
hSum->GetXaxis()->SetRangeUser(100,900);
Int_t ci; // for color index setting
ci = TColor::GetColor("#000099");
hSum->SetLineColor(ci);
hSum->SetLineStyle(0);
hSum->SetMarkerStyle(20);
hSum->GetXaxis()->SetTitle("m_{#tilde{t}} [GeV]");
//hSum->GetXaxis()->SetBit(TAxis::kLabelsVert);
hSum->GetXaxis()->SetLabelFont(42);
//hSum->GetXaxis()->SetLabelOffset(0.005);
hSum->GetXaxis()->SetLabelSize(0.035);
hSum->GetXaxis()->SetTitleSize(0.06);
hSum->GetXaxis()->SetTitleOffset(1.2);
hSum->GetXaxis()->SetTitleFont(42);
hSum->GetYaxis()->SetTitle("m_{#tilde{#chi}}_{1}^{0} [GeV]");
hSum->GetYaxis()->SetLabelFont(42);
//hSum->GetYaxis()->SetLabelOffset(0.007);
hSum->GetYaxis()->SetLabelSize(0.035);
hSum->GetYaxis()->SetTitleSize(0.05);
hSum->GetYaxis()->SetTitleOffset(1.3);
hSum->GetYaxis()->SetTitleFont(42);
/*
TLegend *legO = new TLegend(0.175,0.675,0.50,0.855,NULL,"brNDC");
//legO-> SetNColumns(2);
legO->SetBorderSize(0);
legO->SetTextSize(0.04);
legO->SetTextFont(42);
legO->SetLineColor(1);
legO->SetLineStyle(1);
legO->SetLineWidth(2);
legO->SetFillColor(0);
legO->SetFillStyle(1001);
legO->SetHeader("Observed");
legO->AddEntry(gObs, "unpolarized","l");
legO->AddEntry(gObsR, "right-handed","l");
legO->AddEntry(gObsL, "left-handed","l");
*/
TGraph* graphWhite = new TGraph(5);
graphWhite->SetName("white");
graphWhite->SetTitle("white");
graphWhite->SetFillColor(kWhite);
graphWhite->SetFillStyle(1001);
graphWhite->SetLineColor(kBlack);
graphWhite->SetLineStyle(1);
graphWhite->SetLineWidth(3);
graphWhite->SetPoint(0,100, 500);
graphWhite->SetPoint(1,900, 500);
graphWhite->SetPoint(2,900, 500*0.75);
graphWhite->SetPoint(3,100, 500*0.75);
graphWhite->SetPoint(4,100, 500);
Float_t diagX[4] = {175.+25.,175.+25.+5000,175.-25.+5000,175.-25.};
Float_t diagY[4] = {0,5000,5000,0};
TGraph *gdiagonal = new TGraph(4, diagX, diagY);
gdiagonal->SetName("MtopDiagonal");
gdiagonal->SetFillColor(kWhite);
//#gdiagonal->SetFillColor(18);
TLine* ldiagonal = new TLine(175,0.,650-25.,450);
//TLine* ldiagonal = new TLine(175.,25,175+500,500);
ldiagonal->SetLineColor(kGray);
ldiagonal->SetLineStyle(2);
TLatex* tdiagonal = new TLatex(400-2.5, 400-172.5,"m_{#tilde{t}} = m_{t} + m_{#tilde{#chi}_{1}^{0}}");
//tdiagonal->SetTextAngle(TMath::RadToDeg()*TMath::ATan(float(800)/float(500)));
tdiagonal->SetTextAngle(56.31);
tdiagonal->SetTextColor(kGray+2);
tdiagonal->SetTextAlign(11);
tdiagonal->SetTextSize(0.025);
TLine* l2 = new TLine(150,75,585,500);
l2->SetLineColor(kGray);
l2->SetLineStyle(2);
// if(killlowdiag){
// l2->SetX1(200); l2->SetY1(0); l2->SetX2(600); l2->SetY2(400);
// }
TLatex *t2 = new TLatex(300, 300-72.5,"m_{#tilde{t}} = m_{W} + m_{#tilde{#chi}_{1}^{0}}");
//t2->SetTextAngle(TMath::RadToDeg()*TMath::ATan(float(800)/float(500)));
t2->SetTextAngle(56.31);
t2->SetTextColor(kGray+2);
t2->SetTextAlign(11);
t2->SetTextSize(0.025);
hSum->Draw("axis");
h->Draw("COLZsame");
gdiagonal->Draw("FSAME");
ldiagonal->Draw("LSAME");
l2->Draw();
// if(!killlowdiag) t2->Draw();
tdiagonal->Draw("SAME");
graphWhite->Draw("FSAME");
graphWhite->Draw("LSAME");
string textstring = "observed";
if(exp!=0) textstring = "expected";
TLatex* textOE= new TLatex(0.175,0.715,textstring.c_str() );
textOE->SetNDC();
textOE->SetTextAlign(13);
textOE->SetTextFont(42);
textOE->SetTextSize(0.042);
textOE->Draw();
TLatex* textModelLabel= new TLatex(0.175,0.92,"pp #rightarrow #tilde{t} #tilde{t}*, #tilde{t} #rightarrow t #tilde{#chi}^{0}_{1}");
//TLatex* textModelLabel= new TLatex(0.175,0.92,"pp #rightarrow #tilde{t} #tilde{t}*, #tilde{t} #rightarrow t #tilde{#chi}^{0}_{1}");
//TLatex* textModelLabel= new TLatex(0.175,0.92,"#tilde{#chi} ");
textModelLabel->SetNDC();
textModelLabel->SetTextAlign(13);
textModelLabel->SetTextFont(42);
textModelLabel->SetTextSize(0.042);
textModelLabel->Draw();
TLatex* textlLabel= new TLatex(0.175,0.85,"NLO+NLL significance");
textlLabel->SetNDC();
textlLabel->SetTextAlign(13);
textlLabel->SetTextFont(42);
textlLabel->SetTextSize(0.042);
textlLabel->Draw();
string psig = "significance [#sigma]";
if(pval) psig = "p-value";
TLatex * ztex = new TLatex(0.985,0.92,psig.c_str() );
ztex->SetNDC();
ztex->SetTextAlign(31);
ztex->SetTextFont(42);
ztex->SetTextSize(0.045);
ztex->SetTextAngle(90);
ztex->SetLineWidth(2);
ztex->Draw();
//final CMS style
TLatex *tLumi = new TLatex(0.81,0.944,"2.3 fb^{-1} (13 TeV)");
tLumi->SetNDC();
tLumi->SetTextAlign(31);
tLumi->SetTextFont(42);
tLumi->SetTextSize(0.042);
tLumi->SetLineWidth(2);
tLumi->Draw();
TLatex *tCMS = new TLatex(0.152,0.944,"CMS");
tCMS->SetNDC();
tCMS->SetTextAlign(11);
tCMS->SetTextFont(61);
tCMS->SetTextSize(0.0525);
tCMS->SetLineWidth(2);
tCMS->Draw();
TLatex *tPrel = new TLatex(0.265,0.944,"Preliminary");
tPrel->SetNDC();
tPrel->SetTextAlign(11);
tPrel->SetTextFont(52);
tPrel->SetTextSize(0.042);
tPrel->SetLineWidth(2);
tPrel->Draw();
c1->Modified();
c1->cd();
c1->Update();
c1->SetSelected(c1);
}
TObjArray getDistributionFromPlotter(TString plot,TString baseURL="~/scratch0/top-nosyst/plotter.root")
{
using namespace std;
setStyle();
//the relevant processes
TString procs[]={"Di-bosons","Single top", "W+jets", "Z-#gamma^{*}+jets#rightarrow ll", "other t#bar{t}", "t#bar{t} dileptons", "data"};
const size_t nprocs=sizeof(procs)/sizeof(TString);
//containers for the histos
TList *data = new TList;
TH1F *totalData=0;
TList *mc = new TList;
TH1F *totalMC=0;
TH1F *ttbarMC=0;
TList *spimpose = new TList;
//open file with histograms
TFile *f=TFile::Open(baseURL);
for(size_t iproc=0; iproc<nprocs; iproc++)
{
TH1F *histo = (TH1F *) f->Get(procs[iproc]+"/"+plot);
if(histo==0) { cout << "[Warning] " << plot << " not found for " << procs[iproc] << " ...skipping" << endl; continue; }
histo->SetDirectory(0);
if(procs[iproc].Contains("data"))
{
data->Add(histo);
if(totalData==0) { totalData = (TH1F *) histo->Clone(plot+"totaldata"); totalData->SetDirectory(0); }
else { totalData->Add(histo); }
}
else
{
mc->Add(histo);
if(totalMC==0) { totalMC = (TH1F *) histo->Clone(plot+"totalmc"); totalMC->SetDirectory(0); }
else { totalMC->Add(histo); }
if(procs[iproc]=="t#bar{t} dileptons") { ttbarMC = (TH1F *)histo->Clone(plot+"ttbar"); ttbarMC->SetDirectory(0); }
}
}
f->Close();
cout << "Drawing now" << endl;
//draw
TCanvas *cnv = getNewCanvas(plot+"c",plot+"c",false);
cnv->Clear();
cnv->SetWindowSize(600,600);
cnv->cd();
TLegend *leg=showPlotsAndMCtoDataComparison(cnv,*mc,*spimpose,*data,false);
formatForCmsPublic(cnv,leg,"CMS preliminary", 4);
cnv->SaveAs(plot+".C");
cout << "Stat comparison for " << plot << endl
<< "Sample \t Average \t\t RMS " << endl
<< "----------------------------------------" << endl;
if(totalData) cout << "Data \t " << totalData->GetMean() << " +/- " << totalData->GetMeanError() << " \t " << totalData->GetRMS() << " +/- " << totalData->GetRMSError() << endl;
if(totalMC) cout << "MC \t " << totalMC->GetMean() << " +/- " << totalMC->GetMeanError() << " \t " << totalMC->GetRMS() << " +/- " << totalMC->GetRMSError() << endl;
if(ttbarMC) cout << "Signal \t " << ttbarMC->GetMean() << " +/- " << ttbarMC->GetMeanError() << " \t " << ttbarMC->GetRMS() << " +/- " << ttbarMC->GetRMSError() << endl;
TObjArray res;
res.Add(totalData);
res.Add(totalMC);
res.Add(ttbarMC);
res.Add(mc);
return res;
}
void compare_wls1(TString filename="../p15m_nwls/wcsim.root",TString histoname="p15m_nwls", Int_t *flag, TString rootfile = "temp.root") {
TFile *file1;
if (*flag!=0) {
//file1 = new TFile(rootfile,"Update");
file1 = new TFile(rootfile,"RECREATE");
} else {
file1 = new TFile(rootfile,"RECREATE");
}
TString filename1;
filename1 = histoname + "_digi";
TTree *T = new TTree(filename1,filename1);
T->SetDirectory(file1);
Double_t diginpe,digitime,cor_digitime,digitheta,dis_digihit;
Int_t neve;
Double_t mom;
Double_t pos_x,pos_y,pos_z;
Double_t dir_x,dir_y,dir_z;
Double_t tube_x,tube_y,tube_z;
Double_t totankdis;
Double_t vertex[3],dir[3];
Double_t tube_pos[3];
T->Branch("digi_eve",&neve,"data/I");
T->Branch("diginpe",&diginpe,"data/D");
T->Branch("digitime",&digitime,"data/D");
T->Branch("cor_digitime",&cor_digitime,"data/D");
T->Branch("digitheta",&digitheta,"data/D");
T->Branch("dis_dighit",&dis_digihit,"data/D");
T->Branch("mom",&mom,"data/D");
T->Branch("totankdis",&totankdis,"data/D");
T->Branch("pos_x",&vertex[0],"data/D");
T->Branch("pos_y",&vertex[1],"data/D");
T->Branch("pos_z",&vertex[2],"data/D");
T->Branch("dir_x",&dir[0],"data/D");
T->Branch("dir_y",&dir[1],"data/D");
T->Branch("dir_z",&dir[2],"data/D");
T->Branch("tube_x",&tube_pos[0],"data/D");
T->Branch("tube_y",&tube_pos[1],"data/D");
T->Branch("tube_z",&tube_pos[2],"data/D");
filename1 = histoname + "_hit";
TTree *t1 = new TTree(filename1,filename1);
t1->SetDirectory(file1);
Double_t wavelength, truetime, corr_time,theta,distance,index;
Int_t qe_flag,parentid,tubeid,totalpe;
Int_t ntracks;
t1->Branch("ntracks",&ntracks,"data/I");
t1->Branch("neve",&neve,"data/I");
t1->Branch("wavelength",&wavelength,"data/D");
t1->Branch("truetime",&truetime,"data/D");
t1->Branch("corr_time",&corr_time,"data/D");
t1->Branch("theta",&theta,"data/D");
t1->Branch("distance",&distance,"data/D");
t1->Branch("index",&index,"data/D");
t1->Branch("mom",&mom,"data/D");
t1->Branch("totankdis",&totankdis,"data/D");
t1->Branch("pos_x",&vertex[0],"data/D");
t1->Branch("pos_y",&vertex[1],"data/D");
t1->Branch("pos_z",&vertex[2],"data/D");
t1->Branch("dir_x",&dir[0],"data/D");
t1->Branch("dir_y",&dir[1],"data/D");
t1->Branch("dir_z",&dir[2],"data/D");
t1->Branch("tube_x",&tube_pos[0],"data/D");
t1->Branch("tube_y",&tube_pos[1],"data/D");
t1->Branch("tube_z",&tube_pos[2],"data/D");
// t1->Branch("pos_x",&pos_x,"data/D");
// t1->Branch("pos_y",&pos_y,"data/D");
// t1->Branch("pos_z",&pos_z,"data/D");
// t1->Branch("dir_x",&dir_x,"data/D");
// t1->Branch("dir_y",&dir_y,"data/D");
// t1->Branch("dir_z",&dir_z,"data/D");
// t1->Branch("tube_x",&tube_x,"data/D");
// t1->Branch("tube_y",&tube_y,"data/D");
// t1->Branch("tube_z",&tube_z,"data/D");
t1->Branch("qe_flag",&qe_flag,"data/I");
t1->Branch("parentid",&parentid,"data/I");
t1->Branch("tubeid",&tubeid,"data/I");
t1->Branch("totalpe",&totalpe,"data/I");
TFile *file = new TFile(filename);
TTree *wcsimT = file->Get("wcsimT");
WCSimRootEvent *wcsimrootsuperevent = new WCSimRootEvent();
wcsimT->SetBranchAddress("wcsimrootevent",&wcsimrootsuperevent);
wcsimT->GetBranch("wcsimrootevent")->SetAutoDelete(kTRUE);
TTree *gtree = file->Get("wcsimGeoT");
WCSimRootGeom *wcsimrootgeom = new WCSimRootGeom();
gbranch = gtree->GetBranch("wcsimrootgeom");
gbranch->SetAddress(&wcsimrootgeom);
gtree->GetEntry(0);
WCSimRootPMT *pmt;
Double_t pmt_pos[500000][3];
for (Int_t i=0; i!=wcsimrootgeom->GetWCNumPMT(); i++) {
pmt_pos[i][0] = (wcsimrootgeom->GetPMT(i)).GetPosition(0);
pmt_pos[i][1] = (wcsimrootgeom->GetPMT(i)).GetPosition(1);
pmt_pos[i][2] = (wcsimrootgeom->GetPMT(i)).GetPosition(2);
}
//in terms of wavelength (total NPE) real hit
filename1 = histoname + "_total_wl";
TH1F *hqx = new TH1F(filename1,filename1,600,200,800);
//NPE in each event sum over digi hit
filename1 = histoname + "_total_npe";
TH1F *hqx2 = new TH1F(filename1,filename1,1000,0.,10000);
//digitized hit time
filename1 = histoname + "_digitime";
TH1F *hqx1 = new TH1F(filename1,filename1,500,900,1400);
//corrected digitized hit time
filename1 = histoname + "_cor_digitime";
TH1F *hqx4 = new TH1F(filename1,filename1,1000,400,1400);
//digitized hit angle
filename1 = histoname + "_digitheta";
TH1F *hqx5 = new TH1F(filename1,filename1,180,0,180);
//TH2F *h1 = new TH2F("h1","h1",100,1000,20000,100,90000,140000);
Double_t index = 1.333;
neve = *flag;
cout << histoname << "\t" << wcsimT->GetEntries() << endl;
for (Int_t j=0; j!=wcsimT->GetEntries(); j++) {
//for (Int_t j=0;j!=90;j++){
// cout << j << endl;
wcsimT->GetEvent(j);
neve ++;
WCSimRootTrigger *wcsimrootevent = wcsimrootsuperevent->GetTrigger(0);
temp = (TClonesArray*)wcsimrootevent->GetTracks();
Int_t ntrack = wcsimrootevent->GetNtrack();
//cout << ntrack << endl;
ntracks = ntrack;
mom = ((WCSimRootTrack*)temp->At(ntrack-1))->GetP();
//get the vertex information
vertex[0] = ((WCSimRootTrack*)temp->At(ntrack-1))->GetStart(0);
vertex[1] = ((WCSimRootTrack*)temp->At(ntrack-1))->GetStart(1);
vertex[2] = ((WCSimRootTrack*)temp->At(ntrack-1))->GetStart(2);
//get position information
dir[0] = ((WCSimRootTrack*)temp->At(ntrack-1))->GetDir(0);
dir[1] = ((WCSimRootTrack*)temp->At(ntrack-1))->GetDir(1);
dir[2] = ((WCSimRootTrack*)temp->At(ntrack-1))->GetDir(2);
totankdis=ToTankDistance(vertex,dir);
TVector3 vertex3(vertex[0],vertex[1],vertex[2]);
TVector3 dir3(dir[0],dir[1],dir[2]);
//loop through digi hit
int max = wcsimrootevent->GetNcherenkovdigihits();
double sum = 0;
for (int i=0; i<max; i++) {
// cout << max << "\t" << i << endl;
WCSimRootCherenkovDigiHit *cDigiHit = ((WCSimRootCherenkovDigiHit*)wcsimrootevent->GetCherenkovDigiHits()->At(i));
hqx1->Fill(cDigiHit->GetT());
tube_pos[0] = pmt_pos[(cDigiHit->GetTubeId()-1)][0];
tube_pos[1] = pmt_pos[(cDigiHit->GetTubeId()-1)][1];
tube_pos[2] = pmt_pos[(cDigiHit->GetTubeId()-1)][2];
TVector3 hit3(tube_pos[0],tube_pos[1],tube_pos[2]);
TVector3 dis = hit3-vertex3;
diginpe = cDigiHit->GetQ();
digitime = cDigiHit->GetT();
cor_digitime = digitime-dis.Mag()/299792458.*1.333*1.e7;
digitheta = dis.Angle(dir3)/3.1415926*180.;
dis_digihit = dis.Mag();
hqx4->Fill(cor_digitime,diginpe);
hqx5->Fill(digitheta,diginpe);
sum += diginpe;
T->Fill();
}
hqx2->Fill(sum);
//loop through real hit
//loop through PMT hit first
max = wcsimrootevent-> GetNcherenkovhits();
//cout << max << endl;
if (max ==0) {
t1->Fill();
}
for (int i=0; i<max; i++) {
WCSimRootCherenkovHit* wcsimrootcherenkovhit =
dynamic_cast<WCSimRootCherenkovHit*>((wcsimrootevent->GetCherenkovHits())->At(i));
totalpe = wcsimrootcherenkovhit->GetTotalPe(1);
tubeid = wcsimrootcherenkovhit->GetTubeID() ;
//loop through hit time etc
for (int k=0; k<totalpe; k++) {
TObject *element2 = (wcsimrootevent->GetCherenkovHitTimes())->
At(wcsimrootcherenkovhit->GetTotalPe(0)+k);
WCSimRootCherenkovHitTime *wcsimrootcherenkovhittime
= dynamic_cast<WCSimRootCherenkovHitTime*>(element2);
wavelength =wcsimrootcherenkovhittime->GetWavelength();
qe_flag = wcsimrootcherenkovhittime->GetQe_flag();
truetime = wcsimrootcherenkovhittime->GetTruetime();
parentid = wcsimrootcherenkovhittime->GetParentID();
pos_x = wcsimrootcherenkovhittime->GetPosX() ;
pos_y = wcsimrootcherenkovhittime->GetPosY() ;
pos_z = wcsimrootcherenkovhittime->GetPosZ() ;
dir_x = wcsimrootcherenkovhittime->GetDirX() ;
dir_y = wcsimrootcherenkovhittime->GetDirY() ;
dir_z = wcsimrootcherenkovhittime->GetDirZ() ;
tube_pos[0] = pmt_pos[tubeid-1][0];
tube_pos[1] = pmt_pos[tubeid-1][1];
tube_pos[2] = pmt_pos[tubeid-1][2];
tube_x = tube_pos[0];
tube_y = tube_pos[1];
tube_z = tube_pos[2];
TVector3 hit3(tube_pos[0],tube_pos[1],tube_pos[2]);
TVector3 dis = hit3-vertex3;
distance = dis.Mag();
theta = dis.Angle(dir3)/3.1415926*180.;
//index = index(wavelength);
index = 1.34;
corr_time = truetime - distance/299792458.*1e7*index;
if (qe_flag==1) {
hqx->Fill(wavelength);
}
t1->Fill();
}
}
}
if (flag==1) {
hqx->SetDirectory(file1);
hqx2->SetDirectory(file1);
hqx1->SetDirectory(file1);
hqx4->SetDirectory(file1);
hqx5->SetDirectory(file1);
file1->Write();
file1->Close();
} else {
hqx->SetDirectory(file1);
hqx2->SetDirectory(file1);
hqx1->SetDirectory(file1);
hqx4->SetDirectory(file1);
hqx5->SetDirectory(file1);
file1->Write();
file1->Close();
}
*flag = neve;
}
//
// Main function
//
void drawROCandWPv4(){
bazinga("Step #0");
TCanvas *c1 = new TCanvas("c1","",10,10,600,600);
// c1->cd();
TString tmvaFileName1 = tmvaFileNameBarrel[0];
TString tmvaFileName2 = tmvaFileNameBarrel[1];
TString tmvaFileName3 = tmvaFileNameBarrel[2];
TString tmvaFileName4 = tmvaFileNameBarrel[3];
bazinga("Step #1");
const TString *cutFileNamesSet1 = cutFileNamesBarrelSet1;
const TString *cutFileNamesSet2 = cutFileNamesBarrelSet2;
const TString *cutFileNamesSet3 = cutFileNamesBarrelSet3;
const TString *cutFileNamesSet4 = cutFileNamesBarrelSet4;
if( !drawBarrel ){
tmvaFileName1 = tmvaFileNameEndcap[0];
tmvaFileName2 = tmvaFileNameEndcap[1];
tmvaFileName3 = tmvaFileNameEndcap[2];
tmvaFileName4 = tmvaFileNameEndcap[3];
cutFileNamesSet1 = cutFileNamesEndcapSet1;
cutFileNamesSet2 = cutFileNamesEndcapSet2;
cutFileNamesSet3 = cutFileNamesEndcapSet3;
cutFileNamesSet4 = cutFileNamesEndcapSet4;
}
bazinga("Step #2");
// Open the file with TMVA output
TFile *tmvaFile1 = new TFile(tmvaFileName1);
TFile *tmvaFile2 = new TFile(tmvaFileName2);
TFile *tmvaFile3 = new TFile(tmvaFileName3);
TFile *tmvaFile4 = new TFile(tmvaFileName4);
if( !tmvaFile1 || !tmvaFile2 || !tmvaFile3 || !tmvaFile4)
assert(0);
bazinga("Step #3");
//
// Draw the ROC curve
//
TH1F *hROC1 = (TH1F*)tmvaFile1->Get("Method_Cuts/Cuts/MVA_Cuts_rejBvsS");
TH1F *hROC2 = (TH1F*)tmvaFile2->Get("Method_Cuts/Cuts/MVA_Cuts_rejBvsS");
TH1F *hROC3 = (TH1F*)tmvaFile3->Get("Method_Cuts/Cuts/MVA_Cuts_rejBvsS");
TH1F *hROC4 = (TH1F*)tmvaFile4->Get("Method_Cuts/Cuts/MVA_Cuts_rejBvsS");
if( !hROC1 || !hROC2 || !hROC3|| !hROC3 )
assert(0);
//c1->cd();
//hROC1->Draw();
bazinga("Step #4");
TH1F * hROC = new TH1F("hROC", "", 100, 0, 1);
hROC->SetDirectory(0);
for(int iBin = 1; iBin <=100; ++iBin){
if (drawBarrel){
// barrrel
if(1<=iBin && iBin<=75)
hROC->SetBinContent(iBin, hROC3->GetBinContent(iBin)) ;
else if(76 <= iBin && iBin<=89)
hROC->SetBinContent(iBin, hROC2->GetBinContent(iBin)) ;
else if(90 <=iBin && iBin<=100)
hROC->SetBinContent(iBin, hROC1->GetBinContent(iBin)) ;
}
else {
// for endcap
if(1<=iBin && iBin<=70)
hROC->SetBinContent(iBin, hROC3->GetBinContent(iBin)) ;
else if(71 <= iBin && iBin<=89)
hROC->SetBinContent(iBin, hROC2->GetBinContent(iBin)) ;
else if(90 <=iBin && iBin<=100)
hROC->SetBinContent(iBin, hROC1->GetBinContent(iBin)) ;
}
}
bazinga("Step #5");
//Set histogram attributes and draw the ROC curve
hROC->SetStats(0);
hROC->SetLineWidth(2);
hROC->SetTitle("");
hROC->GetXaxis()->SetTitle("signal efficiency");
hROC->GetYaxis()->SetTitle("background rejection");
hROC->GetYaxis()->SetTitleOffset(1.4);
if( drawBarrel ){
hROC->GetXaxis()->SetRangeUser(0.6, 1.0);
hROC->GetYaxis()->SetRangeUser(0.951, 1.0);
}else{
hROC->GetXaxis()->SetRangeUser(0.6, 1.0);
hROC->GetYaxis()->SetRangeUser(0.8, 1.0);
}
c1->cd();
// hROC->Draw("L");
hROC1->SetLineColor(kRed);
hROC2->SetLineColor(kOrange);
hROC3->SetLineColor(kBlue);
hROC4->SetLineColor(kGreen);
hROC1->GetYaxis()->SetRangeUser(0.9, 1.0);
hROC1->SetStats(0);
hROC1->Draw("L");
//hROC1->Draw("Lsame");
//hROC2->Draw("Lsame");
//hROC3->Draw("Lsame");
//hROC4->Draw("Lsame");
bazinga("Step #6");
TString commentText = "barrel electrons";
if( !drawBarrel )
commentText = "endcap electrons";
TLatex *comment = new TLatex(0.2, 0.2, commentText);
comment->SetNDC(kTRUE);
comment->Draw();
c1->Update();
bazinga("Step #7");
//
// Overlay the cuts
//
// First find the TestTree for measuring efficiency and rejection
printf("\n Take true electrons from %s tree %s\n",
fnameSignal.Data(), signalTreeName.Data());
TTree *signalTree = getTreeFromFile( fnameSignal, signalTreeName);
// Input background tree
printf("\n Take background electrons from %s tree %s\n",
fnameBackground.Data(), backgroundTreeName.Data());
TTree *backgroundTree = getTreeFromFile( fnameBackground, backgroundTreeName);
bazinga("Step #8");
// Next, draw all working point sets
if( nWorkingPointSets==4 ){
TLegend *leg = new TLegend(0.15, 0.45, 0.5, 0.7);
leg->SetFillStyle(0);
leg->SetBorderSize(0);
overlayWorkingPoints(c1, signalTree, backgroundTree, cutFileNamesSet1,
markerColorSet1, markerStyleSet1, leg, legendSet1);
// bazinga("Step #9");
// overlayWorkingPoints(c1, signalTree, backgroundTree, cutFileNamesSet2,
// markerColorSet2, markerStyleSet2, leg, legendSet2);
// bazinga("Step #10");
// overlayWorkingPoints(c1, signalTree, backgroundTree, cutFileNamesSet3,
// markerColorSet3, markerStyleSet3, leg, legendSet3);
// bazinga("Step #11");
// overlayWorkingPoints(c1, signalTree, backgroundTree, cutFileNamesSet4,
// markerColorSet4, markerStyleSet4, leg, legendSet4);
// bazinga("Step #12");
leg->Draw("same");
}
// Save the figure into a file
TString outname = "figures/plot_ROCandWP_barrel.png";
bazinga("Step #13");
if( !drawBarrel )
outname = "figures/plot_ROCandWP_endcap.png";
c1->Print(outname);
return;
};
void compare_ATLAS_pp_fitBoth_TH1F(Int_t nfit=6, Int_t FitStart=50, Int_t FitEnd=450){
TH1::SetDefaultSumw2();
gStyle->SetOptFit(1);
gStyle->SetOptStat(0);
//=========Macro generated from canvas: cATLAS_pp/
//========= (Wed Jul 22 23:01:26 2015) by ROOT version5.32/00
TF1 *fitppATLAS = new TF1("fitppATLAS","[0]*pow(x+[2],[1])"); //create function
fitppATLAS->SetParameters(1e10,-5,0);
fitppATLAS->SetLineColor(kRed);
TF1 *fitppCMS = new TF1("fitppCMS","[0]*pow(x+[2],[1])"); //create function
fitppCMS->SetParameters(1e10,-5,0);
fitppCMS->SetLineColor(kBlue);
TF1 *fitppATLASHist = new TF1("fitppATLASHist","[0]*pow(x+[2],[1])"); //create function
fitppATLASHist->SetParameters(1e10,-5,0);
fitppATLASHist->SetLineColor(kGreen+1);
TGraphAsymmErrors *grae = new TGraphAsymmErrors(12);
grae->SetName("/HepData/8719/d2x1y1");
grae->SetTitle(" ");
grae->SetFillColor(1);
grae->SetMarkerStyle(33);
grae->SetPoint(0,35,180);
grae->SetPointError(0,4,4,29.95905,29.95905);
grae->SetPoint(1,44.5,55.7);
grae->SetPointError(1,5.5,5.5,7.828377,7.828377);
grae->SetPoint(2,56.5,16.9);
grae->SetPointError(2,6.5,6.5,2.625436,2.625436);
grae->SetPoint(3,71,4.85);
grae->SetPointError(3,8,8,0.6276957,0.6276957);
grae->SetPoint(4,89.5,1.42);
grae->SetPointError(4,10.5,10.5,0.1878054,0.1878054);
grae->SetPoint(5,112.5,0.364);
grae->SetPointError(5,12.5,12.5,0.04772427,0.04772427);
grae->SetPoint(6,141.5,0.0882);
grae->SetPointError(6,16.5,16.5,0.01103805,0.01103805);
grae->SetPoint(7,178.5,0.0197);
grae->SetPointError(7,20.5,20.5,0.002292152,0.002292152);
grae->SetPoint(8,225,0.00406);
grae->SetPointError(8,26,26,0.0004822521,0.0004822521);
grae->SetPoint(9,283.5,0.000735);
grae->SetPointError(9,32.5,32.5,8.981748e-05,8.981748e-05);
grae->SetPoint(10,357,0.000114);
grae->SetPointError(10,41,41,1.442494e-05,1.442494e-05);
grae->SetPoint(11,449.5,1.41e-05);
grae->SetPointError(11,51.5,51.5,1.98855e-06,1.98855e-06);
TH1F *hATLASpp = new TH1F("hATLASpp"," ",100,50,450);
hATLASpp->SetMinimum(1.090031e-05);
hATLASpp->SetMaximum(230.955);
hATLASpp->SetDirectory(0);
hATLASpp->SetStats(0);
Int_t ci; // for color index setting
ci = TColor::GetColor("#000099");
hATLASpp->SetLineColor(ci);
hATLASpp->GetXaxis()->SetTitle("ak R=0.4 Jet p_{T} (GeV/c)");
hATLASpp->GetXaxis()->SetLabelFont(42);
hATLASpp->GetXaxis()->SetLabelSize(0.035);
hATLASpp->GetXaxis()->SetTitleSize(0.035);
hATLASpp->GetXaxis()->SetTitleFont(42);
hATLASpp->GetYaxis()->SetTitle("#frac{d^{2}#sigma}{dp_{T} d#eta} nb");
hATLASpp->GetYaxis()->SetLabelFont(42);
hATLASpp->GetYaxis()->SetLabelSize(0.035);
hATLASpp->GetYaxis()->SetTitleSize(0.035);
hATLASpp->GetYaxis()->SetTitleFont(42);
hATLASpp->GetZaxis()->SetLabelFont(42);
hATLASpp->GetZaxis()->SetLabelSize(0.035);
hATLASpp->GetZaxis()->SetTitleSize(0.035);
hATLASpp->GetZaxis()->SetTitleFont(42);
grae->SetHistogram(hATLASpp);
Double_t xAxisATLASpp[13] = {31,39,50,63,79,100,125,158,199,251,316,398,501};
TH1F *hATLASppHist = new TH1F("hATLASppHist"," ",12,xAxisATLASpp);
hATLASppHist->SetMinimum(1.090031e-05);
hATLASppHist->SetMaximum(230.955);
hATLASppHist->SetDirectory(0);
hATLASppHist->SetStats(0);
hATLASppHist->SetBinContent(1,180);
hATLASppHist->SetBinError(1,29.95905);
hATLASppHist->SetBinContent(2,55.7);
hATLASppHist->SetBinError(2,7.828377);
hATLASppHist->SetBinContent(3,16.9);
hATLASppHist->SetBinError(3,2.625436);
hATLASppHist->SetBinContent(4,4.85);
hATLASppHist->SetBinError(4,0.6276957);
hATLASppHist->SetBinContent(5,1.42);
hATLASppHist->SetBinError(5,0.1878054);
hATLASppHist->SetBinContent(6,0.364);
hATLASppHist->SetBinError(6,0.04772427);
hATLASppHist->SetBinContent(7,0.0882);
hATLASppHist->SetBinError(7,0.01103805);
hATLASppHist->SetBinContent(8,0.0197);
hATLASppHist->SetBinError(8,0.002292152);
hATLASppHist->SetBinContent(9,0.00406);
hATLASppHist->SetBinError(9,0.0004822521);
hATLASppHist->SetBinContent(10,0.000735);
hATLASppHist->SetBinError(10,8.981748e-05);
hATLASppHist->SetBinContent(11,0.000114);
hATLASppHist->SetBinError(11,1.442494e-05);
hATLASppHist->SetBinContent(12,1.41e-05);
hATLASppHist->SetBinError(12,1.98855e-06);
// c1=new TCanvas();
// // c1.cd();
// hATLASppHist->Draw();
// was grae
for(int i=0; i<nfit; ++i){
grae->Fit("fitppATLAS","","",FitStart,FitEnd); //fit function
}
cout<<"now to fit hATLASppHist"<<endl;
for(int ib=0; ib<nfit; ++ib){
hATLASppHist->Fit("fitppATLASHist","IL","",FitStart,FitEnd); //fit function
}
TCanvas *cATLAS_ppHist = new TCanvas("cATLAS_ppHist", "",0,0,1200,1000);
cATLAS_ppHist->Range(-3.725291e-06,-5.878322,500,3.279288);
cATLAS_ppHist->SetFillColor(0);
cATLAS_ppHist->SetBorderMode(0);
cATLAS_ppHist->SetBorderSize(2);
cATLAS_ppHist->SetLogy();
cATLAS_ppHist->SetFrameBorderMode(0);
cATLAS_ppHist->SetFrameBorderMode(0);
// grae->SetHistogram(hATLASpp);
TLegend *leg = new TLegend(0.4,0.65,0.6,0.85,NULL,"BRNDC");
leg->SetBorderSize(0);
leg->SetTextSize(0.04);
leg->SetLineColor(1);
leg->SetLineStyle(1);
leg->SetLineWidth(1);
leg->SetFillColor(10);
leg->SetFillStyle(1001);
TLegendEntry *entry=leg->AddEntry("NULL","","h");
entry->SetLineColor(1);
entry->SetLineStyle(1);
entry->SetLineWidth(1);
entry->SetMarkerColor(1);
entry->SetMarkerStyle(21);
entry->SetMarkerSize(1);
entry->SetTextFont(62);
entry=leg->AddEntry("hATLASppHist","ATLAS pp histogram","p");
entry->SetLineColor(1);
entry->SetLineStyle(1);
entry->SetLineWidth(1);
entry->SetMarkerColor(kGreen);
entry->SetMarkerStyle(22);
entry->SetMarkerSize(1);
entry->SetTextFont(62);
entry=leg->AddEntry("grae","ATLAS pp TGraphAsymErrors","p");
entry->SetLineColor(1);
entry->SetLineStyle(1);
entry->SetLineWidth(1);
entry->SetMarkerColor(1);
entry->SetMarkerStyle(33);
entry->SetMarkerSize(1);
leg->Draw();
hATLASppHist->SetMarkerColor(kGreen);
hATLASppHist->SetMarkerStyle(22);
grae->SetMarkerStyle(21);
grae->SetMarkerColor(1);
hATLASpp->Draw();
grae->Draw("ap,same");
// uPP_R4_SVD->Draw("same E1");
hATLASppHist->Draw("ap,same");
TPaveText *pt = new TPaveText(0.4845652,0.94,0.5154348,0.995,"blNDC");
pt->SetName("title");
pt->SetBorderSize(0);
pt->SetFillColor(0);
pt->SetFillStyle(0);
pt->SetTextFont(42);
TText *text = pt->AddText(" ");
pt->Draw();
cATLAS_ppHist->Modified();
cATLAS_ppHist->cd();
cATLAS_ppHist->SetSelected(cATLAS_ppHist);
// for(int ic=0; ic<nfit; ic++){
// uPP_R4_SVD->Fit("fitppCMS","IL","",60,FitEnd); //fit function
// // uPP_R4_SVD->Fit("fitppCMS","IL","",50,300); //fit function
// }
// hATLASpp->Draw();
// grae->Draw("ap,same");
// uPP_R4_SVD->Draw("same E1");
// hATLASppHist->Draw("same E1");
leg->Draw();
cATLAS_ppHist->SaveAs("Plots/ATLASHistfit_spectra_pp.pdf");
Double_t xAxis2086[101] = {0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160, 170, 180, 190, 200, 210, 220, 230, 240, 250, 260, 270, 280, 290, 300, 310, 320, 330, 340, 350, 360, 370, 380, 390, 400, 410, 420, 430, 440, 450, 460, 470, 480, 490, 500, 510, 520, 530, 540, 550, 560, 570, 580, 590, 600, 610, 620, 630, 640, 650, 660, 670, 680, 690, 700, 710, 720, 730, 740, 750, 760, 770, 780, 790, 800, 810, 820, 830, 840, 850, 860, 870, 880, 890, 900, 910, 920, 930, 940, 950, 960, 970, 980, 990, 1000};
TH1F *uPP_R4_SVD = new TH1F("uPP_R4_SVD","Unfold Matrix refpt jtpt from trigger addition R4 20_eta_20 ",100, xAxis2086);
uPP_R4_SVD->SetBinContent(1,15.44572);
uPP_R4_SVD->SetBinContent(2,81.73347);
uPP_R4_SVD->SetBinContent(3,85.49986);
uPP_R4_SVD->SetBinContent(4,90.07588);
uPP_R4_SVD->SetBinContent(5,47.67952);
uPP_R4_SVD->SetBinContent(6,18.31659);
uPP_R4_SVD->SetBinContent(7,7.348095);
uPP_R4_SVD->SetBinContent(8,3.295203);
uPP_R4_SVD->SetBinContent(9,1.60486);
uPP_R4_SVD->SetBinContent(10,0.8393627);
uPP_R4_SVD->SetBinContent(11,0.4622419);
uPP_R4_SVD->SetBinContent(12,0.265131);
uPP_R4_SVD->SetBinContent(13,0.1587068);
uPP_R4_SVD->SetBinContent(14,0.09774788);
uPP_R4_SVD->SetBinContent(15,0.06153403);
uPP_R4_SVD->SetBinContent(16,0.03981187);
uPP_R4_SVD->SetBinContent(17,0.02620752);
uPP_R4_SVD->SetBinContent(18,0.01766706);
uPP_R4_SVD->SetBinContent(19,0.01206758);
uPP_R4_SVD->SetBinContent(20,0.008403017);
uPP_R4_SVD->SetBinContent(21,0.005956108);
uPP_R4_SVD->SetBinContent(22,0.004267026);
uPP_R4_SVD->SetBinContent(23,0.003102345);
uPP_R4_SVD->SetBinContent(24,0.002273482);
uPP_R4_SVD->SetBinContent(25,0.001699103);
uPP_R4_SVD->SetBinContent(26,0.001281323);
uPP_R4_SVD->SetBinContent(27,0.000971557);
uPP_R4_SVD->SetBinContent(28,0.0007444665);
uPP_R4_SVD->SetBinContent(29,0.0005746992);
uPP_R4_SVD->SetBinContent(30,0.0004462709);
uPP_R4_SVD->SetBinContent(31,0.0003483805);
uPP_R4_SVD->SetBinContent(32,0.0002725941);
uPP_R4_SVD->SetBinContent(33,0.0002141152);
uPP_R4_SVD->SetBinContent(34,0.0001705039);
uPP_R4_SVD->SetBinContent(35,0.0001352845);
uPP_R4_SVD->SetBinContent(36,0.0001073623);
uPP_R4_SVD->SetBinContent(37,8.559958e-05);
uPP_R4_SVD->SetBinContent(38,6.847693e-05);
uPP_R4_SVD->SetBinContent(39,5.506579e-05);
uPP_R4_SVD->SetBinContent(40,4.404838e-05);
uPP_R4_SVD->SetBinContent(41,3.566817e-05);
uPP_R4_SVD->SetBinContent(42,2.88001e-05);
uPP_R4_SVD->SetBinContent(43,2.33088e-05);
uPP_R4_SVD->SetBinContent(44,1.897322e-05);
uPP_R4_SVD->SetBinContent(45,1.546483e-05);
uPP_R4_SVD->SetBinContent(46,1.251424e-05);
uPP_R4_SVD->SetBinContent(47,1.020799e-05);
uPP_R4_SVD->SetBinContent(48,8.267746e-06);
uPP_R4_SVD->SetBinContent(49,6.760333e-06);
uPP_R4_SVD->SetBinContent(50,5.504337e-06);
uPP_R4_SVD->SetBinContent(51,4.514429e-06);
uPP_R4_SVD->SetBinContent(52,3.665816e-06);
uPP_R4_SVD->SetBinContent(53,3.010496e-06);
uPP_R4_SVD->SetBinContent(54,2.463812e-06);
uPP_R4_SVD->SetBinContent(55,2.01082e-06);
uPP_R4_SVD->SetBinContent(56,1.624154e-06);
uPP_R4_SVD->SetBinContent(57,1.334625e-06);
uPP_R4_SVD->SetBinContent(58,1.088798e-06);
uPP_R4_SVD->SetBinContent(59,8.896167e-07);
uPP_R4_SVD->SetBinContent(60,7.305952e-07);
uPP_R4_SVD->SetBinContent(61,5.930196e-07);
uPP_R4_SVD->SetBinContent(62,4.863888e-07);
uPP_R4_SVD->SetBinContent(63,3.941485e-07);
uPP_R4_SVD->SetBinContent(64,3.221651e-07);
uPP_R4_SVD->SetBinContent(65,2.636797e-07);
uPP_R4_SVD->SetBinContent(66,2.146457e-07);
uPP_R4_SVD->SetBinContent(67,1.742243e-07);
uPP_R4_SVD->SetBinContent(68,1.409108e-07);
uPP_R4_SVD->SetBinContent(69,1.142703e-07);
uPP_R4_SVD->SetBinContent(70,9.293402e-08);
uPP_R4_SVD->SetBinContent(71,7.511816e-08);
uPP_R4_SVD->SetBinContent(72,6.013509e-08);
uPP_R4_SVD->SetBinContent(73,4.927971e-08);
uPP_R4_SVD->SetBinContent(74,3.992714e-08);
uPP_R4_SVD->SetBinContent(75,3.176246e-08);
uPP_R4_SVD->SetBinContent(76,2.560933e-08);
uPP_R4_SVD->SetBinContent(77,2.039975e-08);
uPP_R4_SVD->SetBinContent(78,1.627726e-08);
uPP_R4_SVD->SetBinContent(79,1.272043e-08);
uPP_R4_SVD->SetBinContent(80,1.022684e-08);
uPP_R4_SVD->SetBinContent(81,8.172451e-09);
uPP_R4_SVD->SetBinContent(82,6.570082e-09);
uPP_R4_SVD->SetBinContent(83,5.205766e-09);
uPP_R4_SVD->SetBinContent(84,4.075393e-09);
uPP_R4_SVD->SetBinContent(85,3.265506e-09);
uPP_R4_SVD->SetBinContent(86,2.62088e-09);
uPP_R4_SVD->SetBinContent(87,2.003114e-09);
uPP_R4_SVD->SetBinContent(88,1.535628e-09);
uPP_R4_SVD->SetBinContent(89,1.063791e-09);
uPP_R4_SVD->SetBinContent(90,9.092138e-10);
uPP_R4_SVD->SetBinContent(91,6.803265e-10);
uPP_R4_SVD->SetBinContent(92,4.778346e-10);
uPP_R4_SVD->SetBinContent(93,3.988072e-10);
uPP_R4_SVD->SetBinContent(94,2.474126e-10);
uPP_R4_SVD->SetBinContent(95,2.140924e-10);
uPP_R4_SVD->SetBinContent(96,1.623732e-10);
uPP_R4_SVD->SetBinContent(97,1.45067e-10);
uPP_R4_SVD->SetBinContent(98,9.186947e-11);
uPP_R4_SVD->SetBinContent(99,6.040857e-11);
uPP_R4_SVD->SetBinContent(100,6.157141e-11);
uPP_R4_SVD->SetBinError(1,0.1237595);
uPP_R4_SVD->SetBinError(2,0.6234048);
uPP_R4_SVD->SetBinError(3,0.586929);
uPP_R4_SVD->SetBinError(4,0.5173901);
uPP_R4_SVD->SetBinError(5,0.2055361);
uPP_R4_SVD->SetBinError(6,0.04990473);
uPP_R4_SVD->SetBinError(7,0.01308245);
uPP_R4_SVD->SetBinError(8,0.006804987);
uPP_R4_SVD->SetBinError(9,0.003260532);
uPP_R4_SVD->SetBinError(10,0.001534405);
uPP_R4_SVD->SetBinError(11,0.001026545);
uPP_R4_SVD->SetBinError(12,0.000705749);
uPP_R4_SVD->SetBinError(13,0.0004784051);
uPP_R4_SVD->SetBinError(14,0.0003483983);
uPP_R4_SVD->SetBinError(15,0.0002598719);
uPP_R4_SVD->SetBinError(16,0.0001903908);
uPP_R4_SVD->SetBinError(17,0.0001387089);
uPP_R4_SVD->SetBinError(18,0.0001040173);
uPP_R4_SVD->SetBinError(19,7.981541e-05);
uPP_R4_SVD->SetBinError(20,6.24475e-05);
uPP_R4_SVD->SetBinError(21,4.937991e-05);
uPP_R4_SVD->SetBinError(22,3.947987e-05);
uPP_R4_SVD->SetBinError(23,3.254473e-05);
uPP_R4_SVD->SetBinError(24,2.764293e-05);
uPP_R4_SVD->SetBinError(25,2.429597e-05);
uPP_R4_SVD->SetBinError(26,2.159774e-05);
uPP_R4_SVD->SetBinError(27,1.917051e-05);
uPP_R4_SVD->SetBinError(28,1.6997e-05);
uPP_R4_SVD->SetBinError(29,1.498669e-05);
uPP_R4_SVD->SetBinError(30,1.312744e-05);
uPP_R4_SVD->SetBinError(31,1.142902e-05);
uPP_R4_SVD->SetBinError(32,9.871913e-06);
uPP_R4_SVD->SetBinError(33,8.480939e-06);
uPP_R4_SVD->SetBinError(34,7.324674e-06);
uPP_R4_SVD->SetBinError(35,6.255272e-06);
uPP_R4_SVD->SetBinError(36,5.306614e-06);
uPP_R4_SVD->SetBinError(37,4.495288e-06);
uPP_R4_SVD->SetBinError(38,3.800242e-06);
uPP_R4_SVD->SetBinError(39,3.214166e-06);
uPP_R4_SVD->SetBinError(40,2.692884e-06);
uPP_R4_SVD->SetBinError(41,2.275421e-06);
uPP_R4_SVD->SetBinError(42,1.910914e-06);
uPP_R4_SVD->SetBinError(43,1.60384e-06);
uPP_R4_SVD->SetBinError(44,1.350324e-06);
uPP_R4_SVD->SetBinError(45,1.135728e-06);
uPP_R4_SVD->SetBinError(46,9.463317e-07);
uPP_R4_SVD->SetBinError(47,7.933288e-07);
uPP_R4_SVD->SetBinError(48,6.591956e-07);
uPP_R4_SVD->SetBinError(49,5.520988e-07);
uPP_R4_SVD->SetBinError(50,4.597711e-07);
uPP_R4_SVD->SetBinError(51,3.851643e-07);
uPP_R4_SVD->SetBinError(52,3.190695e-07);
uPP_R4_SVD->SetBinError(53,2.670117e-07);
uPP_R4_SVD->SetBinError(54,2.22444e-07);
uPP_R4_SVD->SetBinError(55,1.84622e-07);
uPP_R4_SVD->SetBinError(56,1.515098e-07);
uPP_R4_SVD->SetBinError(57,1.263889e-07);
uPP_R4_SVD->SetBinError(58,1.045901e-07);
uPP_R4_SVD->SetBinError(59,8.662012e-08);
uPP_R4_SVD->SetBinError(60,7.20551e-08);
uPP_R4_SVD->SetBinError(61,5.920339e-08);
uPP_R4_SVD->SetBinError(62,4.912298e-08);
uPP_R4_SVD->SetBinError(63,4.024705e-08);
uPP_R4_SVD->SetBinError(64,3.324212e-08);
uPP_R4_SVD->SetBinError(65,2.747888e-08);
uPP_R4_SVD->SetBinError(66,2.258106e-08);
uPP_R4_SVD->SetBinError(67,1.849393e-08);
uPP_R4_SVD->SetBinError(68,1.50859e-08);
uPP_R4_SVD->SetBinError(69,1.233344e-08);
uPP_R4_SVD->SetBinError(70,1.010825e-08);
uPP_R4_SVD->SetBinError(71,8.230567e-09);
uPP_R4_SVD->SetBinError(72,6.634947e-09);
uPP_R4_SVD->SetBinError(73,5.473309e-09);
uPP_R4_SVD->SetBinError(74,4.462479e-09);
uPP_R4_SVD->SetBinError(75,3.571148e-09);
uPP_R4_SVD->SetBinError(76,2.895626e-09);
uPP_R4_SVD->SetBinError(77,2.318939e-09);
uPP_R4_SVD->SetBinError(78,1.859689e-09);
uPP_R4_SVD->SetBinError(79,1.460273e-09);
uPP_R4_SVD->SetBinError(80,1.179314e-09);
uPP_R4_SVD->SetBinError(81,9.46416e-10);
uPP_R4_SVD->SetBinError(82,7.638915e-10);
uPP_R4_SVD->SetBinError(83,6.075323e-10);
uPP_R4_SVD->SetBinError(84,4.772801e-10);
uPP_R4_SVD->SetBinError(85,3.836821e-10);
uPP_R4_SVD->SetBinError(86,3.088773e-10);
uPP_R4_SVD->SetBinError(87,2.367363e-10);
uPP_R4_SVD->SetBinError(88,1.819577e-10);
uPP_R4_SVD->SetBinError(89,1.263493e-10);
uPP_R4_SVD->SetBinError(90,1.082238e-10);
uPP_R4_SVD->SetBinError(91,8.113796e-11);
uPP_R4_SVD->SetBinError(92,5.70881e-11);
uPP_R4_SVD->SetBinError(93,4.772047e-11);
uPP_R4_SVD->SetBinError(94,2.964495e-11);
uPP_R4_SVD->SetBinError(95,2.568217e-11);
uPP_R4_SVD->SetBinError(96,1.949672e-11);
uPP_R4_SVD->SetBinError(97,1.743206e-11);
uPP_R4_SVD->SetBinError(98,1.104588e-11);
uPP_R4_SVD->SetBinError(99,7.265969e-12);
uPP_R4_SVD->SetBinError(100,7.407249e-12);
uPP_R4_SVD->SetEntries(100);
uPP_R4_SVD->SetStats(0);
ci = TColor::GetColor("#000099");
uPP_R4_SVD->SetLineColor(ci);
// ci = TColor::GetColor("#0000ff");
// uPP_R4_SVD->SetMarkerColor(ci);
// uPP_R4_SVD->SetMarkerStyle(24);
// uPP_R4_SVD->GetXaxis()->CenterTitle(true);
// uPP_R4_SVD->GetXaxis()->SetLabelFont(42);
// uPP_R4_SVD->GetXaxis()->SetLabelSize(0.035);
// uPP_R4_SVD->GetXaxis()->SetTitleSize(0.035);
// uPP_R4_SVD->GetXaxis()->SetTitleFont(42);
// uPP_R4_SVD->GetYaxis()->CenterTitle(true);
// uPP_R4_SVD->GetYaxis()->SetLabelFont(42);
// uPP_R4_SVD->GetYaxis()->SetLabelSize(0.035);
// uPP_R4_SVD->GetYaxis()->SetTitleSize(0.035);
// uPP_R4_SVD->GetYaxis()->SetTitleFont(42);
// uPP_R4_SVD->GetZaxis()->SetLabelFont(42);
// uPP_R4_SVD->GetZaxis()->SetLabelSize(0.035);
// uPP_R4_SVD->GetZaxis()->SetTitleSize(0.035);
// uPP_R4_SVD->GetZaxis()->SetTitleFont(42);
// uPP_R4_SVD->Draw("same E1");
// TBox *box = new TBox(60,7.108492,70,7.587699);
// box->SetFillColor(2);
// box->SetFillStyle(0);
// box->SetLineColor(2);
// box->Draw();
// box = new TBox(70,3.186674,80,3.403731);
// box->SetFillColor(2);
// box->SetFillStyle(0);
// box->SetLineColor(2);
// box->Draw();
// box = new TBox(80,1.551541,90,1.658179);
// box->SetFillColor(2);
// box->SetFillStyle(0);
// box->SetLineColor(2);
// box->Draw();
// box = new TBox(90,0.8111346,100,0.8675909);
// box->SetFillColor(2);
// box->SetFillStyle(0);
// box->SetLineColor(2);
// box->Draw();
// box = new TBox(100,0.4464541,110,0.4780297);
// box->SetFillColor(2);
// box->SetFillStyle(0);
// box->SetLineColor(2);
// box->Draw();
// box = new TBox(110,0.2045159,130,0.2193219);
// box->SetFillColor(2);
// box->SetFillStyle(0);
// box->SetLineColor(2);
// box->Draw();
// box = new TBox(130,0.07677678,150,0.08250514);
// box->SetFillColor(2);
// box->SetFillStyle(0);
// box->SetLineColor(2);
// box->Draw();
// box = new TBox(150,0.03180206,170,0.03421734);
// box->SetFillColor(2);
// box->SetFillStyle(0);
// box->SetLineColor(2);
// box->Draw();
// box = new TBox(170,0.01431415,190,0.01542048);
// box->SetFillColor(2);
// box->SetFillStyle(0);
// box->SetLineColor(2);
// box->Draw();
// box = new TBox(190,0.006909775,210,0.007449351);
// box->SetFillColor(2);
// box->SetFillStyle(0);
// box->SetLineColor(2);
// box->Draw();
// box = new TBox(210,0.003092187,240,0.003336382);
// box->SetFillColor(2);
// box->SetFillStyle(0);
// box->SetLineColor(2);
// box->Draw();
// box = new TBox(240,0.001266417,270,0.001368238);
// box->SetFillColor(2);
// box->SetFillStyle(0);
// box->SetLineColor(2);
// box->Draw();
// box = new TBox(270,0.00056544,300,0.0006115177);
// box->SetFillColor(2);
// box->SetFillStyle(0);
// box->SetLineColor(2);
// box->Draw();
TCanvas *cATLAS_pp = new TCanvas("cATLAS_pp", "",0,0,1200,1000);
cATLAS_pp->Range(-3.725291e-06,-5.878322,500,3.279288);
cATLAS_pp->SetFillColor(0);
cATLAS_pp->SetBorderMode(0);
cATLAS_pp->SetBorderSize(2);
cATLAS_pp->SetLogy();
cATLAS_pp->SetFrameBorderMode(0);
cATLAS_pp->SetFrameBorderMode(0);
grae->SetHistogram(hATLASpp);
hATLASpp->Draw();
grae->Draw("ap,same");
TLegend *leg = new TLegend(0.4,0.65,0.6,0.85,NULL,"BRNDC");
leg->SetBorderSize(0);
leg->SetTextSize(0.04);
leg->SetLineColor(1);
leg->SetLineStyle(1);
leg->SetLineWidth(1);
leg->SetFillColor(10);
leg->SetFillStyle(1001);
TLegendEntry *entry=leg->AddEntry("NULL","","h");
entry->SetLineColor(1);
entry->SetLineStyle(1);
entry->SetLineWidth(1);
entry->SetMarkerColor(1);
entry->SetMarkerStyle(21);
entry->SetMarkerSize(1);
entry->SetTextFont(62);
entry=leg->AddEntry("/HepData/8719/d2x1y1","ATLAS pp","p");
entry->SetLineColor(1);
entry->SetLineStyle(1);
entry->SetLineWidth(1);
entry->SetMarkerColor(1);
entry->SetMarkerStyle(33);
entry->SetMarkerSize(1);
entry=leg->AddEntry("uPP_R4_SVD","CMS pp","p");
entry->SetLineColor(1);
entry->SetLineStyle(1);
entry->SetLineWidth(1);
ci = TColor::GetColor("#0000ff");
entry->SetMarkerColor(ci);
entry->SetMarkerStyle(24);
entry->SetMarkerSize(1);
leg->Draw();
TPaveText *pt = new TPaveText(0.4845652,0.94,0.5154348,0.995,"blNDC");
pt->SetName("title");
pt->SetBorderSize(0);
pt->SetFillColor(0);
pt->SetFillStyle(0);
pt->SetTextFont(42);
TText *text = pt->AddText(" ");
pt->Draw();
cATLAS_pp->Modified();
cATLAS_pp->cd();
cATLAS_pp->SetSelected(cATLAS_pp);
for(int ic=0; ic<nfit; ic++){
uPP_R4_SVD->Fit("fitppCMS","IL","",60,FitEnd); //fit function
// uPP_R4_SVD->Fit("fitppCMS","IL","",50,300); //fit function
}
hATLASpp->Draw();
grae->Draw("ap,same");
uPP_R4_SVD->Draw("same E1");
leg->Draw();
cATLAS_pp->SaveAs("Plots/CMSfit_ATLASfit_spectra_pp.pdf");
TCanvas *cCMS_pp = new TCanvas("cCMS_pp", "",0,0,1200,1000);
cCMS_pp->Range(-3.725291e-06,-5.878322,500,3.279288);
cCMS_pp->SetFillColor(0);
cCMS_pp->SetBorderMode(0);
cCMS_pp->SetBorderSize(2);
cCMS_pp->SetLogy();
cCMS_pp->SetLogx();
cCMS_pp->SetFrameBorderMode(0);
cCMS_pp->SetFrameBorderMode(0);
uPP_R4_SVD->GetXaxis()->SetTitle("ak R=0.4 Jet p_{T} (GeV/c)");
uPP_R4_SVD->GetXaxis()->SetLabelFont(42);
uPP_R4_SVD->GetXaxis()->SetLabelSize(0.035);
uPP_R4_SVD->GetXaxis()->SetTitleSize(0.035);
uPP_R4_SVD->GetXaxis()->SetTitleFont(42);
uPP_R4_SVD->GetXaxis()->SetRangeUser(50,450);
uPP_R4_SVD->GetYaxis()->SetTitle("#frac{d^{2}#sigma}{dp_{T} d#eta} nb");
uPP_R4_SVD->GetYaxis()->SetLabelFont(42);
uPP_R4_SVD->GetYaxis()->SetLabelSize(0.035);
uPP_R4_SVD->GetYaxis()->SetTitleSize(0.035);
uPP_R4_SVD->GetYaxis()->SetTitleFont(42);
uPP_R4_SVD->GetZaxis()->SetLabelFont(42);
uPP_R4_SVD->GetZaxis()->SetLabelSize(0.035);
uPP_R4_SVD->GetZaxis()->SetTitleSize(0.035);
uPP_R4_SVD->GetZaxis()->SetTitleFont(42);
uPP_R4_SVD->Draw();
TLegend *leg = new TLegend(0.4,0.65,0.6,0.85,NULL,"BRNDC");
leg->SetBorderSize(0);
leg->SetTextSize(0.04);
leg->SetLineColor(1);
leg->SetLineStyle(1);
leg->SetLineWidth(1);
leg->SetFillColor(10);
leg->SetFillStyle(1001);
TLegendEntry *entry=leg->AddEntry("NULL","","h");
entry->SetLineColor(1);
entry->SetLineStyle(1);
entry->SetLineWidth(1);
entry->SetMarkerColor(1);
entry->SetMarkerStyle(33);
entry->SetMarkerSize(1);
entry=leg->AddEntry("uPP_R4_SVD","CMS pp","p");
entry->SetLineColor(1);
entry->SetLineStyle(1);
entry->SetLineWidth(1);
ci = TColor::GetColor("#0000ff");
entry->SetMarkerColor(ci);
entry->SetMarkerStyle(24);
entry->SetMarkerSize(1);
leg->Draw();
TPaveText *pt = new TPaveText(0.4845652,0.94,0.5154348,0.995,"blNDC");
pt->SetName("title");
pt->SetBorderSize(0);
pt->SetFillColor(0);
pt->SetFillStyle(0);
pt->SetTextFont(42);
TText *text = pt->AddText(" ");
pt->Draw();
cCMS_pp->Modified();
cCMS_pp->cd();
cCMS_pp->SetSelected(cCMS_pp);
cCMS_pp->SaveAs("Plots/CMSfit_spectra_pp.pdf");
TCanvas *cATLAS_lin_pp = new TCanvas("cATLAS_lin_pp", "",0,0,1200,1000);
cATLAS_lin_pp->Range(-3.725291e-06,-5.878322,500,3.279288);
cATLAS_lin_pp->SetFillColor(0);
cATLAS_lin_pp->SetBorderMode(0);
cATLAS_lin_pp->SetBorderSize(2);
cATLAS_lin_pp->SetFrameBorderMode(0);
cATLAS_lin_pp->SetFrameBorderMode(0);
cATLAS_lin_pp->SetLogy();
cATLAS_lin_pp->SetLogx();
hATLASpp->Draw();
grae->Draw("ap,same");
TLegend *leg = new TLegend(0.4,0.65,0.6,0.85,NULL,"BRNDC");
leg->SetBorderSize(0);
leg->SetTextSize(0.04);
leg->SetLineColor(1);
leg->SetLineStyle(1);
leg->SetLineWidth(1);
leg->SetFillColor(10);
leg->SetFillStyle(1001);
TLegendEntry *entry=leg->AddEntry("NULL","","h");
entry->SetLineColor(1);
entry->SetLineStyle(1);
entry->SetLineWidth(1);
entry->SetMarkerColor(1);
entry->SetMarkerStyle(21);
entry->SetMarkerSize(1);
entry->SetTextFont(62);
entry=leg->AddEntry("/HepData/8719/d2x1y1","ATLAS pp","p");
entry->SetLineColor(1);
entry->SetLineStyle(1);
entry->SetLineWidth(1);
entry->SetMarkerColor(1);
entry->SetMarkerStyle(33);
entry->SetMarkerSize(1);
entry=leg->AddEntry("uPP_R4_SVD","CMS pp","p");
entry->SetLineColor(1);
entry->SetLineStyle(1);
entry->SetLineWidth(1);
ci = TColor::GetColor("#0000ff");
entry->SetMarkerColor(ci);
entry->SetMarkerStyle(24);
entry->SetMarkerSize(1);
leg->Draw();
TPaveText *pt = new TPaveText(0.4845652,0.94,0.5154348,0.995,"blNDC");
pt->SetName("title");
pt->SetBorderSize(0);
pt->SetFillColor(0);
pt->SetFillStyle(0);
pt->SetTextFont(42);
TText *text = pt->AddText(" ");
pt->Draw();
cATLAS_lin_pp->Modified();
cATLAS_lin_pp->cd();
cATLAS_lin_pp->SetSelected(cATLAS_lin_pp);
// for(int ic=0; ic<nfit; ic++){
// uPP_R4_SVD->Fit("fitppCMS","IL","",60,FitEnd); //fit function
// // uPP_R4_SVD->Fit("fitppCMS","IL","",50,300); //fit function
// }
hATLASpp->Draw();
grae->Draw("ap,same");
uPP_R4_SVD->Draw("same E1");
leg->Draw();
cATLAS_lin_pp->SaveAs("Plots/CMSfit_ATLASfit_spectra_loglog_pp.pdf");
fitppCMS->SetBit(TF1::kNotDraw);
fitppCMS->SetLineColor(0);
uPP_R4_SVD->SetBit(TF1::kNotDraw);
TH1F *hFitRatioATLAS = (TH1F*)functionHist(fitppCMS,uPP_R4_SVD,"hFitRatioATLAS"); //clone fitRatioATLAS from fitppCMS
// hFitRatioATLAS->SetLineColor(0);
TH1F *hRatioATLAS = (TH1F*)uPP_R4_SVD->Clone("hRatioATLAS"); //clone histogram hRatio from h
TH1F *hfunctionATLAS = (TH1F*)functionHist(fitppATLAS,uPP_R4_SVD,"hfunctionATLAS");
hFitRatioATLAS->Divide(hfunctionATLAS);
hFitRatioATLAS->SetMarkerColor(kRed);
hFitRatioATLAS->SetMarkerStyle(21);
hFitRatioATLAS->SetMarkerSize(1.2);
hFitRatioATLAS->SetLineColor(0);
TH1F *hfunctionATLASHist = (TH1F*)functionHist(fitppATLASHist,uPP_R4_SVD,"hfunctionATLASHist");
TH1F *hRatioATLASHist = (TH1F*)uPP_R4_SVD->Clone("hRatioATLASHist"); //clone histogram hRatio from h
hRatioATLASHist->Divide(hfunctionATLASHist);
hRatioATLASHist->SetMarkerColor(kGreen+1);
hRatioATLASHist->SetMarkerStyle(22);
hRatioATLASHist->SetMarkerSize(1.2);
hRatioATLASHist->SetLineColor(0);
// hfunctionATLAS->Draw();
// hATLASpp->Draw();
hRatioATLAS->Divide(hfunctionATLAS);
TCanvas *cRatio_pp = new TCanvas("cRatio_pp", "",0,0,1200,1000);
gStyle->SetOptFit(1);
gStyle->SetOptStat(0);
gStyle->SetOptTitle(0);
cRatio_pp->Range(-50.00001,-6.302699,538.2353,2.631555);
cRatio_pp->SetFillColor(0);
cRatio_pp->SetBorderMode(0);
cRatio_pp->SetBorderSize(0);
cRatio_pp->SetTickx(1);
cRatio_pp->SetTicky(1);
cRatio_pp->SetLeftMargin(0.17);
cRatio_pp->SetRightMargin(0.15);
cRatio_pp->SetTopMargin(0.03);
cRatio_pp->SetBottomMargin(0.15);
cRatio_pp->SetFrameLineColor(0);
cRatio_pp->SetFrameBorderMode(0);
cRatio_pp->SetFrameLineColor(0);
cRatio_pp->SetFrameBorderMode(0);
TH1F *hRatioBlank = new TH1F("hRatioBlank"," ",100,50,300);
hRatioBlank->SetMinimum(0);
hRatioBlank->SetMaximum(1.2);
hRatioBlank->SetDirectory(0);
hRatioBlank->SetStats(0);
hRatioBlank->SetFillColor(1);
hRatioBlank->SetFillStyle(0);
hRatioBlank->SetLineStyle(0);
hRatioBlank->SetMarkerStyle(20);
hRatioBlank->SetMarkerSize(1.2);
hRatioBlank->GetXaxis()->SetTitle("ak R=0.4 Jet p_{T} (GeV/c)");
hRatioBlank->GetXaxis()->SetLabelFont(42);
hRatioBlank->GetXaxis()->SetLabelOffset(0.01);
hRatioBlank->GetXaxis()->SetLabelSize(0.045);
hRatioBlank->GetXaxis()->SetTitleSize(0.055);
hRatioBlank->GetXaxis()->SetTitleFont(42);
hRatioBlank->GetYaxis()->SetTitle("CMS/ATLAS #frac{d^{2}#sigma}{dp_{T} d#eta} nb");
hRatioBlank->GetYaxis()->SetLabelFont(42);
hRatioBlank->GetYaxis()->SetLabelOffset(0.01);
hRatioBlank->GetYaxis()->SetLabelSize(0.045);
hRatioBlank->GetYaxis()->SetTitleSize(0.055);
hRatioBlank->GetYaxis()->SetTitleOffset(1.5);
hRatioBlank->GetYaxis()->SetTitleFont(42);
hRatioBlank->GetZaxis()->SetLabelFont(42);
hRatioBlank->GetZaxis()->SetLabelSize(0.045);
hRatioBlank->GetZaxis()->SetTitleSize(0.035);
hRatioBlank->GetZaxis()->SetTitleFont(42);
hRatioBlank->Draw();
// hRatioATLAS->Scale(5.3/4);
// hFitRatioATLAS->Scale(5.3/4);
hFitRatioATLAS->Draw("ap,same");
hRatioATLAS->Draw("ap,same");
hRatioATLASHist->Draw("ap,same");
cRatio_pp->SaveAs("Plots/CMSfit_ATLASfit_ratio_pp.pdf");
}
void plot(int mass) {
double myQCDRelUncert = 0.038;
double myEWKRelUncert = 0.131;
double myFakesRelUncert = 0.238;
double delta = 1.4;
double br = 0.05;
bool debug = false;
bool log = false;
double ymin = 0.001;
double ymax = 48;
static bool bMessage = false;
if (!bMessage) {
cout << "Values used as relative uncertainty (please check):" << endl;
cout << " QCD: " << myQCDRelUncert << endl;
cout << " EWK genuine tau: " << myEWKRelUncert << endl;
cout << " EWK fake tau: " << myFakesRelUncert << endl << endl;
bMessage = true;
}
cout << "Processing mass point: " << mass << " GeV/c2" << endl;
gStyle->SetOptFit(1);
gStyle->SetOptStat(0);
gStyle->SetOptTitle(0);
gStyle->SetTitleFont(43, "xyz");
gStyle->SetTitleSize(33, "xyz");
gStyle->SetLabelFont(43, "xyz");
gStyle->SetLabelSize(27, "xyz");
//std::string infile = "EPS_data_nodeltaphi/hplus_100.root";
//std::string infile = "EPS_data_deltaphi160/hplus_100.root";
std::stringstream s;
s << "lands_histograms_hplushadronic_m" << mass << ".root";
std::string infile = s.str();
// Canvas
TCanvas *myCanvas = new TCanvas("myCanvas", "",0,0,600,600);
myCanvas->SetHighLightColor(2);
myCanvas->Range(0,0,1,1);
myCanvas->SetFillColor(0);
myCanvas->SetBorderMode(0);
myCanvas->SetBorderSize(2);
if (log)
myCanvas->SetLogy();
myCanvas->SetTickx(1);
myCanvas->SetTicky(1);
myCanvas->SetLeftMargin(0.16);
myCanvas->SetRightMargin(0.05);
myCanvas->SetTopMargin(0.05);
myCanvas->SetBottomMargin(0.08);
myCanvas->SetFrameFillStyle(0);
myCanvas->SetFrameBorderMode(0);
myCanvas->SetFrameFillStyle(0);
myCanvas->SetFrameBorderMode(0);
myCanvas->cd();
Int_t ci;
TFile* f = TFile::Open(infile.c_str());
s.str("");
s << "HW" << mass << "_1";
TH1* hw = (TH1*)f->Get(s.str().c_str());
s.str("");
s << "HH" << mass << "_1";
TH1* hh = (TH1*)f->Get(s.str().c_str());
TH1* data = (TH1*)f->Get("data_obs");
data->SetLineWidth(2);
data->SetMarkerStyle(20);
data->SetMarkerSize(1.2);
TH1* ewktau = (TH1*)f->Get("EWK_Tau");
ci = TColor::GetColor("#993399");
ewktau->SetFillColor(ci);
ewktau->SetLineWidth(0);
TH1* ewkDY = (TH1*)f->Get("EWK_DYx");
TH1* ewkVV = (TH1*)f->Get("EWK_VVx");
ewktau->Add(ewkDY);
ewktau->Add(ewkVV);
//TH1* qcd = (TH1*)f->Get("QCDInv");
TH1* qcd = (TH1*)f->Get("QCD");
ci = TColor::GetColor("#ffcc33");
qcd->SetFillColor(ci);
qcd->SetLineWidth(0);
TH1* fakett = (TH1*)f->Get("fake_tt");
ci = TColor::GetColor("#669900");
fakett->SetFillColor(ci);
fakett->SetLineWidth(0);
TH1* fakeW = (TH1*)f->Get("fake_W");
ci = TColor::GetColor("#cc3300");
fakeW->SetFillColor(ci);
fakeW->SetLineWidth(0);
TH1* faket = (TH1*)f->Get("fake_t");
TH1F *hFrame = new TH1F("hFrame","",20,0,400);
hFrame->SetMinimum(ymin);
if (log)
hFrame->SetMaximum(ymax*1.5);
else
hFrame->SetMaximum(ymax);
hFrame->SetDirectory(0);
hFrame->SetStats(0);
hFrame->SetLineStyle(0);
hFrame->SetMarkerStyle(20);
hFrame->SetXTitle("Transverse mass (#tau jet, E_{T}^{miss}), (GeV/c^{2})");
if (paperStatus)
hFrame->SetXTitle("Transverse mass (#tau_{h}, E_{T}^{miss}), (GeV/c^{2})");
hFrame->SetYTitle("Events / 20 GeV/c^{2}");
hFrame->GetXaxis()->SetTitleSize(0);
hFrame->GetXaxis()->SetLabelSize(0);
hFrame->GetYaxis()->SetTitleFont(43);
hFrame->GetYaxis()->SetTitleSize(27);
hFrame->GetYaxis()->SetTitleOffset(1.3);
// signal
hh->Scale(br*br);
hw->Scale(2*br*(1.0-br));
TH1* signal = (TH1*)hh->Clone();
signal->Add(hw);
ci = TColor::GetColor("#ff3399");
signal->SetLineColor(ci);
signal->SetLineStyle(2);
signal->SetLineWidth(2);
// Fakes
TH1* fakes = (TH1*)(fakett->Clone());
fakes->Add(fakeW);
fakes->Add(faket);
// stacked backgrounds
THStack *exp = new THStack();
exp->SetName("exp");
exp->SetTitle("exp");
exp->Add(fakes);
exp->Add(ewktau);
exp->Add(qcd);
exp->Add(signal);
TH1* hExpBkg = (TH1*)fakes->Clone();
hExpBkg->Add(ewktau);
hExpBkg->Add(qcd);
// uncertainty
TH1* uncert = (TH1*)fakeW->Clone();
uncert->Add(fakett);
uncert->Add(ewktau);
uncert->Add(qcd);
uncert->SetFillColor(1);
uncert->SetFillStyle(3344);
uncert->SetLineColor(0);
uncert->SetLineStyle(0);
uncert->SetLineWidth(0);
TH1* hExpBkgTotalUncert = (TH1*)uncert->Clone();
hExpBkgTotalUncert->SetFillStyle(3354);
TH1* hAgreement = (TH1*)data->Clone();
hAgreement->Divide(hExpBkg);
TGraphErrors* hAgreementRelUncert = new TGraphErrors(hAgreement->GetNbinsX());
hAgreementRelUncert->SetLineWidth(2);
hAgreementRelUncert->SetLineColor(kBlack);
for (int i = 1; i <= hFrame->GetNbinsX(); ++i) {
double myQCDTotalUncert = TMath::Power(qcd->GetBinError(i), 2)
+ TMath::Power(qcd->GetBinContent(i)*myQCDRelUncert, 2);
double myEWKTotalUncert = TMath::Power(ewktau->GetBinError(i), 2)
+ TMath::Power(ewktau->GetBinContent(i)*myEWKRelUncert, 2);
double myFakesTotalUncert = TMath::Power(fakes->GetBinError(i), 2)
+ TMath::Power(fakes->GetBinContent(i)*myFakesRelUncert, 2);
hExpBkgTotalUncert->SetBinError(i, TMath::Sqrt(myQCDTotalUncert + myEWKTotalUncert + myFakesTotalUncert));
if (hExpBkg->GetBinContent(i) > 0) {
hAgreementRelUncert->SetPoint(i-1, hExpBkg->GetBinCenter(i), data->GetBinContent(i) / hExpBkg->GetBinContent(i));
double myUncertData = 0;
if (data->GetBinContent(i) > 0)
myUncertData = TMath::Power(data->GetBinError(i) / data->GetBinContent(i), 2);
double myUncertBkg = (myQCDTotalUncert + myEWKTotalUncert + myFakesTotalUncert) / TMath::Power(hExpBkg->GetBinContent(i), 2);
hAgreementRelUncert->SetPointError(i-1, 0, data->GetBinContent(i) / hExpBkg->GetBinContent(i) * TMath::Sqrt(myUncertData + myUncertBkg));
} else {
hAgreementRelUncert->SetPoint(i-1, hExpBkg->GetBinCenter(i), 0);
hAgreementRelUncert->SetPointError(i-1, 0, 0);
}
if (debug) {
cout << "Point: " << hAgreementRelUncert->GetX()[i-1]-10 << "-" << hAgreementRelUncert->GetX()[i-1]+10
<< " GeV/c2, agreement: " << hAgreementRelUncert->GetY()[i-1] << ", uncert: " << hAgreement->GetBinError(i) << ", " << hAgreementRelUncert->GetErrorY(i-1) << endl;
cout << " bkg. stat. uncert. " << hExpBkg->GetBinError(i) << " (i.e. " << hExpBkg->GetBinError(i) / hExpBkg->GetBinContent(i) * 100.0 << " %)"
<< ", stat+syst uncert. " << TMath::Sqrt(myQCDTotalUncert + myEWKTotalUncert + myFakesTotalUncert)
<< " (i.e. " << TMath::Sqrt(myQCDTotalUncert + myEWKTotalUncert + myFakesTotalUncert) / hExpBkg->GetBinContent(i) * 100.0 << " %)" << endl;
}
}
// Agreement pad
TPad* pad = new TPad("ratiopad","ratiopad",0.,0.,1.,.3);
pad->Draw();
pad->cd();
pad->Range(0,0,1,1);
pad->SetFillColor(0);
pad->SetFillStyle(4000);
pad->SetBorderMode(0);
pad->SetBorderSize(2);
pad->SetTickx(1);
pad->SetTicky(1);
pad->SetLeftMargin(0.16);
pad->SetRightMargin(0.05);
pad->SetTopMargin(0);
pad->SetBottomMargin(0.34);
pad->SetFrameFillStyle(0);
pad->SetFrameBorderMode(0);
// Plot here ratio
if (1.0-delta > 0)
hAgreement->SetMinimum(1.0-delta);
else
hAgreement->SetMinimum(0.);
hAgreement->SetMaximum(1.0+delta);
hAgreement->GetXaxis()->SetLabelOffset(0.007);
hAgreement->GetXaxis()->SetLabelFont(43);
hAgreement->GetXaxis()->SetLabelSize(27);
hAgreement->GetYaxis()->SetLabelFont(43);
hAgreement->GetYaxis()->SetLabelSize(27);
hAgreement->GetYaxis()->SetLabelOffset(0.007);
hAgreement->GetYaxis()->SetNdivisions(505);
hAgreement->GetXaxis()->SetTitleFont(43);
hAgreement->GetYaxis()->SetTitleFont(43);
hAgreement->GetXaxis()->SetTitleSize(33);
hAgreement->GetYaxis()->SetTitleSize(33);
hAgreement->SetTitleSize(27, "xyz");
hAgreement->GetXaxis()->SetTitleOffset(3.2);
hAgreement->GetYaxis()->SetTitleOffset(1.3);
hAgreement->SetXTitle(hFrame->GetXaxis()->GetTitle());
hAgreement->SetYTitle("Data/#Sigmabkg");
hAgreement->Draw("e2");
// Plot line at zero
TH1* hAgreementLine = dynamic_cast<TH1*>(hAgreement->Clone());
for (int i = 1; i <= hAgreementLine->GetNbinsX(); ++i) {
hAgreementLine->SetBinContent(i,1.0);
hAgreementLine->SetBinError(i,0.0);
}
hAgreementLine->SetLineColor(kRed);
hAgreementLine->SetLineWidth(2);
hAgreementLine->SetLineStyle(3);
hAgreementLine->Draw("hist same");
hAgreement->Draw("same");
hAgreementRelUncert->Draw("[]");
pad->RedrawAxis();
myCanvas->cd();
TPad* plotpad = new TPad("plotpad", "plotpad",0,0.3,1.,1.);
plotpad->Draw();
plotpad->cd();
plotpad->Range(0,0,1,1);
plotpad->SetFillColor(0);
plotpad->SetFillStyle(4000);
plotpad->SetBorderMode(0);
plotpad->SetBorderSize(2);
//if (logy)
// plotpad->SetLogy();
plotpad->SetTickx(1);
plotpad->SetTicky(1);
plotpad->SetLeftMargin(0.16);
plotpad->SetRightMargin(0.05);
plotpad->SetTopMargin(0.065);
plotpad->SetBottomMargin(0.0);
plotpad->SetFrameFillStyle(0);
plotpad->SetFrameBorderMode(0);
hFrame->GetXaxis()->SetTitleSize(0);
hFrame->GetXaxis()->SetLabelSize(0);
hFrame->GetYaxis()->SetTitleFont(43);
hFrame->GetYaxis()->SetTitleSize(33);
hFrame->GetYaxis()->SetTitleOffset(1.3);
// Draw objects
hFrame->Draw();
exp->Draw("hist same");
uncert->Draw("E2 same");
hExpBkgTotalUncert->Draw("E2 same");
// Data
data->Draw("same");
//signal->Draw("same");
TLegend *leg = new TLegend(0.53,0.6,0.87,0.91,NULL,"brNDC");
leg->SetBorderSize(0);
leg->SetTextFont(63);
leg->SetTextSize(18);
leg->SetLineColor(1);
leg->SetLineStyle(1);
leg->SetLineWidth(1);
leg->SetFillColor(kWhite);
//leg->SetFillStyle(4000); // enabling this will cause the plot to be erased from the pad
TLegendEntry* entry = leg->AddEntry(data, "Data", "P");
s.str("");
s << "with H^{#pm}#rightarrow#tau^{#pm}#nu";
entry = leg->AddEntry(signal, s.str().c_str(), "L");
entry = leg->AddEntry(qcd, "QCD (meas.)", "F");
entry = leg->AddEntry(ewktau, "EWK genuine #tau (meas.)", "F");
entry = leg->AddEntry(fakes, "EWK fake #tau (MC)", "F");
entry = leg->AddEntry(uncert, "stat. uncert.", "F");
entry = leg->AddEntry(hExpBkgTotalUncert, "stat. #oplus syst. uncert.", "F");
leg->Draw();
string myTitle = "CMS Preliminary";
if (paperStatus)
myTitle = "CMS";
TLatex *tex = new TLatex(0.62,0.945,myTitle.c_str());
tex->SetNDC();
tex->SetTextFont(43);
tex->SetTextSize(27);
tex->SetLineWidth(2);
tex->Draw();
tex = new TLatex(0.2,0.945,"#sqrt{s} = 7 TeV");
tex->SetNDC();
tex->SetTextFont(43);
tex->SetTextSize(27);
tex->SetLineWidth(2);
tex->Draw();
tex = new TLatex(0.43,0.945,"2.2 fb^{-1}");
tex->SetNDC();
tex->SetTextFont(43);
tex->SetTextSize(27);
tex->SetLineWidth(2);
tex->Draw();
s.str("");
s << "m_{H^{#pm}} = " << mass << " GeV/c^{2}";
tex = new TLatex(0.28,0.865,s.str().c_str());
tex->SetNDC();
tex->SetTextFont(63);
tex->SetTextSize(20);
tex->SetLineWidth(2);
tex->Draw();
s.str("");
s << "BR(t#rightarrowbH^{#pm})=" << setprecision(2) << br;
tex = new TLatex(0.28,0.805,s.str().c_str());
tex->SetNDC();
tex->SetTextFont(63);
tex->SetTextSize(20);
tex->SetLineWidth(2);
tex->Draw();
plotpad->RedrawAxis();
plotpad->Modified();
s.str("");
s << "mT_datadriven_m" << mass << ".png";
myCanvas->Print(s.str().c_str());
s.str("");
s << "mT_datadriven_m" << mass << ".C";
myCanvas->Print(s.str().c_str());
s.str("");
s << "mT_datadriven_m" << mass << ".eps";
myCanvas->Print(s.str().c_str());
}
int main(int argc, char** argv)
{
//Check if all nedeed arguments to parse are there
if(argc != 2)
{
std::cerr << ">>>>> VertexStudiesAnalysis::usage: " << argv[0] << " configFileName" << std::endl ;
return 1;
}
// Parse the config file
parseConfigFile (argv[1]) ;
std::string inputFileList = gConfigParser -> readStringOption("Input::inputFileList");
std::string treeName = gConfigParser -> readStringOption("Input::treeName");
std::string outputRootFilePath = gConfigParser -> readStringOption("Output::outputRootFilePath");
std::string outputRootFileName = gConfigParser -> readStringOption("Output::outputRootFileName");
std::string tmvaMethod = gConfigParser -> readStringOption("Input::tmvaMethod");
std::string tmvaWeights = gConfigParser -> readStringOption("Input::tmvaWeights");
int entryMIN = gConfigParser -> readIntOption("Options::entryMIN");
int entryMAX = gConfigParser -> readIntOption("Options::entryMAX");
int isZee = gConfigParser -> readIntOption("Options::isZee");
int isZmumu = gConfigParser -> readIntOption("Options::isZmumu");
int isHiggs = gConfigParser -> readIntOption("Options::isHiggs");
int isData = gConfigParser -> readIntOption("Options::isData");
double trackThr = gConfigParser -> readDoubleOption("Options::trackThr");
int useWeights = gConfigParser -> readIntOption("Options::useWeights");
int poissonWeights = gConfigParser -> readIntOption("Options::poissonWeights");
int nAvePU = gConfigParser -> readIntOption("Options::nAvePU");
std::string puweightsFileName = gConfigParser -> readStringOption("Options::puweightsFileName");
int useJSON = gConfigParser -> readIntOption("Options::useJSON");
std::string jsonFileName = gConfigParser -> readStringOption("Options::jsonFileName");
//******* Get run/LS map from JSON file *******
std::map<int, std::vector<std::pair<int, int> > > jsonMap;
if ( isData && useJSON ) {
std::cout << ">>> Getting GOOD run/LS from JSON file" << std::endl;
jsonMap = readJSONFile(jsonFileName);
std::cout << std::endl;
std::cout << std::endl;
}
//****** Get weights for MC ******
float nmax;
float w[50];
TRandom *gRandom = new TRandom();
if (useWeights){
TFile weightsFile(puweightsFileName.c_str(),"READ");
TH1F* hweights;
if ( poissonWeights ){
std::cout << "N ave PU for Poisson PU reweighting : " << nAvePU << std::endl;
char hname[100];
sprintf(hname,"hwpoisson_%d",nAvePU);
hweights = (TH1F*)weightsFile.Get(hname);
}
else {
hweights = (TH1F*)weightsFile.Get("hweights");
}
nmax = hweights ->GetMaximum();
std::cout << " Max weight " << nmax << std::endl;
for (int ibin = 1; ibin < hweights->GetNbinsX()+1; ibin++){
w[ibin-1] = hweights->GetBinContent(ibin); // bin 1 --> nvtx = 0
}
weightsFile.Close();
}
//****** open TH1 with tracks pt for kolmogorov test
TH1F *hTrackPt;
TFile ptFile("hTracksPt_PU25_upTo10GeV.root","READ");
hTrackPt = (TH1F*)ptFile.Get("hTracksPt")->Clone("hTrackPt");
hTrackPt->SetDirectory(0);
ptFile.Close();
std::cout << hTrackPt->GetEntries() << std::endl;
TH1F *htemp = (TH1F*)hTrackPt->Clone("htemp");
htemp->Reset();
//****** Parameters for vertex finding algo ******
VertexAlgoParameters vtxAlgoParams_;
vtxAlgoParams_.rescaleTkPtByError = false;
vtxAlgoParams_.trackCountThr = 1.;
vtxAlgoParams_.highPurityOnly = false;
vtxAlgoParams_.maxD0Signif = 9999999.;
vtxAlgoParams_.maxDzSignif = 9999999.;
vtxAlgoParams_.removeTracksInCone = 1;
vtxAlgoParams_.coneSize = 0.05;
//--- sumpt2 ordering
vector<string> ranksumpt2_;
ranksumpt2_.push_back("logsumpt2");
//--- ranking product variables
vector<string> rankVariables_;
// variables order matters to resolve ties
rankVariables_.push_back("ptbal"), rankVariables_.push_back("ptasym"),rankVariables_.push_back("logsumpt2");
//--- book TMVA
int isSig, evtNumber, nVertices;
float diphopt;
float logsumpt2;
float ptbal, ptasym, ptmax, ptmax3, sumpt, nchthr, nch, sumtwd;
float dk;
TMVA::Reader *tmvaReader_ = new TMVA::Reader( "!Color:!Silent" );
tmvaReader_->AddVariable( "logsumpt2",&logsumpt2 );
tmvaReader_->AddVariable( "ptbal" , &ptbal);
tmvaReader_->AddVariable( "ptasym", &ptasym );
tmvaReader_->AddVariable( "nch",&nch );
tmvaReader_->AddVariable( "nchthr",&nchthr );
tmvaReader_->AddVariable( "ptmax" ,&ptmax );
tmvaReader_->AddVariable( "ptmax3",&ptmax3 );
tmvaReader_->AddVariable( "sumtwd",&sumtwd );
tmvaReader_->AddVariable( "dk",&dk );
tmvaReader_->BookMVA( tmvaMethod.c_str(), tmvaWeights.c_str() );
//****** BOOK OUTPUT HISTOGRAMS ******
TH1F PtAll("PtAll","Pt of boson all",80,0,400);
TH1F PtGood("PtGood","Pt of boson good",80,0,400);
TH1F PtGood_BDT("PtGood_BDT","Pt of boson good (BDT)",80,0,400);
TH1F PtGood_RANK("PtGood_RANK","Pt of boson good (RANKING)",80,0,400);
TH1F PtAll_EBEB("PtAll_EBEB","Pt of boson all",80,0,400);
TH1F PtGood_EBEB("PtGood_EBEB","Pt of boson good",80,0,400);
TH1F PtGood_BDT_EBEB("PtGood_BDT_EBEB","Pt of boson good (BDT)",80,0,400);
TH1F PtGood_RANK_EBEB("PtGood_RANK_EBEB","Pt of boson good (RANKING)",80,0,400);
TH1F PtAll_EBEE("PtAll_EBEE","Pt of boson all",80,0,400);
TH1F PtGood_EBEE("PtGood_EBEE","Pt of boson good",80,0,400);
TH1F PtGood_BDT_EBEE("PtGood_BDT_EBEE","Pt of boson good (BDT)",80,0,400);
TH1F PtGood_RANK_EBEE("PtGood_RANK_EBEE","Pt of boson good (RANKING)",80,0,400);
TH1F PtAll_EEEE("PtAll_EEEE","Pt of boson all",80,0,400);
TH1F PtGood_EEEE("PtGood_EEEE","Pt of boson good",80,0,400);
TH1F PtGood_BDT_EEEE("PtGood_BDT_EEEE","Pt of boson good (BDT)",80,0,400);
TH1F PtGood_RANK_EEEE("PtGood_RANK_EEEE","Pt of boson good (RANKING)",80,0,400);
TH1F EtaAll("EtaAll","Eta of max SC",50,-5,5);
TH1F EtaGood("EtaGood","Eta of max SC good",50,-5,5);
TH1F EtaGood_BDT("EtaGood_BDT","Eta of max SC good (BDT)",50,-5,5);
TH1F EtaGood_RANK("EtaGood_RANK","Eta of max SC good (RANKING)",50,-5,5);
TH1F NvtAll("NvtAll","number of PV all",50,0,50);
TH1F NvtGood("NvtGood","number of PV good",50,0,50);
TH1F NvtGood_BDT("NvtGood_BDT","number of PV good (BDT)",50,0,50);
TH1F NvtGood_RANK("NvtGood_RANK","number of PV good (RANKING)",50,0,50);
TH1F NpuAll("NpuAll","number of PV all",50,0,50);
TH1F NpuGood("NpuGood","number of PV good",50,0,50);
TH1F NpuGood_BDT("NpuGood_BDT","number of PV good (BDT)",50,0,50);
TH1F NpuGood_RANK("NpuGood_RANK","number of PV good (RANKING)",50,0,50);
TH1F PtGood_matchedClosest("PtGood_matchedClosest","Pt of boson good",80,0,400);
TH1F PtGood_BDT_matchedClosest("PtGood_BDT_matchedClosest","Pt of boson good (BDT)",80,0,400);
TH1F PtGood_RANK_matchedClosest("PtGood_RANK_matchedClosest","Pt of boson good (RANKING)",80,0,400);
TH1F EtaGood_matchedClosest("EtaGood_matchedClosest","Eta of max SC good",50,-5,5);
TH1F EtaGood_BDT_matchedClosest("EtaGood_BDT_matchedClosest","Eta of max SC good (BDT)",50,-5,5);
TH1F EtaGood_RANK_matchedClosest("EtaGood_RANK_matchedClosest","Eta of max SC good (RANKING)",50,-5,5);
TH1F NvtGood_matchedClosest("NvtGood_matchedClosest","number of PV good",50,0,50);
TH1F NvtGood_BDT_matchedClosest("NvtGood_BDT_matchedClosest","number of PV good (BDT)",50,0,50);
TH1F NvtGood_RANK_matchedClosest("NvtGood_RANK_matchedClosest","number of PV good (RANKING)",50,0,50);
TH1F NpuGood_matchedClosest("NpuGood_matchedClosest","number of PV good",50,0,50);
TH1F NpuGood_BDT_matchedClosest("NpuGood_BDT_matchedClosest","number of PV good (BDT)",50,0,50);
TH1F NpuGood_RANK_matchedClosest("NpuGood_RANK_matchedClosest","number of PV good (RANKING)",50,0,50);
TH2F hdist("hdist"," hdist",80,0,200,400,-10,10);
TH2F hdiff_dZ_muons("hdiff_dZ_muons","hdiff_dZ_muons",80,0,200,400,-10,10);
TH2F hdiff_dZ_electrons("hdiff_dZ_electrons","hdiff_dZ_electrons",80,0,200,400,-10,10);
TH1F BDToutput("BDToutput","BDT output",500,-1,1);
TH1F BDToutput_sig("BDToutput_sig","BDT output - signal vertices",500,-1,1);
TH1F BDToutput_bkg("BDToutput_bkg","BDT output - background",500,-1,1);
TH1F pt2h("pt2h","pt2 H",500,0,500);
TH1F pt2bkg("pt2bkg","pt2 bkg",500,0,500);
TH2F * hAcceptedLumis = new TH2F("hAcceptedLumis","hAcceptedLumis",20000, 160000, 180000, 10000, 0, 10000);
float ww = 1;
float r9cut = 0.93;
//****** LOAD TREE ******
TChain* chain = new TChain(treeName.c_str());
FillChain(*chain, inputFileList.c_str());
treeReader reader((TTree*)(chain));
std::cout<<"found "<< reader.GetEntries() <<" entries"<<std::endl;
//****** Start loop over entries ******
int runId, lumiId;
for (int u = 0; u < reader.GetEntries(); u++ )
{
if(u == entryMAX) break;
if(u < entryMIN) continue;
if(u%10000 == 0) std::cout<<"reading event "<< u <<std::endl;
reader.GetEntry(u);
//*** filter bad runs/lumis
runId = reader.GetInt("runId")->at(0);
lumiId = reader.GetInt("lumiId")->at(0);
bool skipEvent = false;
if( isData && useJSON ){
if(AcceptEventByRunAndLumiSection(runId,lumiId,jsonMap) == false)
skipEvent = true;
}
if( skipEvent == true ) continue;
hAcceptedLumis -> Fill(runId, lumiId);
//*** pu weights
std::vector<float>*PU_z ;
std::vector<int>* mc_PUit_NumInteractions;
int npu ;
if ( !isData ){
mc_PUit_NumInteractions = reader.GetInt("mc_PUit_NumInteractions");
npu = mc_PUit_NumInteractions->at(0);
//--- use weights
if (useWeights){
float myrnd = gRandom->Uniform(0,nmax);
if (myrnd > w[npu]) continue;
}
}
//*** setup common branches ***
std::vector<int>* PV_nTracks;
std::vector<float>* PV_z;
std::vector<float>* PV_d0;
std::vector<ROOT::Math::XYZVector>* PVtracks;
std::vector<int>* PVtracks_PVindex;
std::vector<int>* tracks_PVindex;
std::vector<float>* tracks_dz ; //?
std::vector<float>* tracks_dz_PV ; //?
std::vector<float>* tracks_dxy_PV ; //?
std::vector<ROOT::Math::XYZTVector>* sc; // supercluster
int accept = 0;
int indpho1 = -100;
int indpho2 = -100;
ROOT::Math::XYZTVector sum2pho;
float etaMaxSC ;
float TrueVertex_Z;
//*** selections for Hgg ***
if (isHiggs){
std::vector<ROOT::Math::XYZVector>* mc_H_vertex = reader.Get3V("mc_H_vertex");
std::vector<ROOT::Math::XYZTVector>* mcV1 = reader.Get4V("mcV1");
std::vector<ROOT::Math::XYZTVector>* mcV2 = reader.Get4V("mcV2");
std::vector<ROOT::Math::XYZTVector>* photons = reader.Get4V("photons");
std::vector<float>* photons_r9 = reader.GetFloat("photons_r9");
if (mc_H_vertex->size() != 1) continue;
PV_nTracks = reader.GetInt("PV_nTracks");
PV_z = reader.GetFloat("PV_z");
PV_d0 = reader.GetFloat("PV_d0");
PVtracks = reader.Get3V("PVtracks");
PVtracks_PVindex = reader.GetInt("PVtracks_PVindex");
tracks_PVindex = reader.GetInt("tracks_PVindex");
tracks_dxy_PV = reader.GetFloat("tracks_dxy_PV");
tracks_dz_PV = reader.GetFloat("tracks_dz_PV");
tracks_dz = reader.GetFloat("tracks_dz");
sc = reader.Get4V("photons_SC");
hggSelection(mcV1, mcV2, photons, sc, photons_r9, accept, indpho1, indpho2);
if (!accept) continue;
if ( photons_r9->at(indpho1) < r9cut ) continue;
if ( photons_r9->at(indpho2) < r9cut ) continue;
etaMaxSC = sc->at(indpho1).eta();
sum2pho = photons->at(indpho1)+ photons->at(indpho2);
TrueVertex_Z = mc_H_vertex->at(0).Z();
}// end Hgg selection
//*** selections for Zee ***
if (isZee){
std::vector<ROOT::Math::XYZTVector>* electrons = reader.Get4V("electrons");
// std::vector<float>* eleid = reader.GetFloat("simpleEleId95cIso");
// no eleID95 available for data 2011 --> compute it by hand
std::vector<float>* eleid = new std::vector<float>;
eleid->clear();
if ( electrons->size() < 2) continue;
for (unsigned int iele = 0; iele < electrons->size(); iele++){
float pt = electrons->at(iele).pt();
float tkIso = reader.GetFloat("electrons_tkIsoR03")->at(iele);
float emIso = reader.GetFloat("electrons_emIsoR03")->at(iele);
float hadIso = reader.GetFloat("electrons_hadIsoR03_depth1")->at(iele) + reader.GetFloat("electrons_hadIsoR03_depth2")->at(iele);
float combIso = tkIso + emIso + hadIso;
int isEB = reader.GetInt("electrons_isEB")->at(iele);
float sigmaIetaIeta = reader.GetFloat("electrons_sigmaIetaIeta")->at(iele);
float DetaIn = reader.GetFloat("electrons_deltaEtaIn")->at(iele);
float DphiIn = reader.GetFloat("electrons_deltaPhiIn")->at(iele);
float HOverE = reader.GetFloat("electrons_hOverE")->at(iele);
int mishits = reader.GetInt("electrons_mishits")->at(iele);
float id = eleId95 ( pt, tkIso, emIso, hadIso, combIso, isEB, sigmaIetaIeta, DetaIn, DphiIn, HOverE, mishits);
id *= 7.; // to emulate simpleEleId95cIso
eleid->push_back( id );
}
std::vector<float>* electrons_dz_PV_noEle = reader.GetFloat("electrons_dz_PV_noEle");
PV_nTracks = reader.GetInt("PV_noEle_nTracks");
PV_z = reader.GetFloat("PV_noEle_z");
PV_d0 = reader.GetFloat("PV_noEle_d0");
PVtracks = reader.Get3V("PVEleLessTracks");
PVtracks_PVindex = reader.GetInt("PVEleLessTracks_PVindex");
tracks_PVindex = reader.GetInt("tracks_PVindex");
tracks_dxy_PV = reader.GetFloat("tracks_dxy_PV");
tracks_dz_PV = reader.GetFloat("tracks_dz_PV");
tracks_dz = reader.GetFloat("tracks_dz");
//sc = reader.Get4V("electrons_SC");
sc = reader.Get4V("electrons");
zeeSelection(electrons, eleid, accept, indpho1, indpho2);
if (!accept) continue;
etaMaxSC = sc->at(indpho1).eta();
sum2pho = electrons->at(indpho1)+ electrons->at(indpho2);
TrueVertex_Z = PV_z->at(0) + (electrons_dz_PV_noEle->at(indpho1) + electrons_dz_PV_noEle->at(indpho2))/2.;
hdiff_dZ_electrons.Fill( sum2pho.pt(), electrons_dz_PV_noEle->at(indpho1) - electrons_dz_PV_noEle->at(indpho2) );
}
//*** selections for Zmumu
if ( isZmumu ){
std::vector<ROOT::Math::XYZTVector>* muons = reader.Get4V("muons");
std::vector<int>* muons_global = reader.GetInt("muons_global");
std::vector<int>* muons_tracker = reader.GetInt("muons_tracker");
std::vector<float>* muons_tkIsoR03 = reader.GetFloat("muons_tkIsoR03");
std::vector<float>* muons_normalizedChi2 = reader.GetFloat("muons_normalizedChi2");
std::vector<int>* muons_numberOfValidMuonHits = reader.GetInt("muons_numberOfValidMuonHits");
std::vector<int>* muons_numberOfValidPixelHits = reader.GetInt("muons_numberOfValidPixelHits");
std::vector<float>* muons_dxy_PV = reader.GetFloat("muons_dxy_PV");
std::vector<float>* muons_dz_PV = reader.GetFloat("muons_dz_PV");
std::vector<float>* muons_dz_PV_noMuon = reader.GetFloat("muons_dz_PV_noMuon");
PV_nTracks = reader.GetInt("PV_noMuon_nTracks");
PV_z = reader.GetFloat("PV_noMuon_z");
PV_d0 = reader.GetFloat("PV_noMuon_d0");
PVtracks = reader.Get3V("PVMuonLessTracks");
PVtracks_PVindex = reader.GetInt("PVMuonLessTracks_PVindex");
tracks_PVindex = reader.GetInt("tracks_PVindex");
tracks_dxy_PV = reader.GetFloat("tracks_dxy_PV");
tracks_dz_PV = reader.GetFloat("tracks_dz_PV");
tracks_dz = reader.GetFloat("tracks_dz");
sc = reader.Get4V("muons"); // use muon info for SC
zmumuSelection(muons,muons_global,muons_tracker, muons_tkIsoR03,
muons_normalizedChi2 ,
muons_numberOfValidMuonHits,
muons_numberOfValidPixelHits,
muons_dxy_PV,
muons_dz_PV,
accept, indpho1, indpho2);
if (!accept) continue;
etaMaxSC = muons->at(indpho1).eta();
sum2pho = muons->at(indpho1)+ muons->at(indpho2);
TrueVertex_Z = PV_z->at(0) + (muons_dz_PV_noMuon->at(indpho1) + muons_dz_PV_noMuon->at(indpho2))/2.;
hdiff_dZ_muons.Fill( sum2pho.pt(), muons_dz_PV_noMuon->at(indpho1) - muons_dz_PV_noMuon->at(indpho2) );
if ( fabs(muons_dz_PV_noMuon->at(indpho1) - muons_dz_PV_noMuon->at(indpho2))> 0.5) continue;
}//Zmumu end
// branches buffers
int nvtx_;
float vtxx_[1000], vtxy_[1000], vtxz_[1000];
int ntracks_;
float tkpx_[1000], tkpy_[1000], tkpz_[1000], tkPtErr_[1000], tkWeight_[1000],
tkd0_[1000], tkd0Err_[1000], tkdz_[1000], tkdzErr_[1000];
int tkVtxId_[1000];
bool tkIsHighPurity_[1000];
float phocalox_[100], phocaloy_[100], phocaloz_[100], phoen_[100];
// set variables
// vertices
nvtx_ = (int) PV_z->size();
for ( int iv = 0; iv < nvtx_; iv++){
vtxx_[iv] = 0;
vtxy_[iv] = 0;
vtxz_[iv] = PV_z->at(iv) ;
}
// tracks
ntracks_ = PVtracks->size();
for (int itrk = 0; itrk <ntracks_; itrk++ ){
tkpx_[itrk] = PVtracks->at(itrk).X();
tkpy_[itrk] = PVtracks->at(itrk).Y();
tkpz_[itrk] = PVtracks->at(itrk).Z();
tkPtErr_[itrk] = 0;
tkVtxId_[itrk] = PVtracks_PVindex->at(itrk);
tkWeight_[itrk]= 1.;
tkd0_[itrk] = 0;
tkd0Err_[itrk] = 0;
tkdz_[itrk] = 0;
tkdzErr_[itrk] = 0;
tkIsHighPurity_[itrk]= 1.;
}
// photons
for (int ipho = 0 ; ipho < sc->size(); ipho++){
float px = sc->at(ipho).X();
float py = sc->at(ipho).Y();
float pz = sc->at(ipho).Z();
float pt = sqrt ( px*px+py*py );
float theta = 2*atan(exp(-sc->at(ipho).eta()) );
float tantheta = tan(theta);
if ( fabs(sc->at(ipho).eta()) < etaEB ) {
phocalox_[ipho] = R_ECAL*px/pt;
phocaloy_[ipho] = R_ECAL*py/pt;
phocaloz_[ipho] = R_ECAL/tantheta;
}
if ( fabs(sc->at(ipho).eta()) > etaEE ) {
float r_endcap = fabs(Z_ENDCAP * tantheta);
phocalox_[ipho] = r_endcap * px/pt;
phocaloy_[ipho] = r_endcap * py/pt;
if (pz > 0) phocaloz_[ipho] = Z_ENDCAP;
else phocaloz_[ipho] = -Z_ENDCAP;
}
phoen_[ipho] = sc->at(ipho).E();
}
float eta1 = sc->at(indpho1).eta();
float eta2 = sc->at(indpho2).eta();
if ( (fabs(eta1) > etaEB && fabs(eta1) < etaEE) || fabs(eta1) > 2.5) continue;
if ( (fabs(eta2) > etaEB && fabs(eta2) < etaEE) || fabs(eta2) > 2.5) continue;
//*** set vertex info
TupleVertexInfo vinfo( nvtx_, vtxx_ , vtxy_, vtxz_, ntracks_, tkpx_, tkpy_, tkpz_, tkPtErr_, tkVtxId_, tkWeight_, tkd0_, tkd0Err_,tkdz_, tkdzErr_ , tkIsHighPurity_);
//*** set photon info
PhotonInfo pho1(indpho1, TVector3(phocalox_[indpho1],phocaloy_[indpho1],phocaloz_[indpho1]),phoen_[indpho1]);
PhotonInfo pho2(indpho2, TVector3(phocalox_[indpho2],phocaloy_[indpho2],phocaloz_[indpho2]),phoen_[indpho2]);
//*** vertex analyzer
HggVertexAnalyzer vAna(vtxAlgoParams_,nvtx_);
vAna.analyze(vinfo,pho1,pho2);
// if Zmumu : setNconv to zero
if (isZmumu) vAna.setNConv(0);
//*** preselect vertices
std::vector<int> presel;
for(int i=0; i<nvtx_; i++) {
presel.push_back(i);
}
vAna.preselection(presel);
//*** Look if the H vertex matches one of the PV vertices
float dmin = 10000;
int iClosest = -1;
for ( int uu = 0; uu < nvtx_; uu++){
float distt = fabs( PV_z->at(uu) - TrueVertex_Z );
if ( distt < dmin) { dmin = distt; iClosest = uu; }
}
//*** NOW FILL HISTOGRAMS
PtAll.Fill( sum2pho.pt(),ww );
if (fabs(eta1) < etaEB && fabs(eta2) < etaEB) PtAll_EBEB.Fill( sum2pho.pt(),ww );
if (fabs(eta1) > etaEE && fabs(eta2) > etaEE) PtAll_EEEE.Fill( sum2pho.pt(),ww );
if ( (fabs(eta1) < etaEB && fabs(eta2) > etaEE) || (fabs(eta2) < etaEB && fabs(eta1) > etaEE)) PtAll_EBEE.Fill( sum2pho.pt(),ww );
EtaAll.Fill( etaMaxSC ,ww);
NvtAll.Fill( nvtx_,ww );
if (!isData) NpuAll.Fill(npu,ww);
//*** SUMPT2 CRITERION
vector<int> ranksumpt2 = vAna.rankprod(ranksumpt2_);
//-- matching 1cm
if ( fabs( TrueVertex_Z - PV_z->at(ranksumpt2[0]) ) < 1.) {
PtGood.Fill( sum2pho.pt(),ww );
EtaGood.Fill( etaMaxSC ,ww);
NvtGood.Fill( nvtx_ ,ww);
if (!isData) NpuGood.Fill(npu,ww);
}
//-- matching closest vtx
if ( iClosest == ranksumpt2[0]){
PtGood_matchedClosest.Fill( sum2pho.pt(),ww );
EtaGood_matchedClosest.Fill( etaMaxSC ,ww);
NvtGood_matchedClosest.Fill( nvtx_ ,ww);
if (!isData) NpuGood_matchedClosest.Fill(npu,ww);
}
//*** RANKING PRODUCT
vector<int> rankprod = vAna.rankprod(rankVariables_);
//-- matching 1cm
if ( fabs( TrueVertex_Z - PV_z->at(rankprod[0]) ) < 1.) {
PtGood_RANK.Fill( sum2pho.pt(),ww );
EtaGood_RANK.Fill( etaMaxSC ,ww);
NvtGood_RANK.Fill( nvtx_,ww );
if (!isData) NpuGood_RANK.Fill(npu,ww);
}
//-- matching closest vtx
if ( iClosest == rankprod[0]){
PtGood_RANK_matchedClosest.Fill( sum2pho.pt(),ww );
EtaGood_RANK_matchedClosest.Fill( etaMaxSC ,ww);
NvtGood_RANK_matchedClosest.Fill( nvtx_,ww );
if (!isData) NpuGood_RANK_matchedClosest.Fill(npu,ww);
}
//*** BDT
int TMVAind = -1;
float TMVAmax = -1000.;
for ( int uu = 0; uu < nvtx_; uu++){
diphopt = vAna.diphopt(uu);
logsumpt2 = vAna.logsumpt2(uu);
nch = vAna.nch(uu);
nchthr = vAna.nchthr(uu);
ptbal = vAna.ptbal(uu);
ptasym = vAna.ptasym(uu);
ptmax = vAna.ptmax(uu);
ptmax3 = vAna.ptmax3(uu);
sumtwd = vAna.sumtwd(uu);
htemp->Reset();
for (unsigned int kk = 0; kk < PVtracks->size(); ++kk){
if (PVtracks_PVindex->at(kk) == uu){
float tkpt = sqrt(PVtracks->at(kk).perp2()) ;
htemp ->Fill( (tkpt < 10. ? tkpt : 10.) );
}
}
if ( htemp->GetEntries()!=0 )
dk = htemp->KolmogorovTest(hTrackPt);
//--- Evaluate TMVA
Double_t mva = tmvaReader_->EvaluateMVA( "BDTG" );
BDToutput.Fill( mva );
if ( fabs( TrueVertex_Z - PV_z->at(uu) ) < 1.)
BDToutput_sig.Fill( mva );
else
BDToutput_bkg.Fill( mva );
// take the highest score
if ( mva > TMVAmax) {
TMVAmax = mva;
TMVAind = uu;
}
} // end loop over vertices
//-- matching 1cm
if ( fabs( TrueVertex_Z - PV_z->at(TMVAind) ) < 1.) {
PtGood_BDT.Fill( sum2pho.pt(),ww );
EtaGood_BDT.Fill( etaMaxSC ,ww);
NvtGood_BDT.Fill( nvtx_ ,ww);
if (!isData) NpuGood_BDT.Fill(npu,ww);
}
//-- matching closest vtx
if ( iClosest == TMVAind){
PtGood_BDT_matchedClosest.Fill( sum2pho.pt(),ww );
EtaGood_BDT_matchedClosest.Fill( etaMaxSC ,ww);
NvtGood_BDT_matchedClosest.Fill( nvtx_,ww );
if (!isData) NpuGood_BDT_matchedClosest.Fill(npu,ww);
}
}// end loop over entries
std::cout << "END LOOP OVER ENTRIES" << std::endl;
std::cout << "Saving histos on file ..." << std::endl;
TFile ff( (outputRootFilePath+outputRootFileName).c_str(),"recreate");
hAcceptedLumis -> Write();
PtAll.Write();
PtGood.Write();
PtGood_BDT.Write();
PtGood_RANK.Write();
EtaAll.Write();
EtaGood.Write();
EtaGood_BDT.Write();
EtaGood_RANK.Write();
NvtAll.Write();
NvtGood.Write();
NvtGood_BDT.Write();
NvtGood_RANK.Write();
NpuAll.Write();
NpuGood.Write();
NpuGood_BDT.Write();
NpuGood_RANK.Write();
PtGood_matchedClosest.Write();
PtGood_BDT_matchedClosest.Write();
PtGood_RANK_matchedClosest.Write();
EtaGood_matchedClosest.Write();
EtaGood_BDT_matchedClosest.Write();
EtaGood_RANK_matchedClosest.Write();
NvtGood_matchedClosest.Write();
NvtGood_BDT_matchedClosest.Write();
NvtGood_RANK_matchedClosest.Write();
NpuGood_matchedClosest.Write();
NpuGood_BDT_matchedClosest.Write();
NpuGood_RANK_matchedClosest.Write();
hdist.Write();
hdiff_dZ_muons.Write();
hdiff_dZ_electrons.Write();
BDToutput.Write();
BDToutput_sig.Write();
BDToutput_bkg.Write();
ff.Close();
std::cout << "BYE BYE !!!! " << std::endl;
return 0;
}
void mlpHiggs(Int_t ntrain=100) {
// Example of a Multi Layer Perceptron
// For a LEP search for invisible Higgs boson, a neural network
// was used to separate the signal from the background passing
// some selection cuts. Here is a simplified version of this network,
// taking into account only WW events.
//Author: Christophe Delaere
if (!gROOT->GetClass("TMultiLayerPerceptron")) {
gSystem->Load("libMLP");
}
// Prepare inputs
// The 2 trees are merged into one, and a "type" branch,
// equal to 1 for the signal and 0 for the background is added.
const char *fname = "mlpHiggs.root";
TFile *input = 0;
if (!gSystem->AccessPathName(fname)) {
input = TFile::Open(fname);
} else {
printf("accessing %s file from http://root.cern.ch/files\n",fname);
input = TFile::Open(Form("http://root.cern.ch/files/%s",fname));
}
if (!input) return;
TTree *signal = (TTree *) input->Get("sig_filtered");
TTree *background = (TTree *) input->Get("bg_filtered");
TTree *simu = new TTree("MonteCarlo", "Filtered Monte Carlo Events");
Float_t ptsumf, qelep, nch, msumf, minvis, acopl, acolin;
Int_t type;
signal->SetBranchAddress("ptsumf", &ptsumf);
signal->SetBranchAddress("qelep", &qelep);
signal->SetBranchAddress("nch", &nch);
signal->SetBranchAddress("msumf", &msumf);
signal->SetBranchAddress("minvis", &minvis);
signal->SetBranchAddress("acopl", &acopl);
signal->SetBranchAddress("acolin", &acolin);
background->SetBranchAddress("ptsumf", &ptsumf);
background->SetBranchAddress("qelep", &qelep);
background->SetBranchAddress("nch", &nch);
background->SetBranchAddress("msumf", &msumf);
background->SetBranchAddress("minvis", &minvis);
background->SetBranchAddress("acopl", &acopl);
background->SetBranchAddress("acolin", &acolin);
simu->Branch("ptsumf", &ptsumf, "ptsumf/F");
simu->Branch("qelep", &qelep, "qelep/F");
simu->Branch("nch", &nch, "nch/F");
simu->Branch("msumf", &msumf, "msumf/F");
simu->Branch("minvis", &minvis, "minvis/F");
simu->Branch("acopl", &acopl, "acopl/F");
simu->Branch("acolin", &acolin, "acolin/F");
simu->Branch("type", &type, "type/I");
type = 1;
Int_t i;
for (i = 0; i < signal->GetEntries(); i++) {
signal->GetEntry(i);
simu->Fill();
}
type = 0;
for (i = 0; i < background->GetEntries(); i++) {
background->GetEntry(i);
simu->Fill();
}
// Build and train the NN ptsumf is used as a weight since we are primarly
// interested by high pt events.
// The datasets used here are the same as the default ones.
TMultiLayerPerceptron *mlp =
new TMultiLayerPerceptron("@msumf,@ptsumf,@acolin:5:3:type",
"ptsumf",simu,"Entry$%2","(Entry$+1)%2");
mlp->Train(ntrain, "text,graph,update=10");
mlp->Export("test","python");
// Use TMLPAnalyzer to see what it looks for
TCanvas* mlpa_canvas = new TCanvas("mlpa_canvas","Network analysis");
mlpa_canvas->Divide(2,2);
TMLPAnalyzer ana(mlp);
// Initialisation
ana.GatherInformations();
// output to the console
ana.CheckNetwork();
mlpa_canvas->cd(1);
// shows how each variable influences the network
ana.DrawDInputs();
mlpa_canvas->cd(2);
// shows the network structure
mlp->Draw();
mlpa_canvas->cd(3);
// draws the resulting network
ana.DrawNetwork(0,"type==1","type==0");
mlpa_canvas->cd(4);
// Use the NN to plot the results for each sample
// This will give approx. the same result as DrawNetwork.
// All entries are used, while DrawNetwork focuses on
// the test sample. Also the xaxis range is manually set.
TH1F *bg = new TH1F("bgh", "NN output", 50, -.5, 1.5);
TH1F *sig = new TH1F("sigh", "NN output", 50, -.5, 1.5);
bg->SetDirectory(0);
sig->SetDirectory(0);
Double_t params[4];
for (i = 0; i < background->GetEntries(); i++) {
background->GetEntry(i);
params[0] = msumf;
params[1] = ptsumf;
params[2] = acolin;
params[3] = acopl;
bg->Fill(mlp->Evaluate(0, params));
}
for (i = 0; i < signal->GetEntries(); i++) {
signal->GetEntry(i);
params[0] = msumf;
params[1] = ptsumf;
params[2] = acolin;
params[3] = acopl;
sig->Fill(mlp->Evaluate(0,params));
}
bg->SetLineColor(kBlue);
bg->SetFillStyle(3008); bg->SetFillColor(kBlue);
sig->SetLineColor(kRed);
sig->SetFillStyle(3003); sig->SetFillColor(kRed);
bg->SetStats(0);
sig->SetStats(0);
bg->Draw();
sig->Draw("same");
TLegend *legend = new TLegend(.75, .80, .95, .95);
legend->AddEntry(bg, "Background (WW)");
legend->AddEntry(sig, "Signal (Higgs)");
legend->Draw();
mlpa_canvas->cd(0);
delete input;
}
void PlotAlignmentValidation::plotDMR(const std::string variable, Int_t minHits )
{
setNiceStyle();
gStyle->SetOptStat(0);
// TList treeList=getTreeList();
TCanvas *c = new TCanvas("canv", "canv", 600, 600);
setCanvasStyle( *c );
//loop over sub-detectors
for (int i=1;i<7;++i){
int histo_Counter=1;
TLegend *leg_hist = new TLegend(0.17,0.8,0.85,0.88);
setLegendStyle(*leg_hist);
//loop over file list
//TTree *tree= (TTree*)treeList.First();
//binning
int nbinsX=100;
double xmin=0;
double xmax=0;
float maxY=0;
bool isHisto = false;
std::string plotVar=variable;
THStack *hstack=new THStack("hstack","hstack");
for(std::vector<TkOfflineVariables*>::iterator it = sourceList.begin();
it != sourceList.end(); ++it){
//while ( tree ){
plotVar=variable;
TString subdet = "entries>=";
subdet+=minHits;
subdet+=" && subDetId==";
subdet+=i;
char binning [50]="";
sprintf (binning, ">>myhisto(%d, %f , %f)", nbinsX, xmin, xmax);
TH1F *h = 0;
if (histo_Counter==1&&plotVar=="meanX")(*it)->getTree()->Draw( (plotVar+=">>myhisto(50,-0.005,0.005)").c_str(),subdet,"goff");
else if (histo_Counter==1&&plotVar=="meanY")(*it)->getTree()->Draw( (plotVar+=">>myhisto(50,-0.005,0.005)").c_str(),subdet,"goff");
else if (histo_Counter==1&&plotVar=="medianX")(*it)->getTree()->Draw( (plotVar+=">>myhisto(50,-0.005,0.005)").c_str(),subdet,"goff");
else if (histo_Counter==1&&plotVar=="meanNormX")(*it)->getTree()->Draw( (plotVar+=">>myhisto(100,-2,2)").c_str(),subdet,"goff");
else if (histo_Counter==1&&plotVar=="rmsX")(*it)->getTree()->Draw( (plotVar+=">>myhisto(100,0.,0.1)").c_str(),subdet,"goff");
else if (histo_Counter!=1)(*it)->getTree()->Draw( (plotVar+=binning).c_str(),subdet,"goff");
if (gDirectory) gDirectory->GetObject("myhisto", h);
std::pair<float,float> fitResults(9999., 9999.);
if (h){
if (h->GetEntries()>0) {
isHisto = true;
h->SetDirectory(0);
//general draw options
h->SetLineWidth(2);
//first histo only, setting optStat...
if (histo_Counter==1)
setHistStyle(*h,plotVar.c_str() ,"#modules", 1 ); //set color later
h->SetLineColor( (*it)->getLineColor() );
h->SetLineStyle( (*it)->getLineStyle() );
//h->SetMarkerStyle(20+file_Counter);
//draw options
if (maxY<h->GetMaximum()){
maxY=h->GetMaximum();
}
//fit histogram for median and mean
if (variable=="medianX"||variable =="meanX")fitResults=fitGauss(h, (*it)->getLineColor() );
if (histo_Counter==1){
//get mean and sigma from fit: gauss for 2sigma range
hstack->Add(h);
nbinsX=h->GetXaxis()->GetNbins();
xmin=h->GetXaxis()->GetXmin();
xmax=h->GetXaxis()->GetXmax();
}else if (histo_Counter!=1 && h->GetEntries()>0)hstack->Add(h);
char legend [50]="";
std::string legEntry = (*it)->getName();
if (variable=="medianX"||variable =="meanX")sprintf (legend, "%s: #mu = %4.2f#mum, #sigma = %4.2f#mum ",legEntry.c_str(),fitResults.first ,fitResults.second);
else sprintf (legend, "%s ",legEntry.c_str());
if(h)
leg_hist->AddEntry(h,legend,"l");
else
std::cerr<< "histogram did not exist!";
}
}
// tree= (TTree*)treeList.After( tree );
// file_Counter++;
histo_Counter++;
}
if (isHisto){
hstack->Draw("nostack");
hstack->SetMaximum(maxY*1.3);
setTitleStyle(*hstack,plotVar.c_str() ,"#modules",i);
setHistStyle(*hstack->GetHistogram(),plotVar.c_str() ,"#modules", 1 );
leg_hist->Draw();
std::string histName="D";
if (variable=="medianX") histName+="medianR_";
else if (variable=="meanX") histName+="meanR_";
else if (variable=="meanY") histName+="meanYR_";
else if (variable=="rmsX") histName+="rmsR_";
std::string subDetector ="";
switch (i){
case 1 : subDetector+="TPB";break;
case 2 : subDetector+="TPE";break;
case 3 : subDetector+="TIB";break;
case 4 : subDetector+="TID";break;
case 5 : subDetector+="TOB";break;
case 6 : subDetector+="TEC";break;
}
char PlotName[100];
sprintf( PlotName, "%s/%s%s.eps",outputDir.c_str(), histName.c_str(), subDetector.c_str() );
c->Update();
c->Print(PlotName);
//c->Update();
//c->Close();
}
delete hstack;
hstack=0;
}
delete c;
c=0;
}
void Polarization(){
TGraph *gObs;
TGraph *gExp;
TGraph *gObsL;
TGraph *gExpL;
TGraph *gObsR;
TGraph *gExpR;
TFile *fc = TFile::Open("Limits2DHistograms_T2tt_postfit.root");
TFile *fl = TFile::Open("Limits2DHistograms_T2tt_lefthanded_postfit.root");
TFile *fr = TFile::Open("Limits2DHistograms_T2tt_righthanded_postfit.root");
TGraph *g;
fc->cd();
g = (TGraph*)fc->Get("gObs");
gObs = (TGraph*)g->Clone("Obs");
g = (TGraph*)fc->Get("gExp");
gExp = (TGraph*)g->Clone("Exp");
fl->cd();
g = (TGraph*)fl->Get("gObs_2");
gObsL = (TGraph*)g->Clone("ObsL");
g = (TGraph*)fl->Get("gExp_2");
gExpL = (TGraph*)g->Clone("ExpL");
fr->cd();
g = (TGraph*)fr->Get("gObs");
gObsR = (TGraph*)g->Clone("ObsR");
g = (TGraph*)fr->Get("gExp");
gExpR = (TGraph*)g->Clone("ExpR");
gObs->SetLineWidth(4);
gExp->SetLineWidth(4);
gObsL->SetLineWidth(2);
gExpL->SetLineWidth(2);
gObsR->SetLineWidth(2);
gExpR->SetLineWidth(2);
gObs->SetLineStyle(1);
gExp->SetLineStyle(7);
gObsL->SetLineStyle(1);
gExpL->SetLineStyle(7);
gObsR->SetLineStyle(1);
gExpR->SetLineStyle(7);
gObs->SetLineColor(kBlack);
gExp->SetLineColor(kBlack);
gObsL->SetLineColor(kBlue);
gExpL->SetLineColor(kBlue);
gObsR->SetLineColor(kRed);
gExpR->SetLineColor(kRed);
if(killlowdiag){
for( int i = gObs->GetN()-1; i>=0;--i){
double x,y;
gObs->GetPoint(i,x,y);
if(x-y<172.5) gObs->RemovePoint(i);
}
for( int i = gExp->GetN()-1; i>=0;--i){
double x,y;
gExp->GetPoint(i,x,y);
if(x-y<172.5) gExp->RemovePoint(i);
}
}
for( int i = gObsL->GetN()-1; i>=0;--i){
double x,y;
gObsL->GetPoint(i,x,y);
if(x-y<172.5) gObsL->RemovePoint(i);
}
for( int i = gObsR->GetN()-1; i>=0;--i){
double x,y;
gObsR->GetPoint(i,x,y);
if(x-y<172.5) gObsR->RemovePoint(i);
}
for( int i = gExpL->GetN()-1; i>=0;--i){
double x,y;
gExpL->GetPoint(i,x,y);
if(x-y<172.5) gExpL->RemovePoint(i);
}
for( int i = gExpR->GetN()-1; i>=0;--i){
double x,y;
gExpR->GetPoint(i,x,y);
if(x-y<172.5) gExpR->RemovePoint(i);
}
TCanvas *c1 = new TCanvas("c1", "c1",50,50,600,600);
gStyle->SetOptFit(1);
gStyle->SetOptStat(0);
gStyle->SetOptTitle(0);
gStyle->SetErrorX(0.5);
//c1->Range(-6.311689,-1.891383,28.75325,4.56342);
c1->SetFillColor(0);
c1->SetBorderMode(0);
c1->SetBorderSize(2);
//c1->SetLogy();
c1->SetTickx(1);
c1->SetTicky(1);
c1->SetLeftMargin(0.15);
c1->SetRightMargin(0.05);
c1->SetTopMargin(0.07);
c1->SetBottomMargin(0.15);
c1->SetFrameFillStyle(0);
c1->SetFrameBorderMode(0);
c1->SetFrameFillStyle(0);
c1->SetFrameBorderMode(0);
gStyle->SetHatchesLineWidth(0);
TH1F *hSum = new TH1F("hSum","",10,150,950);
hSum->SetMinimum(0.);
hSum->SetMaximum(550);
hSum->SetDirectory(0);
hSum->SetStats(0);
hSum->Draw();
hSum->GetYaxis()->SetRangeUser(0,500);
hSum->GetXaxis()->SetRangeUser(150,950);
Int_t ci; // for color index setting
ci = TColor::GetColor("#000099");
hSum->SetLineColor(ci);
hSum->SetLineStyle(0);
hSum->SetMarkerStyle(20);
hSum->GetXaxis()->SetTitle("m_{#tilde{t}} [GeV]");
//hSum->GetXaxis()->SetBit(TAxis::kLabelsVert);
hSum->GetXaxis()->SetLabelFont(42);
//hSum->GetXaxis()->SetLabelOffset(0.005);
hSum->GetXaxis()->SetLabelSize(0.035);
hSum->GetXaxis()->SetTitleSize(0.06);
hSum->GetXaxis()->SetTitleOffset(1.2);
hSum->GetXaxis()->SetTitleFont(42);
hSum->GetYaxis()->SetTitle("m_{#tilde{#chi}}_{1}^{0} [GeV]");
hSum->GetYaxis()->SetLabelFont(42);
//hSum->GetYaxis()->SetLabelOffset(0.007);
hSum->GetYaxis()->SetLabelSize(0.035);
hSum->GetYaxis()->SetTitleSize(0.05);
hSum->GetYaxis()->SetTitleOffset(1.3);
hSum->GetYaxis()->SetTitleFont(42);
//TLegend *leg = new TLegend(0.4992416,0.4811189,0.898906,0.7503497,NULL,"brNDC");
//TLegend *leg = new TLegend(0.4992416,0.4811189,0.698906,0.7503497,NULL,"brNDC");
//TLegend *leg = new TLegend(0.6992416,0.2811189,0.898906,0.4503497,NULL,"brNDC");
//TLegend *leg = new TLegend(0.6992416,0.3311189,0.898906,0.7903497,NULL,"brNDC");
//TLegend *leg = new TLegend(0.7582416,0.4211189,0.912,0.8043497,NULL,"brNDC");
TLegend *legE = new TLegend(0.51,0.675,0.81,0.855,NULL,"brNDC");
//leg-> SetNColumns(2);
legE->SetBorderSize(0);
legE->SetTextSize(0.04);
legE->SetTextFont(42);
legE->SetLineColor(1);
legE->SetLineStyle(1);
legE->SetLineWidth(2);
legE->SetFillColor(0);
legE->SetFillStyle(1001);
legE->SetHeader("Expected");
legE->AddEntry(gExp, "unpolarized","l");
legE->AddEntry(gExpR, "right-handed","l");
legE->AddEntry(gExpL, "left-handed","l");
TLegend *legO = new TLegend(0.175,0.675,0.50,0.855,NULL,"brNDC");
//legO-> SetNColumns(2);
legO->SetBorderSize(0);
legO->SetTextSize(0.04);
legO->SetTextFont(42);
legO->SetLineColor(1);
legO->SetLineStyle(1);
legO->SetLineWidth(2);
legO->SetFillColor(0);
legO->SetFillStyle(1001);
legO->SetHeader("Observed");
legO->AddEntry(gObs, "unpolarized","l");
legO->AddEntry(gObsR, "right-handed","l");
legO->AddEntry(gObsL, "left-handed","l");
TGraph* graphWhite = new TGraph(5);
graphWhite->SetName("white");
graphWhite->SetTitle("white");
graphWhite->SetFillColor(kWhite);
graphWhite->SetFillStyle(1001);
graphWhite->SetLineColor(kBlack);
graphWhite->SetLineStyle(1);
graphWhite->SetLineWidth(3);
graphWhite->SetPoint(0,150, 500);
graphWhite->SetPoint(1,950, 500);
graphWhite->SetPoint(2,950, 500*0.6666666667);
graphWhite->SetPoint(3,150, 500*0.6666666667);
graphWhite->SetPoint(4,150, 500);
Float_t diagX[4] = {175.+25.,175.+25.+5000,175.-25.+5000,175.-25.};
Float_t diagY[4] = {0,5000,5000,0};
TGraph *gdiagonal = new TGraph(4, diagX, diagY);
gdiagonal->SetName("MtopDiagonal");
gdiagonal->SetFillColor(kWhite);
//#gdiagonal->SetFillColor(18);
TLine* ldiagonal = new TLine(175,0.,650-25.,450);
//TLine* ldiagonal = new TLine(175.,25,175+500,500);
ldiagonal->SetLineColor(kGray);
ldiagonal->SetLineStyle(2);
TLatex* tdiagonal = new TLatex(400-2.5, 400-172.5,"m_{#tilde{t}} = m_{t} + m_{#tilde{#chi}_{1}^{0}}");
//tdiagonal->SetTextAngle(TMath::RadToDeg()*TMath::ATan(float(800)/float(500)));
tdiagonal->SetTextAngle(56.31);
tdiagonal->SetTextColor(kGray+2);
tdiagonal->SetTextAlign(11);
tdiagonal->SetTextSize(0.025);
TLine* l2 = new TLine(150,75,585,500);
l2->SetLineColor(kGray);
l2->SetLineStyle(2);
if(killlowdiag){
l2->SetX1(200); l2->SetY1(0); l2->SetX2(600); l2->SetY2(400);
}
TLatex *t2 = new TLatex(300, 300-72.5,"m_{#tilde{t}} = m_{W} + m_{#tilde{#chi}_{1}^{0}}");
//t2->SetTextAngle(TMath::RadToDeg()*TMath::ATan(float(800)/float(500)));
t2->SetTextAngle(56.31);
t2->SetTextColor(kGray+2);
t2->SetTextAlign(11);
t2->SetTextSize(0.025);
hSum->Draw("axis");
gExpR->Draw("c");
gExpL->Draw("c");
gExp->Draw("c");
gObsR->Draw("c");
gObsL->Draw("c");
gObs->Draw("c");
gdiagonal->Draw("FSAME");
ldiagonal->Draw("LSAME");
l2->Draw();
if(!killlowdiag) t2->Draw();
tdiagonal->Draw("SAME");
graphWhite->Draw("FSAME");
graphWhite->Draw("LSAME");
legE->Draw();
legO->Draw();
TLatex* textModelLabel= new TLatex(0.175,0.92,"pp #rightarrow #tilde{t} #tilde{t}*, #tilde{t} #rightarrow t #tilde{#chi}^{0}_{1} NLO+NLL exclusion");
//TLatex* textModelLabel= new TLatex(0.175,0.92,"pp #rightarrow #tilde{t} #tilde{t}*, #tilde{t} #rightarrow t #tilde{#chi}^{0}_{1}");
//TLatex* textModelLabel= new TLatex(0.175,0.92,"#tilde{#chi} ");
textModelLabel->SetNDC();
textModelLabel->SetTextAlign(13);
textModelLabel->SetTextFont(42);
textModelLabel->SetTextSize(0.042);
textModelLabel->Draw();
//final CMS style
TLatex *tLumi = new TLatex(0.95,0.944,"2.3 fb^{-1} (13 TeV)");
tLumi->SetNDC();
tLumi->SetTextAlign(31);
tLumi->SetTextFont(42);
tLumi->SetTextSize(0.042);
tLumi->SetLineWidth(2);
tLumi->Draw();
TLatex *tCMS = new TLatex(0.152,0.944,"CMS");
tCMS->SetNDC();
tCMS->SetTextAlign(11);
tCMS->SetTextFont(61);
tCMS->SetTextSize(0.0525);
tCMS->SetLineWidth(2);
tCMS->Draw();
TLatex *tPrel = new TLatex(0.265,0.944,"Preliminary");
tPrel->SetNDC();
tPrel->SetTextAlign(11);
tPrel->SetTextFont(52);
tPrel->SetTextSize(0.042);
tPrel->SetLineWidth(2);
tPrel->Draw();
c1->Modified();
c1->cd();
c1->Update();
c1->SetSelected(c1);
}
void gyieldsp()
{
//=========Macro generated from canvas: c1/c1
//========= (Fri Jul 31 19:31:43 2015) by ROOT version6.05/01
TCanvas *c1 = new TCanvas("c1", "c1",0,23,600,600);
gStyle->SetOptFit(1);
gStyle->SetOptStat(0);
gStyle->SetOptTitle(0);
c1->Range(0,0,1,1);
c1->SetFillColor(0);
c1->SetBorderMode(0);
c1->SetBorderSize(2);
c1->SetTickx(1);
c1->SetTicky(1);
c1->SetLeftMargin(0.16);
c1->SetRightMargin(0.04);
c1->SetTopMargin(0.08);
c1->SetBottomMargin(0.12);
c1->SetFrameFillStyle(0);
c1->SetFrameBorderMode(0);
// ------------>Primitives in pad: pad1
TPad *pad1 = new TPad("pad1", "pad1",0,0.26,1,1);
pad1->Draw();
pad1->cd();
pad1->Range(-3.5,-6.621622,2.75,158.9189);
pad1->SetFillColor(0);
pad1->SetBorderMode(0);
pad1->SetBorderSize(2);
pad1->SetTickx(1);
pad1->SetTicky(1);
pad1->SetLeftMargin(0.16);
pad1->SetRightMargin(0.04);
pad1->SetTopMargin(0.1142857);
pad1->SetBottomMargin(0.04);
pad1->SetFrameFillStyle(0);
pad1->SetFrameBorderMode(0);
pad1->SetFrameFillStyle(0);
pad1->SetFrameBorderMode(0);
Double_t Graph0_fx3021[10] = {
2.2,
1.75,
1.25,
0.75,
0.25,
-0.25,
-0.75,
-1.25,
-1.75,
-2.2};
Double_t Graph0_fy3021[10] = {
103.56,
105.744,
103.4081,
100.0093,
97.03688,
94.36609,
90.5471,
82.43278,
65.82142,
43.43165};
Double_t Graph0_felx3021[10] = {
0.2,
0.25,
0.25,
0.25,
0.25,
0.25,
0.25,
0.25,
0.25,
0.2};
Double_t Graph0_fely3021[10] = {
7.299733,
7.206486,
6.824632,
6.594841,
6.406375,
6.079494,
5.746822,
5.225105,
4.165823,
2.787035};
Double_t Graph0_fehx3021[10] = {
0.2,
0.25,
0.25,
0.25,
0.25,
0.25,
0.25,
0.25,
0.25,
0.2};
Double_t Graph0_fehy3021[10] = {
5.988963,
6.218694,
6.307709,
6.368316,
5.847823,
5.655323,
5.083818,
4.561256,
3.722445,
2.542957};
TGraphAsymmErrors *grae = new TGraphAsymmErrors(10,Graph0_fx3021,Graph0_fy3021,Graph0_felx3021,Graph0_fehx3021,Graph0_fely3021,Graph0_fehy3021);
grae->SetName("Graph0");
grae->SetTitle("Graph");
Int_t ci; // for color index setting
TColor *color; // for color definition with alpha
ci = TColor::GetColor("#ffff00");
grae->SetFillColor(ci);
ci = TColor::GetColor("#ff0000");
grae->SetLineColor(ci);
grae->SetLineWidth(4);
grae->SetMarkerStyle(20);
grae->SetMarkerSize(0);
TH1F *Graph_Graph3021 = new TH1F("Graph_Graph3021","Graph",100,-2.5,2.5);
Graph_Graph3021->SetMinimum(0);
Graph_Graph3021->SetMaximum(140);
Graph_Graph3021->SetDirectory(0);
Graph_Graph3021->SetStats(0);
Graph_Graph3021->SetLineStyle(0);
Graph_Graph3021->SetMarkerStyle(20);
Graph_Graph3021->GetXaxis()->SetNdivisions(505);
Graph_Graph3021->GetXaxis()->SetLabelFont(42);
Graph_Graph3021->GetXaxis()->SetLabelOffset(0.007);
Graph_Graph3021->GetXaxis()->SetLabelSize(0);
Graph_Graph3021->GetXaxis()->SetTitleSize(0.07142857);
Graph_Graph3021->GetXaxis()->SetTitleOffset(1.1);
Graph_Graph3021->GetXaxis()->SetTitleFont(42);
Graph_Graph3021->GetYaxis()->SetTitle("d#sigma (W^{+}#rightarrow#font[12]{l}^{+}#nu) / d#eta_{lab} [nb]");
Graph_Graph3021->GetYaxis()->SetLabelFont(42);
Graph_Graph3021->GetYaxis()->SetLabelOffset(0.007);
Graph_Graph3021->GetYaxis()->SetLabelSize(0.07142857);
Graph_Graph3021->GetYaxis()->SetTitleSize(0.07142857);
Graph_Graph3021->GetYaxis()->SetTitleOffset(1.05);
Graph_Graph3021->GetYaxis()->SetTitleFont(42);
Graph_Graph3021->GetZaxis()->SetLabelFont(42);
Graph_Graph3021->GetZaxis()->SetLabelOffset(0.007);
Graph_Graph3021->GetZaxis()->SetLabelSize(0.05);
Graph_Graph3021->GetZaxis()->SetTitleSize(0.06);
Graph_Graph3021->GetZaxis()->SetTitleFont(42);
grae->SetHistogram(Graph_Graph3021);
grae->Draw("a2");
Double_t Graph1_fx3022[10] = {
2.2,
1.75,
1.25,
0.75,
0.25,
-0.25,
-0.75,
-1.25,
-1.75,
-2.2};
Double_t Graph1_fy3022[10] = {
103.56,
105.744,
103.4081,
100.0093,
97.03688,
94.36609,
90.5471,
82.43278,
65.82142,
43.43165};
Double_t Graph1_felx3022[10] = {
0.2,
0.25,
0.25,
0.25,
0.25,
0.25,
0.25,
0.25,
0.25,
0.2};
Double_t Graph1_fely3022[10] = {
0,
0,
0,
0,
0,
0,
0,
0,
0,
0};
Double_t Graph1_fehx3022[10] = {
0.2,
0.25,
0.25,
0.25,
0.25,
0.25,
0.25,
0.25,
0.25,
0.2};
Double_t Graph1_fehy3022[10] = {
0,
0,
0,
0,
0,
0,
0,
0,
0,
0};
grae = new TGraphAsymmErrors(10,Graph1_fx3022,Graph1_fy3022,Graph1_felx3022,Graph1_fehx3022,Graph1_fely3022,Graph1_fehy3022);
grae->SetName("Graph1");
grae->SetTitle("Graph");
ci = TColor::GetColor("#ffff00");
grae->SetFillColor(ci);
ci = TColor::GetColor("#ff0000");
grae->SetLineColor(ci);
grae->SetLineWidth(4);
grae->SetMarkerStyle(20);
grae->SetMarkerSize(0);
grae->Draw("z");
Double_t Graph2_fx3023[10] = {
2.2,
1.75,
1.25,
0.75,
0.25,
-0.25,
-0.75,
-1.25,
-1.75,
-2.2};
Double_t Graph2_fy3023[10] = {
91.59545,
95.26883,
95.65156,
95.47892,
95.94693,
96.02597,
93.3635,
84.56484,
65.95871,
42.11706};
Double_t Graph2_felx3023[10] = {
0.2,
0.25,
0.25,
0.25,
0.25,
0.25,
0.25,
0.25,
0.25,
0.2};
Double_t Graph2_fely3023[10] = {
8.336985,
8.261181,
7.634488,
6.438496,
6.661149,
6.164321,
6.1019,
4.954787,
4.773841,
2.599375};
Double_t Graph2_fehx3023[10] = {
0.2,
0.25,
0.25,
0.25,
0.25,
0.25,
0.25,
0.25,
0.25,
0.2};
Double_t Graph2_fehy3023[10] = {
8.262572,
7.14746,
6.62492,
6.725295,
5.946212,
5.838684,
5.077774,
5.257491,
3.443198,
2.602454};
grae = new TGraphAsymmErrors(10,Graph2_fx3023,Graph2_fy3023,Graph2_felx3023,Graph2_fehx3023,Graph2_fely3023,Graph2_fehy3023);
grae->SetName("Graph2");
grae->SetTitle("Graph");
ci = TColor::GetColor("#009900");
grae->SetFillColor(ci);
grae->SetFillStyle(3375);
ci = TColor::GetColor("#009900");
grae->SetLineColor(ci);
grae->SetLineStyle(7);
grae->SetLineWidth(4);
grae->SetMarkerStyle(20);
TH1F *Graph_Graph3023 = new TH1F("Graph_Graph3023","Graph",100,-2.88,2.88);
Graph_Graph3023->SetMinimum(33.22782);
Graph_Graph3023->SetMaximum(108.7062);
Graph_Graph3023->SetDirectory(0);
Graph_Graph3023->SetStats(0);
Graph_Graph3023->SetLineStyle(0);
Graph_Graph3023->SetMarkerStyle(20);
Graph_Graph3023->GetXaxis()->SetLabelFont(42);
Graph_Graph3023->GetXaxis()->SetLabelOffset(0.007);
Graph_Graph3023->GetXaxis()->SetLabelSize(0.05);
Graph_Graph3023->GetXaxis()->SetTitleSize(0.06);
Graph_Graph3023->GetXaxis()->SetTitleOffset(1.1);
Graph_Graph3023->GetXaxis()->SetTitleFont(42);
Graph_Graph3023->GetYaxis()->SetLabelFont(42);
Graph_Graph3023->GetYaxis()->SetLabelOffset(0.007);
Graph_Graph3023->GetYaxis()->SetLabelSize(0.05);
Graph_Graph3023->GetYaxis()->SetTitleSize(0.06);
Graph_Graph3023->GetYaxis()->SetTitleOffset(1.5);
Graph_Graph3023->GetYaxis()->SetTitleFont(42);
Graph_Graph3023->GetZaxis()->SetLabelFont(42);
Graph_Graph3023->GetZaxis()->SetLabelOffset(0.007);
Graph_Graph3023->GetZaxis()->SetLabelSize(0.05);
Graph_Graph3023->GetZaxis()->SetTitleSize(0.06);
Graph_Graph3023->GetZaxis()->SetTitleFont(42);
grae->SetHistogram(Graph_Graph3023);
grae->Draw("2");
Double_t Graph3_fx3024[10] = {
2.2,
1.75,
1.25,
0.75,
0.25,
-0.25,
-0.75,
-1.25,
-1.75,
-2.2};
Double_t Graph3_fy3024[10] = {
91.59545,
95.26883,
95.65156,
95.47892,
95.94693,
96.02597,
93.3635,
84.56484,
65.95871,
42.11706};
Double_t Graph3_felx3024[10] = {
0.2,
0.25,
0.25,
0.25,
0.25,
0.25,
0.25,
0.25,
0.25,
0.2};
Double_t Graph3_fely3024[10] = {
0,
0,
0,
0,
0,
0,
0,
0,
0,
0};
Double_t Graph3_fehx3024[10] = {
0.2,
0.25,
0.25,
0.25,
0.25,
0.25,
0.25,
0.25,
0.25,
0.2};
Double_t Graph3_fehy3024[10] = {
0,
0,
0,
0,
0,
0,
0,
0,
0,
0};
grae = new TGraphAsymmErrors(10,Graph3_fx3024,Graph3_fy3024,Graph3_felx3024,Graph3_fehx3024,Graph3_fely3024,Graph3_fehy3024);
grae->SetName("Graph3");
grae->SetTitle("Graph");
ci = TColor::GetColor("#009900");
grae->SetFillColor(ci);
grae->SetFillStyle(3375);
ci = TColor::GetColor("#009900");
grae->SetLineColor(ci);
grae->SetLineStyle(7);
grae->SetLineWidth(4);
grae->SetMarkerStyle(20);
grae->Draw("z");
Double_t Graph4_fx1011[10] = {
2.2,
1.75,
1.25,
0.75,
0.25,
-0.25,
-0.75,
-1.25,
-1.75,
-2.2};
Double_t Graph4_fy1011[10] = {
108.0732,
102.2597,
100.2246,
101.796,
105.3416,
99.73788,
98.62062,
85.94448,
62.90271,
44.47931};
Double_t Graph4_fex1011[10] = {
0,
0,
0,
0,
0,
0,
0,
0,
0,
0};
Double_t Graph4_fey1011[10] = {
6.667786,
4.792637,
3.765295,
3.224798,
3.479167,
3.377478,
3.07273,
3.40604,
2.800731,
2.87761};
TGraphErrors *gre = new TGraphErrors(10,Graph4_fx1011,Graph4_fy1011,Graph4_fex1011,Graph4_fey1011);
gre->SetName("Graph4");
gre->SetTitle("Graph");
gre->SetFillColor(1);
gre->SetFillStyle(0);
gre->SetLineWidth(2);
gre->SetMarkerStyle(20);
gre->Draw("||");
Double_t gyieldsp_exp_statonly_1_fx1012[10] = {
2.2,
1.75,
1.25,
0.75,
0.25,
-0.25,
-0.75,
-1.25,
-1.75,
-2.2};
Double_t gyieldsp_exp_statonly_1_fy1012[10] = {
108.0732,
102.2597,
100.2246,
101.796,
105.3416,
99.73788,
98.62062,
85.94448,
62.90271,
44.47931};
Double_t gyieldsp_exp_statonly_1_fex1012[10] = {
0,
0,
0,
0,
0,
0,
0,
0,
0,
0};
Double_t gyieldsp_exp_statonly_1_fey1012[10] = {
2.814265,
2.293805,
2.181326,
2.056934,
2.054972,
2.059018,
2.050204,
2.01317,
1.754638,
1.667829};
gre = new TGraphErrors(10,gyieldsp_exp_statonly_1_fx1012,gyieldsp_exp_statonly_1_fy1012,gyieldsp_exp_statonly_1_fex1012,gyieldsp_exp_statonly_1_fey1012);
gre->SetName("gyieldsp_exp_statonly_1");
gre->SetTitle("Graph");
gre->SetFillColor(1);
gre->SetLineWidth(2);
gre->SetMarkerStyle(20);
gre->SetMarkerSize(1.2);
TH1F *Graph_gyieldsp_exp_statonly_11012 = new TH1F("Graph_gyieldsp_exp_statonly_11012","Graph",100,-2.64,2.64);
Graph_gyieldsp_exp_statonly_11012->SetMinimum(36.00388);
Graph_gyieldsp_exp_statonly_11012->SetMaximum(117.6951);
Graph_gyieldsp_exp_statonly_11012->SetDirectory(0);
Graph_gyieldsp_exp_statonly_11012->SetStats(0);
Graph_gyieldsp_exp_statonly_11012->SetLineStyle(0);
Graph_gyieldsp_exp_statonly_11012->SetMarkerStyle(20);
Graph_gyieldsp_exp_statonly_11012->GetXaxis()->SetLabelFont(42);
Graph_gyieldsp_exp_statonly_11012->GetXaxis()->SetLabelOffset(0.007);
Graph_gyieldsp_exp_statonly_11012->GetXaxis()->SetLabelSize(0.05);
Graph_gyieldsp_exp_statonly_11012->GetXaxis()->SetTitleSize(0.06);
Graph_gyieldsp_exp_statonly_11012->GetXaxis()->SetTitleOffset(1.1);
Graph_gyieldsp_exp_statonly_11012->GetXaxis()->SetTitleFont(42);
Graph_gyieldsp_exp_statonly_11012->GetYaxis()->SetLabelFont(42);
Graph_gyieldsp_exp_statonly_11012->GetYaxis()->SetLabelOffset(0.007);
Graph_gyieldsp_exp_statonly_11012->GetYaxis()->SetLabelSize(0.05);
Graph_gyieldsp_exp_statonly_11012->GetYaxis()->SetTitleSize(0.06);
Graph_gyieldsp_exp_statonly_11012->GetYaxis()->SetTitleOffset(1.5);
Graph_gyieldsp_exp_statonly_11012->GetYaxis()->SetTitleFont(42);
Graph_gyieldsp_exp_statonly_11012->GetZaxis()->SetLabelFont(42);
Graph_gyieldsp_exp_statonly_11012->GetZaxis()->SetLabelOffset(0.007);
Graph_gyieldsp_exp_statonly_11012->GetZaxis()->SetLabelSize(0.05);
Graph_gyieldsp_exp_statonly_11012->GetZaxis()->SetTitleSize(0.06);
Graph_gyieldsp_exp_statonly_11012->GetZaxis()->SetTitleFont(42);
gre->SetHistogram(Graph_gyieldsp_exp_statonly_11012);
gre->Draw("pz");
TLegend *leg = new TLegend(0.6,0.1,0.9,0.3142857,NULL,"brNDC");
leg->SetBorderSize(0);
leg->SetTextSize(0.05714286);
leg->SetLineColor(1);
leg->SetLineStyle(1);
leg->SetLineWidth(1);
leg->SetFillColor(0);
leg->SetFillStyle(1001);
TLegendEntry *entry=leg->AddEntry("Graph4","Data","p");
entry->SetLineColor(1);
entry->SetLineStyle(1);
entry->SetLineWidth(1);
entry->SetMarkerColor(1);
entry->SetMarkerStyle(20);
entry->SetMarkerSize(1);
entry->SetTextFont(42);
entry=leg->AddEntry("Graph0","CT10","lf");
ci = TColor::GetColor("#ffff00");
entry->SetFillColor(ci);
entry->SetFillStyle(1001);
ci = TColor::GetColor("#ff0000");
entry->SetLineColor(ci);
entry->SetLineStyle(1);
entry->SetLineWidth(4);
entry->SetMarkerColor(1);
entry->SetMarkerStyle(21);
entry->SetMarkerSize(1);
entry->SetTextFont(42);
entry=leg->AddEntry("Graph2","CT10+EPS09","lf");
ci = TColor::GetColor("#009900");
entry->SetFillColor(ci);
entry->SetFillStyle(3375);
ci = TColor::GetColor("#009900");
entry->SetLineColor(ci);
entry->SetLineStyle(7);
entry->SetLineWidth(4);
entry->SetMarkerColor(1);
entry->SetMarkerStyle(21);
entry->SetMarkerSize(1);
entry->SetTextFont(42);
leg->Draw();
TPaveText *pt = new TPaveText(-2.35,125,-0.35,140,"br");
pt->SetBorderSize(0);
pt->SetFillColor(0);
pt->SetFillStyle(0);
pt->SetTextAlign(13);
pt->SetTextFont(42);
pt->SetTextSize(0.05714286);
TText *AText = pt->AddText("Luminosity uncertainty: 3.5%");
pt->Draw();
pt = new TPaveText(0.27,0.2,0.5,0.3428571,"brNDC");
pt->SetBorderSize(0);
pt->SetFillColor(0);
pt->SetFillStyle(0);
pt->SetTextAlign(13);
pt->SetTextFont(42);
pt->SetTextSize(0.05714286);
AText = pt->AddText("W^{+} #rightarrow #font[12]{l}^{+} + #nu");
AText = pt->AddText("p_{T}^{#font[12]{l}} > 25 GeV/c");
pt->Draw();
tex = new TLatex(0.96,0.9177143," #sqrt{s_{NN}} = 5.02 TeV");
tex->SetNDC();
tex->SetTextAlign(31);
tex->SetTextFont(42);
tex->SetTextSize(0.05714286);
tex->SetLineWidth(2);
tex->Draw();
tex = new TLatex(0.16,0.9177143,"pPb 34.6 nb^{-1}");
tex->SetNDC();
tex->SetTextFont(42);
tex->SetTextSize(0.05714286);
tex->SetLineWidth(2);
tex->Draw();
tex = new TLatex(0.924,0.8476571,"CMS");
tex->SetNDC();
tex->SetTextAlign(33);
tex->SetTextFont(61);
tex->SetTextSize(0.06857143);
tex->SetLineWidth(2);
tex->Draw();
TH1F *Graph_copy = new TH1F("Graph_copy","Graph",100,-2.5,2.5);
Graph_copy->SetMinimum(0);
Graph_copy->SetMaximum(140);
Graph_copy->SetDirectory(0);
Graph_copy->SetStats(0);
Graph_copy->SetLineStyle(0);
Graph_copy->SetMarkerStyle(20);
Graph_copy->GetXaxis()->SetNdivisions(505);
Graph_copy->GetXaxis()->SetLabelFont(42);
Graph_copy->GetXaxis()->SetLabelOffset(0.007);
Graph_copy->GetXaxis()->SetLabelSize(0);
Graph_copy->GetXaxis()->SetTitleSize(0.07142857);
Graph_copy->GetXaxis()->SetTitleOffset(1.1);
Graph_copy->GetXaxis()->SetTitleFont(42);
Graph_copy->GetYaxis()->SetTitle("d#sigma (W^{+}#rightarrow#font[12]{l}^{+}#nu) / d#eta_{lab} [nb]");
Graph_copy->GetYaxis()->SetLabelFont(42);
Graph_copy->GetYaxis()->SetLabelOffset(0.007);
Graph_copy->GetYaxis()->SetLabelSize(0.07142857);
Graph_copy->GetYaxis()->SetTitleSize(0.07142857);
Graph_copy->GetYaxis()->SetTitleOffset(1.05);
Graph_copy->GetYaxis()->SetTitleFont(42);
Graph_copy->GetZaxis()->SetLabelFont(42);
Graph_copy->GetZaxis()->SetLabelOffset(0.007);
Graph_copy->GetZaxis()->SetLabelSize(0.05);
Graph_copy->GetZaxis()->SetTitleSize(0.06);
Graph_copy->GetZaxis()->SetTitleFont(42);
Graph_copy->Draw("sameaxis");
pad1->Modified();
c1->cd();
// ------------>Primitives in pad: pad2
TPad *pad2 = new TPad("pad2", "pad2",0,0,1,0.288);
pad2->Draw();
pad2->cd();
pad2->Range(-3.5,0.35,2.75,1.35);
pad2->SetFillColor(0);
pad2->SetFillStyle(4000);
pad2->SetBorderMode(0);
pad2->SetBorderSize(2);
pad2->SetTickx(1);
pad2->SetTicky(1);
pad2->SetLeftMargin(0.16);
pad2->SetRightMargin(0.04);
pad2->SetTopMargin(0);
pad2->SetBottomMargin(0.4);
pad2->SetFrameFillStyle(4000);
pad2->SetFrameBorderMode(0);
pad2->SetFrameFillStyle(4000);
pad2->SetFrameBorderMode(0);
TH1F *Graph = new TH1F("Graph","Graph",100,-2.5,2.5);
Graph->SetMinimum(0.75);
Graph->SetMaximum(1.35);
Graph->SetDirectory(0);
Graph->SetStats(0);
Graph->SetLineStyle(0);
Graph->SetMarkerStyle(20);
Graph->GetXaxis()->SetTitle("#eta_{lab}");
Graph->GetXaxis()->SetNdivisions(505);
Graph->GetXaxis()->SetLabelFont(42);
Graph->GetXaxis()->SetLabelOffset(0.007);
Graph->GetXaxis()->SetLabelSize(0.1666667);
Graph->GetXaxis()->SetTitleSize(0.1666667);
Graph->GetXaxis()->SetTitleOffset(1.1);
Graph->GetXaxis()->SetTitleFont(42);
Graph->GetYaxis()->SetTitle("Ratio ");
Graph->GetYaxis()->SetNdivisions(503);
Graph->GetYaxis()->SetLabelFont(42);
Graph->GetYaxis()->SetLabelOffset(0.007);
Graph->GetYaxis()->SetLabelSize(0.1666667);
Graph->GetYaxis()->SetTitleSize(0.1666667);
Graph->GetYaxis()->SetTitleOffset(0.45);
Graph->GetYaxis()->SetTitleFont(42);
Graph->GetZaxis()->SetLabelFont(42);
Graph->GetZaxis()->SetLabelOffset(0.007);
Graph->GetZaxis()->SetLabelSize(0.05);
Graph->GetZaxis()->SetTitleSize(0.06);
Graph->GetZaxis()->SetTitleFont(42);
Graph->Draw("");
Double_t Graph0_fx1013[10] = {
2.2,
1.75,
1.25,
0.75,
0.25,
-0.25,
-0.75,
-1.25,
-1.75,
-2.2};
Double_t Graph0_fy1013[10] = {
1,
1,
1,
1,
1,
1,
1,
1,
1,
1};
Double_t Graph0_fex1013[10] = {
0.2,
0.25,
0.25,
0.25,
0.25,
0.25,
0.25,
0.25,
0.25,
0.2};
Double_t Graph0_fey1013[10] = {
0.0644708,
0.06365122,
0.06354681,
0.06481966,
0.06320752,
0.0622177,
0.05991862,
0.05949606,
0.06001632,
0.06142499};
gre = new TGraphErrors(10,Graph0_fx1013,Graph0_fy1013,Graph0_fex1013,Graph0_fey1013);
gre->SetName("Graph0");
gre->SetTitle("Graph");
ci = TColor::GetColor("#ffff00");
gre->SetFillColor(ci);
ci = TColor::GetColor("#ff0000");
gre->SetLineColor(ci);
gre->SetLineWidth(4);
gre->SetMarkerStyle(20);
gre->SetMarkerSize(0);
TH1F *Graph_Graph1013 = new TH1F("Graph_Graph1013","Graph",100,-2.88,2.88);
Graph_Graph1013->SetMinimum(0.9222164);
Graph_Graph1013->SetMaximum(1.077784);
Graph_Graph1013->SetDirectory(0);
Graph_Graph1013->SetStats(0);
Graph_Graph1013->SetLineStyle(0);
Graph_Graph1013->SetMarkerStyle(20);
Graph_Graph1013->GetXaxis()->SetLabelFont(42);
Graph_Graph1013->GetXaxis()->SetLabelOffset(0.007);
Graph_Graph1013->GetXaxis()->SetLabelSize(0.05);
Graph_Graph1013->GetXaxis()->SetTitleSize(0.06);
Graph_Graph1013->GetXaxis()->SetTitleOffset(1.1);
Graph_Graph1013->GetXaxis()->SetTitleFont(42);
Graph_Graph1013->GetYaxis()->SetLabelFont(42);
Graph_Graph1013->GetYaxis()->SetLabelOffset(0.007);
Graph_Graph1013->GetYaxis()->SetLabelSize(0.05);
Graph_Graph1013->GetYaxis()->SetTitleSize(0.06);
Graph_Graph1013->GetYaxis()->SetTitleOffset(1.5);
Graph_Graph1013->GetYaxis()->SetTitleFont(42);
Graph_Graph1013->GetZaxis()->SetLabelFont(42);
Graph_Graph1013->GetZaxis()->SetLabelOffset(0.007);
Graph_Graph1013->GetZaxis()->SetLabelSize(0.05);
Graph_Graph1013->GetZaxis()->SetTitleSize(0.06);
Graph_Graph1013->GetZaxis()->SetTitleFont(42);
gre->SetHistogram(Graph_Graph1013);
gre->Draw("2");
Double_t Graph1_fx1014[10] = {
2.2,
1.75,
1.25,
0.75,
0.25,
-0.25,
-0.75,
-1.25,
-1.75,
-2.2};
Double_t Graph1_fy1014[10] = {
1,
1,
1,
1,
1,
1,
1,
1,
1,
1};
Double_t Graph1_fex1014[10] = {
0.2,
0.25,
0.25,
0.25,
0.25,
0.25,
0.25,
0.25,
0.25,
0.2};
Double_t Graph1_fey1014[10] = {
0,
0,
0,
0,
0,
0,
0,
0,
0,
0};
gre = new TGraphErrors(10,Graph1_fx1014,Graph1_fy1014,Graph1_fex1014,Graph1_fey1014);
gre->SetName("Graph1");
gre->SetTitle("Graph");
ci = TColor::GetColor("#ffff00");
gre->SetFillColor(ci);
ci = TColor::GetColor("#ff0000");
gre->SetLineColor(ci);
gre->SetLineWidth(4);
gre->SetMarkerStyle(20);
gre->SetMarkerSize(0);
gre->Draw("z");
Double_t Graph2_fx1015[10] = {
2.2,
1.75,
1.25,
0.75,
0.25,
-0.25,
-0.75,
-1.25,
-1.75,
-2.2};
Double_t Graph2_fy1015[10] = {
0.8844678,
0.9009383,
0.9249909,
0.9547005,
0.9887677,
1.01759,
1.031104,
1.025864,
1.002086,
0.9697318};
Double_t Graph2_fex1015[10] = {
0.2,
0.25,
0.25,
0.25,
0.25,
0.25,
0.25,
0.25,
0.25,
0.2};
Double_t Graph2_fey1015[10] = {
0.05296218,
0.042007,
0.03326947,
0.02116912,
0.0170915,
0.01890429,
0.01672622,
0.01681633,
0.01541551,
0.01597539};
gre = new TGraphErrors(10,Graph2_fx1015,Graph2_fy1015,Graph2_fex1015,Graph2_fey1015);
gre->SetName("Graph2");
gre->SetTitle("Graph");
ci = TColor::GetColor("#009900");
gre->SetFillColor(ci);
gre->SetFillStyle(3375);
ci = TColor::GetColor("#009900");
gre->SetLineColor(ci);
gre->SetLineStyle(7);
gre->SetLineWidth(4);
gre->SetMarkerStyle(20);
TH1F *Graph_Graph1015 = new TH1F("Graph_Graph1015","Graph",100,-2.88,2.88);
Graph_Graph1015->SetMinimum(0.8098732);
Graph_Graph1015->SetMaximum(1.069463);
Graph_Graph1015->SetDirectory(0);
Graph_Graph1015->SetStats(0);
Graph_Graph1015->SetLineStyle(0);
Graph_Graph1015->SetMarkerStyle(20);
Graph_Graph1015->GetXaxis()->SetLabelFont(42);
Graph_Graph1015->GetXaxis()->SetLabelOffset(0.007);
Graph_Graph1015->GetXaxis()->SetLabelSize(0.05);
Graph_Graph1015->GetXaxis()->SetTitleSize(0.06);
Graph_Graph1015->GetXaxis()->SetTitleOffset(1.1);
Graph_Graph1015->GetXaxis()->SetTitleFont(42);
Graph_Graph1015->GetYaxis()->SetLabelFont(42);
Graph_Graph1015->GetYaxis()->SetLabelOffset(0.007);
Graph_Graph1015->GetYaxis()->SetLabelSize(0.05);
Graph_Graph1015->GetYaxis()->SetTitleSize(0.06);
Graph_Graph1015->GetYaxis()->SetTitleOffset(1.5);
Graph_Graph1015->GetYaxis()->SetTitleFont(42);
Graph_Graph1015->GetZaxis()->SetLabelFont(42);
Graph_Graph1015->GetZaxis()->SetLabelOffset(0.007);
Graph_Graph1015->GetZaxis()->SetLabelSize(0.05);
Graph_Graph1015->GetZaxis()->SetTitleSize(0.06);
Graph_Graph1015->GetZaxis()->SetTitleFont(42);
gre->SetHistogram(Graph_Graph1015);
gre->Draw("2");
Double_t Graph3_fx1016[10] = {
2.2,
1.75,
1.25,
0.75,
0.25,
-0.25,
-0.75,
-1.25,
-1.75,
-2.2};
Double_t Graph3_fy1016[10] = {
0.8844678,
0.9009383,
0.9249909,
0.9547005,
0.9887677,
1.01759,
1.031104,
1.025864,
1.002086,
0.9697318};
Double_t Graph3_fex1016[10] = {
0.2,
0.25,
0.25,
0.25,
0.25,
0.25,
0.25,
0.25,
0.25,
0.2};
Double_t Graph3_fey1016[10] = {
0,
0,
0,
0,
0,
0,
0,
0,
0,
0};
gre = new TGraphErrors(10,Graph3_fx1016,Graph3_fy1016,Graph3_fex1016,Graph3_fey1016);
gre->SetName("Graph3");
gre->SetTitle("Graph");
ci = TColor::GetColor("#009900");
gre->SetFillColor(ci);
gre->SetFillStyle(3375);
ci = TColor::GetColor("#009900");
gre->SetLineColor(ci);
gre->SetLineStyle(7);
gre->SetLineWidth(4);
gre->SetMarkerStyle(20);
gre->Draw("z");
Double_t Graph4_fx1017[10] = {
2.2,
1.75,
1.25,
0.75,
0.25,
-0.25,
-0.75,
-1.25,
-1.75,
-2.2};
Double_t Graph4_fy1017[10] = {
1.043581,
0.9670498,
0.9692137,
1.017865,
1.085583,
1.056925,
1.089164,
1.042601,
0.9556571,
1.024122};
Double_t Graph4_fex1017[10] = {
0,
0,
0,
0,
0,
0,
0,
0,
0,
0};
Double_t Graph4_fey1017[10] = {
0.06438575,
0.04532301,
0.03641199,
0.03224499,
0.03585407,
0.03579123,
0.03393516,
0.041319,
0.04255045,
0.06625605};
gre = new TGraphErrors(10,Graph4_fx1017,Graph4_fy1017,Graph4_fex1017,Graph4_fey1017);
gre->SetName("Graph4");
gre->SetTitle("Graph");
gre->SetFillColor(1);
gre->SetFillStyle(0);
gre->SetLineWidth(2);
gre->SetMarkerStyle(20);
gre->Draw("||");
Double_t Graph5_fx1018[10] = {
2.2,
1.75,
1.25,
0.75,
0.25,
-0.25,
-0.75,
-1.25,
-1.75,
-2.2};
Double_t Graph5_fy1018[10] = {
1.043581,
0.9670498,
0.9692137,
1.017865,
1.085583,
1.056925,
1.089164,
1.042601,
0.9556571,
1.024122};
Double_t Graph5_fex1018[10] = {
0,
0,
0,
0,
0,
0,
0,
0,
0,
0};
Double_t Graph5_fey1018[10] = {
0.02717523,
0.02169205,
0.02109434,
0.02056743,
0.02117723,
0.02181947,
0.02264241,
0.02442196,
0.02665755,
0.03840124};
gre = new TGraphErrors(10,Graph5_fx1018,Graph5_fy1018,Graph5_fex1018,Graph5_fey1018);
gre->SetName("Graph5");
gre->SetTitle("Graph");
gre->SetFillColor(1);
gre->SetLineWidth(2);
gre->SetMarkerStyle(20);
TH1F *Graph_Graph1018 = new TH1F("Graph_Graph1018","Graph",100,-2.64,2.64);
Graph_Graph1018->SetMinimum(0.9107189);
Graph_Graph1018->SetMaximum(1.130087);
Graph_Graph1018->SetDirectory(0);
Graph_Graph1018->SetStats(0);
Graph_Graph1018->SetLineStyle(0);
Graph_Graph1018->SetMarkerStyle(20);
Graph_Graph1018->GetXaxis()->SetLabelFont(42);
Graph_Graph1018->GetXaxis()->SetLabelOffset(0.007);
Graph_Graph1018->GetXaxis()->SetLabelSize(0.05);
Graph_Graph1018->GetXaxis()->SetTitleSize(0.06);
Graph_Graph1018->GetXaxis()->SetTitleOffset(1.1);
Graph_Graph1018->GetXaxis()->SetTitleFont(42);
Graph_Graph1018->GetYaxis()->SetLabelFont(42);
Graph_Graph1018->GetYaxis()->SetLabelOffset(0.007);
Graph_Graph1018->GetYaxis()->SetLabelSize(0.05);
Graph_Graph1018->GetYaxis()->SetTitleSize(0.06);
Graph_Graph1018->GetYaxis()->SetTitleOffset(1.5);
Graph_Graph1018->GetYaxis()->SetTitleFont(42);
Graph_Graph1018->GetZaxis()->SetLabelFont(42);
Graph_Graph1018->GetZaxis()->SetLabelOffset(0.007);
Graph_Graph1018->GetZaxis()->SetLabelSize(0.05);
Graph_Graph1018->GetZaxis()->SetTitleSize(0.06);
Graph_Graph1018->GetZaxis()->SetTitleFont(42);
gre->SetHistogram(Graph_Graph1018);
gre->Draw("pz");
TH1F *Graph_copy = new TH1F("Graph_copy","Graph",100,-2.5,2.5);
Graph_copy->SetMinimum(0.75);
Graph_copy->SetMaximum(1.35);
Graph_copy->SetDirectory(0);
Graph_copy->SetStats(0);
Graph_copy->SetLineStyle(0);
Graph_copy->SetMarkerStyle(20);
Graph_copy->GetXaxis()->SetTitle("#eta_{lab}");
Graph_copy->GetXaxis()->SetNdivisions(505);
Graph_copy->GetXaxis()->SetLabelFont(42);
Graph_copy->GetXaxis()->SetLabelOffset(0.007);
Graph_copy->GetXaxis()->SetLabelSize(0.1666667);
Graph_copy->GetXaxis()->SetTitleSize(0.1666667);
Graph_copy->GetXaxis()->SetTitleOffset(1.1);
Graph_copy->GetXaxis()->SetTitleFont(42);
Graph_copy->GetYaxis()->SetTitle("Ratio ");
Graph_copy->GetYaxis()->SetNdivisions(503);
Graph_copy->GetYaxis()->SetLabelFont(42);
Graph_copy->GetYaxis()->SetLabelOffset(0.007);
Graph_copy->GetYaxis()->SetLabelSize(0.1666667);
Graph_copy->GetYaxis()->SetTitleSize(0.1666667);
Graph_copy->GetYaxis()->SetTitleOffset(0.45);
Graph_copy->GetYaxis()->SetTitleFont(42);
Graph_copy->GetZaxis()->SetLabelFont(42);
Graph_copy->GetZaxis()->SetLabelOffset(0.007);
Graph_copy->GetZaxis()->SetLabelSize(0.05);
Graph_copy->GetZaxis()->SetTitleSize(0.06);
Graph_copy->GetZaxis()->SetTitleFont(42);
Graph_copy->Draw("sameaxis");
pad2->Modified();
c1->cd();
c1->Modified();
c1->cd();
c1->SetSelected(c1);
}
int ListMaxRes(int start=0,int num=1){
const int NumOfFiles =60;
if (start + num > NumOfFiles ){
cout<<"Only have "<<NumOfFiles <<" files"<<endl;
}
std::string list[]={"FL3FG0d2w0run-0324--softwareCFD.root",
"FL3FG0d2w10run-0324--softwareCFD.root",
"FL3FG0d2w20run-0324--softwareCFD.root",
"FL3FG0d2w30run-0324--softwareCFD.root",
"FL3FG0d2w40run-0324--softwareCFD.root",
"FL3FG0d3w0run-0324--softwareCFD.root",
"FL3FG0d3w10run-0324--softwareCFD.root",
"FL3FG0d3w20run-0324--softwareCFD.root",
"FL3FG0d3w30run-0324--softwareCFD.root",
"FL3FG0d3w40run-0324--softwareCFD.root",
"FL3FG1d2w0run-0324--softwareCFD.root",
"FL3FG1d2w10run-0324--softwareCFD.root",
"FL3FG1d2w20run-0324--softwareCFD.root",
"FL3FG1d2w30run-0324--softwareCFD.root",
"FL3FG1d2w40run-0324--softwareCFD.root",
"FL3FG1d3w0run-0324--softwareCFD.root",
"FL3FG1d3w10run-0324--softwareCFD.root",
"FL3FG1d3w20run-0324--softwareCFD.root",
"FL3FG1d3w30run-0324--softwareCFD.root",
"FL4FG0d2w0run-0324--softwareCFD.root",
"FL4FG0d2w30run-0324--softwareCFD.root",
"FL4FG0d3w0run-0324--softwareCFD.root",
"FL4FG0d3w10run-0324--softwareCFD.root",
"FL4FG0d3w20run-0324--softwareCFD.root",
"FL4FG0d3w30run-0324--softwareCFD.root",
"FL4FG0d3w40run-0324--softwareCFD.root",
"FL4FG1d2w0run-0324--softwareCFD.root",
"FL4FG1d2w10run-0324--softwareCFD.root",
"FL4FG1d2w20run-0324--softwareCFD.root",
"FL4FG1d2w30run-0324--softwareCFD.root",
"FL4FG1d3w0run-0324--softwareCFD.root",
"FL4FG1d3w10run-0324--softwareCFD.root",
"FL4FG1d3w20run-0324--softwareCFD.root",
"FL4FG1d3w30run-0324--softwareCFD.root",
"FL4FG1d3w40run-0324--softwareCFD.root",
"FL5FG0d2w0run-0324--softwareCFD.root",
"FL5FG0d2w10run-0324--softwareCFD.root",
"FL5FG0d2w20run-0324--softwareCFD.root",
"FL5FG0d2w30run-0324--softwareCFD.root",
"FL5FG0d2w40run-0324--softwareCFD.root",
"FL5FG0d3w0run-0324--softwareCFD.root",
"FL5FG0d3w20run-0324--softwareCFD.root",
"FL5FG0d3w40run-0324--softwareCFD.root",
"FL5FG1d2w0run-0324--softwareCFD.root"};
TCanvas *c = new TCanvas("c");
c->cd(1);
for (int i=start;i<start+num;i++){
const char * stupid = list[i].c_str();
TFile f(stupid);
TH1F * h = new TH1F("h","h",100,0.1,0.6);
TTree *flt = (TTree*)f.Get("flt");
flt->Project("h","softTimes[0]-softTimes[1]+0.617706*GOE",
"NumOfChannelsInEvent==2&&channels[0]==0&&abs(GOE)<0.6&&softwareCFDs[0]>0 && softwareCFDs[1]>0 && energies[0]>2600 && energies[0]<3600 &&energies[1]>2600&& energies[1]<3600");
h->SetDirectory(0);
TFitResultPtr p = h->Fit("gaus","QSN");
int status = p;
if (status==0)
cout<<"The file is "<<stupid<<" "<<p->Value(2)*2.35*10000<<endl;
}
return 0;
}
int main(int argc, char* argv[]){
UImanager uimanager(argc, argv, "dndt_fit");
//work directory
TString workdir(getenv("WORKDIR"));
//***************************set constant ****************************************
Double_t acdntl_corr = 1., respf_corr = 1.;
Double_t eff_corr = uimanager.get_adcerr() * uimanager.get_br_corr() * uimanager.get_ta_corr() * acdntl_corr * respf_corr;// adcerr x tdiff_cut_eff x veto_eff x pi0 decay products abs. (set to 1, since included in current rmat) x bkg_in_fit (not in current rmat)
if(uimanager.best_tdiff()) eff_corr *= uimanager.get_bit_corr();
if(uimanager.ismc()) eff_corr = uimanager.get_ta_corr();
cout << eff_corr << " " << uimanager.flux() << " " << uimanager.get_tgt_lumi() << endl;
Double_t f_l = uimanager.flux() * uimanager.get_tgt_lumi() * eff_corr;
//************ start reading files *******************************
//read tables/eflux.dat [tables/effcor.dat] tables/dfp1_xx.dat or current_foler/dfp1_xx.dat
//get echn flux
Double_t flw[180];
ifstream eflux(workdir+"tables/eflux.dat");
if (!eflux.is_open()) {
cout << "eflux doesn't exist" << endl;
exit(1);
}
for(int i=0;i<180;i++)eflux>>flw[i];
//get efficiency table
TString dfp;
if (!uimanager.target()) dfp = Form("dfp%d", int(uimanager.isouter())) + uimanager.input_filename("mc") + "_si.dat";
else dfp = Form("dfp%d", int(uimanager.isouter())) + uimanager.input_filename("mc") + "_c12.dat";
ifstream profile;
profile.open(dfp);
if (profile.is_open()) {
cout << "use local efficiency table: " << dfp << endl;
} else {
//profile.open(workdir+"efficiency2/tables/"+dfp);
profile.open(workdir+"/tables/"+dfp);
if(!profile.is_open()) cout << " can't open table " << dfp << endl;
cout << " use efficiency table in tables: " << dfp << endl;
}
const int phy = 5;
const int ech = 180;
Double_t dfprob[phy][nangle][ech];
Double_t coulm[nangle], ncohe[nangle], cosfiint[nangle], sinfiint[nangle], ninco[nangle];
for(int i=0;i<nangle;i++){
coulm[i]=0;
ncohe[i]=0;
cosfiint[i]=0;
sinfiint[i]=0;
ninco[i]=0;
}
for(int i = 0;i < 180;i++)
for(int j = 0;j < nangle;j++)
for(int k = 0;k < 5;k++){
Double_t f_l_j=f_l;
int ic = 0;
int jc = 0;
int kc = 0;
profile>>ic>>jc>>kc>>dfprob[k][j][i];
if(ic!=i+1||jc!=j+1||kc!=k+1){
cout << i << " " << j << " " << k << endl;
cout << ic << " " << jc << " " << kc << " " << dfprob[k][j][i] << endl;
cout<<"Bad data given for dfprob"<<endl;
exit(1);
}
if(kc==1)coulm[j]+=flw[i]*dfprob[k][j][i]*f_l_j;
else if(kc==2)cosfiint[j]+=flw[i]*dfprob[k][j][i]*f_l_j;
else if(kc==3)ncohe[j]+=flw[i]*dfprob[k][j][i]*f_l_j;
else if(kc==4)ninco[j]+=flw[i]*dfprob[k][j][i]*f_l_j;
else sinfiint[j]+=flw[i]*dfprob[k][j][i]*f_l_j;
}
for(int i=1;i<=nangle;i++){
hcoulm->SetBinContent(i,coulm[i-1]);
hcosfiint->SetBinContent(i,cosfiint[i-1]);
hncohe->SetBinContent(i,ncohe[i-1]);
hninco->SetBinContent(i,ninco[i-1]);
hsinfiint->SetBinContent(i,sinfiint[i-1]);
}
//read yield
TString inrootname("pi0alt" + uimanager.input_filename("fit") + ".root");
TFile *yield = new TFile(inrootname);
if (!yield->IsOpen()) exit(open_err(inrootname));
TH1F *yieldhist = (TH1F*)yield->Get("hyield");
//TH1F *yieldhist = (TH1F*)yield->Get("hyield_mc_nocut");
yieldhist->SetDirectory(0);
if (!uimanager.target() && !uimanager.isouter()) yieldhist->SetTitle("#pi^{0} yield (Si, crystal w/o tran.)");
else if (!uimanager.target()) yieldhist->SetTitle("#pi^{0} yield (Si, crystal w/ tran.)");
else if (!uimanager.isouter()) yieldhist->SetTitle("#pi^{0} yield (C12, crystal w/o tran.)");
else yieldhist->SetTitle("#pi^{0} yield (C12, crystal w/ tran.)");
double nyield = 0, nyield_err = 0;
for(int i = 1; i<=125; i++) {
nyield += yieldhist->GetBinContent(i);
nyield_err += yieldhist->GetBinError(i)*yieldhist->GetBinError(i);
}
nyield_err = sqrt(nyield_err);
//***************** end reading files **************************************
gStyle->SetOptFit(1);
gStyle->SetOptStat(0);
gStyle->SetPaperSize(12,24);
//Double_t parameter[4] = {7.9, 1.0, 1.0, 0.8};
Double_t parameter[4] = {7.7, 1.0, 0.8, 0.5};
TF1 *ftot = new TF1("ftot", dndt, 0., dndt_fit_range, 4);
ftot->SetParNames("#Gamma","C1","#phi","C2");
ftot->SetParameter(0,parameter[0]);
ftot->SetParameter(1,parameter[1]);
ftot->SetParameter(2,parameter[2]);
ftot->SetParameter(3,parameter[3]);
/*
ftot->FixParameter(0,parameter[0]);
ftot->FixParameter(1,parameter[1]);
ftot->FixParameter(2,parameter[2]);
ftot->FixParameter(3,parameter[3]);
*/
ftot->SetParLimits(0, 3, 10);
ftot->SetParLimits(1, 0.3, 1.5);
ftot->SetParLimits(2, 0, 3.1415936/2);
ftot->SetParLimits(3, 0., 10.0);
yieldhist->Fit("ftot", "RMBE0");
Double_t chi2 = ftot->GetChisquare()/ftot->GetNDF();
parameter[0]=ftot->GetParameter(0);
parameter[1]=ftot->GetParameter(1);
parameter[2]=ftot->GetParameter(2);
parameter[3]=ftot->GetParameter(3);
Double_t e1 = ftot->GetParError(0);
Double_t e2 = ftot->GetParError(1);
Double_t e3 = ftot->GetParError(2);
Double_t e4 = ftot->GetParError(3);
//cout<<chi2<<" "<<parameter[0]<<" "<<parameter[1]<<" "<<parameter[2]<<" "<<parameter[3]<<endl;
TString fname = "fitresult" + uimanager.input_filename("fit") + ".dat";
ofstream output(fname);
output<<nyield<<" "<<nyield_err<<" "<<chi2<<" "<<parameter[0]<<" "<<e1<<" "<<parameter[1]<<" "<<e2<<" "<<parameter[2]<<" "<<e3<<" "<<parameter[3]<<" "<<e4<<endl;
TH1F *fithist = new TH1F("fithist", "fithist", fit_nangle, 0, dndt_fit_range);
TH1F *fitcoulm = new TH1F("fitcolum", "fitcolum", fit_nangle, 0, dndt_fit_range);
TH1F *fitncohe = new TH1F("fitncohe", "fitncohe", fit_nangle, 0, dndt_fit_range);
TH1F *fitit = new TH1F("fitit", "fitit", fit_nangle, 0, dndt_fit_range);
TH1F *fitninco = new TH1F("fitninco", "fitninco", fit_nangle, 0, dndt_fit_range);
yieldhist->SetLineWidth(2);
fithist->SetLineWidth(2);
fitcoulm->SetLineWidth(2);
fitncohe->SetLineWidth(2);
fitit->SetLineWidth(2);
fitninco->SetLineWidth(2);
float accfit[fit_nangle], acchist[fit_nangle], acchisterr[fit_nangle], diff[fit_nangle];
for(int i=1;i<=fit_nangle;i++){
fithist->SetBinContent(i,ftot->Eval(max_angle/nangle*(i-0.5)));
fitcoulm->SetBinContent(i,parameter[0]*hcoulm->GetBinContent(i));
fitncohe->SetBinContent(i,parameter[1]*hncohe->GetBinContent(i));
fitit->SetBinContent(i,TMath::Sqrt(parameter[0]*parameter[1])*(TMath::Cos(parameter[2])*hcosfiint->GetBinContent(i)+TMath::Sin(parameter[2])*hsinfiint->GetBinContent(i)));
fitninco->SetBinContent(i,parameter[3]*hninco->GetBinContent(i));
if (i == 1) {
accfit[0] = fithist->GetBinContent(1);
acchist[0] = yieldhist->GetBinContent(1);
acchisterr[0] = yieldhist->GetBinError(1) * yieldhist->GetBinError(1);
}
if (i != fit_nangle) {
acchist[i] = yieldhist->GetBinContent(i) + acchist[i - 1];
accfit[i] = fithist->GetBinContent(i) + accfit[i - 1];
acchisterr[i] = acchisterr[i - 1] + yieldhist->GetBinError(i) * yieldhist->GetBinError(i);
}
}
for(int i = 0; i < fit_nangle; ++i) {
diff[i] = acchist[i] - accfit[i];
acchisterr[i] = sqrt(acchisterr[i]);
}
TString outfilename("fyield" + uimanager.input_filename("fit"));
float angles[fit_nangle], ex[fit_nangle];
for(int i=0;i<fit_nangle;i++) {
angles[i] = 0.02*(i+0.5);
ex[i] = 0;
}
TGraphErrors ge(fit_nangle, angles, diff, ex, acchisterr);
TGraphErrors ge1(fit_nangle, angles, acchist, ex, acchisterr);
TGraph ge2(fit_nangle, angles, accfit);
TCanvas *c1 = new TCanvas("c1","c1",1600,1200);
c1->SaveAs(outfilename+".pdf[");
yieldhist->SetMinimum(0);
yieldhist->SetMaximum(yieldhist->GetMaximum()*1.05);
yieldhist->Draw("e1");
fitcoulm->SetLineColor(kBlue);
fitcoulm->Draw("sameC");
fitncohe->SetLineColor(32);
fitncohe->Draw("sameC");
fitit->SetLineColor(kBlack);
fitit->Draw("sameC");
fitninco->SetLineColor(kYellow);
fitninco->Draw("sameC");
fithist->SetLineColor(kRed);
fithist->Draw("sameC");
TLegend *leg = new TLegend(0.1,0.7,0.45,0.9);
leg->SetFillColor(0);
leg->SetTextSize(0.03);
leg->AddEntry(fitcoulm,"Primakoff","L");
leg->AddEntry(fitncohe,"Nuclear Coherent","L");
leg->AddEntry(fitit,"Interference","L");
leg->AddEntry(fitninco,"Nuclear Incoherent","L");
//leg->Draw();
c1->SaveAs(outfilename+".pdf");
ge.SetMarkerStyle(20);
ge.SetMarkerColor(kBlue);
ge.SetTitle("accumulated yield - fit vs. #theta");
ge.Draw("ap");
c1->SaveAs(outfilename + ".pdf");
ge1.SetMarkerStyle(20);
ge1.SetMarkerColor(kBlue);
ge1.SetTitle("accumulated yield and fitting vs. #theta");
ge1.Draw("ap");
ge2.SetLineColor(kRed);
ge2.Draw("sameC");
c1->SaveAs(outfilename + ".pdf");
c1->SaveAs(outfilename+".pdf]");
TFile *ftyd = new TFile(outfilename+".root", "RECREATE");
yieldhist->Write();
fithist->Write();
fitcoulm->Write();
fitncohe->Write();
fitit->Write();
fitninco->Write();
hcoulm->Write();
hncohe->Write();
hninco->Write();
hcosfiint->Write();
hsinfiint->Write();
ftyd->Close();
return 0;
}
int ScanChain( TChain* chain, bool fast = true, int nEvents = -1, string skimFilePrefix = "test") {
// Benchmark
TBenchmark *bmark = new TBenchmark();
bmark->Start("benchmark");
// Example Histograms
TDirectory *rootdir = gDirectory->GetDirectory("Rint:");
TH1F *samplehisto = new TH1F("samplehisto", "Example histogram", 200,0,200);
samplehisto->SetDirectory(rootdir);
// Loop over events to Analyze
unsigned int nEventsTotal = 0;
unsigned int nEventsChain = chain->GetEntries();
if( nEvents >= 0 ) nEventsChain = nEvents;
TObjArray *listOfFiles = chain->GetListOfFiles();
TIter fileIter(listOfFiles);
TFile *currentFile = 0;
// File Loop
while ( (currentFile = (TFile*)fileIter.Next()) ) {
// Get File Content
TFile *file = new TFile( currentFile->GetTitle() );
TTree *tree = (TTree*)file->Get("t");
if(fast) TTreeCache::SetLearnEntries(10);
if(fast) tree->SetCacheSize(128*1024*1024);
cms3.Init(tree);
// 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
if( nEventsTotal >= nEventsChain ) continue;
if(fast) tree->LoadTree(event);
cms3.GetEntry(event);
++nEventsTotal;
// Progress
StopBabies10012015::progress( nEventsTotal, nEventsChain );
// Analysis Code
}
// Clean Up
delete tree;
file->Close();
delete file;
}
if ( nEventsChain != nEventsTotal ) {
cout << Form( "ERROR: number of events from files (%d) is not equal to total number of events (%d)", nEventsChain, nEventsTotal ) << endl;
}
// Example Histograms
samplehisto->Draw();
// return
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;
return 0;
}
TCanvas *drawOneVariable(TTree *signalTree, TTree *backgroundTree1, TTree *backgroundTree2,TTree *backgroundTree3,
TCut signalCuts, TCut backgroundCuts,
TString var,
int nbins, double xlow, double xhigh,
TString sigLegend, TString bg1Legend, TString bg2Legend,TString bg3Legend,
TString comment)
{
TString cname = "c_";
cname += var;
TCanvas *c1 = new TCanvas(cname,cname,10,10,600,600);
c1->cd();
TH1F *hsig = new TH1F(TString("hsig_")+var,"",nbins, xlow, xhigh);
TH1F *hbg1 = new TH1F(TString("hbg1_")+var,"",nbins, xlow, xhigh);
TH1F *hbg2 = new TH1F(TString("hbg2_")+var,"",nbins, xlow, xhigh);
TH1F *hbg3 = new TH1F(TString("hbg3_")+var,"",nbins, xlow, xhigh);
TString projectCommandSig = var+TString(">>hsig_")+var;
TString projectCommandBg1 = var+TString(">>hbg1_")+var;
TString projectCommandBg2 = var+TString(">>hbg2_")+var;
TString projectCommandBg3 = var+TString(">>hbg3_")+var;
if( !useSmallEventCount ){
signalTree->Draw(projectCommandSig, "genWeight"*signalCuts);
}else{
printf("DEBUG MODE: using small event count\n");
signalTree->Draw(projectCommandSig, "genWeight"*signalCuts, "", 100000);
}
TGaxis::SetMaxDigits(3);
hsig->GetXaxis()->SetTitle(var);
hsig->SetDirectory(0);
if(backgroundTree1 != 0){
if( !useSmallEventCount ){
backgroundTree1->Draw(projectCommandBg1, "genWeight"*backgroundCuts);
}else{
printf("DEBUG MODE: using small event count\n");
backgroundTree1->Draw(projectCommandBg1, "genWeight"*backgroundCuts, "", 100000);
}
hbg1->Scale(hsig->GetSumOfWeights() / hbg1->GetSumOfWeights());
hbg1->SetDirectory(0);
} else {
delete hbg1;
hbg1 = 0;
}
if(backgroundTree2 != 0){
if( !useSmallEventCount ){
backgroundTree2->Draw(projectCommandBg2, "genWeight"*backgroundCuts);
}else{
printf("DEBUG MODE: using small event count\n");
backgroundTree2->Draw(projectCommandBg2, "genWeight"*backgroundCuts, "", 100000);
}
hbg2->Scale(hsig->GetSumOfWeights() / hbg2->GetSumOfWeights());
hbg2->SetDirectory(0);
} else {
delete hbg2;
hbg2 = 0;
}
if(backgroundTree3 != 0){
if( !useSmallEventCount ){
backgroundTree3->Draw(projectCommandBg3, "genWeight"*backgroundCuts);
}else{
printf("DEBUG MODE: using small event count\n");
backgroundTree3->Draw(projectCommandBg3, "genWeight"*backgroundCuts, "", 100000);
}
hbg3->Scale(hsig->GetSumOfWeights() / hbg3->GetSumOfWeights());
hbg3->SetDirectory(0);
} else {
delete hbg3;
hbg3 = 0;
}
setHistogramAttributes(hsig, hbg1, hbg2, hbg3);
c1->Clear();
hsig->Draw("hist");
if( hbg1 ){
hbg1->Draw("same");
}
if( hbg2 ){
hbg2->Draw("same");
}
if( hbg3 ){
//hbg3->Draw("same");
}
TLegend *leg = new TLegend(0.55, 0.65, 0.95, 0.80); // 0.6 0.9
leg->SetFillStyle(0);
leg->SetBorderSize(0);
leg->AddEntry(hsig, sigLegend, "lf");
leg->AddEntry(hbg1, bg1Legend, "lf");
leg->AddEntry(hbg2, bg2Legend, "lf");
// leg->AddEntry(hbg3, bg3Legend, "lf");
leg->Draw("same");
TLatex *lat = new TLatex(0.5, 0.95, comment); // 0.85
lat->SetNDC(kTRUE);
lat->Draw("same");
c1->Update();
return c1;
}
//*************************************************************************************************
//Function to create a distribution stacked histogram for all the bkg processes
//for the variable given
//*************************************************************************************************
THStack* makeBkgDistributionHistogram ( int variableIndex, MitNtupleEvent* event ,
Int_t nentries, TLegend *legend,
int OnlyThisFinalState = -1) {
assert(variableIndex >= 0 && variableIndex < NVARIABLES);
string histName = fVariableNames[variableIndex] + "_bkg";
string axisLabel = ";" + fVariableNames[variableIndex] + ";Number of Events";
THStack *stackHistogram = new THStack(histName.c_str(),axisLabel.c_str());
//stackHistogram->SetDirectory(0);
vector< pair<int, TH1F*> > bkgHistograms;
for (int n=0;n<nentries;n++) {
event->GetEntry(n);
float eventweight = event->H_weight;
int finalstatetype = (int)event->H_ltype;
int decay = (int)event->H_decay;
//only look at events with the given finalstatetype
if (OnlyThisFinalState >= 0 && OnlyThisFinalState != finalstatetype)
continue;
Float_t cutAboveValues[NVARIABLES];
Float_t cutBelowValues[NVARIABLES];
Float_t variableValues[NVARIABLES];
//only look at events with the given finalstatetype
//convert finalstatetype into the array index
int fs;
if (finalstatetype == 10)
fs = 0;
else if (finalstatetype == 11)
fs = 1;
else if (finalstatetype == 12)
fs = 2;
else {
fs = -1;
continue;
}
for (int j=0;j<NVARIABLES;j++) {
cutAboveValues[j] = fCutAboveInitialValue[fs][j];
cutBelowValues[j] = fCutBelowInitialValue[fs][j];
variableValues[j] = GetVariableValue(j, event);
}
//printf(" B %d\n", n);
//For N-1 Distributions
//if (passCut(event,variableValues, cutAboveValues, cutBelowValues, variableIndex)) {
if (passCut(event,variableValues, cutAboveValues, cutBelowValues)) {
//Search for the bkg process to see if it already exists
bool foundProcess = false;
int foundIndex = -1;
for (UInt_t p=0;p<bkgHistograms.size();p++) {
//cout << "Check bkgHistograms " << p << " " << bkgHistograms[p].first << " "
// << bkgHistograms[p].second << endl;
if (decay == bkgHistograms[p].first) {
foundProcess = true;
foundIndex = p;
}
}
if (!foundProcess) {
//get name of the process
int decayIndex = -1;
for (int k=0;k<NPROCESSES;k++) {
if (fProcessCode[k] == decay)
decayIndex = k;
}
string temphistname = "";
if (decayIndex >= 0) {
temphistname = fProcessName[decayIndex];
}
string temphistAxisLabel = ";" + fVariableNames[variableIndex] + ";Number of Events";
TH1F *temphist = new TH1F(temphistname.c_str(),axisLabel.c_str(),NBINS,
fVariableRangeMin[variableIndex],
fVariableRangeMax[variableIndex]);
temphist->SetDirectory(0);
//temphist->SetFillStyle(1001);
temphist->SetFillColor(fColors[decayIndex]);
temphist->SetLineWidth(1);
//Fill histogram
temphist->Fill( variableValues[variableIndex], eventweight);
pair< int, TH1F* > tempPair(decay,temphist);
bkgHistograms.push_back(tempPair);
//Add legend entry
legend->AddEntry(temphist, temphistname.c_str(), "f");
} else {
//fill histogram
bkgHistograms[foundIndex].second->Fill( variableValues[variableIndex], eventweight);
}
}
}
//add to the stack
for (UInt_t p=0;p<bkgHistograms.size();p++) {
stackHistogram->Add(bkgHistograms[p].second);
}
return stackHistogram;
}
TCanvas* example_plot( int iPeriod, int iPos )
{
// if( iPos==0 ) relPosX = 0.12;
int W = 800;
int H = 600;
//
// Simple example of macro: plot with CMS name and lumi text
// (this script does not pretend to work in all configurations)
// iPeriod = 1*(0/1 7 TeV) + 2*(0/1 8 TeV) + 4*(0/1 13 TeV)
// For instance:
// iPeriod = 3 means: 7 TeV + 8 TeV
// iPeriod = 7 means: 7 TeV + 8 TeV + 13 TeV
// Initiated by: Gautier Hamel de Monchenault (Saclay)
// Updated by: Dinko Ferencek (Rutgers)
//
int H_ref = 600;
int W_ref = 800;
// references for T, B, L, R
float T = 0.08*H_ref;
float B = 0.12*H_ref;
float L = 0.12*W_ref;
float R = 0.04*W_ref;
TString canvName = "FigExample_";
canvName += W;
canvName += "-";
canvName += H;
canvName += "_";
canvName += iPeriod;
if( writeExtraText ) canvName += "-prelim";
if( iPos%10==0 ) canvName += "-out";
else if( iPos%10==1 ) canvName += "-left";
else if( iPos%10==2 ) canvName += "-center";
else if( iPos%10==3 ) canvName += "-right";
TCanvas* canv = new TCanvas(canvName,canvName,50,50,W,H);
canv->SetFillColor(0);
canv->SetBorderMode(0);
canv->SetFrameFillStyle(0);
canv->SetFrameBorderMode(0);
canv->SetLeftMargin( L/W );
canv->SetRightMargin( R/W );
canv->SetTopMargin( T/H );
canv->SetBottomMargin( B/H );
canv->SetTickx(0);
canv->SetTicky(0);
TH1* h = new TH1F("h","h",40,70,110);
h->GetXaxis()->SetNdivisions(6,5,0);
h->GetXaxis()->SetTitle("m_{e^{+}e^{-}} (GeV)");
h->GetYaxis()->SetNdivisions(6,5,0);
h->GetYaxis()->SetTitleOffset(1);
h->GetYaxis()->SetTitle("Events / 0.5 GeV");
h->SetMaximum( 260 );
if( iPos==1 ) h->SetMaximum( 300 );
h->Draw();
int histLineColor = kOrange+7;
int histFillColor = kOrange-2;
float markerSize = 1.0;
{
TLatex latex;
int n_ = 2;
float x1_l = 0.92;
float y1_l = 0.60;
float dx_l = 0.30;
float dy_l = 0.18;
float x0_l = x1_l-dx_l;
float y0_l = y1_l-dy_l;
TPad* legend = new TPad("legend_0","legend_0",x0_l,y0_l,x1_l, y1_l );
// legend->SetFillColor( kGray );
legend->Draw();
legend->cd();
float ar_l = dy_l/dx_l;
float x_l[1];
float ex_l[1];
float y_l[1];
float ey_l[1];
// float gap_ = 0.09/ar_l;
float gap_ = 1./(n_+1);
float bwx_ = 0.12;
float bwy_ = gap_/1.5;
x_l[0] = 1.2*bwx_;
// y_l[0] = 1-(1-0.10)/ar_l;
y_l[0] = 1-gap_;
ex_l[0] = 0;
ey_l[0] = 0.04/ar_l;
TGraph* gr_l = new TGraphErrors(1, x_l, y_l, ex_l, ey_l );
gStyle->SetEndErrorSize(0);
gr_l->SetMarkerSize(0.9);
gr_l->Draw("0P");
latex.SetTextFont(42);
latex.SetTextAngle(0);
latex.SetTextColor(kBlack);
latex.SetTextSize(0.25);
latex.SetTextAlign(12);
TLine line_;
TBox box_;
float xx_ = x_l[0];
float yy_ = y_l[0];
latex.DrawLatex(xx_+1.*bwx_,yy_,"Data");
yy_ -= gap_;
box_.SetLineStyle( kSolid );
box_.SetLineWidth( 1 );
// box_.SetLineColor( kBlack );
box_.SetLineColor( histLineColor );
box_.SetFillColor( histFillColor );
box_.DrawBox( xx_-bwx_/2, yy_-bwy_/2, xx_+bwx_/2, yy_+bwy_/2 );
box_.SetFillStyle(0);
box_.DrawBox( xx_-bwx_/2, yy_-bwy_/2, xx_+bwx_/2, yy_+bwy_/2 );
latex.DrawLatex(xx_+1.*bwx_,yy_,"Z #rightarrow e^{+}e^{-} (MC)");
canv->cd();
}
{
// Observed data
TFile file_("histo.root","READ");
TH1F *data = static_cast<TH1F*>(file_.Get("data")->Clone());
data->SetDirectory(0);
data->SetMarkerStyle(20);
data->SetMarkerSize(markerSize);
TH1F *MC = static_cast<TH1F*>(file_.Get("MC")->Clone());
MC->SetDirectory(0);
MC->SetLineColor(histLineColor);
MC->SetFillColor(histFillColor);
MC->Draw("histsame");
data->Draw("esamex0");
file_.Close();
}
// writing the lumi information and the CMS "logo"
CMS_lumi( canv, iPeriod, iPos );
canv->Update();
canv->RedrawAxis();
canv->GetFrame()->Draw();
canv->Print(canvName+".pdf",".pdf");
canv->Print(canvName+".png",".png");
return canv;
}
void fullPedestalAnalysis(string inputDIR, string outputDIR, string inputCablingMap, string outputFileName){
gROOT->ProcessLine("gErrorIgnoreLevel = 1");
// open the file and prepare the cluster tree, adding the other trees as frined --> memory consuming
std::cout<<"##################################"<<std::endl;
std::cout<<"###### fullPedestalAnalysis ######"<<std::endl;
std::cout<<"##################################"<<std::endl;
clock_t tStart = clock();
// prepare style and load macros
setTDRStyle();
gROOT->SetBatch(kTRUE);
system(("mkdir -p "+outputDIR).c_str());
ifstream file;
std::cout<<"### Make input file list"<<std::endl;
system(("find "+inputDIR+" -name \"*.root\" > file.temp").c_str());
std::ifstream infile;
string line;
vector<string> fileList;
infile.open("file.temp",ifstream::in);
if(infile.is_open()){
while(!infile.eof()){
getline(infile,line);
if(line != "" and TString(line).Contains(".root") and line !="\n"){
fileList.push_back(line);
}
}
}
system("rm file.temp");
std::sort(fileList.begin(),fileList.end());
TFile* cablingFile = TFile::Open(inputCablingMap.c_str(),"READ");
cablingFile->cd();
TTree* readoutMap = (TTree*) cablingFile->FindObjectAny("readoutMap");
TTreeReader reader(readoutMap);
TTreeReaderValue<uint32_t> detid (reader,"detid");
TTreeReaderValue<uint16_t> fecCrate (reader,"fecCrate");
TTreeReaderValue<uint16_t> fecSlot (reader,"fecSlot");
TTreeReaderValue<uint16_t> fecRing (reader,"fecRing");
TTreeReaderValue<uint16_t> ccuAdd (reader,"ccuAdd");
TTreeReaderValue<uint16_t> ccuChan (reader,"ccuChan");
TTreeReaderValue<uint16_t> lldChannel (reader,"lldChannel");
TTreeReaderValue<uint16_t> fedId (reader,"fedId");
TTreeReaderValue<uint16_t> fedCh (reader,"fedCh");
// output tree
TFile* ouputTreeFile = new TFile((outputDIR+"/"+outputFileName).c_str(),"RECREATE");
ouputTreeFile->cd();
ouputTreeFile->SetCompressionLevel(0);
TTree* outputTree = new TTree("pedestalFullNoise","pedestalFullNoise");
// branches
uint32_t detid_,fedKey_;
uint16_t fecCrate_,fecSlot_, fecRing_, ccuAdd_, ccuChan_, lldChannel_, fedId_, fedCh_, apvId_, stripId_;
float noiseMean_,noiseRMS_, noiseSkewness_, noiseKurtosis_;
float fitChi2_, fitChi2Probab_, fitStatus_;
float fitGausMean_, fitGausSigma_, fitGausNormalization_;
float fitGausMeanError_, fitGausSigmaError_, fitGausNormalizationError_;
float noiseIntegral3Sigma_, noiseIntegral3SigmaFromFit_;
float noiseIntegral4Sigma_, noiseIntegral4SigmaFromFit_;
float noiseIntegral5Sigma_, noiseIntegral5SigmaFromFit_;
float kSValue_, kSProbab_, jBValue_, jBProbab_, aDValue_, aDProbab_;
vector<float> noiseDistribution_, noiseDistributionError_;
float xMin_, xMax_, nBin_ ;
outputTree->Branch("detid",&detid_,"detid/i");
outputTree->Branch("fedKey",&fedKey_,"fedKey/i");
outputTree->Branch("fecCrate",&fecCrate_,"fecCrate/s");
outputTree->Branch("fecSlot",&fecSlot_,"fecSlot/s");
outputTree->Branch("fecRing",&fecRing_,"fecRing/s");
outputTree->Branch("ccuAdd",&ccuAdd_,"ccuAdd/s");
outputTree->Branch("ccuChan",&ccuChan_,"ccuChan/s");
outputTree->Branch("lldChannel",&lldChannel_,"lldChannel/s");
outputTree->Branch("fedId",&fedId_,"fedId/s");
outputTree->Branch("fedCh",&fedCh_,"fedCh/s");
outputTree->Branch("apvId",&apvId_,"apvId/s");
outputTree->Branch("stripId",&stripId_,"stripId/s");
outputTree->Branch("noiseMean",&noiseMean_,"noiseMean/F");
outputTree->Branch("noiseRMS",&noiseRMS_,"noiseRMS/F");
outputTree->Branch("noiseSkewness",&noiseSkewness_,"noiseSkewness/F");
outputTree->Branch("noiseKurtosis",&noiseKurtosis_,"noiseKurtosis/F");
outputTree->Branch("fitGausNormalization",&fitGausNormalization_,"fitGausNormalization/F");
outputTree->Branch("fitGausMean",&fitGausMean_,"fitGausMean/F");
outputTree->Branch("fitGausSigma",&fitGausSigma_,"fitGausSigma/F");
outputTree->Branch("fitGausNormalizationError",&fitGausNormalizationError_,"fitGausNormalizationError/F");
outputTree->Branch("fitGausMeanError",&fitGausMeanError_,"fitGausMeanError/F");
outputTree->Branch("fitGausSigmaError",&fitGausSigmaError_,"fitGausSigmaError/F");
outputTree->Branch("fitChi2",&fitChi2_,"fitChi2/F");
outputTree->Branch("fitChi2Probab",&fitChi2Probab_,"fitChi2Probab/F");
outputTree->Branch("fitStatus",&fitStatus_,"fitStatus_F");
outputTree->Branch("noiseIntegral3Sigma",&noiseIntegral3Sigma_,"noiseIntegral3Sigma/F");
outputTree->Branch("noiseIntegral3SigmaFromFit",&noiseIntegral3SigmaFromFit_,"noiseIntegral3SigmaFromFit/F");
outputTree->Branch("noiseIntegral4Sigma",&noiseIntegral4Sigma_,"noiseIntegral4Sigma/F");
outputTree->Branch("noiseIntegral4SigmaFromFit",&noiseIntegral4SigmaFromFit_,"noiseIntegral4SigmaFromFit/F");
outputTree->Branch("noiseIntegral5Sigma",&noiseIntegral4Sigma_,"noiseIntegral5Sigma/F");
outputTree->Branch("noiseIntegral5SigmaFromFit",&noiseIntegral4SigmaFromFit_,"noiseIntegral5SigmaFromFit/F");
outputTree->Branch("kSValue",&kSValue_,"kSValue/F");
outputTree->Branch("jBValue",&jBValue_,"jBValue/F");
outputTree->Branch("aDValue",&aDValue_,"aDValue/F");
outputTree->Branch("kSProbab",&kSProbab_,"kSProbab/F");
outputTree->Branch("jBProbab",&jBProbab_,"jBProbab/F");
outputTree->Branch("aDProbab",&aDProbab_,"aDProbab/F");
outputTree->Branch("xMin",&xMin_,"xMin/F");
outputTree->Branch("xMax",&xMax_,"xMax/F");
outputTree->Branch("nBin",&nBin_,"nBin/F");
bool histoBranches = false;
// Loop on the file list to extract each histogram 2D DQM histo with full noise distribution
TH1F* histoNoiseStrip = NULL;
TF1* fitFunc = NULL;
TH1F* randomHisto = NULL;
TFitResultPtr result;
for(auto file : fileList){
cout<<"input file: "<<file<<endl;
TFile* inputFile = TFile::Open(file.c_str(),"READ");
inputFile->cd();
// take into account that the DQM file structure for strips is always the same --> use cabling map to browse the histograms
reader.SetEntry(0);
TH2* histoNoise = NULL;
long int iChannel = 0;
int noFitResult = 0;
while(reader.Next()){
cout.flush();
if(iChannel %10 == 0) cout<<"\r"<<"iChannel "<<100*double(iChannel)/(readoutMap->GetEntries()/reductionFactor)<<" % ";
if(iChannel > double(readoutMap->GetEntries())/reductionFactor) break;
iChannel++;
TString objName;
uint32_t fedKey = SiStripFedKey(*fedId,SiStripFedKey::feUnit(*fedCh),SiStripFedKey::feChan(*fedCh)).key();
std::stringstream stream;
stream << std::hex << fedKey;
string fedKeyStr = stream.str();
if(fedKeyStr.size() == 4)
objName = Form("DQMData/SiStrip/ControlView/FecCrate%d/FecSlot%d/FecRing%d/CcuAddr%d/CcuChan%d/ExpertHisto_PedsFullNoise_FedKey0x0000%s_LldChannel%d_Noise2D",*fecCrate,*fecSlot,*fecRing,*ccuAdd,*ccuChan,fedKeyStr.c_str(),*lldChannel);
else if(fedKeyStr.size() == 5)
objName = Form("DQMData/SiStrip/ControlView/FecCrate%d/FecSlot%d/FecRing%d/CcuAddr%d/CcuChan%d/ExpertHisto_PedsFullNoise_FedKey0x000%s_LldChannel%d_Noise2D",*fecCrate,*fecSlot,*fecRing,*ccuAdd,*ccuChan,fedKeyStr.c_str(),*lldChannel);
else
cerr<<"hex number to short "<<fedKeyStr<<" --> please check "<<endl;
inputFile->GetObject(objName.Data(),histoNoise);
// extract single strip noise histogram --> loop on the y-axis
uint16_t apvID = 0;
uint16_t stripID = 0;
if(histoNoiseStrip == 0 or histoNoiseStrip == NULL){
histoNoiseStrip = new TH1F ("histoNoiseStrip","",histoNoise->GetNbinsX(),histoNoise->GetXaxis()->GetXmin(),histoNoise->GetXaxis()->GetXmax());
histoNoiseStrip->Sumw2();
}
for(int iBinY = 0; iBinY < histoNoise->GetNbinsY(); iBinY++){
histoNoiseStrip->Reset();
histoNoiseStrip->SetDirectory(0);
// two multiplexed APV per line
if(iBinY < histoNoise->GetNbinsY()/2) apvID = 1;
else apvID = 2;
// strip id
stripID++;
if(stripID > 128) stripID = 1;
// loop on x-axis bin
for(int iBinX = 0; iBinX < histoNoise->GetNbinsX(); iBinX++){
histoNoiseStrip->SetBinContent(iBinX+1,histoNoise->GetBinContent(iBinX+1,iBinY+1));
histoNoiseStrip->SetBinError(iBinX+1,histoNoise->GetBinError(iBinX+1,iBinY+1));
}
// to initialize branches
detid_ = 0; fedKey_ = 0; fecCrate_ = 0; fecSlot_ = 0; fecRing_ = 0; ccuAdd_ = 0; ccuChan_ = 0; lldChannel_ = 0; fedId_ = 0; fedCh_ = 0; apvId_ = 0; stripId_ = 0;
noiseMean_ = 0.; noiseRMS_ = 0.; noiseSkewness_ = 0.; noiseKurtosis_ = 0.;
fitGausMean_ = 0.; fitGausSigma_ = 0.;fitGausNormalization_ = 0.;
fitGausMeanError_ = 0.; fitGausSigmaError_ = 0.;fitGausNormalizationError_ = 0.;
fitChi2_ = 0.; fitChi2Probab_ = 0.; fitStatus_ = -1.;
noiseIntegral3Sigma_ = 0.; noiseIntegral3SigmaFromFit_ = 0.;
noiseIntegral4Sigma_ = 0.; noiseIntegral4SigmaFromFit_ = 0.;
noiseIntegral5Sigma_ = 0.; noiseIntegral5SigmaFromFit_ = 0.;
kSProbab_ = 0.; jBProbab_ = 0.;
kSValue_ = 0.; jBValue_ = 0.;
aDValue_= 0.; aDProbab_ = 0.;
nBin_ = 0.; xMin_ = 0.; xMax_ = 0.;
// basic info
detid_ = *detid;
fedKey_ = fedKey;
fecCrate_ = *fecCrate;
fecSlot_ = *fecSlot;
fecRing_ = *fecRing;
ccuAdd_ = *ccuAdd;
ccuChan_ = *ccuChan;
lldChannel_ = *lldChannel;
fedId_ = *fedId;
fedCh_ = *fedCh;
apvId_ = apvID;
stripId_ = stripID;
// basic info of nioise distribution
noiseMean_ = histoNoiseStrip->GetMean();
noiseRMS_ = histoNoiseStrip->GetRMS();
noiseSkewness_ = histoNoiseStrip->GetSkewness();
noiseKurtosis_ = histoNoiseStrip->GetKurtosis();
float integral = histoNoiseStrip->Integral();
noiseIntegral3Sigma_ = (histoNoiseStrip->Integral(histoNoiseStrip->FindBin(noiseMean_+noiseRMS_*3),histoNoiseStrip->GetNbinsX()+1) + histoNoiseStrip->Integral(0,histoNoiseStrip->FindBin(noiseMean_-noiseRMS_*3)))/integral;
noiseIntegral4Sigma_ = (histoNoiseStrip->Integral(histoNoiseStrip->FindBin(noiseMean_+noiseRMS_*4),histoNoiseStrip->GetNbinsX()+1) + histoNoiseStrip->Integral(0,histoNoiseStrip->FindBin(noiseMean_-noiseRMS_*4)))/integral;
noiseIntegral5Sigma_ = (histoNoiseStrip->Integral(histoNoiseStrip->FindBin(noiseMean_+noiseRMS_*5),histoNoiseStrip->GetNbinsX()+1) + histoNoiseStrip->Integral(0,histoNoiseStrip->FindBin(noiseMean_-noiseRMS_*5)))/integral;
// make a gaussian fit
if(fitFunc == NULL or fitFunc == 0){
fitFunc = new TF1 ("fitFunc","gaus(0)",histoNoise->GetXaxis()->GetXmin(),histoNoise->GetXaxis()->GetXmax());
}
fitFunc->SetRange(histoNoise->GetXaxis()->GetXmin(),histoNoise->GetXaxis()->GetXmax());
fitFunc->SetParameters(histoNoiseStrip->Integral(),noiseMean_,noiseRMS_);
result = histoNoiseStrip->Fit(fitFunc,"QSR");
if(result.Get()){
fitStatus_ = result->Status();
fitGausNormalization_ = fitFunc->GetParameter(0);
fitGausMean_ = fitFunc->GetParameter(1);
fitGausSigma_ = fitFunc->GetParameter(2);
fitGausNormalizationError_ = fitFunc->GetParError(0);
fitGausMeanError_ = fitFunc->GetParError(1);
fitGausSigmaError_ = fitFunc->GetParError(2);
fitChi2_ = result->Chi2();
fitChi2Probab_ = result->Prob();
noiseIntegral3SigmaFromFit_ = (histoNoiseStrip->Integral(histoNoiseStrip->FindBin(noiseMean_+fitGausSigma_*3),histoNoiseStrip->GetNbinsX()+1) + histoNoiseStrip->Integral(0,histoNoiseStrip->FindBin(noiseMean_-fitGausSigma_*3)))/histoNoiseStrip->Integral();
noiseIntegral4SigmaFromFit_ = (histoNoiseStrip->Integral(histoNoiseStrip->FindBin(noiseMean_+fitGausSigma_*4),histoNoiseStrip->GetNbinsX()+1) + histoNoiseStrip->Integral(0,histoNoiseStrip->FindBin(noiseMean_-fitGausSigma_*4)))/histoNoiseStrip->Integral();
noiseIntegral5SigmaFromFit_ = (histoNoiseStrip->Integral(histoNoiseStrip->FindBin(noiseMean_+fitGausSigma_*5),histoNoiseStrip->GetNbinsX()+1) + histoNoiseStrip->Integral(0,histoNoiseStrip->FindBin(noiseMean_-fitGausSigma_*5)))/histoNoiseStrip->Integral();
jBValue_ = (histoNoiseStrip->Integral()/6)*(noiseSkewness_*noiseSkewness_+(noiseKurtosis_*noiseKurtosis_)/4);
jBProbab_ = ROOT::Math::chisquared_cdf_c(jBValue_,2);
if(randomHisto == 0 or randomHisto == NULL)
randomHisto = (TH1F*) histoNoiseStrip->Clone("randomHisto");
randomHisto->Reset();
randomHisto->SetDirectory(0);
if(integral != 0){
if(generateRandomDistribution){
randomHisto->FillRandom("fitFunc",histoNoiseStrip->Integral());
kSValue_ = histoNoiseStrip->KolmogorovTest(randomHisto,"MN");
kSProbab_ = histoNoiseStrip->KolmogorovTest(randomHisto,"N");
aDValue_ = histoNoiseStrip->AndersonDarlingTest(randomHisto,"T");
aDProbab_ = histoNoiseStrip->AndersonDarlingTest(randomHisto);
}
else{
randomHisto->Add(fitFunc);
kSValue_ = histoNoiseStrip->KolmogorovTest(randomHisto,"MN");
kSProbab_ = histoNoiseStrip->KolmogorovTest(randomHisto,"N");
// AD test
ROOT::Fit::BinData data1;
ROOT::Fit::BinData data2;
ROOT::Fit::FillData(data1,histoNoiseStrip,0);
data2.Initialize(randomHisto->GetNbinsX()+1,1);
for(int ibin = 0; ibin < randomHisto->GetNbinsX(); ibin++){
if(histoNoiseStrip->GetBinContent(ibin+1) != 0 or randomHisto->GetBinContent(ibin+1) >= 1)
data2.Add(randomHisto->GetBinCenter(ibin+1),randomHisto->GetBinContent(ibin+1),randomHisto->GetBinError(ibin+1));
}
double probab;
double value;
ROOT::Math::GoFTest::AndersonDarling2SamplesTest(data1,data2,probab,value);
aDValue_ = value;
aDProbab_ = probab;
}
}
}
else
noFitResult++;
if(not histoBranches){
noiseDistribution_.clear();
noiseDistributionError_.clear();
outputTree->Branch("noiseDistribution","vector<float>",&noiseDistribution_);
outputTree->Branch("noiseDistributionError","vector<float>",&noiseDistributionError_);
histoBranches = true;
}
// set histogram
noiseDistribution_.clear();
noiseDistributionError_.clear();
for(int iBin = 0; iBin < histoNoiseStrip->GetNbinsX(); iBin++){
noiseDistribution_.push_back(histoNoiseStrip->GetBinContent(iBin+1));
noiseDistributionError_.push_back(histoNoiseStrip->GetBinError(iBin+1));
}
nBin_ = histoNoiseStrip->GetNbinsX();
xMin_ = histoNoise->GetXaxis()->GetBinLowEdge(1);
xMax_ = histoNoise->GetXaxis()->GetBinLowEdge(histoNoise->GetNbinsX()+1);
// fill all branches for each strip
ouputTreeFile->cd();
outputTree->Fill();
}
}
inputFile->Close();
std::cout<<std::endl;
cout<<"No fit results found for "<<100*double(noFitResult)/iChannel<<endl;
}
outputTree->BuildIndex("detid");
outputTree->Write(outputTree->GetName(),TObject::kOverwrite);
ouputTreeFile->Close();
cablingFile->Close();
/* Do your stuff here */
cout<<"Time taken: "<<(double)(clock() - tStart)/CLOCKS_PER_SEC<<endl;
}
